X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-rest-connector%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Frestconf%2Fimpl%2Fjson%2Fto%2Fcnsn%2Ftest%2FJsonToCnSnTest.java;h=d65cb1bdbfe48bc02d132faab0e2cf82756cb785;hp=b02ea9a3a28fe439efc1d04341449bf28bd5e28f;hb=73e969cf365dd78772596c71e940ae44fe2f22d3;hpb=1ff9939abc7a4072b07df6b79516fe344b1b42e3 diff --git a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/json/to/cnsn/test/JsonToCnSnTest.java b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/json/to/cnsn/test/JsonToCnSnTest.java index b02ea9a3a2..d65cb1bdbf 100644 --- a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/json/to/cnsn/test/JsonToCnSnTest.java +++ b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/json/to/cnsn/test/JsonToCnSnTest.java @@ -1,34 +1,44 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ package org.opendaylight.controller.sal.restconf.impl.json.to.cnsn.test; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; -import java.io.*; -import java.net.URISyntaxException; +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.util.HashSet; import java.util.List; import java.util.Set; - -import javax.ws.rs.WebApplicationException; - +import org.junit.Ignore; import org.junit.Test; import org.opendaylight.controller.sal.rest.impl.JsonToCompositeNodeProvider; import org.opendaylight.controller.sal.restconf.impl.CompositeNodeWrapper; +import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException; import org.opendaylight.controller.sal.restconf.impl.test.TestUtils; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.*; -import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.data.api.CompositeNode; +import org.opendaylight.yangtools.yang.data.api.Node; +import org.opendaylight.yangtools.yang.data.api.SimpleNode; import org.opendaylight.yangtools.yang.model.api.Module; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.gson.JsonSyntaxException; - public class JsonToCnSnTest { private static final Logger LOG = LoggerFactory.getLogger(JsonToCnSnTest.class); @Test public void simpleListTest() { - simpleTest("/json-to-cnsn/simple-list.json", "/json-to-cnsn/simple-list-yang", "lst", "simple:list:yang1", + simpleTest("/json-to-cnsn/simple-list.json", "/json-to-cnsn/simple-list-yang/1", "lst", "simple:list:yang1", "simple-list-yang1"); } @@ -43,18 +53,21 @@ public class JsonToCnSnTest { */ @Test public void multipleItemsInLeafList() { - CompositeNode compositeNode = compositeContainerFromJson("/json-to-cnsn/multiple-leaflist-items.json", true); - assertNotNull(compositeNode); - assertEquals(3, compositeNode.getChildren().size()); + Node node = TestUtils.readInputToCnSn("/json-to-cnsn/multiple-leaflist-items.json", true, + JsonToCompositeNodeProvider.INSTANCE); + assertNotNull(node); + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; + assertEquals(3, compositeNode.getValue().size()); boolean lflst1_1 = false; boolean lflst1_2 = false; boolean lflst1_3 = false; - for (Node node : compositeNode.getChildren()) { - assertEquals("lflst1", node.getNodeType().getLocalName()); - assertTrue(node instanceof SimpleNode); - SimpleNode simpleNode = (SimpleNode) node; + for (Node nd : compositeNode.getValue()) { + assertEquals("lflst1", nd.getNodeType().getLocalName()); + assertTrue(nd instanceof SimpleNode); + SimpleNode simpleNode = (SimpleNode) nd; if (simpleNode.getValue().equals("45")) { lflst1_1 = true; } else if (simpleNode.getValue().equals("55")) { @@ -71,14 +84,18 @@ public class JsonToCnSnTest { } /** - * List contains 4 items and in every item are other elements. It is - * supposed that there should be: lf11, lflst11, cont11, lst11 + * List contains 4 items and in every item are other elements. It is supposed that there should be: lf11, lflst11, + * cont11, lst11 */ @Test public void multipleItemsInListTest() { - CompositeNode compositeNode = compositeContainerFromJson("/json-to-cnsn/multiple-items-in-list.json", true); - assertNotNull(compositeNode); + Node node = TestUtils.readInputToCnSn("/json-to-cnsn/multiple-items-in-list.json", true, + JsonToCompositeNodeProvider.INSTANCE); + + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; + assertNotNull(compositeNode); assertEquals("lst", compositeNode.getNodeType().getLocalName()); verityMultipleItemsInList(compositeNode); @@ -86,13 +103,15 @@ public class JsonToCnSnTest { @Test public void nullArrayToSimpleNodeWithNullValueTest() { - CompositeNode compositeNode = compositeContainerFromJson("/json-to-cnsn/array-with-null.json", true); - assertNotNull(compositeNode); + Node node = TestUtils.readInputToCnSn("/json-to-cnsn/array-with-null.json", true, + JsonToCompositeNodeProvider.INSTANCE); + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; assertEquals("cont", compositeNode.getNodeType().getLocalName()); - assertNotNull(compositeNode.getChildren()); - assertEquals(1, compositeNode.getChildren().size()); - Node lfNode = compositeNode.getChildren().iterator().next(); + assertNotNull(compositeNode.getValue()); + assertEquals(1, compositeNode.getValue().size()); + Node lfNode = compositeNode.getValue().iterator().next(); assertTrue(lfNode instanceof SimpleNode); assertEquals(null, ((SimpleNode) lfNode).getValue()); @@ -101,99 +120,110 @@ public class JsonToCnSnTest { @Test public void incorrectTopLevelElementsTest() { - Throwable cause1 = null; + RestconfDocumentedException cause1 = null; try { - compositeContainerFromJson("/json-to-cnsn/wrong-top-level1.json", true); - } catch (WebApplicationException e) { + TestUtils + .readInputToCnSn("/json-to-cnsn/wrong-top-level1.json", true, JsonToCompositeNodeProvider.INSTANCE); + } catch (RestconfDocumentedException e) { cause1 = e; } assertNotNull(cause1); assertTrue(cause1 - .getCause() - .getMessage() + .getErrors() + .get(0) + .getErrorMessage() .contains( "First element in Json Object has to be \"Object\" or \"Array with one Object element\". Other scenarios are not supported yet.")); - Throwable cause2 = null; + RestconfDocumentedException cause2 = null; try { - compositeContainerFromJson("/json-to-cnsn/wrong-top-level2.json", true); - } catch (WebApplicationException e) { + TestUtils + .readInputToCnSn("/json-to-cnsn/wrong-top-level2.json", true, JsonToCompositeNodeProvider.INSTANCE); + } catch (RestconfDocumentedException e) { cause2 = e; } assertNotNull(cause2); - assertTrue(cause2.getCause().getMessage().contains("Json Object should contain one element")); + assertTrue(cause2.getErrors().get(0).getErrorMessage().contains("Json Object should contain one element")); - Throwable cause3 = null; + RestconfDocumentedException cause3 = null; try { - compositeContainerFromJson("/json-to-cnsn/wrong-top-level3.json", true); - } catch (WebApplicationException e) { + TestUtils + + .readInputToCnSn("/json-to-cnsn/wrong-top-level3.json", true, JsonToCompositeNodeProvider.INSTANCE); + } catch (RestconfDocumentedException e) { cause3 = e; } assertNotNull(cause3); assertTrue(cause3 - .getCause() - .getMessage() + .getErrors() + .get(0) + .getErrorMessage() .contains( "First element in Json Object has to be \"Object\" or \"Array with one Object element\". Other scenarios are not supported yet.")); } /** - * if leaf list with no data is in json then no corresponding data is - * created in composite node. if leaf with no data then exception is raised + * if leaf list with no data is in json then no corresponding data is created in composite node. if leaf with no + * data then exception is raised */ @Test public void emptyDataReadTest() { - CompositeNode compositeNode = compositeContainerFromJson("/json-to-cnsn/empty-data.json", true); - - assertNotNull(compositeNode); + Node node = TestUtils.readInputToCnSn("/json-to-cnsn/empty-data.json", true, + JsonToCompositeNodeProvider.INSTANCE); + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; assertEquals("cont", compositeNode.getNodeType().getLocalName()); assertTrue(compositeNode instanceof CompositeNode); - List> children = ((CompositeNode) compositeNode).getChildren(); + List> children = compositeNode.getValue(); assertEquals(1, children.size()); assertEquals("lflst2", children.get(0).getNodeType().getLocalName()); assertEquals("45", children.get(0).getValue()); String reason = null; try { - compositeContainerFromJson("/json-to-cnsn/empty-data1.json", true); - } catch (JsonSyntaxException e) { - reason = e.getMessage(); + TestUtils.readInputToCnSn("/json-to-cnsn/empty-data1.json", true, JsonToCompositeNodeProvider.INSTANCE); + } catch (RestconfDocumentedException e) { + reason = e.getErrors().get(0).getErrorMessage(); } assertTrue(reason.contains("Expected value at line")); } + @Test + public void testJsonBlankInput() throws Exception { + InputStream inputStream = new ByteArrayInputStream("".getBytes()); + Node node = + JsonToCompositeNodeProvider.INSTANCE.readFrom(null, null, null, null, null, inputStream); + assertNull( node ); + } + /** - * Tests whether namespace stay unchanged if concrete values are - * present in composite or simple node and if the method for update is - * called. - * + * Tests whether namespace stay unchanged if concrete values are present in composite or simple node and if + * the method for update is called. + * */ @Test public void notSupplyNamespaceIfAlreadySupplied() { - CompositeNode compositeNode = compositeContainerFromJson("/json-to-cnsn/simple-list.json"); - assertNotNull(compositeNode); - - DataSchemaNode dataSchemaNode1 = null; - DataSchemaNode dataSchemaNode2 = null; - try { - dataSchemaNode1 = TestUtils.obtainSchemaFromYang("/json-to-cnsn/simple-list-yang", "simple-list-yang1"); - dataSchemaNode2 = TestUtils.obtainSchemaFromYang("/json-to-cnsn/simple-list-yang", "simple-list-yang2"); - } catch (FileNotFoundException e) { - LOG.error(e.getMessage()); - assertTrue(false); - } - assertNotNull(dataSchemaNode1); - assertNotNull(dataSchemaNode2); + Node node = TestUtils.readInputToCnSn("/json-to-cnsn/simple-list.json", false, + JsonToCompositeNodeProvider.INSTANCE); + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; // supplement namespaces according to first data schema - // "simple:data:types1" - TestUtils.supplementNamespace(dataSchemaNode1, compositeNode); + Set modules1 = new HashSet<>(); + Set modules2 = new HashSet<>(); + modules1 = TestUtils.loadModulesFrom("/json-to-cnsn/simple-list-yang/1"); + modules2 = TestUtils.loadModulesFrom("/json-to-cnsn/simple-list-yang/2"); + assertNotNull(modules1); + assertNotNull(modules2); + + TestUtils.normalizeCompositeNode(compositeNode, modules1, "simple-list-yang1:lst"); assertTrue(compositeNode instanceof CompositeNodeWrapper); CompositeNode compNode = ((CompositeNodeWrapper) compositeNode).unwrap(); @@ -201,36 +231,36 @@ public class JsonToCnSnTest { assertEquals("lst", compNode.getNodeType().getLocalName()); verifyCompositeNode(compNode, "simple:list:yang1"); - // dataSchemaNode2 should't be taken into account, because compNode - // isn't CompositeNodeWrapper - TestUtils.supplementNamespace(dataSchemaNode2, compNode); + try { + TestUtils.normalizeCompositeNode(compositeNode, modules2, "simple-list-yang2:lst"); + fail("Conversion to normalized node shouldn't be successfull because of different namespaces"); + } catch (IllegalStateException e) { + } +// veryfing has still meaning. despite exception, first phase where normalization of NodeWrappers is called passed successfuly. verifyCompositeNode(compNode, "simple:list:yang1"); - } @Test public void jsonIdentityrefToCompositeNode() { - CompositeNode compositeNode = compositeContainerFromJson("/json-to-cnsn/identityref/json/data.json"); - assertNotNull(compositeNode); + Node node = TestUtils.readInputToCnSn("/json-to-cnsn/identityref/json/data.json", false, + JsonToCompositeNodeProvider.INSTANCE); + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; - Set modules = TestUtils.resolveModules("/json-to-cnsn/identityref"); + Set modules = TestUtils.loadModulesFrom("/json-to-cnsn/identityref"); assertEquals(2, modules.size()); - Module module = TestUtils.resolveModule("identityref-module", modules); - assertNotNull(module); - DataSchemaNode dataSchemaNode = TestUtils.resolveDataSchemaNode(module, null); - assertNotNull(dataSchemaNode); - TestUtils.normalizeCompositeNode(compositeNode, modules, dataSchemaNode, "identityref-module:cont"); + TestUtils.normalizeCompositeNode(compositeNode, modules, "identityref-module:cont"); assertEquals("cont", compositeNode.getNodeType().getLocalName()); - List> childs = compositeNode.getChildren(); + List> childs = compositeNode.getValue(); assertEquals(1, childs.size()); Node nd = childs.iterator().next(); assertTrue(nd instanceof CompositeNode); assertEquals("cont1", nd.getNodeType().getLocalName()); - childs = ((CompositeNode) nd).getChildren(); + childs = ((CompositeNode) nd).getValue(); assertEquals(4, childs.size()); SimpleNode lf11 = null; SimpleNode lf12 = null; @@ -266,31 +296,41 @@ public class JsonToCnSnTest { assertEquals("identity:module", ((QName) lf14.getValue()).getNamespace().toString()); } - private void simpleTest(String jsonPath, String yangPath, String topLevelElementName, String namespace, - String moduleName) { - CompositeNode compositeNode = compositeContainerFromJson(jsonPath); - assertNotNull(compositeNode); + @Ignore + @Test + public void loadDataAugmentedSchemaMoreEqualNamesTest() { + loadAndNormalizeData("/common/augment/json/dataa.json", "/common/augment/yang", "cont", "main"); + loadAndNormalizeData("/common/augment/json/datab.json", "/common/augment/yang", "cont", "main"); - DataSchemaNode dataSchemaNode = null; - try { - dataSchemaNode = TestUtils.obtainSchemaFromYang(yangPath, moduleName); - } catch (FileNotFoundException e) { - LOG.error(e.getMessage()); - assertTrue(false); - } - assertNotNull(dataSchemaNode); + } - TestUtils.supplementNamespace(dataSchemaNode, compositeNode); + private void simpleTest(final String jsonPath, final String yangPath, final String topLevelElementName, + final String namespace, final String moduleName) { + CompositeNode compNode = loadAndNormalizeData(jsonPath, yangPath, topLevelElementName, moduleName); + verifyCompositeNode(compNode, namespace); + } + + private CompositeNode loadAndNormalizeData(final String jsonPath, final String yangPath, + final String topLevelElementName, final String moduleName) { + Node node = TestUtils.readInputToCnSn(jsonPath, false, JsonToCompositeNodeProvider.INSTANCE); + assertTrue(node instanceof CompositeNode); + CompositeNode compositeNode = (CompositeNode)node; + + Set modules = null; + modules = TestUtils.loadModulesFrom(yangPath); + assertNotNull(modules); + + TestUtils.normalizeCompositeNode(compositeNode, modules, moduleName + ":" + topLevelElementName); assertTrue(compositeNode instanceof CompositeNodeWrapper); CompositeNode compNode = ((CompositeNodeWrapper) compositeNode).unwrap(); assertEquals(topLevelElementName, compNode.getNodeType().getLocalName()); - verifyCompositeNode(compNode, namespace); + return compNode; } - private void verityMultipleItemsInList(CompositeNode compositeNode) { - List> childrenNodes = compositeNode.getChildren(); + private void verityMultipleItemsInList(final CompositeNode compositeNode) { + List> childrenNodes = compositeNode.getValue(); assertEquals(4, childrenNodes.size()); boolean lf11Found = false; boolean cont11Found = false; @@ -299,7 +339,7 @@ public class JsonToCnSnTest { assertEquals("lst1", lst1Item.getNodeType().getLocalName()); assertTrue(lst1Item instanceof CompositeNode); - List> childrenLst1 = ((CompositeNode) lst1Item).getChildren(); + List> childrenLst1 = ((CompositeNode) lst1Item).getValue(); assertEquals(1, childrenLst1.size()); String localName = childrenLst1.get(0).getNodeType().getLocalName(); if (localName.equals("lf11")) { @@ -315,7 +355,7 @@ public class JsonToCnSnTest { } else if (localName.equals("lst11")) { lst11Found = true; assertTrue(childrenLst1.get(0) instanceof CompositeNode); - assertEquals(0, ((CompositeNode) childrenLst1.get(0)).getChildren().size()); + assertEquals(0, ((CompositeNode) childrenLst1.get(0)).getValue().size()); } } @@ -324,25 +364,26 @@ public class JsonToCnSnTest { assertTrue(lst11Found); } - private void verifyCompositeNode(CompositeNode compositeNode, String namespace) { + private void verifyCompositeNode(final CompositeNode compositeNode, final String namespace) { boolean cont1Found = false; boolean lst1Found = false; boolean lflst1_1Found = false; boolean lflst1_2Found = false; boolean lf1Found = false; - assertEquals(namespace, compositeNode.getNodeType().getNamespace().toString()); + // assertEquals(namespace, + // compositeNode.getNodeType().getNamespace().toString()); - for (Node node : compositeNode.getChildren()) { + for (Node node : compositeNode.getValue()) { if (node.getNodeType().getLocalName().equals("cont1")) { if (node instanceof CompositeNode) { cont1Found = true; - assertEquals(0, ((CompositeNode) node).getChildren().size()); + assertEquals(0, ((CompositeNode) node).getValue().size()); } } else if (node.getNodeType().getLocalName().equals("lst1")) { if (node instanceof CompositeNode) { lst1Found = true; - assertEquals(0, ((CompositeNode) node).getChildren().size()); + assertEquals(0, ((CompositeNode) node).getValue().size()); } } else if (node.getNodeType().getLocalName().equals("lflst1")) { if (node instanceof SimpleNode) { @@ -369,34 +410,48 @@ public class JsonToCnSnTest { assertTrue(lf1Found); } - private CompositeNode compositeContainerFromJson(String jsonPath) { - return compositeContainerFromJson(jsonPath, false); + @Test + public void unsupportedDataFormatTest() { + String exceptionMessage = ""; + try { + TestUtils.readInputToCnSn("/json-to-cnsn/unsupported-json-format.json", true, + JsonToCompositeNodeProvider.INSTANCE); + } catch (RestconfDocumentedException e) { + exceptionMessage = e.getErrors().get(0).getErrorMessage(); + } + assertTrue(exceptionMessage.contains("Root element of Json has to be Object")); } - private CompositeNode compositeContainerFromJson(String jsonPath, boolean dummyNamespaces) - throws WebApplicationException { - - JsonToCompositeNodeProvider jsonToCompositeNodeProvider = JsonToCompositeNodeProvider.INSTANCE; - InputStream jsonStream = JsonToCnSnTest.class.getResourceAsStream(jsonPath); - try { - CompositeNode compositeNode = jsonToCompositeNodeProvider - .readFrom(null, null, null, null, null, jsonStream); - assertTrue(compositeNode instanceof CompositeNodeWrapper); - if (dummyNamespaces) { - try { - TestUtils.addDummyNamespaceToAllNodes((CompositeNodeWrapper) compositeNode); - return ((CompositeNodeWrapper) compositeNode).unwrap(); - } catch (URISyntaxException e) { - LOG.error(e.getMessage()); - assertTrue(e.getMessage(), false); - } + /** + * Tests case when JSON input data value is in format string1:string2 and first string contain characters "<" or ">" (invalid URI characters). + * + * During loading data it is also interpreting as data value in moduleName:localName (potential leafref value). + * ModuleName part is transformed to URI which causes exception which is caught and URI value is null which cause that potential value in simple node is + * simple string (value from JSON input) and not IdentityValueDTO instance which is used for leaf-ref candidates. + */ + @Test + public void invalidUriCharacterInValue() { + final Node rootNode = TestUtils.readInputToCnSn("/json-to-cnsn/invalid-uri-character-in-value.json", true, + JsonToCompositeNodeProvider.INSTANCE); + + assertTrue(rootNode instanceof CompositeNode); + Node lf1 = null; + Node lf2 = null; + for(Node child : ((CompositeNode)rootNode).getChildren()) { + if (child.getNodeType().getLocalName().equals("lf1")) { + lf1 = child; + } else if (child.getNodeType().getLocalName().equals("lf2")) { + lf2 = child; } - return compositeNode; - } catch (IOException e) { - LOG.error(e.getMessage()); - assertTrue(e.getMessage(), false); } - return null; + + assertNotNull(lf1); + assertNotNull(lf2); + assertTrue(lf1 instanceof SimpleNode); + assertTrue(lf2 instanceof SimpleNode); + + assertEquals("module) lf1).getValue()); + assertEquals("module>Name:value lf2", ((SimpleNode) lf2).getValue()); } }