tests/transportpce_tests/1.2.1/test_end2end.py

   1 #!/usr/bin/env python
   2 ##############################################################################
   3 # Copyright (c) 2017 Orange, Inc. and others.  All rights reserved.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 ##############################################################################
  10
  11
  12 import json
  13 import time
  14 import unittest
  15
  16 import requests
  17 from common import test_utils
  18
  19
  20 class TransportPCEFulltesting(unittest.TestCase):
  21
  22     WAITING = 20  # nominal value is 300
  23
  24     processes = None
  25
  26     @classmethod
  27     def setUpClass(cls):
  28         cls.processes = test_utils.start_tpce()
  29         cls.processes = test_utils.start_sims(['xpdra', 'roadma-full', 'roadmc-full', 'xpdrc'])
  30
  31     @classmethod
  32     def tearDownClass(cls):
  33         for process in cls.processes:
  34             test_utils.shutdown_process(process)
  35         print("all processes killed")
  36
  37     def setUp(self):  # instruction executed before each test method
  38         print("execution of {}".format(self.id().split(".")[-1]))
  39
  40     #  connect netconf devices
  41     def test_01_connect_xpdrA(self):
  42         response = test_utils.mount_device("XPDRA01", 'xpdra')
  43         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  44
  45     def test_02_connect_xpdrC(self):
  46         response = test_utils.mount_device("XPDRC01", 'xpdrc')
  47         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  48
  49     def test_03_connect_rdmA(self):
  50         response = test_utils.mount_device("ROADMA01", 'roadma-full')
  51         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  52
  53     def test_04_connect_rdmC(self):
  54         response = test_utils.mount_device("ROADMC01", 'roadmc-full')
  55         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  56
  57     def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
  58         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
  59                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
  60         self.assertEqual(response.status_code, requests.codes.ok)
  61         res = response.json()
  62         self.assertIn('Xponder Roadm Link created successfully',
  63                       res["output"]["result"])
  64         time.sleep(2)
  65
  66     def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
  67         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
  68         data = {
  69             "networkutils:input": {
  70                 "networkutils:links-input": {
  71                     "networkutils:xpdr-node": "XPDRA01",
  72                     "networkutils:xpdr-num": "1",
  73                     "networkutils:network-num": "1",
  74                     "networkutils:rdm-node": "ROADMA01",
  75                     "networkutils:srg-num": "1",
  76                     "networkutils:termination-point-num": "SRG1-PP1-TXRX"
  77                 }
  78             }
  79         }
  80         response = test_utils.post_request(url, data)
  81         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
  82                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
  83         self.assertEqual(response.status_code, requests.codes.ok)
  84         res = response.json()
  85         self.assertIn('Roadm Xponder links created successfully',
  86                       res["output"]["result"])
  87         time.sleep(2)
  88
  89     def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
  90         response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "1",
  91                                                           "ROADMC01", "1", "SRG1-PP1-TXRX")
  92         self.assertEqual(response.status_code, requests.codes.ok)
  93         res = response.json()
  94         self.assertIn('Xponder Roadm Link created successfully',
  95                       res["output"]["result"])
  96         time.sleep(2)
  97
  98     def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
  99         response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "1",
 100                                                           "ROADMC01", "1", "SRG1-PP1-TXRX")
 101         self.assertEqual(response.status_code, requests.codes.ok)
 102         res = response.json()
 103         self.assertIn('Roadm Xponder links created successfully',
 104                       res["output"]["result"])
 105         time.sleep(2)
 106
 107     def test_09_add_omsAttributes_ROADMA_ROADMC(self):
 108         # Config ROADMA-ROADMC oms-attributes
 109         url = (
 110             "{}/config/ietf-network:"
 111             "networks/network/openroadm-topology/ietf-network-topology:"
 112             "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/"
 113             "org-openroadm-network-topology:"
 114             "OMS-attributes/span"
 115         )
 116         data = {"span": {
 117             "clfi": "fiber1",
 118             "auto-spanloss": "true",
 119             "spanloss-base": 11.4,
 120             "spanloss-current": 12,
 121             "engineered-spanloss": 12.2,
 122             "link-concatenation": [{
 123                 "SRLG-Id": 0,
 124                 "fiber-type": "smf",
 125                 "SRLG-length": 100000,
 126                 "pmd": 0.5}]}}
 127         response = test_utils.put_request(url, data)
 128         self.assertEqual(response.status_code, requests.codes.created)
 129
 130     def test_10_add_omsAttributes_ROADMC_ROADMA(self):
 131         # Config ROADMC-ROADMA oms-attributes
 132         url = (
 133             "{}/config/ietf-network:"
 134             "networks/network/openroadm-topology/ietf-network-topology:"
 135             "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/"
 136             "org-openroadm-network-topology:"
 137             "OMS-attributes/span"
 138         )
 139         data = {"span": {
 140             "clfi": "fiber1",
 141             "auto-spanloss": "true",
 142             "spanloss-base": 11.4,
 143             "spanloss-current": 12,
 144             "engineered-spanloss": 12.2,
 145             "link-concatenation": [{
 146                 "SRLG-Id": 0,
 147                 "fiber-type": "smf",
 148                 "SRLG-length": 100000,
 149                 "pmd": 0.5}]}}
 150         response = test_utils.put_request(url, data)
 151         self.assertEqual(response.status_code, requests.codes.created)
 152
 153     # test service-create for Eth service from xpdr to xpdr
 154     def test_11_create_eth_service1(self):
 155         url = "{}/operations/org-openroadm-service:service-create"
 156         data = {
 157             "input": {
 158                 "sdnc-request-header": {
 159                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 160                     "rpc-action": "service-create",
 161                     "request-system-id": "appname",
 162                     "notification-url":
 163                         "http://localhost:8585/NotificationServer/notify"
 164                 },
 165                 "service-name": "service1",
 166                 "common-id": "ASATT1234567",
 167                 "connection-type": "service",
 168                 "service-a-end": {
 169                     "service-rate": "100",
 170                     "node-id": "XPDRA01",
 171                     "service-format": "Ethernet",
 172                     "clli": "SNJSCAMCJP8",
 173                     "tx-direction": {
 174                         "port": {
 175                             "port-device-name":
 176                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 177                             "port-type": "router",
 178                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 179                             "port-rack": "000000.00",
 180                             "port-shelf": "00"
 181                         },
 182                         "lgx": {
 183                             "lgx-device-name":
 184                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 185                             "lgx-port-name": "LGX Back.3",
 186                             "lgx-port-rack": "000000.00",
 187                             "lgx-port-shelf": "00"
 188                         }
 189                     },
 190                     "rx-direction": {
 191                         "port": {
 192                             "port-device-name":
 193                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 194                             "port-type": "router",
 195                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 196                             "port-rack": "000000.00",
 197                             "port-shelf": "00"
 198                         },
 199                         "lgx": {
 200                             "lgx-device-name":
 201                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 202                             "lgx-port-name": "LGX Back.4",
 203                             "lgx-port-rack": "000000.00",
 204                             "lgx-port-shelf": "00"
 205                         }
 206                     },
 207                     "optic-type": "gray"
 208                 },
 209                 "service-z-end": {
 210                     "service-rate": "100",
 211                     "node-id": "XPDRC01",
 212                     "service-format": "Ethernet",
 213                     "clli": "SNJSCAMCJT4",
 214                     "tx-direction": {
 215                         "port": {
 216                             "port-device-name":
 217                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 218                             "port-type": "router",
 219                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 220                             "port-rack": "000000.00",
 221                             "port-shelf": "00"
 222                         },
 223                         "lgx": {
 224                             "lgx-device-name":
 225                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 226                             "lgx-port-name": "LGX Back.29",
 227                             "lgx-port-rack": "000000.00",
 228                             "lgx-port-shelf": "00"
 229                         }
 230                     },
 231                     "rx-direction": {
 232                         "port": {
 233                             "port-device-name":
 234                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 235                             "port-type": "router",
 236                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 237                             "port-rack": "000000.00",
 238                             "port-shelf": "00"
 239                         },
 240                         "lgx": {
 241                             "lgx-device-name":
 242                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 243                             "lgx-port-name": "LGX Back.30",
 244                             "lgx-port-rack": "000000.00",
 245                             "lgx-port-shelf": "00"
 246                         }
 247                     },
 248                     "optic-type": "gray"
 249                 },
 250                 "due-date": "2016-11-28T00:00:01Z",
 251                 "operator-contact": "pw1234"
 252             }
 253         }
 254         response = test_utils.post_request(url, data)
 255         self.assertEqual(response.status_code, requests.codes.ok)
 256         res = response.json()
 257         self.assertIn('PCE calculation in progress',
 258                       res['output']['configuration-response-common'][
 259                           'response-message'])
 260         time.sleep(self.WAITING)
 261
 262     def test_12_get_eth_service1(self):
 263         url = "{}/operational/org-openroadm-service:service-list/services/service1"
 264         response = test_utils.get_request(url)
 265         self.assertEqual(response.status_code, requests.codes.ok)
 266         res = response.json()
 267         self.assertEqual(
 268             res['services'][0]['administrative-state'],
 269             'inService')
 270         self.assertEqual(
 271             res['services'][0]['service-name'], 'service1')
 272         self.assertEqual(
 273             res['services'][0]['connection-type'], 'service')
 274         self.assertEqual(
 275             res['services'][0]['lifecycle-state'], 'planned')
 276         time.sleep(2)
 277
 278     def test_13_check_xc1_ROADMA(self):
 279         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
 280         self.assertEqual(response.status_code, requests.codes.ok)
 281         res = response.json()
 282         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 283         self.assertDictEqual(
 284             dict({
 285                 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
 286                 'wavelength-number': 1,
 287                 'opticalControlMode': 'gainLoss',
 288                 'target-output-power': -3.0
 289             }, **res['roadm-connections'][0]),
 290             res['roadm-connections'][0]
 291         )
 292         self.assertDictEqual(
 293             {'src-if': 'SRG1-PP1-TXRX-1'},
 294             res['roadm-connections'][0]['source'])
 295         self.assertDictEqual(
 296             {'dst-if': 'DEG1-TTP-TXRX-1'},
 297             res['roadm-connections'][0]['destination'])
 298         time.sleep(5)
 299
 300     def test_14_check_xc1_ROADMC(self):
 301         response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
 302         self.assertEqual(response.status_code, requests.codes.ok)
 303         res = response.json()
 304         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 305         self.assertDictEqual(
 306             dict({
 307                 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
 308                 'wavelength-number': 1,
 309                 'opticalControlMode': 'gainLoss',
 310                 'target-output-power': 2.0
 311             }, **res['roadm-connections'][0]),
 312             res['roadm-connections'][0]
 313         )
 314         self.assertDictEqual(
 315             {'src-if': 'SRG1-PP1-TXRX-1'},
 316             res['roadm-connections'][0]['source'])
 317         self.assertDictEqual(
 318             {'dst-if': 'DEG2-TTP-TXRX-1'},
 319             res['roadm-connections'][0]['destination'])
 320         time.sleep(5)
 321
 322     def test_15_check_topo_XPDRA(self):
 323         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 324         response = test_utils.get_request(url)
 325         self.assertEqual(response.status_code, requests.codes.ok)
 326         res = response.json()
 327         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 328         for ele in liste_tp:
 329             if ele['tp-id'] == 'XPDR1-NETWORK1':
 330                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 331                                  ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 332             if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
 333                 self.assertNotIn(
 334                     'org-openroadm-network-topology:xpdr-client-attributes',
 335                     dict.keys(ele))
 336             if ele['tp-id'] == 'XPDR1-NETWORK2':
 337                 self.assertNotIn(
 338                     'org-openroadm-network-topology:xpdr-network-attributes',
 339                     dict.keys(ele))
 340         time.sleep(3)
 341
 342     def test_16_check_topo_ROADMA_SRG1(self):
 343         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 344         response = test_utils.get_request(url)
 345         self.assertEqual(response.status_code, requests.codes.ok)
 346         res = response.json()
 347         self.assertNotIn({u'index': 1},
 348                          res['node'][0][
 349                              u'org-openroadm-network-topology:srg-attributes'][
 350                              'available-wavelengths'])
 351         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 352         for ele in liste_tp:
 353             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 354                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 355                               ele['org-openroadm-network-topology:'
 356                                   'pp-attributes']['used-wavelength']
 357                               )
 358             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 359                 self.assertNotIn('used-wavelength', dict.keys(ele))
 360         time.sleep(3)
 361
 362     def test_17_check_topo_ROADMA_DEG1(self):
 363         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 364         response = test_utils.get_request(url)
 365         self.assertEqual(response.status_code, requests.codes.ok)
 366         res = response.json()
 367         self.assertNotIn({u'index': 1},
 368                          res['node'][0][
 369                              u'org-openroadm-network-topology:'
 370                              u'degree-attributes'][
 371                              'available-wavelengths'])
 372         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 373         for ele in liste_tp:
 374             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 375                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 376                               ele['org-openroadm-network-topology:'
 377                                   'ctp-attributes'][
 378                                   'used-wavelengths'])
 379             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 380                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 381                               ele['org-openroadm-network-topology:'
 382                                   'tx-ttp-attributes'][
 383                                   'used-wavelengths'])
 384         time.sleep(3)
 385
 386     def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
 387         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "2",
 388                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 389         self.assertEqual(response.status_code, requests.codes.ok)
 390         res = response.json()
 391         self.assertIn('Xponder Roadm Link created successfully',
 392                       res["output"]["result"])
 393         time.sleep(2)
 394
 395     def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
 396         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2",
 397                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 398         self.assertEqual(response.status_code, requests.codes.ok)
 399         res = response.json()
 400         self.assertIn('Roadm Xponder links created successfully',
 401                       res["output"]["result"])
 402         time.sleep(2)
 403
 404     def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
 405         response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "2",
 406                                                           "ROADMC01", "1", "SRG1-PP2-TXRX")
 407         self.assertEqual(response.status_code, requests.codes.ok)
 408         res = response.json()
 409         self.assertIn('Xponder Roadm Link created successfully',
 410                       res["output"]["result"])
 411         time.sleep(2)
 412
 413     def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
 414         response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "2",
 415                                                           "ROADMC01", "1", "SRG1-PP2-TXRX")
 416         self.assertEqual(response.status_code, requests.codes.ok)
 417         res = response.json()
 418         self.assertIn('Roadm Xponder links created successfully',
 419                       res["output"]["result"])
 420         time.sleep(2)
 421
 422     def test_22_create_eth_service2(self):
 423         url = "{}/operations/org-openroadm-service:service-create"
 424         data = {
 425             "input": {
 426                 "sdnc-request-header": {
 427                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 428                     "rpc-action": "service-create",
 429                     "request-system-id": "appname",
 430                     "notification-url":
 431                         "http://localhost:8585/NotificationServer/notify"
 432                 },
 433                 "service-name": "service2",
 434                 "common-id": "ASATT1234567",
 435                 "connection-type": "service",
 436                 "service-a-end": {
 437                     "service-rate": "100",
 438                     "node-id": "XPDRA01",
 439                     "service-format": "Ethernet",
 440                     "clli": "SNJSCAMCJP8",
 441                     "tx-direction": {
 442                         "port": {
 443                             "port-device-name":
 444                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 445                             "port-type": "router",
 446                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 447                             "port-rack": "000000.00",
 448                             "port-shelf": "00"
 449                         },
 450                         "lgx": {
 451                             "lgx-device-name":
 452                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 453                             "lgx-port-name": "LGX Back.3",
 454                             "lgx-port-rack": "000000.00",
 455                             "lgx-port-shelf": "00"
 456                         }
 457                     },
 458                     "rx-direction": {
 459                         "port": {
 460                             "port-device-name":
 461                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 462                             "port-type": "router",
 463                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 464                             "port-rack": "000000.00",
 465                             "port-shelf": "00"
 466                         },
 467                         "lgx": {
 468                             "lgx-device-name":
 469                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 470                             "lgx-port-name": "LGX Back.4",
 471                             "lgx-port-rack": "000000.00",
 472                             "lgx-port-shelf": "00"
 473                         }
 474                     },
 475                     "optic-type": "gray"
 476                 },
 477                 "service-z-end": {
 478                     "service-rate": "100",
 479                     "node-id": "XPDRC01",
 480                     "service-format": "Ethernet",
 481                     "clli": "SNJSCAMCJT4",
 482                     "tx-direction": {
 483                         "port": {
 484                             "port-device-name":
 485                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 486                             "port-type": "router",
 487                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 488                             "port-rack": "000000.00",
 489                             "port-shelf": "00"
 490                         },
 491                         "lgx": {
 492                             "lgx-device-name":
 493                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 494                             "lgx-port-name": "LGX Back.29",
 495                             "lgx-port-rack": "000000.00",
 496                             "lgx-port-shelf": "00"
 497                         }
 498                     },
 499                     "rx-direction": {
 500                         "port": {
 501                             "port-device-name":
 502                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 503                             "port-type": "router",
 504                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 505                             "port-rack": "000000.00",
 506                             "port-shelf": "00"
 507                         },
 508                         "lgx": {
 509                             "lgx-device-name":
 510                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 511                             "lgx-port-name": "LGX Back.30",
 512                             "lgx-port-rack": "000000.00",
 513                             "lgx-port-shelf": "00"
 514                         }
 515                     },
 516                     "optic-type": "gray"
 517                 },
 518                 "due-date": "2016-11-28T00:00:01Z",
 519                 "operator-contact": "pw1234"
 520             }
 521         }
 522         response = test_utils.post_request(url, data)
 523         self.assertEqual(response.status_code, requests.codes.ok)
 524         res = response.json()
 525         self.assertIn('PCE calculation in progress',
 526                       res['output']['configuration-response-common'][
 527                           'response-message'])
 528         time.sleep(self.WAITING)
 529
 530     def test_23_get_eth_service2(self):
 531         url = "{}/operational/org-openroadm-service:service-list/services/service2"
 532         response = test_utils.get_request(url)
 533         self.assertEqual(response.status_code, requests.codes.ok)
 534         res = response.json()
 535         self.assertEqual(
 536             res['services'][0]['administrative-state'],
 537             'inService')
 538         self.assertEqual(
 539             res['services'][0]['service-name'], 'service2')
 540         self.assertEqual(
 541             res['services'][0]['connection-type'], 'service')
 542         self.assertEqual(
 543             res['services'][0]['lifecycle-state'], 'planned')
 544         time.sleep(1)
 545
 546     def test_24_check_xc2_ROADMA(self):
 547         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2")
 548         self.assertEqual(response.status_code, requests.codes.ok)
 549         res = response.json()
 550         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 551         self.assertDictEqual(
 552             dict({
 553                  'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
 554                  'wavelength-number': 2,
 555                  'opticalControlMode': 'power'
 556                  }, **res['roadm-connections'][0]),
 557             res['roadm-connections'][0]
 558         )
 559         self.assertDictEqual(
 560             {'src-if': 'DEG1-TTP-TXRX-2'},
 561             res['roadm-connections'][0]['source'])
 562         self.assertDictEqual(
 563             {'dst-if': 'SRG1-PP2-TXRX-2'},
 564             res['roadm-connections'][0]['destination'])
 565
 566     def test_25_check_topo_XPDRA(self):
 567         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 568         response = test_utils.get_request(url)
 569         self.assertEqual(response.status_code, requests.codes.ok)
 570         res = response.json()
 571         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 572         for ele in liste_tp:
 573             if ele['tp-id'] == 'XPDR1-NETWORK1':
 574                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 575                                  ele['org-openroadm-network-topology:'
 576                                      'xpdr-network-attributes'][
 577                                      'wavelength'])
 578             if ele['tp-id'] == 'XPDR1-NETWORK2':
 579                 self.assertEqual({u'frequency': 196.05, u'width': 40},
 580                                  ele['org-openroadm-network-topology:'
 581                                      'xpdr-network-attributes'][
 582                                      'wavelength'])
 583             if ele['tp-id'] == 'XPDR1-CLIENT1' or \
 584                ele['tp-id'] == 'XPDR1-CLIENT3':
 585                 self.assertNotIn(
 586                     'org-openroadm-network-topology:xpdr-client-attributes',
 587                     dict.keys(ele))
 588         time.sleep(10)
 589
 590     def test_26_check_topo_ROADMA_SRG1(self):
 591         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 592         response = test_utils.get_request(url)
 593         self.assertEqual(response.status_code, requests.codes.ok)
 594         res = response.json()
 595         self.assertNotIn({u'index': 1}, res['node'][0][
 596             u'org-openroadm-network-topology:srg-attributes'][
 597             'available-wavelengths'])
 598         self.assertNotIn({u'index': 2}, res['node'][0][
 599             u'org-openroadm-network-topology:srg-attributes'][
 600             'available-wavelengths'])
 601         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 602         for ele in liste_tp:
 603             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 604                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 605                               ele['org-openroadm-network-topology:'
 606                                   'pp-attributes']['used-wavelength'])
 607                 self.assertNotIn({u'index': 2, u'frequency': 196.05,
 608                                   u'width': 40},
 609                                  ele['org-openroadm-network-topology:'
 610                                      'pp-attributes']['used-wavelength'])
 611             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 612                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 613                               ele['org-openroadm-network-topology:'
 614                                   'pp-attributes']['used-wavelength'])
 615                 self.assertNotIn({u'index': 1, u'frequency': 196.1,
 616                                   u'width': 40},
 617                                  ele['org-openroadm-network-topology:'
 618                                      'pp-attributes']['used-wavelength'])
 619             if ele['tp-id'] == 'SRG1-PP3-TXRX':
 620                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 621                                  dict.keys(ele))
 622         time.sleep(10)
 623
 624     def test_27_check_topo_ROADMA_DEG1(self):
 625         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 626         response = test_utils.get_request(url)
 627         self.assertEqual(response.status_code, requests.codes.ok)
 628         res = response.json()
 629         self.assertNotIn({u'index': 1}, res['node'][0][
 630             u'org-openroadm-network-topology:degree-attributes'][
 631             'available-wavelengths'])
 632         self.assertNotIn({u'index': 2}, res['node'][0][
 633             u'org-openroadm-network-topology:degree-attributes'][
 634             'available-wavelengths'])
 635         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 636         for ele in liste_tp:
 637             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 638                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 639                               ele['org-openroadm-network-topology:'
 640                                   'ctp-attributes']['used-wavelengths'])
 641                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 642                               ele['org-openroadm-network-topology:'
 643                                   'ctp-attributes']['used-wavelengths'])
 644             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 645                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 646                               ele['org-openroadm-network-topology:'
 647                                   'tx-ttp-attributes']['used-wavelengths'])
 648                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 649                               ele['org-openroadm-network-topology:'
 650                                   'tx-ttp-attributes']['used-wavelengths'])
 651         time.sleep(10)
 652
 653     #     creation service test on a non-available resource
 654     def test_28_create_eth_service3(self):
 655         url = "{}/operations/org-openroadm-service:service-create"
 656         data = {
 657             "input": {
 658                 "sdnc-request-header": {
 659                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 660                     "rpc-action": "service-create",
 661                     "request-system-id": "appname",
 662                     "notification-url":
 663                         "http://localhost:8585/NotificationServer/notify"
 664                 },
 665                 "service-name": "service3",
 666                 "common-id": "ASATT1234567",
 667                 "connection-type": "service",
 668                 "service-a-end": {
 669                     "service-rate": "100",
 670                     "node-id": "XPDRA01",
 671                     "service-format": "Ethernet",
 672                     "clli": "SNJSCAMCJP8",
 673                     "tx-direction": {
 674                         "port": {
 675                             "port-device-name":
 676                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 677                             "port-type": "router",
 678                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 679                             "port-rack": "000000.00",
 680                             "port-shelf": "00"
 681                         },
 682                         "lgx": {
 683                             "lgx-device-name":
 684                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 685                             "lgx-port-name": "LGX Back.3",
 686                             "lgx-port-rack": "000000.00",
 687                             "lgx-port-shelf": "00"
 688                         }
 689                     },
 690                     "rx-direction": {
 691                         "port": {
 692                             "port-device-name":
 693                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 694                             "port-type": "router",
 695                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 696                             "port-rack": "000000.00",
 697                             "port-shelf": "00"
 698                         },
 699                         "lgx": {
 700                             "lgx-device-name":
 701                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 702                             "lgx-port-name": "LGX Back.4",
 703                             "lgx-port-rack": "000000.00",
 704                             "lgx-port-shelf": "00"
 705                         }
 706                     },
 707                     "optic-type": "gray"
 708                 },
 709                 "service-z-end": {
 710                     "service-rate": "100",
 711                     "node-id": "XPDRC01",
 712                     "service-format": "Ethernet",
 713                     "clli": "SNJSCAMCJT4",
 714                     "tx-direction": {
 715                         "port": {
 716                             "port-device-name":
 717                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 718                             "port-type": "router",
 719                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 720                             "port-rack": "000000.00",
 721                             "port-shelf": "00"
 722                         },
 723                         "lgx": {
 724                             "lgx-device-name":
 725                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 726                             "lgx-port-name": "LGX Back.29",
 727                             "lgx-port-rack": "000000.00",
 728                             "lgx-port-shelf": "00"
 729                         }
 730                     },
 731                     "rx-direction": {
 732                         "port": {
 733                             "port-device-name":
 734                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 735                             "port-type": "router",
 736                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 737                             "port-rack": "000000.00",
 738                             "port-shelf": "00"
 739                         },
 740                         "lgx": {
 741                             "lgx-device-name":
 742                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 743                             "lgx-port-name": "LGX Back.30",
 744                             "lgx-port-rack": "000000.00",
 745                             "lgx-port-shelf": "00"
 746                         }
 747                     },
 748                     "optic-type": "gray"
 749                 },
 750                 "due-date": "2016-11-28T00:00:01Z",
 751                 "operator-contact": "pw1234"
 752             }
 753         }
 754         response = test_utils.post_request(url, data)
 755         self.assertEqual(response.status_code, requests.codes.ok)
 756         res = response.json()
 757         self.assertIn('PCE calculation in progress',
 758                       res['output']['configuration-response-common'][
 759                           'response-message'])
 760         self.assertIn('200', res['output']['configuration-response-common'][
 761             'response-code'])
 762         time.sleep(self.WAITING)
 763
 764     # add a test that check the openroadm-service-list still only
 765     # contains 2 elements
 766
 767     def test_29_delete_eth_service3(self):
 768         url = "{}/operations/org-openroadm-service:service-delete"
 769         data = {"input": {
 770             "sdnc-request-header": {
 771                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 772                 "rpc-action": "service-delete",
 773                 "request-system-id": "appname",
 774                 "notification-url":
 775                     "http://localhost:8585/NotificationServer/notify"
 776             },
 777             "service-delete-req-info": {
 778                 "service-name": "service3",
 779                 "tail-retention": "no"
 780             }
 781         }
 782         }
 783         response = test_utils.post_request(url, data)
 784         self.assertEqual(response.status_code, requests.codes.ok)
 785         res = response.json()
 786         self.assertIn('Service \'service3\' does not exist in datastore',
 787                       res['output']['configuration-response-common'][
 788                           'response-message'])
 789         self.assertIn('500', res['output']['configuration-response-common'][
 790             'response-code'])
 791         time.sleep(20)
 792
 793     def test_30_delete_eth_service1(self):
 794         url = "{}/operations/org-openroadm-service:service-delete"
 795         data = {"input": {
 796             "sdnc-request-header": {
 797                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 798                 "rpc-action": "service-delete",
 799                 "request-system-id": "appname",
 800                 "notification-url":
 801                     "http://localhost:8585/NotificationServer/notify"
 802             },
 803             "service-delete-req-info": {
 804                 "service-name": "service1",
 805                 "tail-retention": "no"
 806             }
 807         }
 808         }
 809         response = test_utils.post_request(url, data)
 810         self.assertEqual(response.status_code, requests.codes.ok)
 811         res = response.json()
 812         self.assertIn('Renderer service delete in progress',
 813                       res['output']['configuration-response-common'][
 814                           'response-message'])
 815         time.sleep(20)
 816
 817     def test_31_delete_eth_service2(self):
 818         url = "{}/operations/org-openroadm-service:service-delete"
 819         data = {"input": {
 820             "sdnc-request-header": {
 821                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 822                 "rpc-action": "service-delete",
 823                 "request-system-id": "appname",
 824                 "notification-url":
 825                     "http://localhost:8585/NotificationServer/notify"
 826             },
 827             "service-delete-req-info": {
 828                 "service-name": "service2",
 829                 "tail-retention": "no"
 830             }
 831         }
 832         }
 833         response = test_utils.post_request(url, data)
 834         self.assertEqual(response.status_code, requests.codes.ok)
 835         res = response.json()
 836         self.assertIn('Renderer service delete in progress',
 837                       res['output']['configuration-response-common'][
 838                           'response-message'])
 839         time.sleep(20)
 840
 841     def test_32_check_no_xc_ROADMA(self):
 842         response = test_utils.check_netconf_node_request("ROADMA01", "")
 843         res = response.json()
 844         self.assertEqual(response.status_code, requests.codes.ok)
 845         self.assertNotIn('roadm-connections',
 846                          dict.keys(res['org-openroadm-device']))
 847         time.sleep(2)
 848
 849     def test_33_check_topo_XPDRA(self):
 850         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 851         response = test_utils.get_request(url)
 852         self.assertEqual(response.status_code, requests.codes.ok)
 853         res = response.json()
 854         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 855         for ele in liste_tp:
 856             if ((ele[u'org-openroadm-common-network:tp-type'] ==
 857                  'XPONDER-CLIENT')
 858                 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele[
 859                     'tp-id'] == 'XPDR1-CLIENT3')):
 860                 self.assertNotIn(
 861                     'org-openroadm-network-topology:xpdr-client-attributes',
 862                     dict.keys(ele))
 863             elif (ele[u'org-openroadm-common-network:tp-type'] ==
 864                   'XPONDER-NETWORK'):
 865                 self.assertIn(u'tail-equipment-id', dict.keys(
 866                     ele[u'org-openroadm-network-topology:'
 867                         u'xpdr-network-attributes']))
 868                 self.assertNotIn('wavelength', dict.keys(
 869                     ele[u'org-openroadm-network-topology:'
 870                         u'xpdr-network-attributes']))
 871         time.sleep(10)
 872
 873     def test_34_check_topo_ROADMA_SRG1(self):
 874         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 875         response = test_utils.get_request(url)
 876         self.assertEqual(response.status_code, requests.codes.ok)
 877         res = response.json()
 878         self.assertIn({u'index': 1}, res['node'][0][
 879             u'org-openroadm-network-topology:srg-attributes'][
 880             'available-wavelengths'])
 881         self.assertIn({u'index': 2}, res['node'][0][
 882             u'org-openroadm-network-topology:srg-attributes'][
 883             'available-wavelengths'])
 884         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 885         for ele in liste_tp:
 886             if ele['tp-id'] == 'SRG1-PP1-TXRX' or \
 887                ele['tp-id'] == 'SRG1-PP1-TXRX':
 888                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 889                                  dict.keys(ele))
 890             else:
 891                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 892                                  dict.keys(ele))
 893         time.sleep(10)
 894
 895     def test_35_check_topo_ROADMA_DEG1(self):
 896         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 897         response = test_utils.get_request(url)
 898         self.assertEqual(response.status_code, requests.codes.ok)
 899         res = response.json()
 900         self.assertIn({u'index': 1}, res['node'][0][
 901             u'org-openroadm-network-topology:degree-attributes'][
 902             'available-wavelengths'])
 903         self.assertIn({u'index': 2}, res['node'][0][
 904             u'org-openroadm-network-topology:degree-attributes'][
 905             'available-wavelengths'])
 906         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 907         for ele in liste_tp:
 908             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 909                 self.assertNotIn('org-openroadm-network-topology:'
 910                                  'ctp-attributes', dict.keys(ele))
 911             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 912                 self.assertNotIn('org-openroadm-network-topology:'
 913                                  'tx-ttp-attributes', dict.keys(ele))
 914         time.sleep(10)
 915
 916     # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
 917     def test_36_create_oc_service1(self):
 918         url = "{}/operations/org-openroadm-service:service-create"
 919         data = {
 920             "input": {
 921                 "sdnc-request-header": {
 922                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 923                     "rpc-action": "service-create",
 924                     "request-system-id": "appname",
 925                     "notification-url":
 926                         "http://localhost:8585/NotificationServer/notify"
 927                 },
 928                 "service-name": "service1",
 929                 "common-id": "ASATT1234567",
 930                 "connection-type": "roadm-line",
 931                 "service-a-end": {
 932                     "service-rate": "100",
 933                     "node-id": "ROADMA01",
 934                     "service-format": "OC",
 935                     "clli": "SNJSCAMCJP8",
 936                     "tx-direction": {
 937                         "port": {
 938                             "port-device-name":
 939                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 940                             "port-type": "router",
 941                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 942                             "port-rack": "000000.00",
 943                             "port-shelf": "00"
 944                         },
 945                         "lgx": {
 946                             "lgx-device-name":
 947                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 948                             "lgx-port-name": "LGX Back.3",
 949                             "lgx-port-rack": "000000.00",
 950                             "lgx-port-shelf": "00"
 951                         }
 952                     },
 953                     "rx-direction": {
 954                         "port": {
 955                             "port-device-name":
 956                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 957                             "port-type": "router",
 958                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 959                             "port-rack": "000000.00",
 960                             "port-shelf": "00"
 961                         },
 962                         "lgx": {
 963                             "lgx-device-name":
 964                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 965                             "lgx-port-name": "LGX Back.4",
 966                             "lgx-port-rack": "000000.00",
 967                             "lgx-port-shelf": "00"
 968                         }
 969                     },
 970                     "optic-type": "gray"
 971                 },
 972                 "service-z-end": {
 973                     "service-rate": "100",
 974                     "node-id": "ROADMC01",
 975                     "service-format": "OC",
 976                     "clli": "SNJSCAMCJT4",
 977                     "tx-direction": {
 978                         "port": {
 979                             "port-device-name":
 980                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 981                             "port-type": "router",
 982                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 983                             "port-rack": "000000.00",
 984                             "port-shelf": "00"
 985                         },
 986                         "lgx": {
 987                             "lgx-device-name":
 988                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 989                             "lgx-port-name": "LGX Back.29",
 990                             "lgx-port-rack": "000000.00",
 991                             "lgx-port-shelf": "00"
 992                         }
 993                     },
 994                     "rx-direction": {
 995                         "port": {
 996                             "port-device-name":
 997                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 998                             "port-type": "router",
 999                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1000                             "port-rack": "000000.00",
1001                             "port-shelf": "00"
1002                         },
1003                         "lgx": {
1004                             "lgx-device-name":
1005                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1006                             "lgx-port-name": "LGX Back.30",
1007                             "lgx-port-rack": "000000.00",
1008                             "lgx-port-shelf": "00"
1009                         }
1010                     },
1011                     "optic-type": "gray"
1012                 },
1013                 "due-date": "2016-11-28T00:00:01Z",
1014                 "operator-contact": "pw1234"
1015             }
1016         }
1017         response = test_utils.post_request(url, data)
1018         self.assertEqual(response.status_code, requests.codes.ok)
1019         res = response.json()
1020         self.assertIn('PCE calculation in progress',
1021                       res['output']['configuration-response-common'][
1022                           'response-message'])
1023         time.sleep(self.WAITING)
1024
1025     def test_37_get_oc_service1(self):
1026         url = "{}/operational/org-openroadm-service:service-list/services/service1"
1027         response = test_utils.get_request(url)
1028         self.assertEqual(response.status_code, requests.codes.ok)
1029         res = response.json()
1030         self.assertEqual(
1031             res['services'][0]['administrative-state'],
1032             'inService')
1033         self.assertEqual(
1034             res['services'][0]['service-name'], 'service1')
1035         self.assertEqual(
1036             res['services'][0]['connection-type'], 'roadm-line')
1037         self.assertEqual(
1038             res['services'][0]['lifecycle-state'], 'planned')
1039         time.sleep(1)
1040
1041     def test_38_check_xc1_ROADMA(self):
1042         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
1043         self.assertEqual(response.status_code, requests.codes.ok)
1044         res = response.json()
1045         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1046         self.assertDictEqual(
1047             dict({
1048                 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1049                 'wavelength-number': 1,
1050                 'opticalControlMode': 'gainLoss',
1051                 'target-output-power': -3.0
1052             }, **res['roadm-connections'][0]),
1053             res['roadm-connections'][0]
1054         )
1055         self.assertDictEqual(
1056             {'src-if': 'SRG1-PP1-TXRX-1'},
1057             res['roadm-connections'][0]['source'])
1058         self.assertDictEqual(
1059             {'dst-if': 'DEG1-TTP-TXRX-1'},
1060             res['roadm-connections'][0]['destination'])
1061         time.sleep(7)
1062
1063     def test_39_check_xc1_ROADMC(self):
1064         response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
1065         self.assertEqual(response.status_code, requests.codes.ok)
1066         res = response.json()
1067         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1068         self.assertDictEqual(
1069             dict({
1070                 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1071                 'wavelength-number': 1,
1072                 'opticalControlMode': 'gainLoss',
1073                 'target-output-power': 2.0
1074             }, **res['roadm-connections'][0]),
1075             res['roadm-connections'][0]
1076         )
1077         self.assertDictEqual(
1078             {'src-if': 'SRG1-PP1-TXRX-1'},
1079             res['roadm-connections'][0]['source'])
1080         self.assertDictEqual(
1081             {'dst-if': 'DEG2-TTP-TXRX-1'},
1082             res['roadm-connections'][0]['destination'])
1083         time.sleep(7)
1084
1085     def test_40_create_oc_service2(self):
1086         url = "{}/operations/org-openroadm-service:service-create"
1087         data = {
1088             "input": {
1089                 "sdnc-request-header": {
1090                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1091                     "rpc-action": "service-create",
1092                     "request-system-id": "appname",
1093                     "notification-url":
1094                         "http://localhost:8585/NotificationServer/notify"
1095                 },
1096                 "service-name": "service2",
1097                 "common-id": "ASATT1234567",
1098                 "connection-type": "roadm-line",
1099                 "service-a-end": {
1100                     "service-rate": "100",
1101                     "node-id": "ROADMA01",
1102                     "service-format": "OC",
1103                     "clli": "SNJSCAMCJP8",
1104                     "tx-direction": {
1105                         "port": {
1106                             "port-device-name":
1107                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1108                             "port-type": "router",
1109                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1110                             "port-rack": "000000.00",
1111                             "port-shelf": "00"
1112                         },
1113                         "lgx": {
1114                             "lgx-device-name":
1115                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1116                             "lgx-port-name": "LGX Back.3",
1117                             "lgx-port-rack": "000000.00",
1118                             "lgx-port-shelf": "00"
1119                         }
1120                     },
1121                     "rx-direction": {
1122                         "port": {
1123                             "port-device-name":
1124                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1125                             "port-type": "router",
1126                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1127                             "port-rack": "000000.00",
1128                             "port-shelf": "00"
1129                         },
1130                         "lgx": {
1131                             "lgx-device-name":
1132                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1133                             "lgx-port-name": "LGX Back.4",
1134                             "lgx-port-rack": "000000.00",
1135                             "lgx-port-shelf": "00"
1136                         }
1137                     },
1138                     "optic-type": "gray"
1139                 },
1140                 "service-z-end": {
1141                     "service-rate": "100",
1142                     "node-id": "ROADMC01",
1143                     "service-format": "OC",
1144                     "clli": "SNJSCAMCJT4",
1145                     "tx-direction": {
1146                         "port": {
1147                             "port-device-name":
1148                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1149                             "port-type": "router",
1150                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1151                             "port-rack": "000000.00",
1152                             "port-shelf": "00"
1153                         },
1154                         "lgx": {
1155                             "lgx-device-name":
1156                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1157                             "lgx-port-name": "LGX Back.29",
1158                             "lgx-port-rack": "000000.00",
1159                             "lgx-port-shelf": "00"
1160                         }
1161                     },
1162                     "rx-direction": {
1163                         "port": {
1164                             "port-device-name":
1165                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1166                             "port-type": "router",
1167                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1168                             "port-rack": "000000.00",
1169                             "port-shelf": "00"
1170                         },
1171                         "lgx": {
1172                             "lgx-device-name":
1173                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1174                             "lgx-port-name": "LGX Back.30",
1175                             "lgx-port-rack": "000000.00",
1176                             "lgx-port-shelf": "00"
1177                         }
1178                     },
1179                     "optic-type": "gray"
1180                 },
1181                 "due-date": "2016-11-28T00:00:01Z",
1182                 "operator-contact": "pw1234"
1183             }
1184         }
1185         response = test_utils.post_request(url, data)
1186         self.assertEqual(response.status_code, requests.codes.ok)
1187         res = response.json()
1188         self.assertIn('PCE calculation in progress',
1189                       res['output']['configuration-response-common'][
1190                           'response-message'])
1191         time.sleep(self.WAITING)
1192
1193     def test_41_get_oc_service2(self):
1194         url = "{}/operational/org-openroadm-service:service-list/services/service2"
1195         response = test_utils.get_request(url)
1196         self.assertEqual(response.status_code, requests.codes.ok)
1197         res = response.json()
1198         self.assertEqual(
1199             res['services'][0]['administrative-state'],
1200             'inService')
1201         self.assertEqual(
1202             res['services'][0]['service-name'], 'service2')
1203         self.assertEqual(
1204             res['services'][0]['connection-type'], 'roadm-line')
1205         self.assertEqual(
1206             res['services'][0]['lifecycle-state'], 'planned')
1207         time.sleep(2)
1208
1209     def test_42_check_xc2_ROADMA(self):
1210         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2")
1211         self.assertEqual(response.status_code, requests.codes.ok)
1212         res = response.json()
1213         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1214         self.assertDictEqual(
1215             dict({
1216                 'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1217                 'wavelength-number': 2,
1218                 'opticalControlMode': 'gainLoss',
1219                 'target-output-power': -3.0
1220             }, **res['roadm-connections'][0]),
1221             res['roadm-connections'][0]
1222         )
1223         self.assertDictEqual(
1224             {'src-if': 'SRG1-PP2-TXRX-2'},
1225             res['roadm-connections'][0]['source'])
1226         self.assertDictEqual(
1227             {'dst-if': 'DEG1-TTP-TXRX-2'},
1228             res['roadm-connections'][0]['destination'])
1229         time.sleep(2)
1230
1231     def test_43_check_topo_ROADMA(self):
1232         self.test_26_check_topo_ROADMA_SRG1()
1233         self.test_27_check_topo_ROADMA_DEG1()
1234         time.sleep(3)
1235
1236     def test_44_delete_oc_service1(self):
1237         url = "{}/operations/org-openroadm-service:service-delete"
1238         data = {"input": {
1239             "sdnc-request-header": {
1240                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1241                 "rpc-action": "service-delete",
1242                 "request-system-id": "appname",
1243                 "notification-url":
1244                     "http://localhost:8585/NotificationServer/notify"
1245             },
1246             "service-delete-req-info": {
1247                 "service-name": "service1",
1248                 "tail-retention": "no"
1249             }
1250         }
1251         }
1252         response = test_utils.post_request(url, data)
1253         self.assertEqual(response.status_code, requests.codes.ok)
1254         res = response.json()
1255         self.assertIn('Renderer service delete in progress',
1256                       res['output']['configuration-response-common'][
1257                           'response-message'])
1258         time.sleep(20)
1259
1260     def test_45_delete_oc_service2(self):
1261         url = "{}/operations/org-openroadm-service:service-delete"
1262         data = {"input": {
1263             "sdnc-request-header": {
1264                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1265                 "rpc-action": "service-delete",
1266                 "request-system-id": "appname",
1267                 "notification-url":
1268                     "http://localhost:8585/NotificationServer/notify"
1269             },
1270             "service-delete-req-info": {
1271                 "service-name": "service2",
1272                 "tail-retention": "no"
1273             }
1274         }
1275         }
1276         response = test_utils.post_request(url, data)
1277         self.assertEqual(response.status_code, requests.codes.ok)
1278         res = response.json()
1279         self.assertIn('Renderer service delete in progress',
1280                       res['output']['configuration-response-common'][
1281                           'response-message'])
1282         time.sleep(20)
1283
1284     def test_46_get_no_oc_services(self):
1285         print("start test")
1286         url = "{}/operational/org-openroadm-service:service-list"
1287         response = test_utils.get_request(url)
1288         self.assertEqual(response.status_code, requests.codes.not_found)
1289         res = response.json()
1290         self.assertIn(
1291             {
1292                 "error-type": "application",
1293                 "error-tag": "data-missing",
1294                 "error-message":
1295                     "Request could not be completed because the relevant data "
1296                     "model content does not exist"
1297             },
1298             res['errors']['error'])
1299         time.sleep(1)
1300
1301     def test_47_get_no_xc_ROADMA(self):
1302         response = test_utils.check_netconf_node_request("ROADMA01", "")
1303         self.assertEqual(response.status_code, requests.codes.ok)
1304         res = response.json()
1305         self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1306         time.sleep(1)
1307
1308     def test_48_check_topo_ROADMA(self):
1309         self.test_34_check_topo_ROADMA_SRG1()
1310         self.test_35_check_topo_ROADMA_DEG1()
1311
1312     def test_49_loop_create_eth_service(self):
1313         for i in range(1, 6):
1314             print("iteration number {}".format(i))
1315             print("eth service creation")
1316             self.test_11_create_eth_service1()
1317             print("check xc in ROADMA01")
1318             self.test_13_check_xc1_ROADMA()
1319             print("check xc in ROADMC01")
1320             self.test_14_check_xc1_ROADMC()
1321             print("eth service deletion\n")
1322             self.test_30_delete_eth_service1()
1323
1324     def test_50_loop_create_oc_service(self):
1325         url = "{}/operational/org-openroadm-service:service-list/services/service1"
1326         response = test_utils.get_request(url)
1327         if response.status_code != 404:
1328             url = "{}/operations/org-openroadm-service:service-delete"
1329             data = {"input": {
1330                 "sdnc-request-header": {
1331                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1332                     "rpc-action": "service-delete",
1333                     "request-system-id": "appname",
1334                     "notification-url":
1335                         "http://localhost:8585/NotificationServer/notify"
1336                 },
1337                 "service-delete-req-info": {
1338                     "service-name": "service1",
1339                     "tail-retention": "no"
1340                 }
1341             }
1342             }
1343             test_utils.post_request(url, data)
1344             time.sleep(5)
1345
1346         for i in range(1, 6):
1347             print("iteration number {}".format(i))
1348             print("oc service creation")
1349             self.test_36_create_oc_service1()
1350             print("check xc in ROADMA01")
1351             self.test_38_check_xc1_ROADMA()
1352             print("check xc in ROADMC01")
1353             self.test_39_check_xc1_ROADMC()
1354             print("oc service deletion\n")
1355             self.test_44_delete_oc_service1()
1356
1357     def test_51_disconnect_XPDRA(self):
1358         response = test_utils.unmount_device("XPDRA01")
1359         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1360
1361     def test_52_disconnect_XPDRC(self):
1362         response = test_utils.unmount_device("XPDRC01")
1363         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1364
1365     def test_53_disconnect_ROADMA(self):
1366         response = test_utils.unmount_device("ROADMA01")
1367         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1368
1369     def test_54_disconnect_ROADMC(self):
1370         response = test_utils.unmount_device("ROADMC01")
1371         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1372
1373
1374 if __name__ == "__main__":
1375     unittest.main(verbosity=2)