@Test
public void test410TestResource() throws Exception {
final String TEST_NAME = "test410TestResource";
TestUtil.displayTestTile(this, TEST_NAME);
// GIVEN
OperationResult result = new OperationResult(DOT_CLASS + TEST_NAME);
PrismProperty<ScriptingExpressionType> expression = parseAnyData(TEST_DUMMY_RESOURCE_FILE);
// WHEN
ExecutionContext output =
scriptingExpressionEvaluator.evaluateExpression(
expression.getAnyValue().getValue(), result);
// THEN
IntegrationTestTools.display("output", output.getFinalOutput());
IntegrationTestTools.display("stdout", output.getConsoleOutput());
ResourceType dummy =
modelService
.getObject(
ResourceType.class,
RESOURCE_DUMMY_OID,
null,
taskManager.createTaskInstance(),
result)
.asObjectable();
IntegrationTestTools.display("dummy resource after test connection", dummy.asPrismObject());
IntegrationTestTools.display(result);
result.computeStatus();
TestUtil.assertSuccess(result);
assertEquals(1, output.getFinalOutput().getData().size());
assertEquals(
"Tested resource:10000000-0000-0000-0000-000000000004(Dummy Resource): SUCCESS\n",
output.getConsoleOutput());
}
public boolean evaluateConfirmationExpression(
UserType user,
ShadowType shadow,
ExpressionType expressionType,
Task task,
OperationResult result)
throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException {
Validate.notNull(user, "User must not be null.");
Validate.notNull(shadow, "Resource object shadow must not be null.");
Validate.notNull(expressionType, "Expression must not be null.");
Validate.notNull(result, "Operation result must not be null.");
ResourceType resource = resolveResource(shadow, result);
ExpressionVariables variables = getDefaultXPathVariables(user, shadow, resource);
String shortDesc = "confirmation expression for " + resource.asPrismObject();
PrismPropertyDefinition<Boolean> outputDefinition =
new PrismPropertyDefinition<>(
ExpressionConstants.OUTPUT_ELMENT_NAME, DOMUtil.XSD_BOOLEAN, prismContext);
Expression<PrismPropertyValue<Boolean>, PrismPropertyDefinition<Boolean>> expression =
expressionFactory.makeExpression(expressionType, outputDefinition, shortDesc, task, result);
ExpressionEvaluationContext params =
new ExpressionEvaluationContext(null, variables, shortDesc, task, result);
PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple =
ModelExpressionThreadLocalHolder.evaluateExpressionInContext(
expression, params, task, result);
Collection<PrismPropertyValue<Boolean>> nonNegativeValues = outputTriple.getNonNegativeValues();
if (nonNegativeValues == null || nonNegativeValues.isEmpty()) {
throw new ExpressionEvaluationException(
"Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
}
if (nonNegativeValues.size() > 1) {
throw new ExpressionEvaluationException(
"Expression returned more than one value ("
+ nonNegativeValues.size()
+ ") in "
+ shortDesc);
}
PrismPropertyValue<Boolean> resultpval = nonNegativeValues.iterator().next();
if (resultpval == null) {
throw new ExpressionEvaluationException(
"Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
}
Boolean resultVal = resultpval.getValue();
if (resultVal == null) {
throw new ExpressionEvaluationException(
"Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
}
return resultVal;
}
/**
* Simple call to connector test() method.
*
* @throws Exception
*/
@Test
public void test310TestConnectionNegative() throws Exception {
final String TEST_NAME = "test310TestConnectionNegative";
TestUtil.displayTestTile(this, TEST_NAME);
// GIVEN
OperationResult result = new OperationResult(TEST_NAME);
ConnectorInstance badConnector =
factory.createConnectorInstance(
connectorType,
ResourceTypeUtil.getResourceNamespace(badResourceType),
"test connector");
badConnector.configure(
badResourceType.getConnectorConfiguration().asPrismContainerValue(), result);
// WHEN
badConnector.test(result);
// THEN
result.computeStatus("test failed");
display("Test result (FAILURE EXPECTED)", result);
AssertJUnit.assertNotNull(result);
OperationResult connectorConnectionResult = result.getSubresults().get(1);
AssertJUnit.assertNotNull(connectorConnectionResult);
System.out.println(
"Test \"connector connection\" result: "
+ connectorConnectionResult
+ " (FAILURE EXPECTED)");
AssertJUnit.assertTrue(
"Unexpected success of bad connector test", !connectorConnectionResult.isSuccess());
AssertJUnit.assertTrue(!result.isSuccess());
}
public static void setParsedResourceSchemaConditional(
ResourceType resourceType, ResourceSchema parsedSchema) {
if (hasParsedSchema(resourceType)) {
return;
}
PrismObject<ResourceType> resource = resourceType.asPrismObject();
resource.setUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA, parsedSchema);
}
@Test
public void test020AddResourceOpenDj() throws Exception {
final String TEST_NAME = "test020AddResourceOpenDj";
displayTestTitle(TEST_NAME);
LogfileTestTailer tailer = createLogTailer();
ResourceType resource = ModelClientUtil.unmarshallFile(RESOURCE_OPENDJ_FILE);
ObjectDeltaListType deltaList = new ObjectDeltaListType();
ObjectDeltaType delta = new ObjectDeltaType();
delta.setObjectType(getTypeQName(ResourceType.class));
delta.setChangeType(ChangeTypeType.ADD);
delta.setObjectToAdd(resource);
deltaList.getDelta().add(delta);
ModelExecuteOptionsType options = new ModelExecuteOptionsType();
options.setIsImport(Boolean.TRUE);
XMLGregorianCalendar startTs = TestUtil.currentTime();
// WHEN
ObjectDeltaOperationListType deltaOpList = modelPort.executeChanges(deltaList, options);
// THEN
assertSuccess(deltaOpList);
String oid = deltaOpList.getDeltaOperation().get(0).getObjectDelta().getOid();
XMLGregorianCalendar endTs = TestUtil.currentTime();
tailer.tail();
displayAudit(tailer);
assertAuditLoginLogout(tailer);
assertAuditIds(tailer);
assertAuditOperation(tailer, "ADD_OBJECT");
tailer.assertAudit(4);
assertEquals("Wrong OID", RESOURCE_OPENDJ_OID, oid);
ResourceType resourceAfter = getObject(ResourceType.class, RESOURCE_OPENDJ_OID);
display(resourceAfter);
assertEquals("Wrong connector OID", connectorLdapOid, resourceAfter.getConnectorRef().getOid());
assertCreateMetadata(resourceAfter, USER_ADMINISTRATOR_OID, startTs, endTs);
}
public static ExpressionVariables getDefaultXPathVariables(
UserType user, ShadowType shadow, ResourceType resource) {
ExpressionVariables variables = new ExpressionVariables();
if (user != null) {
variables.addVariableDefinition(ExpressionConstants.VAR_USER, user.asPrismObject());
}
if (shadow != null) {
variables.addVariableDefinition(ExpressionConstants.VAR_ACCOUNT, shadow.asPrismObject());
}
if (resource != null) {
variables.addVariableDefinition(ExpressionConstants.VAR_RESOURCE, resource.asPrismObject());
}
return variables;
}
@BeforeMethod
public void initUcf() throws Exception {
TestUtil.displayTestTile("initUcf");
File file = new File(FILENAME_RESOURCE_OPENDJ);
FileInputStream fis = new FileInputStream(file);
// Resource
PrismObject<ResourceType> resource =
PrismTestUtil.parseObject(new File(FILENAME_RESOURCE_OPENDJ));
resourceType = resource.asObjectable();
// Resource: Second copy for negative test cases
PrismObject<ResourceType> badResource =
PrismTestUtil.parseObject(new File(FILENAME_RESOURCE_OPENDJ_BAD));
badResourceType = badResource.asObjectable();
// Connector
PrismObject<ConnectorType> connector =
PrismTestUtil.parseObject(new File(FILENAME_CONNECTOR_LDAP));
connectorType = connector.asObjectable();
factory = connectorFactoryIcfImpl;
cc =
factory.createConnectorInstance(
connectorType, ResourceTypeUtil.getResourceNamespace(resourceType), "test connector");
AssertJUnit.assertNotNull("Cannot create connector instance", cc);
connectorSchema = cc.generateConnectorSchema();
AssertJUnit.assertNotNull("Cannot generate connector schema", cc);
display("Connector schema", connectorSchema);
OperationResult result = new OperationResult("initUcf");
cc.configure(resourceType.getConnectorConfiguration().asPrismContainerValue(), result);
cc.initialize(null, null, false, result);
// TODO: assert something
resourceSchema = cc.fetchResourceSchema(null, result);
display("Resource schema", resourceSchema);
AssertJUnit.assertNotNull(resourceSchema);
}
public static RefinedResourceSchema parse(ResourceType resourceType, PrismContext prismContext)
throws SchemaException {
ResourceSchema originalResourceSchema = getResourceSchema(resourceType, prismContext);
if (originalResourceSchema == null) {
return null;
}
String contextDescription = "definition of " + resourceType;
RefinedResourceSchemaImpl rSchema = new RefinedResourceSchemaImpl(originalResourceSchema);
SchemaHandlingType schemaHandling = resourceType.getSchemaHandling();
if (schemaHandling != null) {
parseObjectTypeDefsFromSchemaHandling(
rSchema,
resourceType,
schemaHandling,
schemaHandling.getObjectType(),
null,
prismContext,
contextDescription);
}
parseObjectTypesFromSchema(rSchema, resourceType, prismContext, contextDescription);
// We need to parse associations and auxiliary object classes in a second pass. We need to have
// all object classes parsed before correctly setting association
// targets
for (RefinedObjectClassDefinition rOcDef : rSchema.getRefinedDefinitions()) {
((RefinedObjectClassDefinitionImpl) rOcDef).parseAssociations(rSchema);
((RefinedObjectClassDefinitionImpl) rOcDef).parseAuxiliaryObjectClasses(rSchema);
}
// We can parse attributes only after we have all the object class info parsed (including
// auxiliary object classes)
for (RefinedObjectClassDefinition rOcDef : rSchema.getRefinedDefinitions()) {
((RefinedObjectClassDefinitionImpl) rOcDef).parseAttributes(rSchema, contextDescription);
}
return rSchema;
}
public static boolean hasParsedSchema(ResourceType resourceType) {
PrismObject<ResourceType> resource = resourceType.asPrismObject();
return resource.getUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA) != null;
}
public static ResourceSchema getResourceSchema(
ResourceType resourceType, PrismContext prismContext) throws SchemaException {
PrismObject<ResourceType> resource = resourceType.asPrismObject();
return getResourceSchema(resource, prismContext);
}
public static boolean hasRefinedSchema(ResourceType resourceType) {
PrismObject<ResourceType> resource = resourceType.asPrismObject();
return resource.getUserData(USER_DATA_KEY_REFINED_SCHEMA) != null;
}
public static LayerRefinedResourceSchema getRefinedSchema(
ResourceType resourceType, LayerType layer, PrismContext prismContext)
throws SchemaException {
PrismObject<ResourceType> resource = resourceType.asPrismObject();
return getRefinedSchema(resource, layer, prismContext);
}
public static LayerRefinedResourceSchema getRefinedSchema(
ResourceType resourceType, LayerType layer) throws SchemaException {
return getRefinedSchema(resourceType, layer, resourceType.asPrismObject().getPrismContext());
}