public static String serializeObjectToXml(PrismObject<? extends ObjectType> object, PrismContext prismContext) { try { return prismContext.serializeObjectToString(object, PrismContext.LANG_XML); } catch (SchemaException e) { throw new SystemException("Couldn't serialize a PrismObject " + object + " into XML", e); } }
public static String serializeObjectToString(PrismObject<? extends Objectable> object, String language) throws SchemaException { return getPrismContext().serializeObjectToString(object, language); }
public static String serializeObjectToString(PrismObject<? extends Objectable> object) throws SchemaException { return getPrismContext().serializeObjectToString(object, PrismContext.LANG_XML); }
PrismObject o = prismContext.parseObject(f); String s = prismContext.serializeObjectToString(o, PrismContext.LANG_YAML); System.out.println("parsed: " + s); String fname = f.getName(); writer.close(); s = prismContext.serializeObjectToString(o, PrismContext.LANG_JSON); System.out.println("parsed: " + s);
private void serializeAndValidate(PrismObject<UserType> user, PrismContext prismContext) throws SchemaException, SAXException, IOException { String xmlString = prismContext.serializeObjectToString(user, PrismContext.LANG_XML); System.out.println("Serialized XML"); System.out.println(xmlString); Document xmlDocument = DOMUtil.parseDocument(xmlString); Schema javaxSchema = prismContext.getSchemaRegistry().getJavaxSchema(); Validator validator = javaxSchema.newValidator(); validator.setResourceResolver(prismContext.getEntityResolver()); validator.validate(new DOMSource(xmlDocument)); }
private void roundTrip(final String TEST_NAME, File file, QName elementName) throws Exception { System.out.println("\n\n===[ "+TEST_NAME+" ]===\n"); // GIVEN PrismContext prismContext = getPrismContext(); // WHEN PrismObject<ObjectTemplateType> object = prismContext.parseObject(file); // THEN System.out.println("Parsed object:"); System.out.println(object.debugDump()); assertObjectTemplate(object, elementName); // do NOT go to the assertObjectTemplateInternals(...) // that will parse the raw values and it may change the clean state // WHEN String xml = prismContext.serializeObjectToString(object, PrismContext.LANG_XML); // THEN System.out.println("Serialized object:"); System.out.println(xml); assertSerializedObject(xml, elementName); // WHEN PrismObject<ObjectTemplateType> reparsedObject = prismContext.parseObject(xml); // THEN System.out.println("Re-parsed object:"); System.out.println(reparsedObject.debugDump()); assertObjectTemplate(reparsedObject, elementName); assertObjectTemplateInternals(reparsedObject, elementName); }
@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); }
@Test public void testResourceSchemaSerializationInResource() throws SchemaException, JAXBException { System.out.println("\n===[ testResourceSchemaSerializationInResource ]====="); // GIVEN ResourceSchema schema = createResourceSchema(); // WHEN Document xsdDocument = schema.serializeToXsd(); Element xsdElement = DOMUtil.getFirstChildElement(xsdDocument); PrismObject<ResourceType> resource = wrapInResource(xsdElement); String resourceXmlString = PrismTestUtil.getPrismContext().serializeObjectToString(resource, PrismContext.LANG_XML); System.out.println("Serialized resource"); System.out.println(resourceXmlString); PrismObject<ResourceType> reparsedResource = PrismTestUtil.getPrismContext().parseObject(resourceXmlString); System.out.println("Re-parsed resource"); System.out.println(reparsedResource.debugDump()); XmlSchemaType reparsedSchemaType = reparsedResource.asObjectable().getSchema(); Element reparsedXsdElement = ObjectTypeUtil.findXsdElement(reparsedSchemaType); System.out.println("Reparsed XSD schema"); System.out.println(DOMUtil.serializeDOMToString(reparsedXsdElement)); assertDomSchema(reparsedXsdElement); }
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()); } }
String serializedGeneric = prismContext.serializeObjectToString(generic, PrismContext.LANG_XML);
@Test public void testParseTableFileRoundTrip() throws Exception { System.out.println("===[ testParseTableFileRoundTrip ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN PrismObject<LookupTableType> table = prismContext.parserFor(LOOKUP_TABLE_FILE).xml().parse(); // THEN System.out.println("Parsed table:"); System.out.println(table.debugDump()); assertTable(table); // WHEN String xml = prismContext.serializeObjectToString(table, PrismContext.LANG_XML); // THEN System.out.println("Serialized object:"); System.out.println(xml); // WHEN PrismObject<ObjectTemplateType> reparsedObject = prismContext.parseObject(xml); // THEN System.out.println("Re-parsed object:"); System.out.println(reparsedObject.debugDump()); assertTable(table); PrismAsserts.assertEquals(table.asObjectable(), reparsedObject.asObjectable()); }
@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); }
String serializedTask = prismContext.serializeObjectToString(task, PrismContext.LANG_XML);
String marshalledResource = prismContext.serializeObjectToString(resource, PrismContext.LANG_XML);
@Test public void test500UserElisabethRoundTrip() throws Exception { final String TEST_NAME = "test500UserElisabethRoundTrip"; PrismInternalTestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext prismContext = constructInitializedPrismContext(); // WHEN PrismObject<UserType> user = prismContext.parseObject(getFile(USER_ELISABETH_FILE_BASENAME)); // THEN System.out.println("User:"); System.out.println(user.debugDump()); assertNotNull(user); assertUserElisabeth(user); // WHEN String serialized = prismContext.serializeObjectToString(user, getOutputFormat()); // THEN assertNotNull(serialized); System.out.println("Serialized user:"); System.out.println(serialized); // WHEN PrismObject<UserType> reparsedUser = prismContext.parseObject(serialized); // THEN System.out.println("Re-parsed user:"); System.out.println(reparsedUser.debugDump()); assertNotNull(reparsedUser); assertUserElisabeth(reparsedUser); }
private void roundTripAdhoc(File file) throws SchemaException, SAXException, IOException { // GIVEN PrismContext prismContext = constructInitializedPrismContext(); PrismObject<UserType> originalUser = prismContext.parseObject(file); System.out.println("Input parsed user:"); System.out.println(originalUser.debugDump()); assertNotNull(originalUser); // precondition assertUserAdhoc(originalUser, true); // WHEN // We need to serialize with composite objects during roundtrip, otherwise the result will not be equal String userXml = prismContext.serializeObjectToString(originalUser, getOutputFormat()); // THEN System.out.println("Serialized user:"); System.out.println(userXml); assertNotNull(userXml); validateXml(userXml, prismContext); // WHEN PrismObject<UserType> parsedUser = prismContext.parseObject(userXml); System.out.println("Re-parsed user:"); System.out.println(parsedUser.debugDump()); assertNotNull(parsedUser); assertUserAdhoc(parsedUser, true); assertTrue("Users not equal", originalUser.equals(parsedUser)); }
String xmlBroken = getPrismContext().serializeObjectToString(resourceBroken, PrismContext.LANG_XML); ObjectDelta<ResourceType> resourceDelta = resourceBroken.diff(resourceFixed, EquivalenceStrategy.LITERAL_IGNORE_METADATA); resourceDelta.applyTo(resourceUpdated); String xmlUpdated = getPrismContext().serializeObjectToString(resourceUpdated, PrismContext.LANG_XML); System.out.println("UPDATED RESOURCE:"); System.out.println(xmlUpdated);
@Test public void test480ListResources() throws Exception { final String TEST_NAME = "test480ListResources"; displayTestTitle(TEST_NAME); // GIVEN OperationResultType result = new OperationResultType(); Holder<OperationResultType> resultHolder = new Holder<>(result); Holder<ObjectListType> objectListHolder = new Holder<>(); SelectorQualifiedGetOptionsType options = new SelectorQualifiedGetOptionsType(); // WHEN modelWeb.searchObjects(ObjectTypes.RESOURCE.getTypeQName(), null, options, objectListHolder, resultHolder); // THEN display("Resources", objectListHolder.value); assertEquals("Unexpected number of resources", 4, objectListHolder.value.getObject().size()); // TODO for(ObjectType object: objectListHolder.value.getObject()) { // Marshalling may fail even though the Java object is OK so test for it String xml = prismContext.serializeObjectToString(object.asPrismObject(), PrismContext.LANG_XML); } }
protected void assertHasSchema(PrismObject<ResourceType> resource, String desc) throws SchemaException { ResourceType resourceType = resource.asObjectable(); display("Resource "+desc, resourceType); XmlSchemaType xmlSchemaTypeAfter = resourceType.getSchema(); assertNotNull("No schema in "+desc, xmlSchemaTypeAfter); Element resourceXsdSchemaElementAfter = ResourceTypeUtil.getResourceXsdSchema(resourceType); assertNotNull("No schema XSD element in "+desc, resourceXsdSchemaElementAfter); String resourceXml = prismContext.serializeObjectToString(resource, PrismContext.LANG_XML); // display("Resource XML", resourceXml); CachingMetadataType cachingMetadata = xmlSchemaTypeAfter.getCachingMetadata(); assertNotNull("No caching metadata in "+desc, cachingMetadata); assertNotNull("No retrievalTimestamp in "+desc, cachingMetadata.getRetrievalTimestamp()); assertNotNull("No serialNumber in "+desc, cachingMetadata.getSerialNumber()); Element xsdElement = ObjectTypeUtil.findXsdElement(xmlSchemaTypeAfter); ResourceSchema parsedSchema = ResourceSchemaImpl.parse(xsdElement, resource.toString(), prismContext); assertNotNull("No schema after parsing in "+desc, parsedSchema); }
assertNotNull("No schema after test connection", resourceXsdSchemaElementAfter); String resourceXml = prismContext.serializeObjectToString(resourceRepoAfter, PrismContext.LANG_XML); display("Resource XML", resourceXml);