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