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