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