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