yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlDocumentUtilsTest.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.yangtools.yang.data.impl.codec.xml;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.collect.Lists;
  13 import java.io.ByteArrayInputStream;
  14 import java.io.File;
  15 import java.io.IOException;
  16 import java.io.InputStream;
  17 import java.nio.charset.StandardCharsets;
  18 import java.util.HashMap;
  19 import java.util.HashSet;
  20 import java.util.Map;
  21 import java.util.Set;
  22 import org.junit.Assert;
  23 import org.junit.Before;
  24 import org.junit.Test;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.Mockito;
  27 import org.mockito.runners.MockitoJUnitRunner;
  28 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  29 import org.opendaylight.yangtools.yang.common.QName;
  30 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
  31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  32 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  33 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  34 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  35 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  36 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  37 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  38 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  41 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  42 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  43 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  44 import org.w3c.dom.Document;
  45 import org.w3c.dom.Element;
  46 import org.xml.sax.SAXException;
  47
  48 @RunWith(MockitoJUnitRunner.class)
  49 public class XmlDocumentUtilsTest {
  50     private static final String NS = "urn:opendaylight:controller:xml:doc:test";
  51     private static final String NS2 = "urn:opendaylight:controller:xml:doc:test2";
  52     private static final String NS3 = "urn:opendaylight:controller:xml:doc:test3";
  53     private static final String REVISION = "2014-07-28";
  54
  55     private static final String XML_CONTENT = "<input xmlns=\"urn:opendaylight:controller:xml:doc:test\">\n"
  56             + "<a>value</a>\n"
  57             + "<ref xmlns:ltha=\"urn:opendaylight:controller:xml:doc:test\">"
  58             + "/ltha:cont/ltha:l[  ltha:id='id/foo/bar'  ]"
  59             + "</ref>\n"
  60             + "</input>";
  61
  62     private SchemaContext schema;
  63
  64     @Before
  65     public void setUp() throws Exception {
  66         final File rpcTestYang1 = new File(getClass().getResource("xml-doc-test.yang").toURI());
  67         final File rpcTestYang2 = new File(getClass().getResource("xml-doc-test2.yang").toURI());
  68
  69         this.schema = YangParserTestUtils.parseYangFiles(rpcTestYang1, rpcTestYang2);
  70     }
  71
  72     public static Document readXmlToDocument(final String xmlContent) throws SAXException, IOException {
  73         return readXmlToDocument(new ByteArrayInputStream(xmlContent.getBytes(StandardCharsets.UTF_8)));
  74     }
  75
  76     public static Document readXmlToDocument(final InputStream xmlContent) throws SAXException, IOException {
  77         final Document doc = UntrustedXML.newDocumentBuilder().parse(xmlContent);
  78         doc.getDocumentElement().normalize();
  79         return doc;
  80     }
  81
  82     @Test
  83     public void xmlDocCreateElementForContWithoutAttrTest() throws Exception {
  84         final Document doc = readXmlToDocument(XML_CONTENT);
  85         final YangInstanceIdentifier.NodeIdentifier container = new YangInstanceIdentifier.NodeIdentifier(
  86                 QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont"));
  87
  88         final NormalizedNode<?, ?> data = ImmutableNodes.fromInstanceId(this.schema,
  89                 YangInstanceIdentifier.create(container));
  90         Assert.assertNotNull(data);
  91
  92         final Element element = XmlDocumentUtils.createElementFor(doc, data);
  93         Assert.assertNotNull(element);
  94         Assert.assertEquals(element.getTagName(), "cont");
  95     }
  96
  97     @Test
  98     public void xmlDocCreateElementForContiWithAttrTest() throws Exception {
  99         final Document doc = readXmlToDocument(XML_CONTENT);
 100         final YangInstanceIdentifier.NodeIdentifier container = new YangInstanceIdentifier.NodeIdentifier(
 101                 QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont"));
 102
 103         final Map<QName, String> attributes = new HashMap<>();
 104         attributes.put(QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "l"), "list");
 105
 106         final ContainerNode node = Builders.containerBuilder().withNodeIdentifier(container).withAttributes(attributes)
 107                 .build();
 108         final NormalizedNode<?, ?> data = node;
 109         Assert.assertNotNull(data);
 110
 111         final Element element = XmlDocumentUtils.createElementFor(doc, data);
 112         Assert.assertNotNull(element);
 113         Assert.assertEquals("cont", element.getTagName());
 114         Assert.assertEquals("list", element.getAttribute("l"));
 115     }
 116
 117     @Test
 118     public void xmlDocgetModifyOperationWithAttributesTest() throws Exception {
 119         final Document doc = readXmlToDocument(XML_CONTENT);
 120         final YangInstanceIdentifier.NodeIdentifier container = new YangInstanceIdentifier.NodeIdentifier(
 121                 QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont"));
 122
 123         final Map<QName, String> attributes = new HashMap<>();
 124         attributes.put(QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "l"), "list");
 125
 126         final ContainerNode node = Builders.containerBuilder().withNodeIdentifier(container).withAttributes(attributes)
 127                 .build();
 128         final NormalizedNode<?, ?> data = node;
 129         Assert.assertNotNull(data);
 130
 131         final Element element = XmlDocumentUtils.createElementFor(doc, data);
 132         final Optional<ModifyAction> modifyOperationFromAttributes = XmlDocumentUtils
 133                 .getModifyOperationFromAttributes(element);
 134         Assert.assertFalse(modifyOperationFromAttributes.isPresent());
 135     }
 136
 137     @Test
 138     public void xmlDocgetModifyOperationWithoutAttributesTest() {
 139         final Element element = Mockito.mock(Element.class);
 140         Mockito.when(element.getAttributeNS(Mockito.anyString(), Mockito.anyString())).thenReturn("hello");
 141
 142         final Optional<ModifyAction> modifyOperationFromAttributes = XmlDocumentUtils
 143                 .getModifyOperationFromAttributes(element);
 144         Assert.assertFalse(modifyOperationFromAttributes.isPresent());
 145     }
 146
 147     @Test
 148     public void xmlDocFindFirstSchemaContTest() {
 149         final QName ID = QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont");
 150         final Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(ID,
 151                 this.schema.getChildNodes());
 152         Assert.assertNotNull(findFirstSchema);
 153         Assert.assertEquals(ID, findFirstSchema.get().getQName());
 154     }
 155
 156     @Test
 157     public void xmlDocFindFirstSchemaCont2Test() {
 158         final QName ID = QName.create(XmlDocumentUtilsTest.NS2, XmlDocumentUtilsTest.REVISION, "cont2");
 159         final Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(ID,
 160                 this.schema.getChildNodes());
 161         final DataSchemaNode dataSchemaNode = findFirstSchema.get();
 162         Assert.assertNotNull(findFirstSchema);
 163         Assert.assertEquals(ID, dataSchemaNode.getQName());
 164     }
 165
 166     @Test
 167     public void xmlDocFindFirstSchemaNullParamsTest() {
 168         Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(null,
 169                 this.schema.getChildNodes());
 170         Assert.assertFalse(findFirstSchema.isPresent());
 171
 172         final QName ID = QName.create(XmlDocumentUtilsTest.NS2, XmlDocumentUtilsTest.REVISION, "cont2");
 173         findFirstSchema = XmlDocumentUtils.findFirstSchema(ID, null);
 174         Assert.assertFalse(findFirstSchema.isPresent());
 175     }
 176
 177     @Test
 178     public void xmlDocFindFirstSchemaContChoicTest() {
 179         final QName ID = QName.create(XmlDocumentUtilsTest.NS3, XmlDocumentUtilsTest.REVISION, "cont");
 180         final DataSchemaNode sch = Mockito.mock(ChoiceSchemaNode.class);
 181         final Set<ChoiceCaseNode> setCases = new HashSet<>();
 182         final ChoiceCaseNode choice = Mockito.mock(ChoiceCaseNode.class);
 183         setCases.add(choice);
 184         Mockito.when(((ChoiceSchemaNode) sch).getCases()).thenReturn(setCases);
 185         Mockito.when(sch.getQName()).thenReturn(QName.create("badNamespace", "badLocalName"));
 186         final Iterable<DataSchemaNode> colls = Lists.newArrayList(sch);
 187         final Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(ID, colls);
 188         Assert.assertNotNull(findFirstSchema);
 189     }
 190
 191     @Test
 192     public void codecProviderTest() {
 193         final XmlCodecProvider provider = XmlDocumentUtils.defaultValueCodecProvider();
 194         Assert.assertNotNull(provider);
 195         Assert.assertEquals(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, provider);
 196
 197         final TypeDefinition<?> baseType = Mockito.mock(BinaryTypeDefinition.class);
 198         final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codec = provider.codecFor(baseType);
 199         Assert.assertNotNull(codec);
 200     }
 201 }