restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/utils/mapping/RestconfMappingNodeUtilTest.java

   1 /*
   2  * Copyright (c) 2016 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 package org.opendaylight.restconf.nb.rfc8040.utils.mapping;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import java.net.URI;
  15 import java.time.Instant;
  16 import java.time.OffsetDateTime;
  17 import java.time.ZoneId;
  18 import java.time.format.DateTimeFormatter;
  19 import java.util.ArrayList;
  20 import java.util.Collection;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24 import org.junit.BeforeClass;
  25 import org.junit.Test;
  26 import org.opendaylight.restconf.nb.rfc8040.Rfc8040;
  27 import org.opendaylight.restconf.nb.rfc8040.Rfc8040.IetfYangLibrary;
  28 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
  29 import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.monitoring.rev170126.RestconfState;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.monitoring.rev170126.restconf.state.Capabilities;
  32 import org.opendaylight.yangtools.yang.common.QName;
  33 import org.opendaylight.yangtools.yang.common.Revision;
  34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  35 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  36 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  37 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  39 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  40 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  41 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  42 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  43 import org.opendaylight.yangtools.yang.model.api.Module;
  44 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * Unit tests for {@link RestconfMappingNodeUtil}.
  50  */
  51 public class RestconfMappingNodeUtilTest {
  52     private static final Logger LOG = LoggerFactory.getLogger(RestconfMappingNodeUtilTest.class);
  53
  54     private static Collection<? extends Module> modules;
  55     private static EffectiveModelContext schemaContext;
  56     private static EffectiveModelContext schemaContextMonitoring;
  57     private static Collection<? extends Module> modulesRest;
  58
  59     @BeforeClass
  60     public static void loadTestSchemaContextAndModules() throws Exception {
  61         // FIXME: assemble these from dependencies
  62         schemaContext =
  63                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/modules/restconf-module-testing"));
  64         schemaContextMonitoring = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/modules"));
  65         modules = schemaContextMonitoring.getModules();
  66         modulesRest = YangParserTestUtils
  67                 .parseYangFiles(TestRestconfUtils.loadFiles("/modules/restconf-module-testing")).getModules();
  68     }
  69
  70     /**
  71      * Test of writing modules into {@link RestconfModule#MODULE_LIST_SCHEMA_NODE} and checking if modules were
  72      * correctly written.
  73      */
  74     @Test
  75     public void restconfMappingNodeTest() {
  76         // write modules into list module in Restconf
  77         final ContainerNode mods = RestconfMappingNodeUtil.mapModulesByIetfYangLibraryYang(
  78             RestconfMappingNodeUtilTest.modules, schemaContext, "1");
  79
  80         // verify loaded modules
  81         verifyLoadedModules(mods);
  82         // verify deviations
  83         verifyDeviations(mods);
  84     }
  85
  86     @Test
  87     public void restconfStateCapabilitesTest() {
  88         final Module monitoringModule = schemaContextMonitoring.findModule(RestconfState.QNAME.getModule()).get();
  89         final ContainerNode normNode = RestconfMappingNodeUtil.mapCapabilites(monitoringModule);
  90         assertNotNull(normNode);
  91         final List<Object> listOfValues = new ArrayList<>();
  92
  93         for (final DataContainerChild child : normNode.body()) {
  94             if (child.getIdentifier().getNodeType().equals(Capabilities.QNAME)) {
  95                 for (final DataContainerChild dataContainerChild : ((ContainerNode) child).body()) {
  96                     for (final Object entry : ((LeafSetNode<?>) dataContainerChild).body()) {
  97                         listOfValues.add(((LeafSetEntryNode<?>) entry).body());
  98                     }
  99                 }
 100             }
 101         }
 102         assertTrue(listOfValues.contains(Rfc8040.Capabilities.DEPTH));
 103         assertTrue(listOfValues.contains(Rfc8040.Capabilities.FIELDS));
 104         assertTrue(listOfValues.contains(Rfc8040.Capabilities.FILTER));
 105         assertTrue(listOfValues.contains(Rfc8040.Capabilities.REPLAY));
 106         assertTrue(listOfValues.contains(Rfc8040.Capabilities.WITH_DEFAULTS));
 107     }
 108
 109     @Test
 110     public void toStreamEntryNodeTest() throws Exception {
 111         final YangInstanceIdentifier path = ParserIdentifier.toInstanceIdentifier(
 112                 "nested-module:depth1-cont/depth2-leaf1", schemaContextMonitoring, null).getInstanceIdentifier();
 113         final Instant start = Instant.now();
 114         final String outputType = "XML";
 115         final URI uri = new URI("uri");
 116         final String streamName = "/nested-module:depth1-cont/depth2-leaf1";
 117
 118         final Map<QName, Object> map = prepareMap(streamName, uri, start, outputType);
 119         final MapEntryNode mappedData = RestconfMappingNodeUtil.mapDataChangeNotificationStreamByIetfRestconfMonitoring(
 120             path, start, outputType, uri, schemaContextMonitoring, streamName);
 121         assertMappedData(map, mappedData);
 122     }
 123
 124     @Test
 125     public void toStreamEntryNodeNotifiTest() throws Exception {
 126         final Instant start = Instant.now();
 127         final String outputType = "JSON";
 128         final URI uri = new URI("uri");
 129
 130         final Map<QName, Object> map = prepareMap("notifi", uri, start, outputType);
 131         map.put(RestconfMappingNodeUtil.DESCRIPTION_QNAME, "Notifi");
 132
 133         final QName notifiQName = QName.create("urn:nested:module", "2014-06-03", "notifi");
 134         final MapEntryNode mappedData = RestconfMappingNodeUtil.mapYangNotificationStreamByIetfRestconfMonitoring(
 135             notifiQName, schemaContextMonitoring.getNotifications(), start, outputType, uri);
 136         assertMappedData(map, mappedData);
 137     }
 138
 139     private static Map<QName, Object> prepareMap(final String name, final URI uri, final Instant start,
 140             final String outputType) {
 141         final Map<QName, Object> map = new HashMap<>();
 142         map.put(RestconfMappingNodeUtil.NAME_QNAME, name);
 143         map.put(RestconfMappingNodeUtil.LOCATION_QNAME, uri.toString());
 144         map.put(RestconfMappingNodeUtil.REPLAY_SUPPORT_QNAME, Boolean.TRUE);
 145         map.put(RestconfMappingNodeUtil.REPLAY_LOG_CREATION_TIME, DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(
 146             OffsetDateTime.ofInstant(start, ZoneId.systemDefault())));
 147         map.put(RestconfMappingNodeUtil.ENCODING_QNAME, outputType);
 148         return map;
 149     }
 150
 151     private static void assertMappedData(final Map<QName, Object> map, final MapEntryNode mappedData) {
 152         assertNotNull(mappedData);
 153         for (final DataContainerChild child : mappedData.body()) {
 154             if (child instanceof LeafNode) {
 155                 final LeafNode<?> leaf = (LeafNode<?>) child;
 156                 assertTrue(map.containsKey(leaf.getIdentifier().getNodeType()));
 157                 assertEquals(map.get(leaf.getIdentifier().getNodeType()), leaf.body());
 158             }
 159         }
 160     }
 161
 162     /**
 163      * Verify whether the loaded modules contain any deviations.
 164      *
 165      * @param containerNode
 166      *             modules
 167      */
 168     private static void verifyDeviations(final ContainerNode containerNode) {
 169         int deviationsFound = 0;
 170         for (final DataContainerChild child : containerNode.body()) {
 171             if (child instanceof MapNode) {
 172                 for (final MapEntryNode mapEntryNode : ((MapNode) child).body()) {
 173                     for (final DataContainerChild dataContainerChild : mapEntryNode.body()) {
 174                         if (dataContainerChild.getIdentifier().getNodeType()
 175                                 .equals(IetfYangLibrary.SPECIFIC_MODULE_DEVIATION_LIST_QNAME)) {
 176                             deviationsFound++;
 177                         }
 178                     }
 179                 }
 180             }
 181         }
 182         assertTrue(deviationsFound > 0);
 183     }
 184
 185     /**
 186      * Verify loaded modules.
 187      *
 188      * @param containerNode
 189      *             modules
 190      */
 191     private static void verifyLoadedModules(final ContainerNode containerNode) {
 192         final Map<String, String> loadedModules = new HashMap<>();
 193
 194         for (final DataContainerChild child : containerNode.body()) {
 195             if (child instanceof LeafNode) {
 196                 assertEquals(IetfYangLibrary.MODULE_SET_ID_LEAF_QNAME, child.getIdentifier().getNodeType());
 197             }
 198             if (child instanceof MapNode) {
 199                 assertEquals(IetfYangLibrary.MODULE_QNAME_LIST, child.getIdentifier().getNodeType());
 200                 for (final MapEntryNode mapEntryNode : ((MapNode) child).body()) {
 201                     String name = "";
 202                     String revision = "";
 203                     for (final DataContainerChild dataContainerChild : mapEntryNode.body()) {
 204                         switch (dataContainerChild.getIdentifier().getNodeType().getLocalName()) {
 205                             case IetfYangLibrary.SPECIFIC_MODULE_NAME_LEAF:
 206                                 name = String.valueOf(dataContainerChild.body());
 207                                 break;
 208                             case IetfYangLibrary.SPECIFIC_MODULE_REVISION_LEAF:
 209                                 revision = String.valueOf(dataContainerChild.body());
 210                                 break;
 211                             default :
 212                                 LOG.info("Unknown local name '{}' of node.",
 213                                         dataContainerChild.getIdentifier().getNodeType().getLocalName());
 214                                 break;
 215                         }
 216                     }
 217                     loadedModules.put(name, revision);
 218                 }
 219             }
 220         }
 221
 222         verifyLoadedModules(RestconfMappingNodeUtilTest.modulesRest, loadedModules);
 223     }
 224
 225     /**
 226      * Verify if correct modules were loaded into Restconf module by comparison with modules from
 227      * <code>SchemaContext</code>.
 228      * @param expectedModules Modules from <code>SchemaContext</code>
 229      * @param loadedModules Loaded modules into Restconf module
 230      */
 231     private static void verifyLoadedModules(final Collection<? extends Module> expectedModules,
 232             final Map<String, String> loadedModules) {
 233         assertEquals("Number of loaded modules is not as expected", expectedModules.size(), loadedModules.size());
 234         for (final Module m : expectedModules) {
 235             final String name = m.getName();
 236
 237             final String revision = loadedModules.get(name);
 238             assertNotNull("Expected module not found", revision);
 239             assertEquals("Incorrect revision of loaded module", Revision.ofNullable(revision), m.getRevision());
 240
 241             loadedModules.remove(name);
 242         }
 243     }
 244 }