@Test public void testIterationCondition() throws Exception { final String TEST_NAME = "testIterationCondition"; TestUtil.displayTestTile(TEST_NAME); // GIVEN OperationResult result = new OperationResult(TestExpression.class.getName() + "." + TEST_NAME); rememberScriptExecutionCount(); ExpressionType expressionType = PrismTestUtil.parseAtomicValue( EXPRESSION_ITERATION_CONDITION_FILE, ExpressionType.COMPLEX_TYPE); PrismPropertyDefinition<Boolean> outputDefinition = new PrismPropertyDefinitionImpl<Boolean>( ExpressionConstants.OUTPUT_ELMENT_NAME, DOMUtil.XSD_BOOLEAN, prismContext); Expression<PrismPropertyValue<Boolean>, PrismPropertyDefinition<Boolean>> expression = expressionFactory.makeExpression(expressionType, outputDefinition, TEST_NAME, null, result); ExpressionVariables variables = new ExpressionVariables(); PrismObject<UserType> user = PrismTestUtil.parseObject(USER_JACK_FILE); variables.addVariableDefinition(ExpressionConstants.VAR_FOCUS, user); variables.addVariableDefinition(ExpressionConstants.VAR_USER, user); PrismObject<ShadowType> account = PrismTestUtil.parseObject(ACCOUNT_JACK_DUMMYFILE); variables.addVariableDefinition(ExpressionConstants.VAR_SHADOW, account); variables.addVariableDefinition(ExpressionConstants.VAR_ITERATION, 1); variables.addVariableDefinition(ExpressionConstants.VAR_ITERATION_TOKEN, "001"); ExpressionEvaluationContext expressionContext = new ExpressionEvaluationContext(null, variables, TEST_NAME, null, result); // WHEN PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple = expression.evaluate(expressionContext); // THEN assertNotNull(outputTriple); outputTriple.checkConsistence(); // Make sure that the script is executed only once. There is no delta in the variables, no need // to do it twice. assertScriptExecutionIncrement(1); }
@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); }
@Test(enabled = true) public void test010FormatUser() throws Exception { // GIVEN PrismObject<UserType> jack = PrismTestUtil.parseObject(new File(USER_JACK_FILE)); System.out.println(jack.debugDump()); // WHEN String jackFormattedHideNone = textFormatter.formatObject(jack, null, true); System.out.println("no hidden paths + show operational attributes: " + jackFormattedHideNone); String jackFormattedHideOper = textFormatter.formatObject(jack, null, false); System.out.println("no hidden paths + hide operational attributes: " + jackFormattedHideOper); String jackFormattedHideAux = textFormatter.formatObject(jack, auxiliaryPaths, true); System.out.println( "hide auxiliary paths + show operational attributes: " + jackFormattedHideAux); String jackFormattedHideAuxAndOper = textFormatter.formatObject(jack, auxiliaryPaths, false); System.out.println( "hide auxiliary paths + hide operational attributes: " + jackFormattedHideAuxAndOper); // THEN assertTrue( "hidden operational attribute when it should be shown ('hide none')", jackFormattedHideNone.contains("createTimestamp:")); assertTrue( "hidden auxiliary attribute (effective status) when it should be shown ('hide none')", jackFormattedHideNone.contains("Effective Status: ENABLED")); assertTrue( "hidden auxiliary attribute (family name) when it should be shown ('hide none')", jackFormattedHideNone.contains("Family Name: Sparrow")); assertTrue( "hidden standard attribute when it should be shown ('hide none')", jackFormattedHideNone.contains("ship: Black Pearl")); assertTrue( "shown operational attribute when it should be hidden ('hide oper')", !jackFormattedHideOper.contains("createTimestamp:")); assertTrue( "hidden auxiliary attribute when it should be shown ('hide oper')", jackFormattedHideOper.contains("Effective Status: ENABLED")); assertTrue( "hidden auxiliary attribute (family name) when it should be shown ('hide oper')", jackFormattedHideOper.contains("Family Name: Sparrow")); assertTrue( "hidden standard attribute when it should be shown ('hide oper')", jackFormattedHideOper.contains("ship: Black Pearl")); assertTrue( "shown auxiliary attribute (metadata) when it should be hidden ('hide aux')", !jackFormattedHideAux.contains("createTimestamp:")); assertTrue( "shown auxiliary attribute (family name) when it should be hidden ('hide aux')", !jackFormattedHideAux.contains("Family Name: Sparrow")); assertTrue( "shown auxiliary attribute (effective status) when it should be hidden ('hide aux')", !jackFormattedHideAux.contains("Effective Status: ENABLED")); assertTrue( "hidden standard attribute when it should be shown ('hide aux')", jackFormattedHideAux.contains("ship: Black Pearl")); assertTrue( "shown operational attribute when it should be hidden ('hide aux and oper')", !jackFormattedHideAuxAndOper.contains("createTimestamp:")); assertTrue( "shown auxiliary attribute (effective status) when it should be hidden ('hide aux and oper')", !jackFormattedHideAuxAndOper.contains("Effective Status: ENABLED")); assertTrue( "shown auxiliary attribute (family name) when it should be hidden ('hide aux and oper')", !jackFormattedHideAuxAndOper.contains("Family Name: Sparrow")); assertTrue( "hidden standard attribute when it should be shown ('hide aux and oper')", jackFormattedHideAuxAndOper.contains("ship: Black Pearl")); }
@Test(enabled = true) public void test030FormatAccount() throws Exception { // GIVEN PrismObject<ShadowType> jack = PrismTestUtil.parseObject(new File(ACCOUNT_JACK_FILE)); System.out.println(jack.debugDump()); // WHEN String jackFormattedHideNone = textFormatter.formatAccountAttributes(jack.asObjectable(), null, true); System.out.println("no hidden paths + show operational attributes: " + jackFormattedHideNone); String jackFormattedHideAux = textFormatter.formatAccountAttributes(jack.asObjectable(), auxiliaryPaths, true); System.out.println( "hide auxiliary paths + show operational attributes: " + jackFormattedHideAux); // THEN assertTrue("account name is not shown", jackFormattedHideNone.contains("Name: jack")); assertTrue( "account password is not shown", jackFormattedHideNone.contains("(protected string)")); assertTrue( "administrative status is not shown", jackFormattedHideNone.contains("Administrative Status: ENABLED")); assertTrue( "effective status is not shown", jackFormattedHideNone.contains("Effective Status: ENABLED")); assertTrue("account name is not shown", jackFormattedHideAux.contains("Name: jack")); assertTrue( "account password is not shown", jackFormattedHideAux.contains("(protected string)")); assertTrue( "administrative status is not shown", jackFormattedHideAux.contains("Administrative Status: ENABLED")); assertTrue( "effective status is shown although it should be hidden", !jackFormattedHideAux.contains("Effective Status: ENABLED")); // AssertJUnit.assertTrue("hidden operational attribute when it should be shown ('hide // none')", jackFormattedHideNone.contains("createTimestamp:")); // AssertJUnit.assertTrue("hidden auxiliary attribute (effective status) when it should // be shown ('hide none')", jackFormattedHideNone.contains("Effective Status: ENABLED")); // AssertJUnit.assertTrue("hidden auxiliary attribute (family name) when it should be // shown ('hide none')", jackFormattedHideNone.contains("Family Name: Sparrow")); // AssertJUnit.assertTrue("hidden standard attribute when it should be shown ('hide // none')", jackFormattedHideNone.contains("ship: Black Pearl")); // // AssertJUnit.assertTrue("shown operational attribute when it should be hidden ('hide // oper')", !jackFormattedHideOper.contains("createTimestamp:")); // AssertJUnit.assertTrue("hidden auxiliary attribute when it should be shown ('hide // oper')", jackFormattedHideOper.contains("Effective Status: ENABLED")); // AssertJUnit.assertTrue("hidden auxiliary attribute (family name) when it should be // shown ('hide oper')", jackFormattedHideOper.contains("Family Name: Sparrow")); // AssertJUnit.assertTrue("hidden standard attribute when it should be shown ('hide // oper')", jackFormattedHideOper.contains("ship: Black Pearl")); // // AssertJUnit.assertTrue("shown auxiliary attribute (metadata) when it should be hidden // ('hide aux')", !jackFormattedHideAux.contains("createTimestamp:")); // AssertJUnit.assertTrue("shown auxiliary attribute (family name) when it should be // hidden ('hide aux')", !jackFormattedHideAux.contains("Family Name: Sparrow")); // AssertJUnit.assertTrue("shown auxiliary attribute (effective status) when it should be // hidden ('hide aux')", !jackFormattedHideAux.contains("Effective Status: ENABLED")); // AssertJUnit.assertTrue("hidden standard attribute when it should be shown ('hide // aux')", jackFormattedHideAux.contains("ship: Black Pearl")); // // AssertJUnit.assertTrue("shown operational attribute when it should be hidden ('hide // aux and oper')", !jackFormattedHideAuxAndOper.contains("createTimestamp:")); // AssertJUnit.assertTrue("shown auxiliary attribute (effective status) when it should be // hidden ('hide aux and oper')", !jackFormattedHideAuxAndOper.contains("Effective Status: // ENABLED")); // AssertJUnit.assertTrue("shown auxiliary attribute (family name) when it should be // hidden ('hide aux and oper')", !jackFormattedHideAuxAndOper.contains("Family Name: // Sparrow")); // AssertJUnit.assertTrue("hidden standard attribute when it should be shown ('hide aux // and oper')", jackFormattedHideAuxAndOper.contains("ship: Black Pearl")); }
@Test(enabled = true) public void test020FormatUserModification() throws Exception { // GIVEN ObjectDelta<UserType> delta = parseDelta(USER_JACK_MODIFICATION_FILE); PrismObject<UserType> jack = PrismTestUtil.parseObject(new File(USER_JACK_FILE)); System.out.println(delta.debugDump()); // WHEN String deltaFormattedHideNone = textFormatter.formatObjectModificationDelta(delta, null, true, jack, null); System.out.println("no hidden paths + show operational attributes: " + deltaFormattedHideNone); String deltaFormattedHideOper = textFormatter.formatObjectModificationDelta(delta, null, false, jack, null); System.out.println("no hidden paths + hide operational attributes: " + deltaFormattedHideOper); String deltaFormattedHideAux = textFormatter.formatObjectModificationDelta(delta, auxiliaryPaths, true, jack, null); System.out.println( "hide auxiliary paths + show operational attributes: " + deltaFormattedHideAux); String deltaFormattedHideAuxAndOper = textFormatter.formatObjectModificationDelta(delta, auxiliaryPaths, false, jack, null); System.out.println( "hide auxiliary paths + hide operational attributes: " + deltaFormattedHideAuxAndOper); // THEN checkNotes(deltaFormattedHideAux); checkNotes(deltaFormattedHideAuxAndOper); checkNotes(deltaFormattedHideNone); checkNotes(deltaFormattedHideOper); assertTrue( "hidden operational attribute when it should be shown ('hide none')", deltaFormattedHideNone.contains("createTimestamp:")); assertTrue( "hidden auxiliary attribute (family name) when it should be shown ('hide none')", deltaFormattedHideNone.contains("SPARROW")); assertTrue( "hidden password change when it should be shown ('hide none')", deltaFormattedHideNone.contains("(protected string)")); assertTrue( "hidden standard attribute when it should be shown ('hide none')", deltaFormattedHideNone.contains("BLACK PEARL")); assertTrue( "shown operational attribute when it should be hidden ('hide oper')", !deltaFormattedHideOper.contains("createTimestamp:")); assertTrue( "hidden auxiliary attribute (family name) when it should be shown ('hide oper')", deltaFormattedHideOper.contains("SPARROW")); assertTrue( "hidden password change when it should be shown ('hide oper')", deltaFormattedHideOper.contains("(protected string)")); assertTrue( "hidden standard attribute when it should be shown ('hide oper')", deltaFormattedHideOper.contains("BLACK PEARL")); assertTrue( "shown auxiliary attribute (metadata) when it should be hidden ('hide aux')", !deltaFormattedHideAux.contains("createTimestamp:")); assertTrue( "shown auxiliary attribute (family name) when it should be hidden ('hide aux')", !deltaFormattedHideAux.contains("SPARROW")); assertTrue( "hidden standard attribute when it should be shown ('hide aux')", deltaFormattedHideAux.contains("BLACK PEARL")); assertTrue( "shown operational attribute when it should be hidden ('hide aux and oper')", !deltaFormattedHideAuxAndOper.contains("createTimestamp:")); assertTrue( "shown auxiliary attribute (family name) when it should be hidden ('hide aux and oper')", !deltaFormattedHideAuxAndOper.contains("SPARROW")); assertTrue( "hidden standard attribute when it should be shown ('hide aux and oper')", deltaFormattedHideAuxAndOper.contains("BLACK PEARL")); }