@Test public void testParseObjectsIteratively_2_Wrong_2() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_2_Wrong_2"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); try { lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_2_WRONG_2), PrismTestUtil.createDefaultParsingContext(), node -> { nodes.add(node); return true; }); fail("unexpected success"); } catch (SchemaException e) { System.out.println("Got expected exception: " + e); } // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 3, nodes.size()); }
@Test public void testParseObjectsIteratively_5_error() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_5_error"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); try { lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_5_ERROR), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); } catch (SchemaException e) { System.out.println("Got expected exception: " + e); } // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 1, nodes.size()); // WHEN+THEN (parse in standard way) try { lexicalProcessor.readObjects(getFileSource(OBJECTS_5_ERROR), createDefaultParsingContext()); } catch (Exception e) { // SchemaException for JSON/YAML, IllegalStateException for XML (do something about this) System.out.println("Got expected exception: " + e); } }
protected List<RootXNodeImpl> standardTest(String TEST_NAME, String fileName, int expectedCount) throws SchemaException, IOException { displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(fileName), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", expectedCount, nodes.size()); // WHEN+THEN (parse in standard way) List<RootXNodeImpl> nodesStandard = lexicalProcessor.readObjects(getFileSource(fileName), createDefaultParsingContext()); System.out.println("Parsed objects (standard way):"); System.out.println(DebugUtil.debugDump(nodesStandard)); assertEquals("Nodes are different", nodesStandard, nodes); return nodes; }
@Test public void testParseObjectsIteratively_7_single() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_7_single"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_7_SINGLE), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 1, nodes.size()); final String NS_C = "http://midpoint.evolveum.com/xml/ns/public/common/common-3"; nodes.forEach(n -> assertEquals("Wrong namespace", NS_C, n.getRootElementName().getNamespaceURI())); // WHEN+THEN (parse in standard way) List<RootXNodeImpl> nodesStandard = lexicalProcessor.readObjects(getFileSource(OBJECTS_7_SINGLE), createDefaultParsingContext()); System.out.println("Parsed objects (standard way):"); System.out.println(DebugUtil.debugDump(nodesStandard)); assertEquals("Nodes are different", nodesStandard, nodes); }
@Test public void testParseObjectsIteratively_8_multiDocument() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_8_multiDocument"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_8_MULTI_DOCUMENT), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 4, nodes.size()); final String NS_C = "http://midpoint.evolveum.com/xml/ns/public/common/common-3"; Iterator<RootXNodeImpl> i = nodes.iterator(); assertEquals("Wrong namespace for node 1", NS_C, i.next().getRootElementName().getNamespaceURI()); assertEquals("Wrong namespace for node 2", NS_C, i.next().getRootElementName().getNamespaceURI()); assertEquals("Wrong namespace for node 3", "", i.next().getRootElementName().getNamespaceURI()); assertEquals("Wrong namespace for node 4", "http://a/", i.next().getRootElementName().getNamespaceURI()); // WHEN+THEN (parse in standard way) List<RootXNodeImpl> nodesStandard = lexicalProcessor.readObjects(getFileSource(OBJECTS_8_MULTI_DOCUMENT), createDefaultParsingContext()); System.out.println("Parsed objects (standard way):"); System.out.println(DebugUtil.debugDump(nodesStandard)); assertEquals("Nodes are different", nodesStandard, nodes); }
@Test public void testParseObjectsIteratively_1_FirstTwo() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_1_FirstTwo"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_1), createDefaultParsingContext(), node -> { nodes.add(node); return nodes.size() != 2; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 2, nodes.size()); final String NS_C = "http://midpoint.evolveum.com/xml/ns/public/common/common-3"; nodes.forEach(n -> assertEquals("Wrong namespace", NS_C, n.getRootElementName().getNamespaceURI())); assertEquals("Wrong namespace for node 1", NS_C, getFirstElementNS(nodes, 0)); assertEquals("Wrong namespace for node 2", NS_C, getFirstElementNS(nodes, 1)); }
@Test public void testParseObjectsIteratively_6_single() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_6_single"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_6_SINGLE), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 1, nodes.size()); final String NS_C = "http://midpoint.evolveum.com/xml/ns/public/common/common-3"; nodes.forEach(n -> assertEquals("Wrong namespace", NS_C, n.getRootElementName().getNamespaceURI())); assertEquals("Wrong namespace for node 1", NS_C, getFirstElementNS(nodes, 0)); // WHEN+THEN (parse in standard way) List<RootXNodeImpl> nodesStandard = lexicalProcessor.readObjects(getFileSource(OBJECTS_6_SINGLE), createDefaultParsingContext()); System.out.println("Parsed objects (standard way):"); System.out.println(DebugUtil.debugDump(nodesStandard)); assertEquals("Nodes are different", nodesStandard, nodes); }
@Test public void testParseResourceRumToPrism() throws Exception { final String TEST_NAME = "testParseResourceRumToPrism"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor lexicalProcessor = createParser(); PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN (parse to xnode) RootXNodeImpl xnode = lexicalProcessor.read(getFileSource(RESOURCE_RUM_FILE_BASENAME), createDefaultParsingContext()); System.out.println("XNode after parsing:"); System.out.println(xnode.debugDump()); // WHEN (parse to prism) PrismObject<ResourceType> resource = prismContext.parserFor(xnode).parse(); // THEN System.out.println("Parsed resource:"); System.out.println(resource.debugDump()); assertResourceRum(resource); }
@Test(enabled = false) public void testParseEventHandler() throws Exception { final String TEST_NAME = "testParseEventHandler"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor lexicalProcessor = createParser(); PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN (parse to xnode) RootXNodeImpl xnode = lexicalProcessor.read(getFileSource(EVENT_HANDLER_FILE_BASENAME), createDefaultParsingContext()); System.out.println("XNode after parsing:"); System.out.println(xnode.debugDump()); // WHEN (parse to prism) EventHandlerType eventHandlerType = prismContext.parserFor(xnode).parseRealValue(EventHandlerChainType.class); // THEN System.out.println("Parsed object:"); System.out.println(eventHandlerType); // WHEN2 (marshalling) MapXNodeImpl marshalled = (MapXNodeImpl) (prismContext.xnodeSerializer().serializeRealValue(eventHandlerType).getSubnode()); System.out.println("XNode after unmarshalling and marshalling back:"); System.out.println(marshalled.debugDump()); }
@Test public void testParseResourceDom() throws Exception { if (!"xml".equals(language)) { return; } final String TEST_NAME = "testParseResourceDom"; displayTestTitle(TEST_NAME); // GIVEN PrismContext prismContext = getPrismContext(); // WHEN DomLexicalProcessor parserDom = ((PrismContextImpl) prismContext).getParserDom(); RootXNode xnode = parserDom.read(new ParserFileSource(getFile(TestConstants.RESOURCE_FILE_BASENAME)), createDefaultParsingContext()); PrismObject<ResourceType> resource = prismContext.parserFor(xnode).parse(); // THEN System.out.println("Parsed resource:"); System.out.println(resource.debugDump()); assertResource(resource, true, true, false); }
@Test public void testParseObjectsIteratively_3_NS() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_3_NS"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_3_NS), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 3, nodes.size()); nodes.forEach(n -> assertEquals("Wrong namespace", "http://a/", n.getRootElementName().getNamespaceURI())); assertEquals("Wrong namespace for node 1", "http://b/", getFirstElementNS(nodes, 0)); assertEquals("Wrong namespace for node 2", "http://c/", getFirstElementNS(nodes, 1)); assertEquals("Wrong namespace for node 3", "http://d/", getFirstElementNS(nodes, 2)); // WHEN+THEN (parse in standard way) List<RootXNodeImpl> nodesStandard = lexicalProcessor.readObjects(getFileSource(OBJECTS_3_NS), createDefaultParsingContext()); System.out.println("Parsed objects (standard way):"); System.out.println(DebugUtil.debugDump(nodesStandard)); assertEquals("Nodes are different", nodesStandard, nodes); }
lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_2_WRONG), PrismTestUtil.createDefaultParsingContext(), node -> { nodes.add(node); .createDefaultParsingContext());
@Test public void testParseUserToPrism() throws Exception { final String TEST_NAME = "testParseUserToPrism"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor lexicalProcessor = createParser(); PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN (parse to xnode) RootXNodeImpl xnode = lexicalProcessor.read(getFileSource(USER_JACK_FILE_BASENAME), createDefaultParsingContext()); System.out.println("XNode after parsing:"); System.out.println(xnode.debugDump()); // WHEN (parse to prism) PrismObject<UserType> user = prismContext.parserFor(xnode).parse(); // THEN System.out.println("Parsed user:"); System.out.println(user.debugDump()); assertUserJackXNodeOrdering("serialized xnode", xnode); assertUserJack(user, true); }
@Test public void testParseObjectsIteratively_4_noRootNs() throws Exception { final String TEST_NAME = "testParseObjectsIteratively_4_noRootNs"; displayTestTitle(TEST_NAME); // GIVEN LexicalProcessor<String> lexicalProcessor = createParser(); // WHEN (parse to xnode) List<RootXNodeImpl> nodes = new ArrayList<>(); lexicalProcessor.readObjectsIteratively(getFileSource(OBJECTS_4_NO_ROOT_NS), createDefaultParsingContext(), node -> { nodes.add(node); return true; }); // THEN System.out.println("Parsed objects (iteratively):"); System.out.println(DebugUtil.debugDump(nodes)); assertEquals("Wrong # of nodes read", 3, nodes.size()); nodes.forEach(n -> assertEquals("Wrong namespace", "", n.getRootElementName().getNamespaceURI())); assertEquals("Wrong namespace for node 1", "http://b/", getFirstElementNS(nodes, 0)); assertEquals("Wrong namespace for node 2", "http://c/", getFirstElementNS(nodes, 1)); assertEquals("Wrong namespace for node 3", "http://d/", getFirstElementNS(nodes, 2)); // WHEN+THEN (parse in standard way) List<RootXNodeImpl> nodesStandard = lexicalProcessor.readObjects(getFileSource(OBJECTS_4_NO_ROOT_NS), createDefaultParsingContext()); System.out.println("Parsed objects (standard way):"); System.out.println(DebugUtil.debugDump(nodesStandard)); assertEquals("Nodes are different", nodesStandard, nodes); }
@Test public void testParseProtectedStringEncrypted() throws Exception { final String TEST_NAME = "testParseProtectedStringEncrypted"; displayTestTitle(TEST_NAME); // GIVEN Protector protector = PrismInternalTestUtil.createProtector(XMLCipher.AES_128); ProtectedStringType protectedStringType = protector.encryptString("salalala"); PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN MapXNodeImpl protectedStringTypeXNode = ((PrismContextImpl) prismContext).getBeanMarshaller().marshalProtectedDataType(protectedStringType, null); System.out.println("Protected string type XNode: " + protectedStringTypeXNode.debugDump()); // THEN ProtectedStringType unmarshalled = new ProtectedStringType(); prismContext.hacks().parseProtectedType(unmarshalled, protectedStringTypeXNode, prismContext, createDefaultParsingContext()); System.out.println("Unmarshalled value: " + unmarshalled); assertEquals("Unmarshalled value differs from the original", protectedStringType, unmarshalled); }
RootXNodeImpl xnode = lexicalProcessor.read(getFileSource(RESOURCE_RUM_FILE_BASENAME), createDefaultParsingContext()); PrismObject<ResourceType> resource = prismContext.parserFor(xnode).parse(); RootXNodeImpl reparsedXnode = lexicalProcessor.read(new ParserStringSource(serializedString), createDefaultParsingContext()); PrismObject<ResourceType> reparsedResource = prismContext.parserFor(reparsedXnode).parse();
RootXNodeImpl xnode = lexicalProcessor.read(getFileSource(USER_JACK_FILE_BASENAME), createDefaultParsingContext()); System.out.println("\nParsed xnode:"); System.out.println(xnode.debugDump()); RootXNodeImpl reparsedXnode = lexicalProcessor.read(new ParserStringSource(serializedString), createDefaultParsingContext()); PrismObject<UserType> reparsedUser = prismContext.parserFor(reparsedXnode).parse();
@Test public void testParseUserToXNode() throws Exception { final String TEST_NAME = "testParseUserToXNode"; displayTestTitle(TEST_NAME); // GIVEN DomLexicalProcessor parser = createParser(); // WHEN XNodeImpl xnode = parser.read(getFile(USER_JACK_FILE_BASENAME), createDefaultParsingContext()); // THEN System.out.println("Parsed XNode:"); System.out.println(xnode.debugDump()); RootXNodeImpl root = getAssertXNode("root node", xnode, RootXNodeImpl.class); MapXNodeImpl rootMap = getAssertXNode("root subnode", root.getSubnode(), MapXNodeImpl.class); PrimitiveXNodeImpl<String> xname = getAssertXMapSubnode("root map", rootMap, UserType.F_NAME, PrimitiveXNodeImpl.class); // TODO: assert value ListXNodeImpl xass = getAssertXMapSubnode("root map", rootMap, UserType.F_ASSIGNMENT, ListXNodeImpl.class); assertEquals("assignment size", 2, xass.size()); // TODO: asserts MapXNodeImpl xextension = getAssertXMapSubnode("root map", rootMap, UserType.F_EXTENSION, MapXNodeImpl.class); }
@Test public void testParseProtectedStringHashed() throws Exception { final String TEST_NAME = "testParseProtectedStringHashed"; displayTestTitle(TEST_NAME); // GIVEN ProtectedStringType protectedStringType = new ProtectedStringType(); protectedStringType.setClearValue("blabla"); Protector protector = PrismInternalTestUtil.createProtector(XMLCipher.AES_128); protector.hash(protectedStringType); PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN MapXNodeImpl protectedStringTypeXNode = ((PrismContextImpl) prismContext).getBeanMarshaller().marshalProtectedDataType(protectedStringType, null); System.out.println("Protected string type XNode: " + protectedStringTypeXNode.debugDump()); // THEN ProtectedStringType unmarshalled = new ProtectedStringType(); prismContext.hacks().parseProtectedType(unmarshalled, protectedStringTypeXNode, prismContext, createDefaultParsingContext()); System.out.println("Unmarshalled value: " + unmarshalled); assertEquals("Unmarshalled value differs from the original", protectedStringType, unmarshalled); } }