restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestGetOperationTest.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.controller.sal.restconf.impl.test;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.assertNull;
  15 import static org.junit.Assert.assertTrue;
  16 import static org.junit.Assert.fail;
  17 import static org.mockito.Matchers.any;
  18 import static org.mockito.Matchers.eq;
  19 import static org.mockito.Mockito.mock;
  20 import static org.mockito.Mockito.when;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.collect.ImmutableMap;
  24 import com.google.common.collect.Maps;
  25 import java.io.FileNotFoundException;
  26 import java.io.UnsupportedEncodingException;
  27 import java.net.URI;
  28 import java.net.URISyntaxException;
  29 import java.text.ParseException;
  30 import java.text.SimpleDateFormat;
  31 import java.util.ArrayList;
  32 import java.util.Date;
  33 import java.util.HashSet;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Set;
  37 import java.util.regex.Matcher;
  38 import java.util.regex.Pattern;
  39 import javax.ws.rs.core.Application;
  40 import javax.ws.rs.core.MediaType;
  41 import javax.ws.rs.core.MultivaluedHashMap;
  42 import javax.ws.rs.core.MultivaluedMap;
  43 import javax.ws.rs.core.Response;
  44 import javax.ws.rs.core.UriInfo;
  45 import org.glassfish.jersey.server.ResourceConfig;
  46 import org.glassfish.jersey.test.JerseyTest;
  47 import org.junit.BeforeClass;
  48 import org.junit.Ignore;
  49 import org.junit.Test;
  50 import org.mockito.Mockito;
  51 import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
  52 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
  53 import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
  54 import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
  55 import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
  56 import org.opendaylight.netconf.sal.rest.impl.RestconfApplication;
  57 import org.opendaylight.netconf.sal.rest.impl.RestconfDocumentedExceptionMapper;
  58 import org.opendaylight.netconf.sal.rest.impl.XmlNormalizedNodeBodyReader;
  59 import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
  60 import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
  61 import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
  62 import org.opendaylight.netconf.sal.restconf.impl.RestconfImpl;
  63 import org.opendaylight.yangtools.yang.common.QName;
  64 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  65 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  66 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  67 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  68 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  69 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  70 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  71 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  72 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
  73 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
  74 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
  75 import org.opendaylight.yangtools.yang.model.api.Module;
  76 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  77 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  78 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  79 import org.w3c.dom.Document;
  80 import org.w3c.dom.Element;
  81 import org.w3c.dom.NodeList;
  82
  83 public class RestGetOperationTest extends JerseyTest {
  84
  85     static class NodeData {
  86         Object key;
  87         Object data; // List for a CompositeNode, value Object for a SimpleNode
  88
  89         NodeData(final Object key, final Object data) {
  90             this.key = key;
  91             this.data = data;
  92         }
  93     }
  94
  95     private static BrokerFacade brokerFacade;
  96     private static RestconfImpl restconfImpl;
  97     private static SchemaContext schemaContextYangsIetf;
  98     private static SchemaContext schemaContextTestModule;
  99     @SuppressWarnings("rawtypes")
 100     private static NormalizedNode answerFromGet;
 101
 102     private static SchemaContext schemaContextModules;
 103     private static SchemaContext schemaContextBehindMountPoint;
 104
 105     private static final String RESTCONF_NS = "urn:ietf:params:xml:ns:yang:ietf-restconf";
 106
 107     @BeforeClass
 108     public static void init() throws FileNotFoundException, ParseException, ReactorException {
 109         schemaContextYangsIetf = TestUtils.loadSchemaContext("/full-versions/yangs");
 110         schemaContextTestModule = TestUtils.loadSchemaContext("/full-versions/test-module");
 111         brokerFacade = mock(BrokerFacade.class);
 112         restconfImpl = RestconfImpl.getInstance();
 113         restconfImpl.setBroker(brokerFacade);
 114         answerFromGet = TestUtils.prepareNormalizedNodeWithIetfInterfacesInterfacesData();
 115
 116         schemaContextModules = TestUtils.loadSchemaContext("/modules");
 117         schemaContextBehindMountPoint = TestUtils.loadSchemaContext("/modules/modules-behind-mount-point");
 118     }
 119
 120     @Override
 121     protected Application configure() {
 122         /* enable/disable Jersey logs to console */
 123         // enable(TestProperties.LOG_TRAFFIC);
 124         // enable(TestProperties.DUMP_ENTITY);
 125         // enable(TestProperties.RECORD_LOG_LEVEL);
 126         // set(TestProperties.RECORD_LOG_LEVEL, Level.ALL.intValue());
 127         ResourceConfig resourceConfig = new ResourceConfig();
 128         resourceConfig = resourceConfig.registerInstances(restconfImpl, new NormalizedNodeJsonBodyWriter(),
 129                 new NormalizedNodeXmlBodyWriter(), new XmlNormalizedNodeBodyReader(), new JsonNormalizedNodeBodyReader());
 130         resourceConfig.registerClasses(RestconfDocumentedExceptionMapper.class);
 131         resourceConfig.registerClasses(new RestconfApplication().getClasses());
 132         return resourceConfig;
 133     }
 134
 135     private static void setControllerContext(final SchemaContext schemaContext) {
 136         final ControllerContext controllerContext = ControllerContext.getInstance();
 137         controllerContext.setSchemas(schemaContext);
 138         restconfImpl.setControllerContext(controllerContext);
 139     }
 140
 141     /**
 142      * Tests of status codes for "/operational/{identifier}".
 143      */
 144     @Test
 145     public void getOperationalStatusCodes() throws UnsupportedEncodingException {
 146         setControllerContext(schemaContextYangsIetf);
 147         mockReadOperationalDataMethod();
 148         String uri = "/operational/ietf-interfaces:interfaces/interface/eth0";
 149         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 150
 151         uri = "/operational/wrong-module:interfaces/interface/eth0";
 152         assertEquals(400, get(uri, MediaType.APPLICATION_XML));
 153     }
 154
 155     /**
 156      * Tests of status codes for "/config/{identifier}".
 157      */
 158     @Test
 159     public void getConfigStatusCodes() throws UnsupportedEncodingException {
 160         setControllerContext(schemaContextYangsIetf);
 161         mockReadConfigurationDataMethod();
 162         String uri = "/config/ietf-interfaces:interfaces/interface/eth0";
 163         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 164
 165         uri = "/config/wrong-module:interfaces/interface/eth0";
 166         assertEquals(400, get(uri, MediaType.APPLICATION_XML));
 167     }
 168
 169     /**
 170      * MountPoint test. URI represents mount point.
 171      */
 172     @SuppressWarnings("unchecked")
 173     @Test
 174     public void getDataWithUrlMountPoint() throws UnsupportedEncodingException, URISyntaxException, ParseException {
 175         when(brokerFacade.readConfigurationData(any(DOMMountPoint.class), any(YangInstanceIdentifier.class),
 176                 Mockito.anyString())).thenReturn(
 177                 prepareCnDataForMountPointTest(false));
 178         final DOMMountPoint mountInstance = mock(DOMMountPoint.class);
 179         when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
 180         final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
 181         when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(Optional.of(mountInstance));
 182
 183         ControllerContext.getInstance().setMountService(mockMountService);
 184
 185         String uri = "/config/ietf-interfaces:interfaces/interface/0/yang-ext:mount/test-module:cont/cont1";
 186         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 187
 188         uri = "/config/ietf-interfaces:interfaces/yang-ext:mount/test-module:cont/cont1";
 189         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 190     }
 191
 192     /**
 193      * MountPoint test. URI represents mount point.
 194      *
 195      * Slashes in URI behind mount point. lst1 element with key GigabitEthernet0%2F0%2F0%2F0 (GigabitEthernet0/0/0/0) is
 196      * requested via GET HTTP operation. It is tested whether %2F character is replaced with simple / in
 197      * InstanceIdentifier parameter in method
 198      * {@link BrokerFacade#readConfigurationData(DOMMountPoint, YangInstanceIdentifier)} which is called in
 199      * method {@link RestconfImpl#readConfigurationData}
 200      *
 201      * @throws ParseException
 202      */
 203     @Test
 204     public void getDataWithSlashesBehindMountPoint() throws Exception {
 205         final YangInstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
 206         when(brokerFacade.readConfigurationData(any(DOMMountPoint.class), eq(awaitedInstanceIdentifier),
 207                 Mockito.anyString())).thenReturn(prepareCnDataForSlashesBehindMountPointTest());
 208         final DOMMountPoint mountInstance = mock(DOMMountPoint.class);
 209         when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
 210         final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
 211         when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(Optional.of(mountInstance));
 212
 213         ControllerContext.getInstance().setMountService(mockMountService);
 214
 215         final String uri = "/config/ietf-interfaces:interfaces/interface/0/yang-ext:mount/test-module:cont/lst1/GigabitEthernet0%2F0%2F0%2F0";
 216         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 217     }
 218
 219     private static YangInstanceIdentifier prepareInstanceIdentifierForList() throws Exception {
 220         final List<PathArgument> parameters = new ArrayList<>();
 221
 222         final QName qNameCont = newTestModuleQName("cont");
 223         final QName qNameList = newTestModuleQName("lst1");
 224         final QName qNameKeyList = newTestModuleQName("lf11");
 225
 226         parameters.add(new YangInstanceIdentifier.NodeIdentifier(qNameCont));
 227         parameters.add(new YangInstanceIdentifier.NodeIdentifier(qNameList));
 228         parameters.add(new YangInstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
 229                 "GigabitEthernet0/0/0/0"));
 230         return YangInstanceIdentifier.create(parameters);
 231     }
 232
 233     private static QName newTestModuleQName(final String localPart) throws Exception {
 234         final Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2014-01-09");
 235         final URI uri = new URI("test:module");
 236         return QName.create(uri, revision, localPart);
 237     }
 238
 239     @Test
 240     public void getDataMountPointIntoHighestElement() throws UnsupportedEncodingException, URISyntaxException,
 241             ParseException {
 242         when(brokerFacade.readConfigurationData(any(DOMMountPoint.class), any(YangInstanceIdentifier.class),
 243                 Mockito.anyString())).thenReturn(
 244                 prepareCnDataForMountPointTest(true));
 245         final DOMMountPoint mountInstance = mock(DOMMountPoint.class);
 246         when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
 247         final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
 248         when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(Optional.of(mountInstance));
 249
 250         ControllerContext.getInstance().setMountService(mockMountService);
 251
 252         final String uri = "/config/ietf-interfaces:interfaces/interface/0/yang-ext:mount/test-module:cont";
 253         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 254     }
 255
 256     @SuppressWarnings("unchecked")
 257     @Test
 258     public void getDataWithIdentityrefInURL() throws Exception {
 259         setControllerContext(schemaContextTestModule);
 260
 261         final QName moduleQN = newTestModuleQName("module");
 262         final ImmutableMap<QName, Object> keyMap = ImmutableMap.<QName, Object>builder()
 263                 .put(newTestModuleQName("type"), newTestModuleQName("test-identity"))
 264                 .put(newTestModuleQName("name"), "foo").build();
 265         final YangInstanceIdentifier iid = YangInstanceIdentifier.builder().node(newTestModuleQName("modules"))
 266                 .node(moduleQN).nodeWithKey(moduleQN, keyMap).build();
 267         @SuppressWarnings("rawtypes")
 268         final
 269         NormalizedNode data = ImmutableMapNodeBuilder.create().withNodeIdentifier(
 270                 new NodeIdentifier(moduleQN)).withChild(ImmutableNodes.mapEntryBuilder()
 271                         .withNodeIdentifier(new NodeIdentifierWithPredicates(moduleQN, keyMap))
 272                         .withChild(ImmutableNodes.leafNode(newTestModuleQName("type"), newTestModuleQName("test-identity")))
 273                         .withChild(ImmutableNodes.leafNode(newTestModuleQName("name"), "foo"))
 274                         .withChild(ImmutableNodes.leafNode(newTestModuleQName("data"), "bar")).build()).build();
 275         when(brokerFacade.readConfigurationData(iid, null)).thenReturn(data);
 276
 277         final String uri = "/config/test-module:modules/module/test-module:test-identity/foo";
 278         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 279     }
 280
 281     // /modules
 282     @Test
 283     public void getModulesTest() throws UnsupportedEncodingException, FileNotFoundException {
 284         final ControllerContext controllerContext = ControllerContext.getInstance();
 285         controllerContext.setGlobalSchema(schemaContextModules);
 286         restconfImpl.setControllerContext(controllerContext);
 287
 288         final String uri = "/modules";
 289
 290         Response response = target(uri).request("application/yang.api+json").get();
 291         validateModulesResponseJson(response);
 292
 293         response = target(uri).request("application/yang.api+xml").get();
 294         validateModulesResponseXml(response,schemaContextModules);
 295     }
 296
 297     // /streams/
 298     @Test
 299     @Ignore // FIXME : find why it is fail by in gerrit build
 300     public void getStreamsTest() throws UnsupportedEncodingException, FileNotFoundException {
 301         setControllerContext(schemaContextModules);
 302
 303         final String uri = "/streams";
 304
 305         Response response = target(uri).request("application/yang.api+json").get();
 306         final String responseBody = response.readEntity(String.class);
 307         assertEquals(200, response.getStatus());
 308         assertNotNull(responseBody);
 309         assertTrue(responseBody.contains("streams"));
 310
 311         response = target(uri).request("application/yang.api+xml").get();
 312         assertEquals(200, response.getStatus());
 313         final Document responseXmlBody = response.readEntity(Document.class);
 314         assertNotNull(responseXmlBody);
 315         final Element rootNode = responseXmlBody.getDocumentElement();
 316
 317         assertEquals("streams", rootNode.getLocalName());
 318         assertEquals(RESTCONF_NS, rootNode.getNamespaceURI());
 319     }
 320
 321     // /modules/module
 322     @Test
 323     public void getModuleTest() throws FileNotFoundException, UnsupportedEncodingException {
 324         setControllerContext(schemaContextModules);
 325
 326         final String uri = "/modules/module/module2/2014-01-02";
 327
 328         Response response = target(uri).request("application/yang.api+xml").get();
 329         assertEquals(200, response.getStatus());
 330         final Document responseXml = response.readEntity(Document.class);
 331
 332         final QName qname = assertedModuleXmlToModuleQName(responseXml.getDocumentElement());
 333         assertNotNull(qname);
 334
 335         assertEquals("module2", qname.getLocalName());
 336         assertEquals("module:2", qname.getNamespace().toString());
 337         assertEquals("2014-01-02", qname.getFormattedRevision());
 338
 339         response = target(uri).request("application/yang.api+json").get();
 340         assertEquals(200, response.getStatus());
 341         final String responseBody = response.readEntity(String.class);
 342         assertTrue("Module2 in json wasn't found", prepareJsonRegex("module2", "2014-01-02", "module:2", responseBody)
 343                 .find());
 344         final String[] split = responseBody.split("\"module\"");
 345         assertEquals("\"module\" element is returned more then once", 2, split.length);
 346
 347     }
 348
 349     // /operations
 350     @Ignore
 351     @Test
 352     public void getOperationsTest() throws FileNotFoundException, UnsupportedEncodingException {
 353         setControllerContext(schemaContextModules);
 354
 355         final String uri = "/operations";
 356
 357         Response response = target(uri).request("application/yang.api+xml").get();
 358         assertEquals(500, response.getStatus());
 359         final Document responseDoc = response.readEntity(Document.class);
 360         validateOperationsResponseXml(responseDoc, schemaContextModules);
 361
 362         response = target(uri).request("application/yang.api+json").get();
 363         assertEquals(200, response.getStatus());
 364         final String responseBody = response.readEntity(String.class);
 365         assertTrue("Json response for /operations dummy-rpc1-module1 is incorrect",
 366                 validateOperationsResponseJson(responseBody, "dummy-rpc1-module1", "module1").find());
 367         assertTrue("Json response for /operations dummy-rpc2-module1 is incorrect",
 368                 validateOperationsResponseJson(responseBody, "dummy-rpc2-module1", "module1").find());
 369         assertTrue("Json response for /operations dummy-rpc1-module2 is incorrect",
 370                 validateOperationsResponseJson(responseBody, "dummy-rpc1-module2", "module2").find());
 371         assertTrue("Json response for /operations dummy-rpc2-module2 is incorrect",
 372                 validateOperationsResponseJson(responseBody, "dummy-rpc2-module2", "module2").find());
 373
 374     }
 375
 376     private static void validateOperationsResponseXml(final Document responseDoc, final SchemaContext schemaContext) {
 377
 378         final Element operationsElem = responseDoc.getDocumentElement();
 379         assertEquals(RESTCONF_NS, operationsElem.getNamespaceURI());
 380         assertEquals("operations", operationsElem.getLocalName());
 381
 382         final NodeList operationsList = operationsElem.getChildNodes();
 383         final HashSet<String> foundOperations = new HashSet<>();
 384
 385         for (int i = 0; i < operationsList.getLength(); i++) {
 386             final org.w3c.dom.Node operation = operationsList.item(i);
 387             foundOperations.add(operation.getLocalName());
 388         }
 389
 390         for (final RpcDefinition schemaOp : schemaContext.getOperations()) {
 391             assertTrue(foundOperations.contains(schemaOp.getQName().getLocalName()));
 392         }
 393     }
 394
 395     // /operations/pathToMountPoint/yang-ext:mount
 396     @Ignore
 397     @Test
 398     public void getOperationsBehindMountPointTest() throws FileNotFoundException, UnsupportedEncodingException {
 399         setControllerContext(schemaContextModules);
 400
 401         final DOMMountPoint mountInstance = mock(DOMMountPoint.class);
 402         when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
 403         final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
 404         when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(Optional.of(mountInstance));
 405
 406         ControllerContext.getInstance().setMountService(mockMountService);
 407
 408         final String uri = "/operations/ietf-interfaces:interfaces/interface/0/yang-ext:mount/";
 409
 410         Response response = target(uri).request("application/yang.api+xml").get();
 411         assertEquals(500, response.getStatus());
 412
 413         final Document responseDoc = response.readEntity(Document.class);
 414         validateOperationsResponseXml(responseDoc, schemaContextBehindMountPoint);
 415
 416         response = target(uri).request("application/yang.api+json").get();
 417         assertEquals(200, response.getStatus());
 418         final String responseBody = response.readEntity(String.class);
 419         assertTrue("Json response for /operations/mount_point rpc-behind-module1 is incorrect",
 420                 validateOperationsResponseJson(responseBody, "rpc-behind-module1", "module1-behind-mount-point").find());
 421         assertTrue("Json response for /operations/mount_point rpc-behind-module2 is incorrect",
 422                 validateOperationsResponseJson(responseBody, "rpc-behind-module2", "module2-behind-mount-point").find());
 423
 424     }
 425
 426     private static Matcher validateOperationsResponseJson(final String searchIn, final String rpcName,
 427             final String moduleName) {
 428         final StringBuilder regex = new StringBuilder();
 429         regex.append(".*\"" + rpcName + "\"");
 430         final Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 431         return ptrn.matcher(searchIn);
 432
 433     }
 434
 435     private static Matcher validateOperationsResponseXml(final String searchIn, final String rpcName,
 436             final String namespace) {
 437         final StringBuilder regex = new StringBuilder();
 438
 439         regex.append("^");
 440
 441         regex.append(".*<operations");
 442         regex.append(".*xmlns=\"urn:ietf:params:xml:ns:yang:ietf-restconf\"");
 443         regex.append(".*>");
 444
 445         regex.append(".*<");
 446         regex.append(".*" + rpcName);
 447         regex.append(".*" + namespace);
 448         regex.append(".*/");
 449         regex.append(".*>");
 450
 451         regex.append(".*</operations.*");
 452         regex.append(".*>");
 453
 454         regex.append(".*");
 455         regex.append("$");
 456         final Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 457         return ptrn.matcher(searchIn);
 458     }
 459
 460     // /restconf/modules/pathToMountPoint/yang-ext:mount
 461     @Test
 462     public void getModulesBehindMountPoint() throws FileNotFoundException, UnsupportedEncodingException {
 463         setControllerContext(schemaContextModules);
 464
 465         final DOMMountPoint mountInstance = mock(DOMMountPoint.class);
 466         when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
 467         final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
 468         when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(Optional.of(mountInstance));
 469
 470         ControllerContext.getInstance().setMountService(mockMountService);
 471
 472         final String uri = "/modules/ietf-interfaces:interfaces/interface/0/yang-ext:mount/";
 473
 474         Response response = target(uri).request("application/yang.api+json").get();
 475         assertEquals(200, response.getStatus());
 476         final String responseBody = response.readEntity(String.class);
 477
 478         assertTrue(
 479                 "module1-behind-mount-point in json wasn't found",
 480                 prepareJsonRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point",
 481                         responseBody).find());
 482         assertTrue(
 483                 "module2-behind-mount-point in json wasn't found",
 484                 prepareJsonRegex("module2-behind-mount-point", "2014-02-04", "module:2:behind:mount:point",
 485                         responseBody).find());
 486
 487         response = target(uri).request("application/yang.api+xml").get();
 488         assertEquals(200, response.getStatus());
 489         validateModulesResponseXml(response, schemaContextBehindMountPoint);
 490
 491     }
 492
 493     // /restconf/modules/module/pathToMountPoint/yang-ext:mount/moduleName/revision
 494     @Test
 495     public void getModuleBehindMountPoint() throws FileNotFoundException, UnsupportedEncodingException {
 496         setControllerContext(schemaContextModules);
 497
 498         final DOMMountPoint mountInstance = mock(DOMMountPoint.class);
 499         when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
 500         final DOMMountPointService mockMountService = mock(DOMMountPointService.class);
 501         when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(Optional.of(mountInstance));
 502
 503         ControllerContext.getInstance().setMountService(mockMountService);
 504
 505         final String uri = "/modules/module/ietf-interfaces:interfaces/interface/0/yang-ext:mount/module1-behind-mount-point/2014-02-03";
 506
 507         Response response = target(uri).request("application/yang.api+json").get();
 508         assertEquals(200, response.getStatus());
 509         final String responseBody = response.readEntity(String.class);
 510
 511         assertTrue(
 512                 "module1-behind-mount-point in json wasn't found",
 513                 prepareJsonRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point",
 514                         responseBody).find());
 515         final String[] split = responseBody.split("\"module\"");
 516         assertEquals("\"module\" element is returned more then once", 2, split.length);
 517
 518         response = target(uri).request("application/yang.api+xml").get();
 519         assertEquals(200, response.getStatus());
 520         final Document responseXml = response.readEntity(Document.class);
 521
 522         final QName module = assertedModuleXmlToModuleQName(responseXml.getDocumentElement());
 523
 524         assertEquals("module1-behind-mount-point", module.getLocalName());
 525         assertEquals("2014-02-03", module.getFormattedRevision());
 526         assertEquals("module:1:behind:mount:point", module.getNamespace().toString());
 527
 528
 529     }
 530
 531     private static void validateModulesResponseXml(final Response response, final SchemaContext schemaContext) {
 532         assertEquals(200, response.getStatus());
 533         final Document responseBody = response.readEntity(Document.class);
 534         final NodeList moduleNodes = responseBody.getDocumentElement().getElementsByTagNameNS(RESTCONF_NS, "module");
 535
 536         assertTrue(moduleNodes.getLength() > 0);
 537
 538         final HashSet<QName> foundModules = new HashSet<>();
 539
 540         for(int i=0;i < moduleNodes.getLength();i++) {
 541             final org.w3c.dom.Node module = moduleNodes.item(i);
 542
 543             final QName name = assertedModuleXmlToModuleQName(module);
 544             foundModules.add(name);
 545         }
 546
 547         assertAllModules(foundModules,schemaContext);
 548     }
 549
 550     private static void assertAllModules(final Set<QName> foundModules, final SchemaContext schemaContext) {
 551         for(final Module module : schemaContext.getModules()) {
 552             final QName current = QName.create(module.getQNameModule(),module.getName());
 553             assertTrue("Module not found in response.",foundModules.contains(current));
 554         }
 555
 556     }
 557
 558     private static QName assertedModuleXmlToModuleQName(final org.w3c.dom.Node module) {
 559         assertEquals("module", module.getLocalName());
 560         assertEquals(RESTCONF_NS, module.getNamespaceURI());
 561         String revision = null;
 562         String namespace = null;
 563         String name = null;
 564
 565
 566         final NodeList childNodes = module.getChildNodes();
 567
 568         for(int i =0;i < childNodes.getLength(); i++) {
 569             final org.w3c.dom.Node child = childNodes.item(i);
 570             assertEquals(RESTCONF_NS, child.getNamespaceURI());
 571
 572             switch(child.getLocalName()) {
 573                 case "name":
 574                     assertNull("Name element appeared multiple times",name);
 575                     name = child.getTextContent().trim();
 576                     break;
 577                 case "revision":
 578                     assertNull("Revision element appeared multiple times",revision);
 579                     revision = child.getTextContent().trim();
 580                     break;
 581
 582                 case "namespace":
 583                     assertNull("Namespace element appeared multiple times",namespace);
 584                     namespace = child.getTextContent().trim();
 585                     break;
 586             }
 587         }
 588
 589         assertNotNull("Revision was not part of xml",revision);
 590         assertNotNull("Module namespace was not part of xml",namespace);
 591         assertNotNull("Module identiffier was not part of xml",name);
 592
 593
 594         // TODO Auto-generated method stub
 595
 596         return QName.create(namespace,revision,name);
 597     }
 598
 599     private static void validateModulesResponseJson(final Response response) {
 600         assertEquals(200, response.getStatus());
 601         final String responseBody = response.readEntity(String.class);
 602
 603         assertTrue("Module1 in json wasn't found", prepareJsonRegex("module1", "2014-01-01", "module:1", responseBody)
 604                 .find());
 605         assertTrue("Module2 in json wasn't found", prepareJsonRegex("module2", "2014-01-02", "module:2", responseBody)
 606                 .find());
 607         assertTrue("Module3 in json wasn't found", prepareJsonRegex("module3", "2014-01-03", "module:3", responseBody)
 608                 .find());
 609     }
 610
 611     private static Matcher prepareJsonRegex(final String module, final String revision, final String namespace,
 612             final String searchIn) {
 613         final StringBuilder regex = new StringBuilder();
 614         regex.append("^");
 615
 616         regex.append(".*\\{");
 617         regex.append(".*\"name\"");
 618         regex.append(".*:");
 619         regex.append(".*\"" + module + "\",");
 620
 621         regex.append(".*\"revision\"");
 622         regex.append(".*:");
 623         regex.append(".*\"" + revision + "\",");
 624
 625         regex.append(".*\"namespace\"");
 626         regex.append(".*:");
 627         regex.append(".*\"" + namespace + "\"");
 628
 629         regex.append(".*\\}");
 630
 631         regex.append(".*");
 632         regex.append("$");
 633         final Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 634         return ptrn.matcher(searchIn);
 635
 636     }
 637
 638
 639     private int get(final String uri, final String mediaType) {
 640         return target(uri).request(mediaType).get().getStatus();
 641     }
 642
 643     /**
 644     container cont {
 645         container cont1 {
 646             leaf lf11 {
 647                 type string;
 648             }
 649     */
 650     @SuppressWarnings("rawtypes")
 651     private static NormalizedNode prepareCnDataForMountPointTest(final boolean wrapToCont)
 652             throws URISyntaxException, ParseException {
 653         final String testModuleDate = "2014-01-09";
 654         final ContainerNode contChild = Builders
 655                 .containerBuilder()
 656                 .withNodeIdentifier(TestUtils.getNodeIdentifier("cont1", "test:module", testModuleDate))
 657                 .withChild(
 658                         Builders.leafBuilder()
 659                                 .withNodeIdentifier(TestUtils.getNodeIdentifier("lf11", "test:module", testModuleDate))
 660                                 .withValue("lf11 value").build()).build();
 661
 662         if (wrapToCont) {
 663             return Builders.containerBuilder()
 664                     .withNodeIdentifier(TestUtils.getNodeIdentifier("cont", "test:module", testModuleDate))
 665                     .withChild(contChild).build();
 666         }
 667         return contChild;
 668
 669     }
 670
 671     @SuppressWarnings("unchecked")
 672     private static void mockReadOperationalDataMethod() {
 673         when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(answerFromGet);
 674     }
 675
 676     @SuppressWarnings("unchecked")
 677     private static void mockReadConfigurationDataMethod() {
 678         when(brokerFacade.readConfigurationData(any(YangInstanceIdentifier.class), Mockito.anyString()))
 679                 .thenReturn(answerFromGet);
 680     }
 681
 682     @SuppressWarnings("rawtypes")
 683     private static NormalizedNode prepareCnDataForSlashesBehindMountPointTest() throws ParseException {
 684         return ImmutableMapEntryNodeBuilder
 685                 .create()
 686                 .withNodeIdentifier(
 687                         TestUtils.getNodeIdentifierPredicate("lst1", "test:module", "2014-01-09", "lf11",
 688                                 "GigabitEthernet0/0/0/0"))
 689                 .withChild(
 690                         ImmutableLeafNodeBuilder.create()
 691                                 .withNodeIdentifier(TestUtils.getNodeIdentifier("lf11", "test:module", "2014-01-09"))
 692                                 .withValue("GigabitEthernet0/0/0/0").build()).build();
 693
 694     }
 695
 696     /**
 697      * If includeWhiteChars URI parameter is set to false then no white characters can be included in returned output
 698      *
 699      * @throws UnsupportedEncodingException
 700      */
 701     @Test
 702     public void getDataWithUriIncludeWhiteCharsParameterTest() throws UnsupportedEncodingException {
 703         getDataWithUriIncludeWhiteCharsParameter("config");
 704         getDataWithUriIncludeWhiteCharsParameter("operational");
 705     }
 706
 707     private void getDataWithUriIncludeWhiteCharsParameter(final String target) throws UnsupportedEncodingException {
 708         mockReadConfigurationDataMethod();
 709         mockReadOperationalDataMethod();
 710         final String uri = "/" + target + "/ietf-interfaces:interfaces/interface/eth0";
 711         Response response = target(uri).queryParam("prettyPrint", "false").request("application/xml").get();
 712         final String xmlData = response.readEntity(String.class);
 713
 714         Pattern pattern = Pattern.compile(".*(>\\s+|\\s+<).*", Pattern.DOTALL);
 715         Matcher matcher = pattern.matcher(xmlData);
 716         // XML element can't surrounded with white character (e.g ">    " or
 717         // "    <")
 718         assertFalse(matcher.matches());
 719
 720         response = target(uri).queryParam("prettyPrint", "false").request("application/json").get();
 721         final String jsonData = response.readEntity(String.class);
 722         pattern = Pattern.compile(".*(\\}\\s+|\\s+\\{|\\]\\s+|\\s+\\[|\\s+:|:\\s+).*", Pattern.DOTALL);
 723         matcher = pattern.matcher(jsonData);
 724         // JSON element can't surrounded with white character (e.g "} ", " {",
 725         // "] ", " [", " :" or ": ")
 726         assertFalse(matcher.matches());
 727     }
 728
 729     /**
 730      * Tests behavior when invalid value of depth URI parameter
 731      */
 732     @Test
 733     @Ignore
 734     public void getDataWithInvalidDepthParameterTest() {
 735         setControllerContext(schemaContextModules);
 736
 737         final MultivaluedMap<String, String> paramMap = new MultivaluedHashMap<>();
 738         paramMap.putSingle("depth", "1o");
 739         final UriInfo mockInfo = mock(UriInfo.class);
 740         when(mockInfo.getQueryParameters(false)).thenAnswer(invocation -> paramMap);
 741
 742         getDataWithInvalidDepthParameterTest(mockInfo);
 743
 744         paramMap.putSingle("depth", "0");
 745         getDataWithInvalidDepthParameterTest(mockInfo);
 746
 747         paramMap.putSingle("depth", "-1");
 748         getDataWithInvalidDepthParameterTest(mockInfo);
 749     }
 750
 751     @SuppressWarnings({"rawtypes", "unchecked"})
 752     private static void getDataWithInvalidDepthParameterTest(final UriInfo uriInfo) {
 753         try {
 754             final QName qNameDepth1Cont = QName.create("urn:nested:module", "2014-06-3", "depth1-cont");
 755             final YangInstanceIdentifier ii = YangInstanceIdentifier.builder().node(qNameDepth1Cont).build();
 756             final NormalizedNode value = (Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(qNameDepth1Cont)).build());
 757             when(brokerFacade.readConfigurationData(eq(ii))).thenReturn(value);
 758             restconfImpl.readConfigurationData("nested-module:depth1-cont", uriInfo);
 759             fail("Expected RestconfDocumentedException");
 760         } catch (final RestconfDocumentedException e) {
 761             assertTrue("Unexpected error message: " + e.getErrors().get(0).getErrorMessage(), e.getErrors().get(0)
 762                     .getErrorMessage().contains("depth"));
 763         }
 764     }
 765
 766     @SuppressWarnings("unused")
 767     private void verifyXMLResponse(final Response response, final NodeData nodeData) {
 768         final Document doc = response.readEntity(Document.class);
 769 //        Document doc = TestUtils.loadDocumentFrom((InputStream) response.getEntity());
 770 //        System.out.println();
 771         assertNotNull("Could not parse XML document", doc);
 772
 773         // System.out.println(TestUtils.getDocumentInPrintableForm( doc ));
 774
 775         verifyContainerElement(doc.getDocumentElement(), nodeData);
 776     }
 777
 778     @SuppressWarnings("unchecked")
 779     private void verifyContainerElement(final Element element, final NodeData nodeData) {
 780
 781         assertEquals("Element local name", nodeData.key, element.getLocalName());
 782
 783         final NodeList childNodes = element.getChildNodes();
 784         if (nodeData.data == null) { // empty container
 785             assertTrue("Expected no child elements for \"" + element.getLocalName() + "\"", childNodes.getLength() == 0);
 786             return;
 787         }
 788
 789         final Map<String, NodeData> expChildMap = Maps.newHashMap();
 790         for (final NodeData expChild : (List<NodeData>) nodeData.data) {
 791             expChildMap.put(expChild.key.toString(), expChild);
 792         }
 793
 794         for (int i = 0; i < childNodes.getLength(); i++) {
 795             final org.w3c.dom.Node actualChild = childNodes.item(i);
 796             if (!(actualChild instanceof Element)) {
 797                 continue;
 798             }
 799
 800             final Element actualElement = (Element) actualChild;
 801             final NodeData expChild = expChildMap.remove(actualElement.getLocalName());
 802             assertNotNull(
 803                     "Unexpected child element for parent \"" + element.getLocalName() + "\": "
 804                             + actualElement.getLocalName(), expChild);
 805
 806             if ((expChild.data == null) || (expChild.data instanceof List)) {
 807                 verifyContainerElement(actualElement, expChild);
 808             } else {
 809                 assertEquals("Text content for element: " + actualElement.getLocalName(), expChild.data,
 810                         actualElement.getTextContent());
 811             }
 812         }
 813
 814         if (!expChildMap.isEmpty()) {
 815             fail("Missing elements for parent \"" + element.getLocalName() + "\": " + expChildMap.keySet());
 816         }
 817     }
 818
 819 }