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 junit.framework.Assert.assertNotNull;
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.Matchers.any;
  14 import static org.mockito.Matchers.eq;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.when;
  17
  18 import java.io.FileNotFoundException;
  19 import java.io.UnsupportedEncodingException;
  20 import java.net.URI;
  21 import java.net.URISyntaxException;
  22 import java.text.ParseException;
  23 import java.text.SimpleDateFormat;
  24 import java.util.ArrayList;
  25 import java.util.Date;
  26 import java.util.List;
  27 import java.util.regex.Matcher;
  28 import java.util.regex.Pattern;
  29
  30 import javax.ws.rs.core.Application;
  31 import javax.ws.rs.core.MediaType;
  32 import javax.ws.rs.core.Response;
  33
  34 import org.glassfish.jersey.server.ResourceConfig;
  35 import org.glassfish.jersey.test.JerseyTest;
  36 import org.junit.BeforeClass;
  37 import org.junit.Test;
  38 import org.opendaylight.controller.sal.core.api.mount.MountInstance;
  39 import org.opendaylight.controller.sal.core.api.mount.MountService;
  40 import org.opendaylight.controller.sal.rest.impl.JsonToCompositeNodeProvider;
  41 import org.opendaylight.controller.sal.rest.impl.RestconfDocumentedExceptionMapper;
  42 import org.opendaylight.controller.sal.rest.impl.StructuredDataToJsonProvider;
  43 import org.opendaylight.controller.sal.rest.impl.StructuredDataToXmlProvider;
  44 import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
  45 import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
  46 import org.opendaylight.controller.sal.restconf.impl.CompositeNodeWrapper;
  47 import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
  48 import org.opendaylight.controller.sal.restconf.impl.RestconfImpl;
  49 import org.opendaylight.controller.sal.restconf.impl.SimpleNodeWrapper;
  50 import org.opendaylight.yangtools.yang.common.QName;
  51 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  52 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  53 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
  54 import org.opendaylight.yangtools.yang.data.api.Node;
  55 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  56
  57 public class RestGetOperationTest extends JerseyTest {
  58
  59     private static BrokerFacade brokerFacade;
  60     private static RestconfImpl restconfImpl;
  61     private static SchemaContext schemaContextYangsIetf;
  62     private static SchemaContext schemaContextTestModule;
  63     private static CompositeNode answerFromGet;
  64
  65     private static SchemaContext schemaContextModules;
  66     private static SchemaContext schemaContextBehindMountPoint;
  67
  68     @BeforeClass
  69     public static void init() throws FileNotFoundException {
  70         schemaContextYangsIetf = TestUtils.loadSchemaContext("/full-versions/yangs");
  71         schemaContextTestModule = TestUtils.loadSchemaContext("/full-versions/test-module");
  72         ControllerContext controllerContext = ControllerContext.getInstance();
  73         controllerContext.setSchemas(schemaContextYangsIetf);
  74         brokerFacade = mock(BrokerFacade.class);
  75         restconfImpl = RestconfImpl.getInstance();
  76         restconfImpl.setBroker(brokerFacade);
  77         restconfImpl.setControllerContext(controllerContext);
  78         answerFromGet = prepareCompositeNodeWithIetfInterfacesInterfacesData();
  79
  80         schemaContextModules = TestUtils.loadSchemaContext("/modules");
  81         schemaContextBehindMountPoint = TestUtils.loadSchemaContext("/modules/modules-behind-mount-point");
  82     }
  83
  84     @Override
  85     protected Application configure() {
  86         /* enable/disable Jersey logs to console */
  87         // enable(TestProperties.LOG_TRAFFIC);
  88         // enable(TestProperties.DUMP_ENTITY);
  89         // enable(TestProperties.RECORD_LOG_LEVEL);
  90         // set(TestProperties.RECORD_LOG_LEVEL, Level.ALL.intValue());
  91         ResourceConfig resourceConfig = new ResourceConfig();
  92         resourceConfig = resourceConfig.registerInstances(restconfImpl, StructuredDataToXmlProvider.INSTANCE,
  93                 StructuredDataToJsonProvider.INSTANCE, XmlToCompositeNodeProvider.INSTANCE,
  94                 JsonToCompositeNodeProvider.INSTANCE);
  95         resourceConfig.registerClasses( RestconfDocumentedExceptionMapper.class );
  96         return resourceConfig;
  97     }
  98
  99     /**
 100      * Tests of status codes for "/operational/{identifier}".
 101      */
 102     @Test
 103     public void getOperationalStatusCodes() throws UnsupportedEncodingException {
 104         mockReadOperationalDataMethod();
 105         String uri = "/operational/ietf-interfaces:interfaces/interface/eth0";
 106         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 107
 108         uri = "/operational/wrong-module:interfaces/interface/eth0";
 109         assertEquals(400, get(uri, MediaType.APPLICATION_XML));
 110     }
 111
 112     /**
 113      * Tests of status codes for "/config/{identifier}".
 114      */
 115     @Test
 116     public void getConfigStatusCodes() throws UnsupportedEncodingException {
 117         mockReadConfigurationDataMethod();
 118         String uri = "/config/ietf-interfaces:interfaces/interface/eth0";
 119         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 120
 121         uri = "/config/wrong-module:interfaces/interface/eth0";
 122         assertEquals(400, get(uri, MediaType.APPLICATION_XML));
 123     }
 124
 125     /**
 126      * MountPoint test. URI represents mount point.
 127      */
 128     @Test
 129     public void getDataWithUrlMountPoint() throws UnsupportedEncodingException, URISyntaxException {
 130         when(
 131                 brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
 132                         any(InstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
 133         MountInstance mountInstance = mock(MountInstance.class);
 134         when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
 135         MountService mockMountService = mock(MountService.class);
 136         when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
 137
 138         ControllerContext.getInstance().setMountService(mockMountService);
 139
 140         String uri = "/config/ietf-interfaces:interfaces/interface/0/yang-ext:mount/test-module:cont/cont1";
 141         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 142
 143         uri = "/config/ietf-interfaces:interfaces/yang-ext:mount/test-module:cont/cont1";
 144         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 145     }
 146
 147     /**
 148      * MountPoint test. URI represents mount point.
 149      *
 150      * Slashes in URI behind mount point. lst1 element with key
 151      * GigabitEthernet0%2F0%2F0%2F0 (GigabitEthernet0/0/0/0) is requested via
 152      * GET HTTP operation. It is tested whether %2F character is replaced with
 153      * simple / in InstanceIdentifier parameter in method
 154      * {@link BrokerFacade#readConfigurationDataBehindMountPoint(MountInstance, InstanceIdentifier)}
 155      * which is called in method {@link RestconfImpl#readConfigurationData}
 156      *
 157      *
 158      * @throws ParseException
 159      */
 160     @Test
 161     public void getDataWithSlashesBehindMountPoint() throws UnsupportedEncodingException, URISyntaxException,
 162             ParseException {
 163         InstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
 164         when(
 165                 brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
 166                         eq(awaitedInstanceIdentifier))).thenReturn(prepareCnDataForMountPointTest());
 167         MountInstance mountInstance = mock(MountInstance.class);
 168         when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
 169         MountService mockMountService = mock(MountService.class);
 170         when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
 171
 172         ControllerContext.getInstance().setMountService(mockMountService);
 173
 174         String uri = "/config/ietf-interfaces:interfaces/interface/0/yang-ext:mount/test-module:cont/lst1/GigabitEthernet0%2F0%2F0%2F0";
 175         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 176     }
 177
 178     private InstanceIdentifier prepareInstanceIdentifierForList() throws URISyntaxException, ParseException {
 179         List<PathArgument> parameters = new ArrayList<>();
 180
 181         Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2014-01-09");
 182         URI uri = new URI("test:module");
 183         QName qNameCont = QName.create(uri, revision, "cont");
 184         QName qNameList = QName.create(uri, revision, "lst1");
 185         QName qNameKeyList = QName.create(uri, revision, "lf11");
 186
 187         parameters.add(new InstanceIdentifier.NodeIdentifier(qNameCont));
 188         parameters.add(new InstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
 189                 "GigabitEthernet0/0/0/0"));
 190         return new InstanceIdentifier(parameters);
 191     }
 192
 193     @Test
 194     public void getDataMountPointIntoHighestElement() throws UnsupportedEncodingException, URISyntaxException {
 195         when(
 196                 brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
 197                         any(InstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
 198         MountInstance mountInstance = mock(MountInstance.class);
 199         when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
 200         MountService mockMountService = mock(MountService.class);
 201         when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
 202
 203         ControllerContext.getInstance().setMountService(mockMountService);
 204
 205         String uri = "/config/ietf-interfaces:interfaces/interface/0/yang-ext:mount/";
 206         assertEquals(200, get(uri, MediaType.APPLICATION_XML));
 207     }
 208
 209     // /modules
 210     @Test
 211     public void getModulesTest() throws UnsupportedEncodingException, FileNotFoundException {
 212         ControllerContext.getInstance().setGlobalSchema(schemaContextModules);
 213
 214         String uri = "/modules";
 215
 216         Response response = target(uri).request("application/yang.api+json").get();
 217         validateModulesResponseJson(response);
 218
 219         response = target(uri).request("application/yang.api+xml").get();
 220         validateModulesResponseXml(response);
 221     }
 222
 223     // /streams/
 224     @Test
 225     public void getStreamsTest() throws UnsupportedEncodingException, FileNotFoundException {
 226         ControllerContext.getInstance().setGlobalSchema(schemaContextModules);
 227
 228         String uri = "/streams";
 229
 230         Response response = target(uri).request("application/yang.api+json").get();
 231         String responseBody = response.readEntity(String.class);
 232         assertNotNull(responseBody);
 233         assertTrue(responseBody.contains("streams"));
 234
 235         response = target(uri).request("application/yang.api+xml").get();
 236         responseBody = response.readEntity(String.class);
 237         assertNotNull(responseBody);
 238         assertTrue(responseBody.contains("<streams xmlns=\"urn:ietf:params:xml:ns:yang:ietf-restconf\""));
 239     }
 240
 241     // /modules/module
 242     @Test
 243     public void getModuleTest() throws FileNotFoundException, UnsupportedEncodingException {
 244         ControllerContext.getInstance().setGlobalSchema(schemaContextModules);
 245
 246         String uri = "/modules/module/module2/2014-01-02";
 247
 248         Response response = target(uri).request("application/yang.api+xml").get();
 249         assertEquals(200, response.getStatus());
 250         String responseBody = response.readEntity(String.class);
 251         assertTrue("Module2 in xml wasn't found", prepareXmlRegex("module2", "2014-01-02", "module:2", responseBody)
 252                 .find());
 253         String[] split = responseBody.split("<module");
 254         assertEquals("<module element is returned more then once", 2, split.length);
 255
 256         response = target(uri).request("application/yang.api+json").get();
 257         assertEquals(200, response.getStatus());
 258         responseBody = response.readEntity(String.class);
 259         assertTrue("Module2 in json wasn't found", prepareJsonRegex("module2", "2014-01-02", "module:2", responseBody)
 260                 .find());
 261         split = responseBody.split("\"module\"");
 262         assertEquals("\"module\" element is returned more then once", 2, split.length);
 263
 264     }
 265
 266     // /operations
 267     @Test
 268     public void getOperationsTest() throws FileNotFoundException, UnsupportedEncodingException {
 269         ControllerContext.getInstance().setGlobalSchema(schemaContextModules);
 270
 271         String uri = "/operations";
 272
 273         Response response = target(uri).request("application/yang.api+xml").get();
 274         assertEquals(200, response.getStatus());
 275         String responseBody = response.readEntity(String.class);
 276         assertTrue("Xml response for /operations dummy-rpc1-module1 is incorrect",
 277                 validateOperationsResponseXml(responseBody, "dummy-rpc1-module1", "module:1").find());
 278         assertTrue("Xml response for /operations dummy-rpc2-module1 is incorrect",
 279                 validateOperationsResponseXml(responseBody, "dummy-rpc2-module1", "module:1").find());
 280         assertTrue("Xml response for /operations dummy-rpc1-module2 is incorrect",
 281                 validateOperationsResponseXml(responseBody, "dummy-rpc1-module2", "module:2").find());
 282         assertTrue("Xml response for /operations dummy-rpc2-module2 is incorrect",
 283                 validateOperationsResponseXml(responseBody, "dummy-rpc2-module2", "module:2").find());
 284
 285         response = target(uri).request("application/yang.api+json").get();
 286         assertEquals(200, response.getStatus());
 287         responseBody = response.readEntity(String.class);
 288         assertTrue("Json response for /operations dummy-rpc1-module1 is incorrect",
 289                 validateOperationsResponseJson(responseBody, "dummy-rpc1-module1", "module1").find());
 290         assertTrue("Json response for /operations dummy-rpc2-module1 is incorrect",
 291                 validateOperationsResponseJson(responseBody, "dummy-rpc2-module1", "module1").find());
 292         assertTrue("Json response for /operations dummy-rpc1-module2 is incorrect",
 293                 validateOperationsResponseJson(responseBody, "dummy-rpc1-module2", "module2").find());
 294         assertTrue("Json response for /operations dummy-rpc2-module2 is incorrect",
 295                 validateOperationsResponseJson(responseBody, "dummy-rpc2-module2", "module2").find());
 296
 297     }
 298
 299     // /operations/pathToMountPoint/yang-ext:mount
 300     @Test
 301     public void getOperationsBehindMountPointTest() throws FileNotFoundException, UnsupportedEncodingException {
 302         ControllerContext controllerContext = ControllerContext.getInstance();
 303         controllerContext.setGlobalSchema(schemaContextModules);
 304
 305         MountInstance mountInstance = mock(MountInstance.class);
 306         when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
 307         MountService mockMountService = mock(MountService.class);
 308         when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
 309
 310         controllerContext.setMountService(mockMountService);
 311
 312         String uri = "/operations/ietf-interfaces:interfaces/interface/0/yang-ext:mount/";
 313
 314         Response response = target(uri).request("application/yang.api+xml").get();
 315         assertEquals(200, response.getStatus());
 316         String responseBody = response.readEntity(String.class);
 317         assertTrue("Xml response for /operations/mount_point rpc-behind-module1 is incorrect",
 318                 validateOperationsResponseXml(responseBody, "rpc-behind-module1", "module:1:behind:mount:point").find());
 319         assertTrue("Xml response for /operations/mount_point rpc-behind-module2 is incorrect",
 320                 validateOperationsResponseXml(responseBody, "rpc-behind-module2", "module:2:behind:mount:point").find());
 321
 322         response = target(uri).request("application/yang.api+json").get();
 323         assertEquals(200, response.getStatus());
 324         responseBody = response.readEntity(String.class);
 325         assertTrue("Json response for /operations/mount_point rpc-behind-module1 is incorrect",
 326                 validateOperationsResponseJson(responseBody, "rpc-behind-module1", "module1-behind-mount-point").find());
 327         assertTrue("Json response for /operations/mount_point rpc-behind-module2 is incorrect",
 328                 validateOperationsResponseJson(responseBody, "rpc-behind-module2", "module2-behind-mount-point").find());
 329
 330     }
 331
 332     private Matcher validateOperationsResponseJson(String searchIn, String rpcName, String moduleName) {
 333         StringBuilder regex = new StringBuilder();
 334         regex.append("^");
 335
 336         regex.append(".*\\{");
 337         regex.append(".*\"");
 338
 339         // operations prefix optional
 340         regex.append("(");
 341         regex.append("ietf-restconf:");
 342         regex.append("|)");
 343         // :operations prefix optional
 344
 345         regex.append("operations\"");
 346         regex.append(".*:");
 347         regex.append(".*\\{");
 348
 349         regex.append(".*\"" + moduleName);
 350         regex.append(":");
 351         regex.append(rpcName + "\"");
 352         regex.append(".*\\[");
 353         regex.append(".*null");
 354         regex.append(".*\\]");
 355
 356         regex.append(".*\\}");
 357         regex.append(".*\\}");
 358
 359         regex.append(".*");
 360         regex.append("$");
 361         Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 362         return ptrn.matcher(searchIn);
 363
 364     }
 365
 366     private Matcher validateOperationsResponseXml(String searchIn, String rpcName, String namespace) {
 367         StringBuilder regex = new StringBuilder();
 368
 369         regex.append("^");
 370
 371         regex.append(".*<operations");
 372         regex.append(".*xmlns=\"urn:ietf:params:xml:ns:yang:ietf-restconf\"");
 373         regex.append(".*>");
 374
 375         regex.append(".*<");
 376         regex.append(".*" + rpcName);
 377         regex.append(".*" + namespace);
 378         regex.append(".*/");
 379         regex.append(".*>");
 380
 381         regex.append(".*</operations.*");
 382         regex.append(".*>");
 383
 384         regex.append(".*");
 385         regex.append("$");
 386         Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 387         return ptrn.matcher(searchIn);
 388     }
 389
 390     // /restconf/modules/pathToMountPoint/yang-ext:mount
 391     @Test
 392     public void getModulesBehindMountPoint() throws FileNotFoundException, UnsupportedEncodingException {
 393         ControllerContext controllerContext = ControllerContext.getInstance();
 394         controllerContext.setGlobalSchema(schemaContextModules);
 395
 396         MountInstance mountInstance = mock(MountInstance.class);
 397         when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
 398         MountService mockMountService = mock(MountService.class);
 399         when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
 400
 401         controllerContext.setMountService(mockMountService);
 402
 403         String uri = "/modules/ietf-interfaces:interfaces/interface/0/yang-ext:mount/";
 404
 405         Response response = target(uri).request("application/yang.api+json").get();
 406         assertEquals(200, response.getStatus());
 407         String responseBody = response.readEntity(String.class);
 408
 409         assertTrue(
 410                 "module1-behind-mount-point in json wasn't found",
 411                 prepareJsonRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point",
 412                         responseBody).find());
 413         assertTrue(
 414                 "module2-behind-mount-point in json wasn't found",
 415                 prepareJsonRegex("module2-behind-mount-point", "2014-02-04", "module:2:behind:mount:point",
 416                         responseBody).find());
 417
 418         response = target(uri).request("application/yang.api+xml").get();
 419         assertEquals(200, response.getStatus());
 420         responseBody = response.readEntity(String.class);
 421         assertTrue(
 422                 "module1-behind-mount-point in json wasn't found",
 423                 prepareXmlRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point", responseBody)
 424                         .find());
 425         assertTrue(
 426                 "module2-behind-mount-point in json wasn't found",
 427                 prepareXmlRegex("module2-behind-mount-point", "2014-02-04", "module:2:behind:mount:point", responseBody)
 428                         .find());
 429
 430     }
 431
 432     // /restconf/modules/module/pathToMountPoint/yang-ext:mount/moduleName/revision
 433     @Test
 434     public void getModuleBehindMountPoint() throws FileNotFoundException, UnsupportedEncodingException {
 435         ControllerContext controllerContext = ControllerContext.getInstance();
 436         controllerContext.setGlobalSchema(schemaContextModules);
 437
 438         MountInstance mountInstance = mock(MountInstance.class);
 439         when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
 440         MountService mockMountService = mock(MountService.class);
 441         when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
 442
 443         controllerContext.setMountService(mockMountService);
 444
 445         String uri = "/modules/module/ietf-interfaces:interfaces/interface/0/yang-ext:mount/module1-behind-mount-point/2014-02-03";
 446
 447         Response response = target(uri).request("application/yang.api+json").get();
 448         assertEquals(200, response.getStatus());
 449         String responseBody = response.readEntity(String.class);
 450
 451         assertTrue(
 452                 "module1-behind-mount-point in json wasn't found",
 453                 prepareJsonRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point",
 454                         responseBody).find());
 455         String[] split = responseBody.split("\"module\"");
 456         assertEquals("\"module\" element is returned more then once", 2, split.length);
 457
 458         response = target(uri).request("application/yang.api+xml").get();
 459         assertEquals(200, response.getStatus());
 460         responseBody = response.readEntity(String.class);
 461         assertTrue(
 462                 "module1-behind-mount-point in json wasn't found",
 463                 prepareXmlRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point", responseBody)
 464                         .find());
 465         split = responseBody.split("<module");
 466         assertEquals("<module element is returned more then once", 2, split.length);
 467
 468     }
 469
 470     private void validateModulesResponseXml(Response response) {
 471         assertEquals(200, response.getStatus());
 472         String responseBody = response.readEntity(String.class);
 473
 474         assertTrue("Module1 in xml wasn't found", prepareXmlRegex("module1", "2014-01-01", "module:1", responseBody)
 475                 .find());
 476         assertTrue("Module2 in xml wasn't found", prepareXmlRegex("module2", "2014-01-02", "module:2", responseBody)
 477                 .find());
 478         assertTrue("Module3 in xml wasn't found", prepareXmlRegex("module3", "2014-01-03", "module:3", responseBody)
 479                 .find());
 480     }
 481
 482     private void validateModulesResponseJson(Response response) {
 483         assertEquals(200, response.getStatus());
 484         String responseBody = response.readEntity(String.class);
 485
 486         assertTrue("Module1 in json wasn't found", prepareJsonRegex("module1", "2014-01-01", "module:1", responseBody)
 487                 .find());
 488         assertTrue("Module2 in json wasn't found", prepareJsonRegex("module2", "2014-01-02", "module:2", responseBody)
 489                 .find());
 490         assertTrue("Module3 in json wasn't found", prepareJsonRegex("module3", "2014-01-03", "module:3", responseBody)
 491                 .find());
 492     }
 493
 494     private Matcher prepareJsonRegex(String module, String revision, String namespace, String searchIn) {
 495         StringBuilder regex = new StringBuilder();
 496         regex.append("^");
 497
 498         regex.append(".*\\{");
 499         regex.append(".*\"name\"");
 500         regex.append(".*:");
 501         regex.append(".*\"" + module + "\",");
 502
 503         regex.append(".*\"revision\"");
 504         regex.append(".*:");
 505         regex.append(".*\"" + revision + "\",");
 506
 507         regex.append(".*\"namespace\"");
 508         regex.append(".*:");
 509         regex.append(".*\"" + namespace + "\"");
 510
 511         regex.append(".*\\}");
 512
 513         regex.append(".*");
 514         regex.append("$");
 515         Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 516         return ptrn.matcher(searchIn);
 517
 518     }
 519
 520     private Matcher prepareXmlRegex(String module, String revision, String namespace, String searchIn) {
 521         StringBuilder regex = new StringBuilder();
 522         regex.append("^");
 523
 524         regex.append(".*<module.*");
 525         regex.append(".*>");
 526
 527         regex.append(".*<name>");
 528         regex.append(".*" + module);
 529         regex.append(".*<\\/name>");
 530
 531         regex.append(".*<revision>");
 532         regex.append(".*" + revision);
 533         regex.append(".*<\\/revision>");
 534
 535         regex.append(".*<namespace>");
 536         regex.append(".*" + namespace);
 537         regex.append(".*<\\/namespace>");
 538
 539         regex.append(".*<\\/module.*>");
 540
 541         regex.append(".*");
 542         regex.append("$");
 543
 544         Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
 545         return ptrn.matcher(searchIn);
 546     }
 547
 548     private void prepareMockForModulesTest(ControllerContext mockedControllerContext) throws FileNotFoundException {
 549         SchemaContext schemaContext = TestUtils.loadSchemaContext("/modules");
 550         mockedControllerContext.setGlobalSchema(schemaContext);
 551         // when(mockedControllerContext.getGlobalSchema()).thenReturn(schemaContext);
 552     }
 553
 554     private int get(String uri, String mediaType) {
 555         return target(uri).request(mediaType).get().getStatus();
 556     }
 557
 558     private CompositeNode prepareCnDataForMountPointTest() throws URISyntaxException {
 559         CompositeNodeWrapper cont1 = new CompositeNodeWrapper(new URI("test:module"), "cont1");
 560         SimpleNodeWrapper lf11 = new SimpleNodeWrapper(new URI("test:module"), "lf11", "lf11 value");
 561         cont1.addValue(lf11);
 562         return cont1.unwrap();
 563     }
 564
 565     private void mockReadOperationalDataMethod() {
 566         when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(answerFromGet);
 567     }
 568
 569     private void mockReadConfigurationDataMethod() {
 570         when(brokerFacade.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(answerFromGet);
 571     }
 572
 573     private static CompositeNode prepareCompositeNodeWithIetfInterfacesInterfacesData() {
 574         CompositeNode intface;
 575         try {
 576             intface = new CompositeNodeWrapper(new URI("interface"), "interface");
 577             List<Node<?>> childs = new ArrayList<>();
 578
 579             childs.add(new SimpleNodeWrapper(new URI("name"), "name", "eth0"));
 580             childs.add(new SimpleNodeWrapper(new URI("type"), "type", "ethernetCsmacd"));
 581             childs.add(new SimpleNodeWrapper(new URI("enabled"), "enabled", Boolean.FALSE));
 582             childs.add(new SimpleNodeWrapper(new URI("description"), "description", "some interface"));
 583             intface.setValue(childs);
 584             return intface;
 585         } catch (URISyntaxException e) {
 586         }
 587
 588         return null;
 589     }
 590
 591 }