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.Charsets;
  12 import com.google.common.base.Optional;
  13 import com.google.common.collect.Lists;
  14 import java.io.ByteArrayInputStream;
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.io.InputStream;
  18 import java.util.HashMap;
  19 import java.util.HashSet;
  20 import java.util.Map;
  21 import java.util.Set;
  22 import javax.xml.parsers.DocumentBuilder;
  23 import javax.xml.parsers.DocumentBuilderFactory;
  24 import javax.xml.parsers.ParserConfigurationException;
  25 import org.junit.Assert;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.junit.runner.RunWith;
  29 import org.mockito.Mockito;
  30 import org.mockito.runners.MockitoJUnitRunner;
  31 import org.opendaylight.yangtools.yang.common.QName;
  32 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
  33 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  34 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  35 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  36 import org.opendaylight.yangtools.yang.data.impl.RetestUtils;
  37 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  38 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  39 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  40 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  41 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  42 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  43 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  44 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  45 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  46 import org.w3c.dom.Document;
  47 import org.w3c.dom.Element;
  48 import org.xml.sax.SAXException;
  49
  50 @RunWith(MockitoJUnitRunner.class)
  51 public class XmlDocumentUtilsTest {
  52     private static final String NS = "urn:opendaylight:controller:xml:doc:test";
  53     private static final String NS2 = "urn:opendaylight:controller:xml:doc:test2";
  54     private static final String NS3 = "urn:opendaylight:controller:xml:doc:test3";
  55     private static final String REVISION = "2014-07-28";
  56     private static final DocumentBuilderFactory BUILDERFACTORY;
  57
  58     static {
  59         final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  60         factory.setNamespaceAware(true);
  61         factory.setCoalescing(true);
  62         factory.setIgnoringElementContentWhitespace(true);
  63         factory.setIgnoringComments(true);
  64         BUILDERFACTORY = factory;
  65     }
  66
  67     private static final String XML_CONTENT = "<input xmlns=\"urn:opendaylight:controller:xml:doc:test\">\n"
  68             +
  69             "<a>value</a>\n" +
  70  "<ref xmlns:ltha=\"urn:opendaylight:controller:xml:doc:test\">"
  71             +
  72             "/ltha:cont/ltha:l[  ltha:id='id/foo/bar'  ]"+
  73             "</ref>\n" +
  74             "</input>";
  75
  76     private SchemaContext schema;
  77
  78     @Before
  79     public void setUp() throws Exception {
  80         final File rpcTestYang1 = new File(getClass().getResource("xml-doc-test.yang").toURI());
  81         final File rpcTestYang2 = new File(getClass().getResource("xml-doc-test2.yang").toURI());
  82
  83         this.schema = RetestUtils.parseYangSources(rpcTestYang1, rpcTestYang2);
  84     }
  85
  86     public static Document readXmlToDocument(final String xmlContent) throws SAXException, IOException {
  87         return readXmlToDocument(new ByteArrayInputStream(xmlContent.getBytes(Charsets.UTF_8)));
  88     }
  89
  90     public static Document readXmlToDocument(final InputStream xmlContent) throws SAXException, IOException {
  91         final DocumentBuilder dBuilder;
  92         try {
  93             dBuilder = BUILDERFACTORY.newDocumentBuilder();
  94         } catch (final ParserConfigurationException e) {
  95             throw new IllegalStateException("Failed to parse XML document", e);
  96         }
  97         final Document doc = dBuilder.parse(xmlContent);
  98
  99         doc.getDocumentElement().normalize();
 100         return doc;
 101     }
 102
 103     @Test
 104     public void xmlDocCreateElementForContWithoutAttrTest() throws Exception {
 105         final Document doc = readXmlToDocument(XML_CONTENT);
 106         final YangInstanceIdentifier.NodeIdentifier container = new YangInstanceIdentifier.NodeIdentifier(
 107                 QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont"));
 108
 109         final NormalizedNode<?, ?> data = ImmutableNodes.fromInstanceId(this.schema,
 110                 YangInstanceIdentifier.create(container));
 111         Assert.assertNotNull(data);
 112
 113         final Element element = XmlDocumentUtils.createElementFor(doc, data);
 114         Assert.assertNotNull(element);
 115         Assert.assertEquals(element.getTagName(), "cont");
 116     }
 117
 118     @Test
 119     public void xmlDocCreateElementForContiWithAttrTest() throws Exception {
 120         final Document doc = readXmlToDocument(XML_CONTENT);
 121         final YangInstanceIdentifier.NodeIdentifier container = new YangInstanceIdentifier.NodeIdentifier(
 122                 QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont"));
 123
 124         final Map<QName, String> attributes = new HashMap<>();
 125         attributes.put(QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "l"), "list");
 126
 127         final ContainerNode node = Builders.containerBuilder().withNodeIdentifier(container).withAttributes(attributes)
 128                 .build();
 129         final NormalizedNode<?, ?> data = node;
 130         Assert.assertNotNull(data);
 131
 132         final Element element = XmlDocumentUtils.createElementFor(doc, data);
 133         Assert.assertNotNull(element);
 134         Assert.assertEquals("cont", element.getTagName());
 135         Assert.assertEquals("list", element.getAttribute("l"));
 136     }
 137
 138     @Test
 139     public void xmlDocgetModifyOperationWithAttributesTest() throws Exception {
 140         final Document doc = readXmlToDocument(XML_CONTENT);
 141         final YangInstanceIdentifier.NodeIdentifier container = new YangInstanceIdentifier.NodeIdentifier(
 142                 QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont"));
 143
 144         final Map<QName, String> attributes = new HashMap<>();
 145         attributes.put(QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "l"), "list");
 146
 147         final ContainerNode node = Builders.containerBuilder().withNodeIdentifier(container).withAttributes(attributes)
 148                 .build();
 149         final NormalizedNode<?, ?> data = node;
 150         Assert.assertNotNull(data);
 151
 152         final Element element = XmlDocumentUtils.createElementFor(doc, data);
 153         final Optional<ModifyAction> modifyOperationFromAttributes = XmlDocumentUtils
 154                 .getModifyOperationFromAttributes(element);
 155         Assert.assertFalse(modifyOperationFromAttributes.isPresent());
 156     }
 157
 158     @Test
 159     public void xmlDocgetModifyOperationWithoutAttributesTest() {
 160         final Element element = Mockito.mock(Element.class);
 161         Mockito.when(element.getAttributeNS(Mockito.anyString(), Mockito.anyString())).thenReturn("hello");
 162
 163         final Optional<ModifyAction> modifyOperationFromAttributes = XmlDocumentUtils
 164                 .getModifyOperationFromAttributes(element);
 165         Assert.assertFalse(modifyOperationFromAttributes.isPresent());
 166     }
 167
 168     @Test
 169     public void xmlDocFindFirstSchemaContTest() {
 170         final QName ID = QName.create(XmlDocumentUtilsTest.NS, XmlDocumentUtilsTest.REVISION, "cont");
 171         final Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(ID,
 172                 this.schema.getChildNodes());
 173         Assert.assertNotNull(findFirstSchema);
 174         Assert.assertEquals(ID, findFirstSchema.get().getQName());
 175     }
 176
 177     @Test
 178     public void xmlDocFindFirstSchemaCont2Test() {
 179         final QName ID = QName.create(XmlDocumentUtilsTest.NS2, XmlDocumentUtilsTest.REVISION, "cont2");
 180         final Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(ID,
 181                 this.schema.getChildNodes());
 182         final DataSchemaNode dataSchemaNode = findFirstSchema.get();
 183         Assert.assertNotNull(findFirstSchema);
 184         Assert.assertEquals(ID, dataSchemaNode.getQName());
 185     }
 186
 187     @Test
 188     public void xmlDocFindFirstSchemaNullParamsTest() {
 189         Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(null,
 190                 this.schema.getChildNodes());
 191         Assert.assertFalse(findFirstSchema.isPresent());
 192
 193         final QName ID = QName.create(XmlDocumentUtilsTest.NS2, XmlDocumentUtilsTest.REVISION, "cont2");
 194         findFirstSchema = XmlDocumentUtils.findFirstSchema(ID, null);
 195         Assert.assertFalse(findFirstSchema.isPresent());
 196     }
 197
 198     @Test
 199     public void xmlDocFindFirstSchemaContChoicTest() {
 200         final QName ID = QName.create(XmlDocumentUtilsTest.NS3, XmlDocumentUtilsTest.REVISION, "cont");
 201         final DataSchemaNode sch = Mockito.mock(ChoiceSchemaNode.class);
 202         final Set<ChoiceCaseNode> setCases = new HashSet<>();
 203         final ChoiceCaseNode choice = Mockito.mock(ChoiceCaseNode.class);
 204         setCases.add(choice);
 205         Mockito.when(((ChoiceSchemaNode) sch).getCases()).thenReturn(setCases);
 206         Mockito.when(sch.getQName()).thenReturn(QName.create("badNamespace", "badLocalName"));
 207         final Iterable<DataSchemaNode> colls = Lists.newArrayList(sch);
 208         final Optional<DataSchemaNode> findFirstSchema = XmlDocumentUtils.findFirstSchema(ID, colls);
 209         Assert.assertNotNull(findFirstSchema);
 210     }
 211
 212     @Test
 213     public void codecProviderTest() {
 214         final XmlCodecProvider provider = XmlDocumentUtils.defaultValueCodecProvider();
 215         Assert.assertNotNull(provider);
 216         Assert.assertEquals(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, provider);
 217
 218         final TypeDefinition<?> baseType = Mockito.mock(BinaryTypeDefinition.class);
 219         final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codec = provider.codecFor(baseType);
 220         Assert.assertNotNull(codec);
 221     }
 222 }