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