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