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         url = (
 280             "{}/config/network-topology:"
 281             "network-topology/topology/topology-netconf/"
 282             "node/ROADMA01/yang-ext:"
 283             "mount/org-openroadm-device:org-openroadm-device/"
 284             "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
 285         )
 286         response = test_utils.get_request(url)
 287         self.assertEqual(response.status_code, requests.codes.ok)
 288         res = response.json()
 289         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 290         self.assertDictEqual(
 291             dict({
 292                 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
 293                 'wavelength-number': 1,
 294                 'opticalControlMode': 'gainLoss',
 295                 'target-output-power': -3.0
 296             }, **res['roadm-connections'][0]),
 297             res['roadm-connections'][0]
 298         )
 299         self.assertDictEqual(
 300             {'src-if': 'SRG1-PP1-TXRX-1'},
 301             res['roadm-connections'][0]['source'])
 302         self.assertDictEqual(
 303             {'dst-if': 'DEG1-TTP-TXRX-1'},
 304             res['roadm-connections'][0]['destination'])
 305         time.sleep(5)
 306
 307     def test_14_check_xc1_ROADMC(self):
 308         url = (
 309             "{}/config/network-topology:"
 310             "network-topology/topology/topology-netconf/"
 311             "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
 312             "org-openroadm-device/"
 313             "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
 314         )
 315         response = test_utils.get_request(url)
 316         self.assertEqual(response.status_code, requests.codes.ok)
 317         res = response.json()
 318         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 319         self.assertDictEqual(
 320             dict({
 321                 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
 322                 'wavelength-number': 1,
 323                 'opticalControlMode': 'gainLoss',
 324                 'target-output-power': 2.0
 325             }, **res['roadm-connections'][0]),
 326             res['roadm-connections'][0]
 327         )
 328         self.assertDictEqual(
 329             {'src-if': 'SRG1-PP1-TXRX-1'},
 330             res['roadm-connections'][0]['source'])
 331         self.assertDictEqual(
 332             {'dst-if': 'DEG2-TTP-TXRX-1'},
 333             res['roadm-connections'][0]['destination'])
 334         time.sleep(5)
 335
 336     def test_15_check_topo_XPDRA(self):
 337         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 338         response = test_utils.get_request(url)
 339         self.assertEqual(response.status_code, requests.codes.ok)
 340         res = response.json()
 341         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 342         for ele in liste_tp:
 343             if ele['tp-id'] == 'XPDR1-NETWORK1':
 344                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 345                                  ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 346             if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
 347                 self.assertNotIn(
 348                     'org-openroadm-network-topology:xpdr-client-attributes',
 349                     dict.keys(ele))
 350             if ele['tp-id'] == 'XPDR1-NETWORK2':
 351                 self.assertNotIn(
 352                     'org-openroadm-network-topology:xpdr-network-attributes',
 353                     dict.keys(ele))
 354         time.sleep(3)
 355
 356     def test_16_check_topo_ROADMA_SRG1(self):
 357         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 358         response = test_utils.get_request(url)
 359         self.assertEqual(response.status_code, requests.codes.ok)
 360         res = response.json()
 361         self.assertNotIn({u'index': 1},
 362                          res['node'][0][
 363                              u'org-openroadm-network-topology:srg-attributes'][
 364                              'available-wavelengths'])
 365         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 366         for ele in liste_tp:
 367             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 368                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 369                               ele['org-openroadm-network-topology:'
 370                                   'pp-attributes']['used-wavelength']
 371                               )
 372             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 373                 self.assertNotIn('used-wavelength', dict.keys(ele))
 374         time.sleep(3)
 375
 376     def test_17_check_topo_ROADMA_DEG1(self):
 377         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 378         response = test_utils.get_request(url)
 379         self.assertEqual(response.status_code, requests.codes.ok)
 380         res = response.json()
 381         self.assertNotIn({u'index': 1},
 382                          res['node'][0][
 383                              u'org-openroadm-network-topology:'
 384                              u'degree-attributes'][
 385                              'available-wavelengths'])
 386         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 387         for ele in liste_tp:
 388             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 389                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 390                               ele['org-openroadm-network-topology:'
 391                                   'ctp-attributes'][
 392                                   'used-wavelengths'])
 393             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 394                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 395                               ele['org-openroadm-network-topology:'
 396                                   'tx-ttp-attributes'][
 397                                   'used-wavelengths'])
 398         time.sleep(3)
 399
 400     def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
 401         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "2",
 402                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 403         self.assertEqual(response.status_code, requests.codes.ok)
 404         res = response.json()
 405         self.assertIn('Xponder Roadm Link created successfully',
 406                       res["output"]["result"])
 407         time.sleep(2)
 408
 409     def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
 410         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2",
 411                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 412         self.assertEqual(response.status_code, requests.codes.ok)
 413         res = response.json()
 414         self.assertIn('Roadm Xponder links created successfully',
 415                       res["output"]["result"])
 416         time.sleep(2)
 417
 418     def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
 419         response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "2",
 420                                                           "ROADMC01", "1", "SRG1-PP2-TXRX")
 421         self.assertEqual(response.status_code, requests.codes.ok)
 422         res = response.json()
 423         self.assertIn('Xponder Roadm Link created successfully',
 424                       res["output"]["result"])
 425         time.sleep(2)
 426
 427     def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
 428         response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "2",
 429                                                           "ROADMC01", "1", "SRG1-PP2-TXRX")
 430         self.assertEqual(response.status_code, requests.codes.ok)
 431         res = response.json()
 432         self.assertIn('Roadm Xponder links created successfully',
 433                       res["output"]["result"])
 434         time.sleep(2)
 435
 436     def test_22_create_eth_service2(self):
 437         url = "{}/operations/org-openroadm-service:service-create"
 438         data = {
 439             "input": {
 440                 "sdnc-request-header": {
 441                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 442                     "rpc-action": "service-create",
 443                     "request-system-id": "appname",
 444                     "notification-url":
 445                         "http://localhost:8585/NotificationServer/notify"
 446                 },
 447                 "service-name": "service2",
 448                 "common-id": "ASATT1234567",
 449                 "connection-type": "service",
 450                 "service-a-end": {
 451                     "service-rate": "100",
 452                     "node-id": "XPDRA01",
 453                     "service-format": "Ethernet",
 454                     "clli": "SNJSCAMCJP8",
 455                     "tx-direction": {
 456                         "port": {
 457                             "port-device-name":
 458                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 459                             "port-type": "router",
 460                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 461                             "port-rack": "000000.00",
 462                             "port-shelf": "00"
 463                         },
 464                         "lgx": {
 465                             "lgx-device-name":
 466                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 467                             "lgx-port-name": "LGX Back.3",
 468                             "lgx-port-rack": "000000.00",
 469                             "lgx-port-shelf": "00"
 470                         }
 471                     },
 472                     "rx-direction": {
 473                         "port": {
 474                             "port-device-name":
 475                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 476                             "port-type": "router",
 477                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 478                             "port-rack": "000000.00",
 479                             "port-shelf": "00"
 480                         },
 481                         "lgx": {
 482                             "lgx-device-name":
 483                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 484                             "lgx-port-name": "LGX Back.4",
 485                             "lgx-port-rack": "000000.00",
 486                             "lgx-port-shelf": "00"
 487                         }
 488                     },
 489                     "optic-type": "gray"
 490                 },
 491                 "service-z-end": {
 492                     "service-rate": "100",
 493                     "node-id": "XPDRC01",
 494                     "service-format": "Ethernet",
 495                     "clli": "SNJSCAMCJT4",
 496                     "tx-direction": {
 497                         "port": {
 498                             "port-device-name":
 499                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 500                             "port-type": "router",
 501                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 502                             "port-rack": "000000.00",
 503                             "port-shelf": "00"
 504                         },
 505                         "lgx": {
 506                             "lgx-device-name":
 507                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 508                             "lgx-port-name": "LGX Back.29",
 509                             "lgx-port-rack": "000000.00",
 510                             "lgx-port-shelf": "00"
 511                         }
 512                     },
 513                     "rx-direction": {
 514                         "port": {
 515                             "port-device-name":
 516                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 517                             "port-type": "router",
 518                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 519                             "port-rack": "000000.00",
 520                             "port-shelf": "00"
 521                         },
 522                         "lgx": {
 523                             "lgx-device-name":
 524                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 525                             "lgx-port-name": "LGX Back.30",
 526                             "lgx-port-rack": "000000.00",
 527                             "lgx-port-shelf": "00"
 528                         }
 529                     },
 530                     "optic-type": "gray"
 531                 },
 532                 "due-date": "2016-11-28T00:00:01Z",
 533                 "operator-contact": "pw1234"
 534             }
 535         }
 536         response = test_utils.post_request(url, data)
 537         self.assertEqual(response.status_code, requests.codes.ok)
 538         res = response.json()
 539         self.assertIn('PCE calculation in progress',
 540                       res['output']['configuration-response-common'][
 541                           'response-message'])
 542         time.sleep(self.WAITING)
 543
 544     def test_23_get_eth_service2(self):
 545         url = "{}/operational/org-openroadm-service:service-list/services/service2"
 546         response = test_utils.get_request(url)
 547         self.assertEqual(response.status_code, requests.codes.ok)
 548         res = response.json()
 549         self.assertEqual(
 550             res['services'][0]['administrative-state'],
 551             'inService')
 552         self.assertEqual(
 553             res['services'][0]['service-name'], 'service2')
 554         self.assertEqual(
 555             res['services'][0]['connection-type'], 'service')
 556         self.assertEqual(
 557             res['services'][0]['lifecycle-state'], 'planned')
 558         time.sleep(1)
 559
 560     def test_24_check_xc2_ROADMA(self):
 561         url = (
 562             "{}/config/network-topology:"
 563             "network-topology/topology/topology-netconf/"
 564             "node/ROADMA01/yang-ext:"
 565             "mount/org-openroadm-device:org-openroadm-device/"
 566             "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
 567         )
 568         response = test_utils.get_request(url)
 569         self.assertEqual(response.status_code, requests.codes.ok)
 570         res = response.json()
 571         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 572         self.assertDictEqual(
 573             dict({
 574                  'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
 575                  'wavelength-number': 2,
 576                  'opticalControlMode': 'power'
 577                  }, **res['roadm-connections'][0]),
 578             res['roadm-connections'][0]
 579         )
 580         self.assertDictEqual(
 581             {'src-if': 'DEG1-TTP-TXRX-2'},
 582             res['roadm-connections'][0]['source'])
 583         self.assertDictEqual(
 584             {'dst-if': 'SRG1-PP2-TXRX-2'},
 585             res['roadm-connections'][0]['destination'])
 586
 587     def test_25_check_topo_XPDRA(self):
 588         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 589         response = test_utils.get_request(url)
 590         self.assertEqual(response.status_code, requests.codes.ok)
 591         res = response.json()
 592         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 593         for ele in liste_tp:
 594             if ele['tp-id'] == 'XPDR1-NETWORK1':
 595                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 596                                  ele['org-openroadm-network-topology:'
 597                                      'xpdr-network-attributes'][
 598                                      'wavelength'])
 599             if ele['tp-id'] == 'XPDR1-NETWORK2':
 600                 self.assertEqual({u'frequency': 196.05, u'width': 40},
 601                                  ele['org-openroadm-network-topology:'
 602                                      'xpdr-network-attributes'][
 603                                      'wavelength'])
 604             if ele['tp-id'] == 'XPDR1-CLIENT1' or \
 605                ele['tp-id'] == 'XPDR1-CLIENT3':
 606                 self.assertNotIn(
 607                     'org-openroadm-network-topology:xpdr-client-attributes',
 608                     dict.keys(ele))
 609         time.sleep(10)
 610
 611     def test_26_check_topo_ROADMA_SRG1(self):
 612         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 613         response = test_utils.get_request(url)
 614         self.assertEqual(response.status_code, requests.codes.ok)
 615         res = response.json()
 616         self.assertNotIn({u'index': 1}, res['node'][0][
 617             u'org-openroadm-network-topology:srg-attributes'][
 618             'available-wavelengths'])
 619         self.assertNotIn({u'index': 2}, res['node'][0][
 620             u'org-openroadm-network-topology:srg-attributes'][
 621             'available-wavelengths'])
 622         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 623         for ele in liste_tp:
 624             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 625                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 626                               ele['org-openroadm-network-topology:'
 627                                   'pp-attributes']['used-wavelength'])
 628                 self.assertNotIn({u'index': 2, u'frequency': 196.05,
 629                                   u'width': 40},
 630                                  ele['org-openroadm-network-topology:'
 631                                      'pp-attributes']['used-wavelength'])
 632             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 633                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 634                               ele['org-openroadm-network-topology:'
 635                                   'pp-attributes']['used-wavelength'])
 636                 self.assertNotIn({u'index': 1, u'frequency': 196.1,
 637                                   u'width': 40},
 638                                  ele['org-openroadm-network-topology:'
 639                                      'pp-attributes']['used-wavelength'])
 640             if ele['tp-id'] == 'SRG1-PP3-TXRX':
 641                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 642                                  dict.keys(ele))
 643         time.sleep(10)
 644
 645     def test_27_check_topo_ROADMA_DEG1(self):
 646         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 647         response = test_utils.get_request(url)
 648         self.assertEqual(response.status_code, requests.codes.ok)
 649         res = response.json()
 650         self.assertNotIn({u'index': 1}, res['node'][0][
 651             u'org-openroadm-network-topology:degree-attributes'][
 652             'available-wavelengths'])
 653         self.assertNotIn({u'index': 2}, res['node'][0][
 654             u'org-openroadm-network-topology:degree-attributes'][
 655             'available-wavelengths'])
 656         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 657         for ele in liste_tp:
 658             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 659                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 660                               ele['org-openroadm-network-topology:'
 661                                   'ctp-attributes']['used-wavelengths'])
 662                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 663                               ele['org-openroadm-network-topology:'
 664                                   'ctp-attributes']['used-wavelengths'])
 665             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 666                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 667                               ele['org-openroadm-network-topology:'
 668                                   'tx-ttp-attributes']['used-wavelengths'])
 669                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 670                               ele['org-openroadm-network-topology:'
 671                                   'tx-ttp-attributes']['used-wavelengths'])
 672         time.sleep(10)
 673
 674     #     creation service test on a non-available resource
 675     def test_28_create_eth_service3(self):
 676         url = "{}/operations/org-openroadm-service:service-create"
 677         data = {
 678             "input": {
 679                 "sdnc-request-header": {
 680                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 681                     "rpc-action": "service-create",
 682                     "request-system-id": "appname",
 683                     "notification-url":
 684                         "http://localhost:8585/NotificationServer/notify"
 685                 },
 686                 "service-name": "service3",
 687                 "common-id": "ASATT1234567",
 688                 "connection-type": "service",
 689                 "service-a-end": {
 690                     "service-rate": "100",
 691                     "node-id": "XPDRA01",
 692                     "service-format": "Ethernet",
 693                     "clli": "SNJSCAMCJP8",
 694                     "tx-direction": {
 695                         "port": {
 696                             "port-device-name":
 697                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 698                             "port-type": "router",
 699                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 700                             "port-rack": "000000.00",
 701                             "port-shelf": "00"
 702                         },
 703                         "lgx": {
 704                             "lgx-device-name":
 705                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 706                             "lgx-port-name": "LGX Back.3",
 707                             "lgx-port-rack": "000000.00",
 708                             "lgx-port-shelf": "00"
 709                         }
 710                     },
 711                     "rx-direction": {
 712                         "port": {
 713                             "port-device-name":
 714                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 715                             "port-type": "router",
 716                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 717                             "port-rack": "000000.00",
 718                             "port-shelf": "00"
 719                         },
 720                         "lgx": {
 721                             "lgx-device-name":
 722                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 723                             "lgx-port-name": "LGX Back.4",
 724                             "lgx-port-rack": "000000.00",
 725                             "lgx-port-shelf": "00"
 726                         }
 727                     },
 728                     "optic-type": "gray"
 729                 },
 730                 "service-z-end": {
 731                     "service-rate": "100",
 732                     "node-id": "XPDRC01",
 733                     "service-format": "Ethernet",
 734                     "clli": "SNJSCAMCJT4",
 735                     "tx-direction": {
 736                         "port": {
 737                             "port-device-name":
 738                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 739                             "port-type": "router",
 740                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 741                             "port-rack": "000000.00",
 742                             "port-shelf": "00"
 743                         },
 744                         "lgx": {
 745                             "lgx-device-name":
 746                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 747                             "lgx-port-name": "LGX Back.29",
 748                             "lgx-port-rack": "000000.00",
 749                             "lgx-port-shelf": "00"
 750                         }
 751                     },
 752                     "rx-direction": {
 753                         "port": {
 754                             "port-device-name":
 755                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 756                             "port-type": "router",
 757                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 758                             "port-rack": "000000.00",
 759                             "port-shelf": "00"
 760                         },
 761                         "lgx": {
 762                             "lgx-device-name":
 763                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 764                             "lgx-port-name": "LGX Back.30",
 765                             "lgx-port-rack": "000000.00",
 766                             "lgx-port-shelf": "00"
 767                         }
 768                     },
 769                     "optic-type": "gray"
 770                 },
 771                 "due-date": "2016-11-28T00:00:01Z",
 772                 "operator-contact": "pw1234"
 773             }
 774         }
 775         response = test_utils.post_request(url, data)
 776         self.assertEqual(response.status_code, requests.codes.ok)
 777         res = response.json()
 778         self.assertIn('PCE calculation in progress',
 779                       res['output']['configuration-response-common'][
 780                           'response-message'])
 781         self.assertIn('200', res['output']['configuration-response-common'][
 782             'response-code'])
 783         time.sleep(self.WAITING)
 784
 785     # add a test that check the openroadm-service-list still only
 786     # contains 2 elements
 787
 788     def test_29_delete_eth_service3(self):
 789         url = "{}/operations/org-openroadm-service:service-delete"
 790         data = {"input": {
 791             "sdnc-request-header": {
 792                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 793                 "rpc-action": "service-delete",
 794                 "request-system-id": "appname",
 795                 "notification-url":
 796                     "http://localhost:8585/NotificationServer/notify"
 797             },
 798             "service-delete-req-info": {
 799                 "service-name": "service3",
 800                 "tail-retention": "no"
 801             }
 802         }
 803         }
 804         response = test_utils.post_request(url, data)
 805         self.assertEqual(response.status_code, requests.codes.ok)
 806         res = response.json()
 807         self.assertIn('Service \'service3\' does not exist in datastore',
 808                       res['output']['configuration-response-common'][
 809                           'response-message'])
 810         self.assertIn('500', res['output']['configuration-response-common'][
 811             'response-code'])
 812         time.sleep(20)
 813
 814     def test_30_delete_eth_service1(self):
 815         url = "{}/operations/org-openroadm-service:service-delete"
 816         data = {"input": {
 817             "sdnc-request-header": {
 818                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 819                 "rpc-action": "service-delete",
 820                 "request-system-id": "appname",
 821                 "notification-url":
 822                     "http://localhost:8585/NotificationServer/notify"
 823             },
 824             "service-delete-req-info": {
 825                 "service-name": "service1",
 826                 "tail-retention": "no"
 827             }
 828         }
 829         }
 830         response = test_utils.post_request(url, data)
 831         self.assertEqual(response.status_code, requests.codes.ok)
 832         res = response.json()
 833         self.assertIn('Renderer service delete in progress',
 834                       res['output']['configuration-response-common'][
 835                           'response-message'])
 836         time.sleep(20)
 837
 838     def test_31_delete_eth_service2(self):
 839         url = "{}/operations/org-openroadm-service:service-delete"
 840         data = {"input": {
 841             "sdnc-request-header": {
 842                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 843                 "rpc-action": "service-delete",
 844                 "request-system-id": "appname",
 845                 "notification-url":
 846                     "http://localhost:8585/NotificationServer/notify"
 847             },
 848             "service-delete-req-info": {
 849                 "service-name": "service2",
 850                 "tail-retention": "no"
 851             }
 852         }
 853         }
 854         response = test_utils.post_request(url, data)
 855         self.assertEqual(response.status_code, requests.codes.ok)
 856         res = response.json()
 857         self.assertIn('Renderer service delete in progress',
 858                       res['output']['configuration-response-common'][
 859                           'response-message'])
 860         time.sleep(20)
 861
 862     def test_32_check_no_xc_ROADMA(self):
 863         url = (
 864             "{}/config/network-topology:"
 865             "network-topology/topology/topology-netconf/"
 866             "node/ROADMA01/yang-ext:"
 867             "mount/org-openroadm-device:org-openroadm-device/"
 868         )
 869         response = test_utils.get_request(url)
 870         res = response.json()
 871         self.assertEqual(response.status_code, requests.codes.ok)
 872         self.assertNotIn('roadm-connections',
 873                          dict.keys(res['org-openroadm-device']))
 874         time.sleep(2)
 875
 876     def test_33_check_topo_XPDRA(self):
 877         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 878         response = test_utils.get_request(url)
 879         self.assertEqual(response.status_code, requests.codes.ok)
 880         res = response.json()
 881         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 882         for ele in liste_tp:
 883             if ((ele[u'org-openroadm-common-network:tp-type'] ==
 884                  'XPONDER-CLIENT')
 885                 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele[
 886                     'tp-id'] == 'XPDR1-CLIENT3')):
 887                 self.assertNotIn(
 888                     'org-openroadm-network-topology:xpdr-client-attributes',
 889                     dict.keys(ele))
 890             elif (ele[u'org-openroadm-common-network:tp-type'] ==
 891                   'XPONDER-NETWORK'):
 892                 self.assertIn(u'tail-equipment-id', dict.keys(
 893                     ele[u'org-openroadm-network-topology:'
 894                         u'xpdr-network-attributes']))
 895                 self.assertNotIn('wavelength', dict.keys(
 896                     ele[u'org-openroadm-network-topology:'
 897                         u'xpdr-network-attributes']))
 898         time.sleep(10)
 899
 900     def test_34_check_topo_ROADMA_SRG1(self):
 901         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 902         response = test_utils.get_request(url)
 903         self.assertEqual(response.status_code, requests.codes.ok)
 904         res = response.json()
 905         self.assertIn({u'index': 1}, res['node'][0][
 906             u'org-openroadm-network-topology:srg-attributes'][
 907             'available-wavelengths'])
 908         self.assertIn({u'index': 2}, res['node'][0][
 909             u'org-openroadm-network-topology:srg-attributes'][
 910             'available-wavelengths'])
 911         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 912         for ele in liste_tp:
 913             if ele['tp-id'] == 'SRG1-PP1-TXRX' or \
 914                ele['tp-id'] == 'SRG1-PP1-TXRX':
 915                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 916                                  dict.keys(ele))
 917             else:
 918                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 919                                  dict.keys(ele))
 920         time.sleep(10)
 921
 922     def test_35_check_topo_ROADMA_DEG1(self):
 923         url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 924         response = test_utils.get_request(url)
 925         self.assertEqual(response.status_code, requests.codes.ok)
 926         res = response.json()
 927         self.assertIn({u'index': 1}, res['node'][0][
 928             u'org-openroadm-network-topology:degree-attributes'][
 929             'available-wavelengths'])
 930         self.assertIn({u'index': 2}, res['node'][0][
 931             u'org-openroadm-network-topology:degree-attributes'][
 932             'available-wavelengths'])
 933         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 934         for ele in liste_tp:
 935             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 936                 self.assertNotIn('org-openroadm-network-topology:'
 937                                  'ctp-attributes', dict.keys(ele))
 938             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 939                 self.assertNotIn('org-openroadm-network-topology:'
 940                                  'tx-ttp-attributes', dict.keys(ele))
 941         time.sleep(10)
 942
 943     # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
 944     def test_36_create_oc_service1(self):
 945         url = "{}/operations/org-openroadm-service:service-create"
 946         data = {
 947             "input": {
 948                 "sdnc-request-header": {
 949                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 950                     "rpc-action": "service-create",
 951                     "request-system-id": "appname",
 952                     "notification-url":
 953                         "http://localhost:8585/NotificationServer/notify"
 954                 },
 955                 "service-name": "service1",
 956                 "common-id": "ASATT1234567",
 957                 "connection-type": "roadm-line",
 958                 "service-a-end": {
 959                     "service-rate": "100",
 960                     "node-id": "ROADMA01",
 961                     "service-format": "OC",
 962                     "clli": "SNJSCAMCJP8",
 963                     "tx-direction": {
 964                         "port": {
 965                             "port-device-name":
 966                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 967                             "port-type": "router",
 968                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 969                             "port-rack": "000000.00",
 970                             "port-shelf": "00"
 971                         },
 972                         "lgx": {
 973                             "lgx-device-name":
 974                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 975                             "lgx-port-name": "LGX Back.3",
 976                             "lgx-port-rack": "000000.00",
 977                             "lgx-port-shelf": "00"
 978                         }
 979                     },
 980                     "rx-direction": {
 981                         "port": {
 982                             "port-device-name":
 983                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 984                             "port-type": "router",
 985                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 986                             "port-rack": "000000.00",
 987                             "port-shelf": "00"
 988                         },
 989                         "lgx": {
 990                             "lgx-device-name":
 991                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 992                             "lgx-port-name": "LGX Back.4",
 993                             "lgx-port-rack": "000000.00",
 994                             "lgx-port-shelf": "00"
 995                         }
 996                     },
 997                     "optic-type": "gray"
 998                 },
 999                 "service-z-end": {
1000                     "service-rate": "100",
1001                     "node-id": "ROADMC01",
1002                     "service-format": "OC",
1003                     "clli": "SNJSCAMCJT4",
1004                     "tx-direction": {
1005                         "port": {
1006                             "port-device-name":
1007                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1008                             "port-type": "router",
1009                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1010                             "port-rack": "000000.00",
1011                             "port-shelf": "00"
1012                         },
1013                         "lgx": {
1014                             "lgx-device-name":
1015                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1016                             "lgx-port-name": "LGX Back.29",
1017                             "lgx-port-rack": "000000.00",
1018                             "lgx-port-shelf": "00"
1019                         }
1020                     },
1021                     "rx-direction": {
1022                         "port": {
1023                             "port-device-name":
1024                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1025                             "port-type": "router",
1026                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1027                             "port-rack": "000000.00",
1028                             "port-shelf": "00"
1029                         },
1030                         "lgx": {
1031                             "lgx-device-name":
1032                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1033                             "lgx-port-name": "LGX Back.30",
1034                             "lgx-port-rack": "000000.00",
1035                             "lgx-port-shelf": "00"
1036                         }
1037                     },
1038                     "optic-type": "gray"
1039                 },
1040                 "due-date": "2016-11-28T00:00:01Z",
1041                 "operator-contact": "pw1234"
1042             }
1043         }
1044         response = test_utils.post_request(url, data)
1045         self.assertEqual(response.status_code, requests.codes.ok)
1046         res = response.json()
1047         self.assertIn('PCE calculation in progress',
1048                       res['output']['configuration-response-common'][
1049                           'response-message'])
1050         time.sleep(self.WAITING)
1051
1052     def test_37_get_oc_service1(self):
1053         url = "{}/operational/org-openroadm-service:service-list/services/service1"
1054         response = test_utils.get_request(url)
1055         self.assertEqual(response.status_code, requests.codes.ok)
1056         res = response.json()
1057         self.assertEqual(
1058             res['services'][0]['administrative-state'],
1059             'inService')
1060         self.assertEqual(
1061             res['services'][0]['service-name'], 'service1')
1062         self.assertEqual(
1063             res['services'][0]['connection-type'], 'roadm-line')
1064         self.assertEqual(
1065             res['services'][0]['lifecycle-state'], 'planned')
1066         time.sleep(1)
1067
1068     def test_38_check_xc1_ROADMA(self):
1069         url = (
1070             "{}/config/network-topology:"
1071             "network-topology/topology/topology-netconf/"
1072             "node/ROADMA01/yang-ext:"
1073             "mount/org-openroadm-device:org-openroadm-device/"
1074             "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1075         )
1076         response = test_utils.get_request(url)
1077         self.assertEqual(response.status_code, requests.codes.ok)
1078         res = response.json()
1079         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1080         self.assertDictEqual(
1081             dict({
1082                 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1083                 'wavelength-number': 1,
1084                 'opticalControlMode': 'gainLoss',
1085                 'target-output-power': -3.0
1086             }, **res['roadm-connections'][0]),
1087             res['roadm-connections'][0]
1088         )
1089         self.assertDictEqual(
1090             {'src-if': 'SRG1-PP1-TXRX-1'},
1091             res['roadm-connections'][0]['source'])
1092         self.assertDictEqual(
1093             {'dst-if': 'DEG1-TTP-TXRX-1'},
1094             res['roadm-connections'][0]['destination'])
1095         time.sleep(7)
1096
1097     def test_39_check_xc1_ROADMC(self):
1098         url = (
1099             "{}/config/network-topology:"
1100             "network-topology/topology/topology-netconf/"
1101             "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
1102             "org-openroadm-device/"
1103             "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1104         )
1105         response = test_utils.get_request(url)
1106         self.assertEqual(response.status_code, requests.codes.ok)
1107         res = response.json()
1108         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1109         self.assertDictEqual(
1110             dict({
1111                 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1112                 'wavelength-number': 1,
1113                 'opticalControlMode': 'gainLoss',
1114                 'target-output-power': 2.0
1115             }, **res['roadm-connections'][0]),
1116             res['roadm-connections'][0]
1117         )
1118         self.assertDictEqual(
1119             {'src-if': 'SRG1-PP1-TXRX-1'},
1120             res['roadm-connections'][0]['source'])
1121         self.assertDictEqual(
1122             {'dst-if': 'DEG2-TTP-TXRX-1'},
1123             res['roadm-connections'][0]['destination'])
1124         time.sleep(7)
1125
1126     def test_40_create_oc_service2(self):
1127         url = "{}/operations/org-openroadm-service:service-create"
1128         data = {
1129             "input": {
1130                 "sdnc-request-header": {
1131                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1132                     "rpc-action": "service-create",
1133                     "request-system-id": "appname",
1134                     "notification-url":
1135                         "http://localhost:8585/NotificationServer/notify"
1136                 },
1137                 "service-name": "service2",
1138                 "common-id": "ASATT1234567",
1139                 "connection-type": "roadm-line",
1140                 "service-a-end": {
1141                     "service-rate": "100",
1142                     "node-id": "ROADMA01",
1143                     "service-format": "OC",
1144                     "clli": "SNJSCAMCJP8",
1145                     "tx-direction": {
1146                         "port": {
1147                             "port-device-name":
1148                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1149                             "port-type": "router",
1150                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1151                             "port-rack": "000000.00",
1152                             "port-shelf": "00"
1153                         },
1154                         "lgx": {
1155                             "lgx-device-name":
1156                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1157                             "lgx-port-name": "LGX Back.3",
1158                             "lgx-port-rack": "000000.00",
1159                             "lgx-port-shelf": "00"
1160                         }
1161                     },
1162                     "rx-direction": {
1163                         "port": {
1164                             "port-device-name":
1165                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1166                             "port-type": "router",
1167                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1168                             "port-rack": "000000.00",
1169                             "port-shelf": "00"
1170                         },
1171                         "lgx": {
1172                             "lgx-device-name":
1173                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1174                             "lgx-port-name": "LGX Back.4",
1175                             "lgx-port-rack": "000000.00",
1176                             "lgx-port-shelf": "00"
1177                         }
1178                     },
1179                     "optic-type": "gray"
1180                 },
1181                 "service-z-end": {
1182                     "service-rate": "100",
1183                     "node-id": "ROADMC01",
1184                     "service-format": "OC",
1185                     "clli": "SNJSCAMCJT4",
1186                     "tx-direction": {
1187                         "port": {
1188                             "port-device-name":
1189                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1190                             "port-type": "router",
1191                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1192                             "port-rack": "000000.00",
1193                             "port-shelf": "00"
1194                         },
1195                         "lgx": {
1196                             "lgx-device-name":
1197                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1198                             "lgx-port-name": "LGX Back.29",
1199                             "lgx-port-rack": "000000.00",
1200                             "lgx-port-shelf": "00"
1201                         }
1202                     },
1203                     "rx-direction": {
1204                         "port": {
1205                             "port-device-name":
1206                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1207                             "port-type": "router",
1208                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1209                             "port-rack": "000000.00",
1210                             "port-shelf": "00"
1211                         },
1212                         "lgx": {
1213                             "lgx-device-name":
1214                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1215                             "lgx-port-name": "LGX Back.30",
1216                             "lgx-port-rack": "000000.00",
1217                             "lgx-port-shelf": "00"
1218                         }
1219                     },
1220                     "optic-type": "gray"
1221                 },
1222                 "due-date": "2016-11-28T00:00:01Z",
1223                 "operator-contact": "pw1234"
1224             }
1225         }
1226         response = test_utils.post_request(url, data)
1227         self.assertEqual(response.status_code, requests.codes.ok)
1228         res = response.json()
1229         self.assertIn('PCE calculation in progress',
1230                       res['output']['configuration-response-common'][
1231                           'response-message'])
1232         time.sleep(self.WAITING)
1233
1234     def test_41_get_oc_service2(self):
1235         url = "{}/operational/org-openroadm-service:service-list/services/service2"
1236         response = test_utils.get_request(url)
1237         self.assertEqual(response.status_code, requests.codes.ok)
1238         res = response.json()
1239         self.assertEqual(
1240             res['services'][0]['administrative-state'],
1241             'inService')
1242         self.assertEqual(
1243             res['services'][0]['service-name'], 'service2')
1244         self.assertEqual(
1245             res['services'][0]['connection-type'], 'roadm-line')
1246         self.assertEqual(
1247             res['services'][0]['lifecycle-state'], 'planned')
1248         time.sleep(2)
1249
1250     def test_42_check_xc2_ROADMA(self):
1251         url = (
1252             "{}/config/network-topology:"
1253             "network-topology/topology/topology-netconf/"
1254             "node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1255             "org-openroadm-device/"
1256             "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1257         )
1258         response = test_utils.get_request(url)
1259         self.assertEqual(response.status_code, requests.codes.ok)
1260         res = response.json()
1261         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1262         self.assertDictEqual(
1263             dict({
1264                 'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1265                 'wavelength-number': 2,
1266                 'opticalControlMode': 'gainLoss',
1267                 'target-output-power': -3.0
1268             }, **res['roadm-connections'][0]),
1269             res['roadm-connections'][0]
1270         )
1271         self.assertDictEqual(
1272             {'src-if': 'SRG1-PP2-TXRX-2'},
1273             res['roadm-connections'][0]['source'])
1274         self.assertDictEqual(
1275             {'dst-if': 'DEG1-TTP-TXRX-2'},
1276             res['roadm-connections'][0]['destination'])
1277         time.sleep(2)
1278
1279     def test_43_check_topo_ROADMA(self):
1280         self.test_26_check_topo_ROADMA_SRG1()
1281         self.test_27_check_topo_ROADMA_DEG1()
1282         time.sleep(3)
1283
1284     def test_44_delete_oc_service1(self):
1285         url = "{}/operations/org-openroadm-service:service-delete"
1286         data = {"input": {
1287             "sdnc-request-header": {
1288                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1289                 "rpc-action": "service-delete",
1290                 "request-system-id": "appname",
1291                 "notification-url":
1292                     "http://localhost:8585/NotificationServer/notify"
1293             },
1294             "service-delete-req-info": {
1295                 "service-name": "service1",
1296                 "tail-retention": "no"
1297             }
1298         }
1299         }
1300         response = test_utils.post_request(url, data)
1301         self.assertEqual(response.status_code, requests.codes.ok)
1302         res = response.json()
1303         self.assertIn('Renderer service delete in progress',
1304                       res['output']['configuration-response-common'][
1305                           'response-message'])
1306         time.sleep(20)
1307
1308     def test_45_delete_oc_service2(self):
1309         url = "{}/operations/org-openroadm-service:service-delete"
1310         data = {"input": {
1311             "sdnc-request-header": {
1312                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1313                 "rpc-action": "service-delete",
1314                 "request-system-id": "appname",
1315                 "notification-url":
1316                     "http://localhost:8585/NotificationServer/notify"
1317             },
1318             "service-delete-req-info": {
1319                 "service-name": "service2",
1320                 "tail-retention": "no"
1321             }
1322         }
1323         }
1324         response = test_utils.post_request(url, data)
1325         self.assertEqual(response.status_code, requests.codes.ok)
1326         res = response.json()
1327         self.assertIn('Renderer service delete in progress',
1328                       res['output']['configuration-response-common'][
1329                           'response-message'])
1330         time.sleep(20)
1331
1332     def test_46_get_no_oc_services(self):
1333         print("start test")
1334         url = ("{}/operational/org-openroadm-service:service-list"
1335                )
1336         response = test_utils.get_request(url)
1337         self.assertEqual(response.status_code, requests.codes.not_found)
1338         res = response.json()
1339         self.assertIn(
1340             {
1341                 "error-type": "application",
1342                 "error-tag": "data-missing",
1343                 "error-message":
1344                     "Request could not be completed because the relevant data "
1345                     "model content does not exist"
1346             },
1347             res['errors']['error'])
1348         time.sleep(1)
1349
1350     def test_47_get_no_xc_ROADMA(self):
1351         url = (
1352             "{}/config/network-topology:"
1353             "network-topology/topology/topology-netconf"
1354             "/node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1355             "org-openroadm-device/"
1356         )
1357         response = test_utils.get_request(url)
1358         self.assertEqual(response.status_code, requests.codes.ok)
1359         res = response.json()
1360         self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1361         time.sleep(1)
1362
1363     def test_48_check_topo_ROADMA(self):
1364         self.test_34_check_topo_ROADMA_SRG1()
1365         self.test_35_check_topo_ROADMA_DEG1()
1366
1367     def test_49_loop_create_eth_service(self):
1368         for i in range(1, 6):
1369             print("iteration number {}".format(i))
1370             print("eth service creation")
1371             self.test_11_create_eth_service1()
1372             print("check xc in ROADMA01")
1373             self.test_13_check_xc1_ROADMA()
1374             print("check xc in ROADMC01")
1375             self.test_14_check_xc1_ROADMC()
1376             print("eth service deletion\n")
1377             self.test_30_delete_eth_service1()
1378
1379     def test_50_loop_create_oc_service(self):
1380         url = "{}/operational/org-openroadm-service:service-list/services/service1"
1381         response = test_utils.get_request(url)
1382         if response.status_code != 404:
1383             url = ("{}/operations/org-openroadm-service:service-delete"
1384                    )
1385             data = {"input": {
1386                 "sdnc-request-header": {
1387                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1388                     "rpc-action": "service-delete",
1389                     "request-system-id": "appname",
1390                     "notification-url":
1391                         "http://localhost:8585/NotificationServer/notify"
1392                 },
1393                 "service-delete-req-info": {
1394                     "service-name": "service1",
1395                     "tail-retention": "no"
1396                 }
1397             }
1398             }
1399             test_utils.post_request(url, data)
1400             time.sleep(5)
1401
1402         for i in range(1, 6):
1403             print("iteration number {}".format(i))
1404             print("oc service creation")
1405             self.test_36_create_oc_service1()
1406             print("check xc in ROADMA01")
1407             self.test_38_check_xc1_ROADMA()
1408             print("check xc in ROADMC01")
1409             self.test_39_check_xc1_ROADMC()
1410             print("oc service deletion\n")
1411             self.test_44_delete_oc_service1()
1412
1413     def test_51_disconnect_XPDRA(self):
1414         response = test_utils.unmount_device("XPDRA01")
1415         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1416
1417     def test_52_disconnect_XPDRC(self):
1418         response = test_utils.unmount_device("XPDRC01")
1419         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1420
1421     def test_53_disconnect_ROADMA(self):
1422         response = test_utils.unmount_device("ROADMA01")
1423         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1424
1425     def test_54_disconnect_ROADMC(self):
1426         response = test_utils.unmount_device("ROADMC01")
1427         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1428
1429
1430 if __name__ == "__main__":
1431     unittest.main(verbosity=2)