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