public static <O extends Objectable> void assertEquivalent(File expectedFile, PrismObject<O> actual) throws SchemaException, IOException { assertEquivalent("Object "+actual+" not equivalent to that from file "+expectedFile,expectedFile,actual); }
public static <O extends Objectable> void assertEquivalent(String message, File expectedFile, PrismObject<O> actual) throws SchemaException, IOException { PrismObject<O> expected = toPrism(expectedFile); assertEquivalent(message, expected, actual); }
@Override public String answer(InvocationOnMock invocation) throws Throwable { PrismObject<ResourceType> resource = (PrismObject<ResourceType>) invocation.getArguments()[0]; PrismAsserts.assertEquivalent("Wrong argument to addObject", expectedResource, resource); return oid; } });
@Override public String answer(InvocationOnMock invocation) throws Throwable { PrismObject<UserType> user = (PrismObject<UserType>) invocation.getArguments()[0]; IntegrationTestTools.display("Got user", user); PrismAsserts.assertEquivalent("Unexpected argument to addObject", expectedUser, user); return oid; } });
private void checkTable(String tableOid, PrismObject<LookupTableType> expectedObject, OperationResult result) throws SchemaException, ObjectNotFoundException { SelectorOptions<GetOperationOptions> retrieve = SelectorOptions.create(prismContext.toUniformPath(F_ROW), GetOperationOptions.createRetrieve(INCLUDE)); PrismObject<LookupTableType> table = repositoryService.getObject(LookupTableType.class, tableOid, Arrays.asList(retrieve), result); expectedObject.setOid(tableOid); PrismAsserts.assertEquivalent("Table is not as expected", expectedObject, table); }
@Test public void testParsePolicyRoundtrip() throws Exception { System.out.println("===[ testParsePolicyRoundtrip ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); PrismObject<ValuePolicyType> policy = prismContext.parseObject(FILE); System.out.println("Parsed policy:"); System.out.println(policy.debugDump()); assertPolicy(policy); // SERIALIZE String serializedPolicy = prismContext.serializeObjectToString(policy, PrismContext.LANG_XML); System.out.println("serialized policy:"); System.out.println(serializedPolicy); // RE-PARSE PrismObject<ValuePolicyType> reparsedPolicy = prismContext.parseObject(serializedPolicy); System.out.println("Re-parsed policy:"); System.out.println(reparsedPolicy.debugDump()); // Cannot assert here. It will cause parsing of some of the raw values and diff will fail assertPolicy(reparsedPolicy); ObjectDelta<ValuePolicyType> objectDelta = policy.diff(reparsedPolicy); System.out.println("Delta:"); System.out.println(objectDelta.debugDump()); assertTrue("Delta is not empty", objectDelta.isEmpty()); PrismAsserts.assertEquivalent("Policy re-parsed equivalence", policy, reparsedPolicy); }
assertTrue("Delta is not empty", objectDelta.isEmpty()); PrismAsserts.assertEquivalent("generic object re-parsed quivalence", generic, reparsedGeneric);
@Test public void testParseTaskRoundtrip() throws Exception { System.out.println("===[ testParseTaskRoundtrip ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); PrismObject<TaskType> task = prismContext.parseObject(TASK_FILE); System.out.println("Parsed task:"); System.out.println(task.debugDump()); assertTask(task); // SERIALIZE String serializedTask = prismContext.serializeObjectToString(task, PrismContext.LANG_XML); System.out.println("serialized task:"); System.out.println(serializedTask); // RE-PARSE RootXNode reparsedToXNode = prismContext.parserFor(serializedTask).xml().parseToXNode(); System.out.println("Re-parsed task (to XNode):"); System.out.println(reparsedToXNode.debugDump()); // real reparse PrismObject<TaskType> reparsedTask = prismContext.parseObject(serializedTask); System.out.println("Re-parsed task:"); System.out.println(reparsedTask.debugDump()); // Cannot assert here. It will cause parsing of some of the raw values and diff will fail assertTask(reparsedTask); ObjectDelta<TaskType> objectDelta = task.diff(reparsedTask); System.out.println("Delta:"); System.out.println(objectDelta.debugDump()); assertTrue("Delta is not empty", objectDelta.isEmpty()); PrismAsserts.assertEquivalent("Task re-parsed equivalence", task, reparsedTask); }
private <O extends ObjectType> void assertSimpleMigration(File fileOld, File fileNew) throws SchemaException, IOException { // GIVEN PrismObject<O> objectOld = prismContext.parseObject(fileOld); // WHEN PrismObject<O> objectNew = migrator.migrate(objectOld); // THEN IntegrationTestTools.display("Migrated object "+fileOld.getName(), objectNew); assertNotNull("No migrated object "+fileOld.getName(), objectNew); IntegrationTestTools.display("Migrated object "+fileOld.getName(), objectNew); String migratedXml = prismContext.serializeObjectToString(objectNew, PrismContext.LANG_XML); IntegrationTestTools.display("Migrated object XML "+fileOld.getName(), migratedXml); PrismObject<O> expectedObject = prismContext.parseObject(fileNew); IntegrationTestTools.display("Expected object "+fileOld.getName(), expectedObject); String expectedXml = prismContext.serializeObjectToString(expectedObject, PrismContext.LANG_XML); IntegrationTestTools.display("Expected object XML "+fileOld.getName(), expectedXml); List<String> expectedXmlLines = MiscUtil.splitLines(expectedXml); Patch patch = DiffUtils.diff(expectedXmlLines, MiscUtil.splitLines(migratedXml)); List<String> diffLines = DiffUtils.generateUnifiedDiff(fileOld.getPath(), fileNew.getPath(), expectedXmlLines, patch, 3); IntegrationTestTools.display("XML textual diff", StringUtils.join(diffLines, '\n')); PrismAsserts.assertEquivalent("Unexpected migration result for "+fileOld.getName(), expectedObject, objectNew); assertEquals("Unexpected element name for "+fileOld.getName(), expectedObject.getElementName(), objectNew.getElementName()); } }
assertTrue("Delta is not empty", objectDelta.isEmpty()); PrismAsserts.assertEquivalent("Task re-parsed equivalence", task, reparsedTask);
@Test public void test000SanityRolePirate() throws Exception { final String TEST_NAME = "test000SanityRolePirate"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); // WHEN PrismObject<RoleType> rolePirate = modelService.getObject(RoleType.class, ROLE_PIRATE_OID, null, task, result); // THEN display("Role pirate", rolePirate); IntegrationTestTools.displayXml("Role pirate", rolePirate); assertNotNull("No pirate", rolePirate); PrismAsserts.assertEquivalent(ROLE_PIRATE_FILE, rolePirate); }
assertTrue("Delta is not empty", objectDelta.isEmpty()); PrismAsserts.assertEquivalent("Resource re-parsed equivalence", resource, reparsedResource);
assertTrue("Delta is not empty", objectDelta.isEmpty()); PrismAsserts.assertEquivalent("Resource re-parsed equivalence", resource, reparsedResource);
private void checkCampaign(String campaignOid, OperationResult result, PrismObject<AccessCertificationCampaignType> expectedObject, List<ItemDelta> modifications, Integer expectedVersion) throws SchemaException, ObjectNotFoundException, IOException { expectedObject.setOid(campaignOid); if (modifications != null) { ItemDeltaCollectionsUtil.applyTo(modifications, expectedObject); } LOGGER.trace("Expected object = \n{}", expectedObject.debugDump()); PrismObject<AccessCertificationCampaignType> campaign = getFullCampaign(campaignOid, result); LOGGER.trace("Actual object from repo = \n{}", campaign.debugDump()); PrismAsserts.assertEquivalent("Campaign is not as expected", expectedObject, campaign); if (expectedVersion != null) { AssertJUnit.assertEquals("Incorrect version", (int) expectedVersion, Integer.parseInt(campaign.getVersion())); } }
PrismAsserts.assertEquivalent("Table is not as expected", expectedObject, actualObject);
assertNotNull("No object in opponent ref value (reparsed)", reparsedUserBarbossa); PrismAsserts.assertEquivalent("User barbossa", userBarbossa, reparsedUserBarbossa); PrismAsserts.assertEquivalent("User jack", userJack, reparsedUserJack);
resourceAfter.checkConsistence(); PrismAsserts.assertEquivalent("Resources after roundtrip not equivalent", resourceAfter, resourceBefore);