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