tests/transportpce_tests/1.2.1/test_end2end.py

   1 #!/usr/bin/env python
   2 ##############################################################################
   3 # Copyright (c) 2017 Orange, Inc. and others.  All rights reserved.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 ##############################################################################
  10
  11
  12 import json
  13 import signal
  14 import time
  15 import unittest
  16
  17 import psutil
  18 import requests
  19 import test_utils
  20
  21
  22 class TransportPCEFulltesting(unittest.TestCase):
  23     headers = {'content-type': 'application/json'}
  24     odl_process = None
  25     honeynode_process1 = None
  26     honeynode_process2 = None
  27     honeynode_process3 = None
  28     honeynode_process4 = None
  29     restconf_baseurl = "http://localhost:8181/restconf"
  30     WAITING = 20  # nominal value is 300
  31
  32     #  START_IGNORE_XTESTING
  33
  34     @classmethod
  35     def setUpClass(cls):
  36         print("starting honeynode1...")
  37         cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
  38         time.sleep(20)
  39
  40         print("starting honeynode2...")
  41         cls.honeynode_process2 = test_utils.start_roadma_full_honeynode()
  42         time.sleep(20)
  43
  44         print("starting honeynode3...")
  45         cls.honeynode_process3 = test_utils.start_roadmc_full_honeynode()
  46         time.sleep(20)
  47
  48         print("starting honeynode4...")
  49         cls.honeynode_process4 = test_utils.start_xpdrc_honeynode()
  50         time.sleep(20)
  51         print("all honeynodes started")
  52
  53         print("starting opendaylight...")
  54         cls.odl_process = test_utils.start_tpce()
  55         time.sleep(80)
  56         print("opendaylight started")
  57
  58     @classmethod
  59     def tearDownClass(cls):
  60         for child in psutil.Process(cls.odl_process.pid).children():
  61             child.send_signal(signal.SIGINT)
  62             child.wait()
  63         cls.odl_process.send_signal(signal.SIGINT)
  64         cls.odl_process.wait()
  65         for child in psutil.Process(cls.honeynode_process1.pid).children():
  66             child.send_signal(signal.SIGINT)
  67             child.wait()
  68         cls.honeynode_process1.send_signal(signal.SIGINT)
  69         cls.honeynode_process1.wait()
  70         for child in psutil.Process(cls.honeynode_process2.pid).children():
  71             child.send_signal(signal.SIGINT)
  72             child.wait()
  73         cls.honeynode_process2.send_signal(signal.SIGINT)
  74         cls.honeynode_process2.wait()
  75         for child in psutil.Process(cls.honeynode_process3.pid).children():
  76             child.send_signal(signal.SIGINT)
  77             child.wait()
  78         cls.honeynode_process3.send_signal(signal.SIGINT)
  79         cls.honeynode_process3.wait()
  80         for child in psutil.Process(cls.honeynode_process4.pid).children():
  81             child.send_signal(signal.SIGINT)
  82             child.wait()
  83         cls.honeynode_process4.send_signal(signal.SIGINT)
  84         cls.honeynode_process4.wait()
  85         print("all processes killed")
  86
  87     def setUp(self):  # instruction executed before each test method
  88         print("execution of {}".format(self.id().split(".")[-1]))
  89
  90     # END_IGNORE_XTESTING
  91
  92     #  connect netconf devices
  93     def test_01_connect_xpdrA(self):
  94         url = ("{}/config/network-topology:"
  95                "network-topology/topology/topology-netconf/node/XPDRA01"
  96                .format(self.restconf_baseurl))
  97         data = {"node": [{
  98             "node-id": "XPDRA01",
  99             "netconf-node-topology:username": "admin",
 100             "netconf-node-topology:password": "admin",
 101             "netconf-node-topology:host": "127.0.0.1",
 102             "netconf-node-topology:port": "17830",
 103             "netconf-node-topology:tcp-only": "false",
 104             "netconf-node-topology:pass-through": {}}]}
 105         headers = {'content-type': 'application/json'}
 106         response = requests.request(
 107             "PUT", url, data=json.dumps(data), headers=headers,
 108             auth=('admin', 'admin'))
 109         self.assertEqual(response.status_code, requests.codes.created)
 110         time.sleep(20)
 111
 112     def test_02_connect_xpdrC(self):
 113         url = ("{}/config/network-topology:"
 114                "network-topology/topology/topology-netconf/node/XPDRC01"
 115                .format(self.restconf_baseurl))
 116         data = {"node": [{
 117             "node-id": "XPDRC01",
 118             "netconf-node-topology:username": "admin",
 119             "netconf-node-topology:password": "admin",
 120             "netconf-node-topology:host": "127.0.0.1",
 121             "netconf-node-topology:port": "17834",
 122             "netconf-node-topology:tcp-only": "false",
 123             "netconf-node-topology:pass-through": {}}]}
 124         headers = {'content-type': 'application/json'}
 125         response = requests.request(
 126             "PUT", url, data=json.dumps(data), headers=headers,
 127             auth=('admin', 'admin'))
 128         self.assertEqual(response.status_code, requests.codes.created)
 129         time.sleep(20)
 130
 131     def test_03_connect_rdmA(self):
 132         url = ("{}/config/network-topology:"
 133                "network-topology/topology/topology-netconf/node/ROADMA01"
 134                .format(self.restconf_baseurl))
 135         data = {"node": [{
 136             "node-id": "ROADMA01",
 137             "netconf-node-topology:username": "admin",
 138             "netconf-node-topology:password": "admin",
 139             "netconf-node-topology:host": "127.0.0.1",
 140             "netconf-node-topology:port": "17821",
 141             "netconf-node-topology:tcp-only": "false",
 142             "netconf-node-topology:pass-through": {}}]}
 143         headers = {'content-type': 'application/json'}
 144         response = requests.request(
 145             "PUT", url, data=json.dumps(data), headers=headers,
 146             auth=('admin', 'admin'))
 147         self.assertEqual(response.status_code, requests.codes.created)
 148         time.sleep(20)
 149
 150     def test_04_connect_rdmC(self):
 151         url = ("{}/config/network-topology:"
 152                "network-topology/topology/topology-netconf/node/ROADMC01"
 153                .format(self.restconf_baseurl))
 154         data = {"node": [{
 155             "node-id": "ROADMC01",
 156             "netconf-node-topology:username": "admin",
 157             "netconf-node-topology:password": "admin",
 158             "netconf-node-topology:host": "127.0.0.1",
 159             "netconf-node-topology:port": "17823",
 160             "netconf-node-topology:tcp-only": "false",
 161             "netconf-node-topology:pass-through": {}}]}
 162         headers = {'content-type': 'application/json'}
 163         response = requests.request(
 164             "PUT", url, data=json.dumps(data), headers=headers,
 165             auth=('admin', 'admin'))
 166         self.assertEqual(response.status_code, requests.codes.created)
 167         time.sleep(20)
 168
 169     def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
 170         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
 171             format(self.restconf_baseurl)
 172         data = {
 173             "networkutils:input": {
 174                 "networkutils:links-input": {
 175                     "networkutils:xpdr-node": "XPDRA01",
 176                     "networkutils:xpdr-num": "1",
 177                     "networkutils:network-num": "1",
 178                     "networkutils:rdm-node": "ROADMA01",
 179                     "networkutils:srg-num": "1",
 180                     "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 181                 }
 182             }
 183         }
 184         headers = {'content-type': 'application/json'}
 185         response = requests.request(
 186             "POST", url, data=json.dumps(data),
 187             headers=headers, auth=('admin', 'admin'))
 188         self.assertEqual(response.status_code, requests.codes.ok)
 189         res = response.json()
 190         self.assertIn('Xponder Roadm Link created successfully',
 191                       res["output"]["result"])
 192         time.sleep(2)
 193
 194     def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
 195         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
 196             format(self.restconf_baseurl)
 197         data = {
 198             "networkutils:input": {
 199                 "networkutils:links-input": {
 200                     "networkutils:xpdr-node": "XPDRA01",
 201                     "networkutils:xpdr-num": "1",
 202                     "networkutils:network-num": "1",
 203                     "networkutils:rdm-node": "ROADMA01",
 204                     "networkutils:srg-num": "1",
 205                     "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 206                 }
 207             }
 208         }
 209         headers = {'content-type': 'application/json'}
 210         response = requests.request(
 211             "POST", url, data=json.dumps(data),
 212             headers=headers, auth=('admin', 'admin'))
 213         self.assertEqual(response.status_code, requests.codes.ok)
 214         res = response.json()
 215         self.assertIn('Roadm Xponder links created successfully',
 216                       res["output"]["result"])
 217         time.sleep(2)
 218
 219     def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
 220         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
 221             format(self.restconf_baseurl)
 222         data = {
 223             "networkutils:input": {
 224                 "networkutils:links-input": {
 225                     "networkutils:xpdr-node": "XPDRC01",
 226                     "networkutils:xpdr-num": "1",
 227                     "networkutils:network-num": "1",
 228                     "networkutils:rdm-node": "ROADMC01",
 229                     "networkutils:srg-num": "1",
 230                     "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 231                 }
 232             }
 233         }
 234         headers = {'content-type': 'application/json'}
 235         response = requests.request(
 236             "POST", url, data=json.dumps(data),
 237             headers=headers, auth=('admin', 'admin'))
 238         self.assertEqual(response.status_code, requests.codes.ok)
 239         res = response.json()
 240         self.assertIn('Xponder Roadm Link created successfully',
 241                       res["output"]["result"])
 242         time.sleep(2)
 243
 244     def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
 245         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
 246             format(self.restconf_baseurl)
 247         data = {
 248             "networkutils:input": {
 249                 "networkutils:links-input": {
 250                     "networkutils:xpdr-node": "XPDRC01",
 251                     "networkutils:xpdr-num": "1",
 252                     "networkutils:network-num": "1",
 253                     "networkutils:rdm-node": "ROADMC01",
 254                     "networkutils:srg-num": "1",
 255                     "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 256                 }
 257             }
 258         }
 259         headers = {'content-type': 'application/json'}
 260         response = requests.request(
 261             "POST", url, data=json.dumps(data),
 262             headers=headers, auth=('admin', 'admin'))
 263         self.assertEqual(response.status_code, requests.codes.ok)
 264         res = response.json()
 265         self.assertIn('Roadm Xponder links created successfully',
 266                       res["output"]["result"])
 267         time.sleep(2)
 268
 269     def test_09_add_omsAttributes_ROADMA_ROADMC(self):
 270         # Config ROADMA-ROADMC oms-attributes
 271         url = (
 272             "{}/config/ietf-network:"
 273             "networks/network/openroadm-topology/ietf-network-topology:"
 274             "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/"
 275             "org-openroadm-network-topology:"
 276             "OMS-attributes/span"
 277             .format(self.restconf_baseurl))
 278         data = {"span": {
 279             "clfi": "fiber1",
 280             "auto-spanloss": "true",
 281             "spanloss-base": 11.4,
 282             "spanloss-current": 12,
 283             "engineered-spanloss": 12.2,
 284             "link-concatenation": [{
 285                 "SRLG-Id": 0,
 286                 "fiber-type": "smf",
 287                 "SRLG-length": 100000,
 288                 "pmd": 0.5}]}}
 289         headers = {'content-type': 'application/json'}
 290         response = requests.request(
 291             "PUT", url, data=json.dumps(data), headers=headers,
 292             auth=('admin', 'admin'))
 293         self.assertEqual(response.status_code, requests.codes.created)
 294
 295     def test_10_add_omsAttributes_ROADMC_ROADMA(self):
 296         # Config ROADMC-ROADMA oms-attributes
 297         url = (
 298             "{}/config/ietf-network:"
 299             "networks/network/openroadm-topology/ietf-network-topology:"
 300             "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/"
 301             "org-openroadm-network-topology:"
 302             "OMS-attributes/span"
 303             .format(self.restconf_baseurl))
 304         data = {"span": {
 305             "clfi": "fiber1",
 306             "auto-spanloss": "true",
 307             "spanloss-base": 11.4,
 308             "spanloss-current": 12,
 309             "engineered-spanloss": 12.2,
 310             "link-concatenation": [{
 311                 "SRLG-Id": 0,
 312                 "fiber-type": "smf",
 313                 "SRLG-length": 100000,
 314                 "pmd": 0.5}]}}
 315         headers = {'content-type': 'application/json'}
 316         response = requests.request(
 317             "PUT", url, data=json.dumps(data), headers=headers,
 318             auth=('admin', 'admin'))
 319         self.assertEqual(response.status_code, requests.codes.created)
 320
 321     # test service-create for Eth service from xpdr to xpdr
 322     def test_11_create_eth_service1(self):
 323         url = ("{}/operations/org-openroadm-service:service-create"
 324                .format(self.restconf_baseurl))
 325         data = {
 326             "input": {
 327                 "sdnc-request-header": {
 328                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 329                     "rpc-action": "service-create",
 330                     "request-system-id": "appname",
 331                     "notification-url":
 332                         "http://localhost:8585/NotificationServer/notify"
 333                 },
 334                 "service-name": "service1",
 335                 "common-id": "ASATT1234567",
 336                 "connection-type": "service",
 337                 "service-a-end": {
 338                     "service-rate": "100",
 339                     "node-id": "XPDRA01",
 340                     "service-format": "Ethernet",
 341                     "clli": "SNJSCAMCJP8",
 342                     "tx-direction": {
 343                         "port": {
 344                             "port-device-name":
 345                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 346                             "port-type": "router",
 347                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 348                             "port-rack": "000000.00",
 349                             "port-shelf": "00"
 350                         },
 351                         "lgx": {
 352                             "lgx-device-name":
 353                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 354                             "lgx-port-name": "LGX Back.3",
 355                             "lgx-port-rack": "000000.00",
 356                             "lgx-port-shelf": "00"
 357                         }
 358                     },
 359                     "rx-direction": {
 360                         "port": {
 361                             "port-device-name":
 362                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 363                             "port-type": "router",
 364                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 365                             "port-rack": "000000.00",
 366                             "port-shelf": "00"
 367                         },
 368                         "lgx": {
 369                             "lgx-device-name":
 370                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 371                             "lgx-port-name": "LGX Back.4",
 372                             "lgx-port-rack": "000000.00",
 373                             "lgx-port-shelf": "00"
 374                         }
 375                     },
 376                     "optic-type": "gray"
 377                 },
 378                 "service-z-end": {
 379                     "service-rate": "100",
 380                     "node-id": "XPDRC01",
 381                     "service-format": "Ethernet",
 382                     "clli": "SNJSCAMCJT4",
 383                     "tx-direction": {
 384                         "port": {
 385                             "port-device-name":
 386                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 387                             "port-type": "router",
 388                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 389                             "port-rack": "000000.00",
 390                             "port-shelf": "00"
 391                         },
 392                         "lgx": {
 393                             "lgx-device-name":
 394                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 395                             "lgx-port-name": "LGX Back.29",
 396                             "lgx-port-rack": "000000.00",
 397                             "lgx-port-shelf": "00"
 398                         }
 399                     },
 400                     "rx-direction": {
 401                         "port": {
 402                             "port-device-name":
 403                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 404                             "port-type": "router",
 405                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 406                             "port-rack": "000000.00",
 407                             "port-shelf": "00"
 408                         },
 409                         "lgx": {
 410                             "lgx-device-name":
 411                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 412                             "lgx-port-name": "LGX Back.30",
 413                             "lgx-port-rack": "000000.00",
 414                             "lgx-port-shelf": "00"
 415                         }
 416                     },
 417                     "optic-type": "gray"
 418                 },
 419                 "due-date": "2016-11-28T00:00:01Z",
 420                 "operator-contact": "pw1234"
 421             }
 422         }
 423         headers = {'content-type': 'application/json',
 424                    "Accept": "application/json"}
 425         response = requests.request(
 426             "POST", url, data=json.dumps(data), headers=headers,
 427             auth=('admin', 'admin'))
 428         self.assertEqual(response.status_code, requests.codes.ok)
 429         res = response.json()
 430         self.assertIn('PCE calculation in progress',
 431                       res['output']['configuration-response-common'][
 432                           'response-message'])
 433         time.sleep(self.WAITING)
 434
 435     def test_12_get_eth_service1(self):
 436         url = ("{}/operational/org-openroadm-service:service-list/services/"
 437                "service1".format(self.restconf_baseurl))
 438         headers = {'content-type': 'application/json',
 439                    "Accept": "application/json"}
 440         response = requests.request(
 441             "GET", url, headers=headers, auth=('admin', 'admin'))
 442         self.assertEqual(response.status_code, requests.codes.ok)
 443         res = response.json()
 444         self.assertEqual(
 445             res['services'][0]['administrative-state'],
 446             'inService')
 447         self.assertEqual(
 448             res['services'][0]['service-name'], 'service1')
 449         self.assertEqual(
 450             res['services'][0]['connection-type'], 'service')
 451         self.assertEqual(
 452             res['services'][0]['lifecycle-state'], 'planned')
 453         time.sleep(2)
 454
 455     def test_13_check_xc1_ROADMA(self):
 456         url = (
 457             "{}/config/network-topology:"
 458             "network-topology/topology/topology-netconf/"
 459             "node/ROADMA01/yang-ext:"
 460             "mount/org-openroadm-device:org-openroadm-device/"
 461             "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
 462             .format(self.restconf_baseurl))
 463         headers = {'content-type': 'application/json'}
 464         response = requests.request(
 465             "GET", url, headers=headers, auth=('admin', 'admin'))
 466         self.assertEqual(response.status_code, requests.codes.ok)
 467         res = response.json()
 468         self.assertDictContainsSubset(
 469             {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
 470              'wavelength-number': 1,
 471              'opticalControlMode': 'gainLoss',
 472              'target-output-power': -3.0},
 473             res['roadm-connections'][0])
 474         self.assertDictEqual(
 475             {'src-if': 'SRG1-PP1-TXRX-1'},
 476             res['roadm-connections'][0]['source'])
 477         self.assertDictEqual(
 478             {'dst-if': 'DEG1-TTP-TXRX-1'},
 479             res['roadm-connections'][0]['destination'])
 480         time.sleep(5)
 481
 482     def test_14_check_xc1_ROADMC(self):
 483         url = (
 484             "{}/config/network-topology:"
 485             "network-topology/topology/topology-netconf/"
 486             "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
 487             "org-openroadm-device/"
 488             "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
 489             .format(self.restconf_baseurl))
 490         headers = {'content-type': 'application/json'}
 491         response = requests.request(
 492             "GET", url, headers=headers, auth=('admin', 'admin'))
 493         self.assertEqual(response.status_code, requests.codes.ok)
 494         res = response.json()
 495         self.assertDictContainsSubset(
 496             {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
 497              'wavelength-number': 1,
 498              'opticalControlMode': 'gainLoss',
 499              'target-output-power': 2.0},
 500             res['roadm-connections'][0])
 501         self.assertDictEqual(
 502             {'src-if': 'SRG1-PP1-TXRX-1'},
 503             res['roadm-connections'][0]['source'])
 504         self.assertDictEqual(
 505             {'dst-if': 'DEG2-TTP-TXRX-1'},
 506             res['roadm-connections'][0]['destination'])
 507         time.sleep(5)
 508
 509     def test_15_check_topo_XPDRA(self):
 510         url1 = (
 511             "{}/config/ietf-network:"
 512             "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 513             .format(self.restconf_baseurl))
 514         response = requests.request(
 515             "GET", url1, auth=('admin', 'admin'))
 516         self.assertEqual(response.status_code, requests.codes.ok)
 517         res = response.json()
 518         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 519         for ele in liste_tp:
 520             if ele['tp-id'] == 'XPDR1-NETWORK1':
 521                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 522                                  ele[
 523                                      'org-openroadm-network-topology:'
 524                                      'xpdr-network-attributes'][
 525                                      'wavelength'])
 526             if ele['tp-id'] == 'XPDR1-CLIENT1' or \
 527                ele['tp-id'] == 'XPDR1-CLIENT3':
 528                 self.assertNotIn(
 529                     'org-openroadm-network-topology:xpdr-client-attributes',
 530                     dict.keys(ele))
 531             if ele['tp-id'] == 'XPDR1-NETWORK2':
 532                 self.assertNotIn(
 533                     'org-openroadm-network-topology:xpdr-network-attributes',
 534                     dict.keys(ele))
 535         time.sleep(3)
 536
 537     def test_16_check_topo_ROADMA_SRG1(self):
 538         url1 = (
 539             "{}/config/ietf-network:"
 540             "networks/network/openroadm-topology/node/ROADMA01-SRG1"
 541             .format(self.restconf_baseurl))
 542         response = requests.request(
 543             "GET", url1, auth=('admin', 'admin'))
 544         self.assertEqual(response.status_code, requests.codes.ok)
 545         res = response.json()
 546         self.assertNotIn({u'index': 1},
 547                          res['node'][0][
 548                              u'org-openroadm-network-topology:srg-attributes'][
 549                              'available-wavelengths'])
 550         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 551         for ele in liste_tp:
 552             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 553                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 554                               ele['org-openroadm-network-topology:'
 555                                   'pp-attributes']['used-wavelength']
 556                               )
 557             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 558                 self.assertNotIn('used-wavelength', dict.keys(ele))
 559         time.sleep(3)
 560
 561     def test_17_check_topo_ROADMA_DEG1(self):
 562         url1 = (
 563             "{}/config/ietf-network:"
 564             "networks/network/openroadm-topology/node/ROADMA01-DEG1"
 565             .format(self.restconf_baseurl))
 566         response = requests.request(
 567             "GET", url1, auth=('admin', 'admin'))
 568         self.assertEqual(response.status_code, requests.codes.ok)
 569         res = response.json()
 570         self.assertNotIn({u'index': 1},
 571                          res['node'][0][
 572                              u'org-openroadm-network-topology:'
 573                              u'degree-attributes'][
 574                              'available-wavelengths'])
 575         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 576         for ele in liste_tp:
 577             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 578                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 579                               ele['org-openroadm-network-topology:'
 580                                   'ctp-attributes'][
 581                                   'used-wavelengths'])
 582             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 583                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 584                               ele['org-openroadm-network-topology:'
 585                                   'tx-ttp-attributes'][
 586                                   'used-wavelengths'])
 587         time.sleep(3)
 588
 589     def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
 590         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
 591             format(self.restconf_baseurl)
 592         data = {
 593             "networkutils:input": {
 594                 "networkutils:links-input": {
 595                     "networkutils:xpdr-node": "XPDRA01",
 596                     "networkutils:xpdr-num": "1",
 597                     "networkutils:network-num": "2",
 598                     "networkutils:rdm-node": "ROADMA01",
 599                     "networkutils:srg-num": "1",
 600                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 601                 }
 602             }
 603         }
 604         headers = {'content-type': 'application/json'}
 605         response = requests.request(
 606             "POST", url, data=json.dumps(data),
 607             headers=headers, auth=('admin', 'admin'))
 608         self.assertEqual(response.status_code, requests.codes.ok)
 609         res = response.json()
 610         self.assertIn('Xponder Roadm Link created successfully',
 611                       res["output"]["result"])
 612         time.sleep(2)
 613
 614     def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
 615         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
 616             format(self.restconf_baseurl)
 617         data = {
 618             "networkutils:input": {
 619                 "networkutils:links-input": {
 620                     "networkutils:xpdr-node": "XPDRA01",
 621                     "networkutils:xpdr-num": "1",
 622                     "networkutils:network-num": "2",
 623                     "networkutils:rdm-node": "ROADMA01",
 624                     "networkutils:srg-num": "1",
 625                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 626                 }
 627             }
 628         }
 629         headers = {'content-type': 'application/json'}
 630         response = requests.request(
 631             "POST", url, data=json.dumps(data),
 632             headers=headers, auth=('admin', 'admin'))
 633         self.assertEqual(response.status_code, requests.codes.ok)
 634         res = response.json()
 635         self.assertIn('Roadm Xponder links created successfully',
 636                       res["output"]["result"])
 637         time.sleep(2)
 638
 639     def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
 640         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
 641             format(self.restconf_baseurl)
 642         data = {
 643             "networkutils:input": {
 644                 "networkutils:links-input": {
 645                     "networkutils:xpdr-node": "XPDRC01",
 646                     "networkutils:xpdr-num": "1",
 647                     "networkutils:network-num": "2",
 648                     "networkutils:rdm-node": "ROADMC01",
 649                     "networkutils:srg-num": "1",
 650                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 651                 }
 652             }
 653         }
 654         headers = {'content-type': 'application/json'}
 655         response = requests.request(
 656             "POST", url, data=json.dumps(data),
 657             headers=headers, auth=('admin', 'admin'))
 658         self.assertEqual(response.status_code, requests.codes.ok)
 659         res = response.json()
 660         self.assertIn('Xponder Roadm Link created successfully',
 661                       res["output"]["result"])
 662         time.sleep(2)
 663
 664     def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
 665         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
 666             format(self.restconf_baseurl)
 667         data = {
 668             "networkutils:input": {
 669                 "networkutils:links-input": {
 670                     "networkutils:xpdr-node": "XPDRC01",
 671                     "networkutils:xpdr-num": "1",
 672                     "networkutils:network-num": "2",
 673                     "networkutils:rdm-node": "ROADMC01",
 674                     "networkutils:srg-num": "1",
 675                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 676                 }
 677             }
 678         }
 679         headers = {'content-type': 'application/json'}
 680         response = requests.request(
 681             "POST", url, data=json.dumps(data),
 682             headers=headers, auth=('admin', 'admin'))
 683         self.assertEqual(response.status_code, requests.codes.ok)
 684         res = response.json()
 685         self.assertIn('Roadm Xponder links created successfully',
 686                       res["output"]["result"])
 687         time.sleep(2)
 688
 689     def test_22_create_eth_service2(self):
 690         url = ("{}/operations/org-openroadm-service:service-create"
 691                .format(self.restconf_baseurl))
 692         data = {
 693             "input": {
 694                 "sdnc-request-header": {
 695                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 696                     "rpc-action": "service-create",
 697                     "request-system-id": "appname",
 698                     "notification-url":
 699                         "http://localhost:8585/NotificationServer/notify"
 700                 },
 701                 "service-name": "service2",
 702                 "common-id": "ASATT1234567",
 703                 "connection-type": "service",
 704                 "service-a-end": {
 705                     "service-rate": "100",
 706                     "node-id": "XPDRA01",
 707                     "service-format": "Ethernet",
 708                     "clli": "SNJSCAMCJP8",
 709                     "tx-direction": {
 710                         "port": {
 711                             "port-device-name":
 712                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 713                             "port-type": "router",
 714                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 715                             "port-rack": "000000.00",
 716                             "port-shelf": "00"
 717                         },
 718                         "lgx": {
 719                             "lgx-device-name":
 720                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 721                             "lgx-port-name": "LGX Back.3",
 722                             "lgx-port-rack": "000000.00",
 723                             "lgx-port-shelf": "00"
 724                         }
 725                     },
 726                     "rx-direction": {
 727                         "port": {
 728                             "port-device-name":
 729                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 730                             "port-type": "router",
 731                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 732                             "port-rack": "000000.00",
 733                             "port-shelf": "00"
 734                         },
 735                         "lgx": {
 736                             "lgx-device-name":
 737                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 738                             "lgx-port-name": "LGX Back.4",
 739                             "lgx-port-rack": "000000.00",
 740                             "lgx-port-shelf": "00"
 741                         }
 742                     },
 743                     "optic-type": "gray"
 744                 },
 745                 "service-z-end": {
 746                     "service-rate": "100",
 747                     "node-id": "XPDRC01",
 748                     "service-format": "Ethernet",
 749                     "clli": "SNJSCAMCJT4",
 750                     "tx-direction": {
 751                         "port": {
 752                             "port-device-name":
 753                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 754                             "port-type": "router",
 755                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 756                             "port-rack": "000000.00",
 757                             "port-shelf": "00"
 758                         },
 759                         "lgx": {
 760                             "lgx-device-name":
 761                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 762                             "lgx-port-name": "LGX Back.29",
 763                             "lgx-port-rack": "000000.00",
 764                             "lgx-port-shelf": "00"
 765                         }
 766                     },
 767                     "rx-direction": {
 768                         "port": {
 769                             "port-device-name":
 770                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
 771                             "port-type": "router",
 772                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 773                             "port-rack": "000000.00",
 774                             "port-shelf": "00"
 775                         },
 776                         "lgx": {
 777                             "lgx-device-name":
 778                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
 779                             "lgx-port-name": "LGX Back.30",
 780                             "lgx-port-rack": "000000.00",
 781                             "lgx-port-shelf": "00"
 782                         }
 783                     },
 784                     "optic-type": "gray"
 785                 },
 786                 "due-date": "2016-11-28T00:00:01Z",
 787                 "operator-contact": "pw1234"
 788             }
 789         }
 790         headers = {'content-type': 'application/json',
 791                    "Accept": "application/json"}
 792         response = requests.request(
 793             "POST", url, data=json.dumps(data), headers=headers,
 794             auth=('admin', 'admin'))
 795         self.assertEqual(response.status_code, requests.codes.ok)
 796         res = response.json()
 797         self.assertIn('PCE calculation in progress',
 798                       res['output']['configuration-response-common'][
 799                           'response-message'])
 800         time.sleep(self.WAITING)
 801
 802     def test_23_get_eth_service2(self):
 803         url = ("{}/operational/org-openroadm-service:"
 804                "service-list/services/service2"
 805                .format(self.restconf_baseurl))
 806         headers = {'content-type': 'application/json',
 807                    "Accept": "application/json"}
 808         response = requests.request(
 809             "GET", url, headers=headers, auth=('admin', 'admin'))
 810         self.assertEqual(response.status_code, requests.codes.ok)
 811         res = response.json()
 812         self.assertEqual(
 813             res['services'][0]['administrative-state'],
 814             'inService')
 815         self.assertEqual(
 816             res['services'][0]['service-name'], 'service2')
 817         self.assertEqual(
 818             res['services'][0]['connection-type'], 'service')
 819         self.assertEqual(
 820             res['services'][0]['lifecycle-state'], 'planned')
 821         time.sleep(1)
 822
 823     def test_24_check_xc2_ROADMA(self):
 824         url = (
 825             "{}/config/network-topology:"
 826             "network-topology/topology/topology-netconf/"
 827             "node/ROADMA01/yang-ext:"
 828             "mount/org-openroadm-device:org-openroadm-device/"
 829             "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
 830             .format(self.restconf_baseurl))
 831         headers = {'content-type': 'application/json'}
 832         response = requests.request(
 833             "GET", url, headers=headers, auth=('admin', 'admin'))
 834         self.assertEqual(response.status_code, requests.codes.ok)
 835         res = response.json()
 836         self.assertDictContainsSubset(
 837             {'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
 838              'wavelength-number': 2,
 839              'opticalControlMode': 'power'},
 840             res['roadm-connections'][0])
 841         self.assertDictEqual(
 842             {'src-if': 'DEG1-TTP-TXRX-2'},
 843             res['roadm-connections'][0]['source'])
 844         self.assertDictEqual(
 845             {'dst-if': 'SRG1-PP2-TXRX-2'},
 846             res['roadm-connections'][0]['destination'])
 847
 848     def test_25_check_topo_XPDRA(self):
 849         url1 = (
 850             "{}/config/ietf-network:"
 851             "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 852             .format(self.restconf_baseurl))
 853         response = requests.request(
 854             "GET", url1, auth=('admin', 'admin'))
 855         self.assertEqual(response.status_code, requests.codes.ok)
 856         res = response.json()
 857         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 858         for ele in liste_tp:
 859             if ele['tp-id'] == 'XPDR1-NETWORK1':
 860                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 861                                  ele['org-openroadm-network-topology:'
 862                                      'xpdr-network-attributes'][
 863                                      'wavelength'])
 864             if ele['tp-id'] == 'XPDR1-NETWORK2':
 865                 self.assertEqual({u'frequency': 196.05, u'width': 40},
 866                                  ele['org-openroadm-network-topology:'
 867                                      'xpdr-network-attributes'][
 868                                      'wavelength'])
 869             if ele['tp-id'] == 'XPDR1-CLIENT1' or \
 870                ele['tp-id'] == 'XPDR1-CLIENT3':
 871                 self.assertNotIn(
 872                     'org-openroadm-network-topology:xpdr-client-attributes',
 873                     dict.keys(ele))
 874         time.sleep(10)
 875
 876     def test_26_check_topo_ROADMA_SRG1(self):
 877         url1 = (
 878             "{}/config/ietf-network:"
 879             "networks/network/openroadm-topology/node/ROADMA01-SRG1"
 880             .format(self.restconf_baseurl))
 881         response = requests.request(
 882             "GET", url1, auth=('admin', 'admin'))
 883         self.assertEqual(response.status_code, requests.codes.ok)
 884         res = response.json()
 885         self.assertNotIn({u'index': 1}, res['node'][0][
 886             u'org-openroadm-network-topology:srg-attributes'][
 887             'available-wavelengths'])
 888         self.assertNotIn({u'index': 2}, res['node'][0][
 889             u'org-openroadm-network-topology:srg-attributes'][
 890             'available-wavelengths'])
 891         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 892         for ele in liste_tp:
 893             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 894                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 895                               ele['org-openroadm-network-topology:'
 896                                   'pp-attributes']['used-wavelength'])
 897                 self.assertNotIn({u'index': 2, u'frequency': 196.05,
 898                                   u'width': 40},
 899                                  ele['org-openroadm-network-topology:'
 900                                      'pp-attributes']['used-wavelength'])
 901             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 902                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 903                               ele['org-openroadm-network-topology:'
 904                                   'pp-attributes']['used-wavelength'])
 905                 self.assertNotIn({u'index': 1, u'frequency': 196.1,
 906                                   u'width': 40},
 907                                  ele['org-openroadm-network-topology:'
 908                                      'pp-attributes']['used-wavelength'])
 909             if ele['tp-id'] == 'SRG1-PP3-TXRX':
 910                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
 911                                  dict.keys(ele))
 912         time.sleep(10)
 913
 914     def test_27_check_topo_ROADMA_DEG1(self):
 915         url1 = (
 916             "{}/config/ietf-network:"
 917             "networks/network/openroadm-topology/node/ROADMA01-DEG1"
 918             .format(self.restconf_baseurl))
 919         response = requests.request(
 920             "GET", url1, auth=('admin', 'admin'))
 921         self.assertEqual(response.status_code, requests.codes.ok)
 922         res = response.json()
 923         self.assertNotIn({u'index': 1}, res['node'][0][
 924             u'org-openroadm-network-topology:degree-attributes'][
 925             'available-wavelengths'])
 926         self.assertNotIn({u'index': 2}, res['node'][0][
 927             u'org-openroadm-network-topology:degree-attributes'][
 928             'available-wavelengths'])
 929         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 930         for ele in liste_tp:
 931             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 932                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 933                               ele['org-openroadm-network-topology:'
 934                                   'ctp-attributes']['used-wavelengths'])
 935                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 936                               ele['org-openroadm-network-topology:'
 937                                   'ctp-attributes']['used-wavelengths'])
 938             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 939                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 940                               ele['org-openroadm-network-topology:'
 941                                   'tx-ttp-attributes']['used-wavelengths'])
 942                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 943                               ele['org-openroadm-network-topology:'
 944                                   'tx-ttp-attributes']['used-wavelengths'])
 945         time.sleep(10)
 946
 947     #     creation service test on a non-available resource
 948     def test_28_create_eth_service3(self):
 949         url = ("{}/operations/org-openroadm-service:service-create"
 950                .format(self.restconf_baseurl))
 951         data = {
 952             "input": {
 953                 "sdnc-request-header": {
 954                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 955                     "rpc-action": "service-create",
 956                     "request-system-id": "appname",
 957                     "notification-url":
 958                         "http://localhost:8585/NotificationServer/notify"
 959                 },
 960                 "service-name": "service3",
 961                 "common-id": "ASATT1234567",
 962                 "connection-type": "service",
 963                 "service-a-end": {
 964                     "service-rate": "100",
 965                     "node-id": "XPDRA01",
 966                     "service-format": "Ethernet",
 967                     "clli": "SNJSCAMCJP8",
 968                     "tx-direction": {
 969                         "port": {
 970                             "port-device-name":
 971                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 972                             "port-type": "router",
 973                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 974                             "port-rack": "000000.00",
 975                             "port-shelf": "00"
 976                         },
 977                         "lgx": {
 978                             "lgx-device-name":
 979                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 980                             "lgx-port-name": "LGX Back.3",
 981                             "lgx-port-rack": "000000.00",
 982                             "lgx-port-shelf": "00"
 983                         }
 984                     },
 985                     "rx-direction": {
 986                         "port": {
 987                             "port-device-name":
 988                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
 989                             "port-type": "router",
 990                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 991                             "port-rack": "000000.00",
 992                             "port-shelf": "00"
 993                         },
 994                         "lgx": {
 995                             "lgx-device-name":
 996                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
 997                             "lgx-port-name": "LGX Back.4",
 998                             "lgx-port-rack": "000000.00",
 999                             "lgx-port-shelf": "00"
1000                         }
1001                     },
1002                     "optic-type": "gray"
1003                 },
1004                 "service-z-end": {
1005                     "service-rate": "100",
1006                     "node-id": "XPDRC01",
1007                     "service-format": "Ethernet",
1008                     "clli": "SNJSCAMCJT4",
1009                     "tx-direction": {
1010                         "port": {
1011                             "port-device-name":
1012                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1013                             "port-type": "router",
1014                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1015                             "port-rack": "000000.00",
1016                             "port-shelf": "00"
1017                         },
1018                         "lgx": {
1019                             "lgx-device-name":
1020                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1021                             "lgx-port-name": "LGX Back.29",
1022                             "lgx-port-rack": "000000.00",
1023                             "lgx-port-shelf": "00"
1024                         }
1025                     },
1026                     "rx-direction": {
1027                         "port": {
1028                             "port-device-name":
1029                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1030                             "port-type": "router",
1031                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1032                             "port-rack": "000000.00",
1033                             "port-shelf": "00"
1034                         },
1035                         "lgx": {
1036                             "lgx-device-name":
1037                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1038                             "lgx-port-name": "LGX Back.30",
1039                             "lgx-port-rack": "000000.00",
1040                             "lgx-port-shelf": "00"
1041                         }
1042                     },
1043                     "optic-type": "gray"
1044                 },
1045                 "due-date": "2016-11-28T00:00:01Z",
1046                 "operator-contact": "pw1234"
1047             }
1048         }
1049         headers = {'content-type': 'application/json',
1050                    "Accept": "application/json"}
1051         response = requests.request(
1052             "POST", url, data=json.dumps(data), headers=headers,
1053             auth=('admin', 'admin'))
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'][
1058                           'response-message'])
1059         self.assertIn('200', res['output']['configuration-response-common'][
1060             'response-code'])
1061         time.sleep(self.WAITING)
1062
1063     # add a test that check the openroadm-service-list still only
1064     # contains 2 elements
1065
1066     def test_29_delete_eth_service3(self):
1067         url = ("{}/operations/org-openroadm-service:service-delete"
1068                .format(self.restconf_baseurl))
1069         data = {"input": {
1070             "sdnc-request-header": {
1071                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1072                 "rpc-action": "service-delete",
1073                 "request-system-id": "appname",
1074                 "notification-url":
1075                     "http://localhost:8585/NotificationServer/notify"
1076             },
1077             "service-delete-req-info": {
1078                 "service-name": "service3",
1079                 "tail-retention": "no"
1080             }
1081         }
1082         }
1083         headers = {'content-type': 'application/json'}
1084         response = requests.request(
1085             "POST", url, data=json.dumps(data), headers=headers,
1086             auth=('admin', 'admin'))
1087         self.assertEqual(response.status_code, requests.codes.ok)
1088         res = response.json()
1089         self.assertIn('Service \'service3\' does not exist in datastore',
1090                       res['output']['configuration-response-common'][
1091                           'response-message'])
1092         self.assertIn('500', res['output']['configuration-response-common'][
1093             'response-code'])
1094         time.sleep(20)
1095
1096     def test_30_delete_eth_service1(self):
1097         url = ("{}/operations/org-openroadm-service:service-delete"
1098                .format(self.restconf_baseurl))
1099         data = {"input": {
1100             "sdnc-request-header": {
1101                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1102                 "rpc-action": "service-delete",
1103                 "request-system-id": "appname",
1104                 "notification-url":
1105                     "http://localhost:8585/NotificationServer/notify"
1106             },
1107             "service-delete-req-info": {
1108                 "service-name": "service1",
1109                 "tail-retention": "no"
1110             }
1111         }
1112         }
1113         headers = {'content-type': 'application/json'}
1114         response = requests.request(
1115             "POST", url, data=json.dumps(data), headers=headers,
1116             auth=('admin', 'admin'))
1117         self.assertEqual(response.status_code, requests.codes.ok)
1118         res = response.json()
1119         self.assertIn('Renderer service delete in progress',
1120                       res['output']['configuration-response-common'][
1121                           'response-message'])
1122         time.sleep(20)
1123
1124     def test_31_delete_eth_service2(self):
1125         url = ("{}/operations/org-openroadm-service:service-delete"
1126                .format(self.restconf_baseurl))
1127         data = {"input": {
1128             "sdnc-request-header": {
1129                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1130                 "rpc-action": "service-delete",
1131                 "request-system-id": "appname",
1132                 "notification-url":
1133                     "http://localhost:8585/NotificationServer/notify"
1134             },
1135             "service-delete-req-info": {
1136                 "service-name": "service2",
1137                 "tail-retention": "no"
1138             }
1139         }
1140         }
1141         headers = {'content-type': 'application/json'}
1142         response = requests.request(
1143             "POST", url, data=json.dumps(data), headers=headers,
1144             auth=('admin', 'admin'))
1145         self.assertEqual(response.status_code, requests.codes.ok)
1146         res = response.json()
1147         self.assertIn('Renderer service delete in progress',
1148                       res['output']['configuration-response-common'][
1149                           'response-message'])
1150         time.sleep(20)
1151
1152     def test_32_check_no_xc_ROADMA(self):
1153         url = (
1154             "{}/config/network-topology:"
1155             "network-topology/topology/topology-netconf/"
1156             "node/ROADMA01/yang-ext:"
1157             "mount/org-openroadm-device:org-openroadm-device/"
1158             .format(self.restconf_baseurl))
1159         response = requests.request(
1160             "GET", url, auth=('admin', 'admin'))
1161         res = response.json()
1162         self.assertEqual(response.status_code, requests.codes.ok)
1163         self.assertNotIn('roadm-connections',
1164                          dict.keys(res['org-openroadm-device']))
1165         time.sleep(2)
1166
1167     def test_33_check_topo_XPDRA(self):
1168         url1 = (
1169             "{}/config/ietf-network:"
1170             "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1171             .format(self.restconf_baseurl))
1172         response = requests.request(
1173             "GET", url1, auth=('admin', 'admin'))
1174         self.assertEqual(response.status_code, requests.codes.ok)
1175         res = response.json()
1176         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1177         for ele in liste_tp:
1178             if ((ele[u'org-openroadm-common-network:tp-type'] ==
1179                  'XPONDER-CLIENT')
1180                 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele[
1181                     'tp-id'] == 'XPDR1-CLIENT3')):
1182                 self.assertNotIn(
1183                     'org-openroadm-network-topology:xpdr-client-attributes',
1184                     dict.keys(ele))
1185             elif (ele[u'org-openroadm-common-network:tp-type'] ==
1186                   'XPONDER-NETWORK'):
1187                 self.assertIn(u'tail-equipment-id', dict.keys(
1188                     ele[u'org-openroadm-network-topology:'
1189                         u'xpdr-network-attributes']))
1190                 self.assertNotIn('wavelength', dict.keys(
1191                     ele[u'org-openroadm-network-topology:'
1192                         u'xpdr-network-attributes']))
1193         time.sleep(10)
1194
1195     def test_34_check_topo_ROADMA_SRG1(self):
1196         url1 = (
1197             "{}/config/ietf-network:"
1198             "networks/network/openroadm-topology/node/ROADMA01-SRG1"
1199             .format(self.restconf_baseurl))
1200         response = requests.request(
1201             "GET", url1, auth=('admin', 'admin'))
1202         self.assertEqual(response.status_code, requests.codes.ok)
1203         res = response.json()
1204         self.assertIn({u'index': 1}, res['node'][0][
1205             u'org-openroadm-network-topology:srg-attributes'][
1206             'available-wavelengths'])
1207         self.assertIn({u'index': 2}, res['node'][0][
1208             u'org-openroadm-network-topology:srg-attributes'][
1209             'available-wavelengths'])
1210         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1211         for ele in liste_tp:
1212             if ele['tp-id'] == 'SRG1-PP1-TXRX' or \
1213                ele['tp-id'] == 'SRG1-PP1-TXRX':
1214                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
1215                                  dict.keys(ele))
1216             else:
1217                 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
1218                                  dict.keys(ele))
1219         time.sleep(10)
1220
1221     def test_35_check_topo_ROADMA_DEG1(self):
1222         url1 = (
1223             "{}/config/ietf-network:"
1224             "networks/network/openroadm-topology/node/ROADMA01-DEG1"
1225             .format(self.restconf_baseurl))
1226         response = requests.request(
1227             "GET", url1, auth=('admin', 'admin'))
1228         self.assertEqual(response.status_code, requests.codes.ok)
1229         res = response.json()
1230         self.assertIn({u'index': 1}, res['node'][0][
1231             u'org-openroadm-network-topology:degree-attributes'][
1232             'available-wavelengths'])
1233         self.assertIn({u'index': 2}, res['node'][0][
1234             u'org-openroadm-network-topology:degree-attributes'][
1235             'available-wavelengths'])
1236         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1237         for ele in liste_tp:
1238             if ele['tp-id'] == 'DEG1-CTP-TXRX':
1239                 self.assertNotIn('org-openroadm-network-topology:'
1240                                  'ctp-attributes', dict.keys(ele))
1241             if ele['tp-id'] == 'DEG1-TTP-TXRX':
1242                 self.assertNotIn('org-openroadm-network-topology:'
1243                                  'tx-ttp-attributes', dict.keys(ele))
1244         time.sleep(10)
1245
1246     # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1247     def test_36_create_oc_service1(self):
1248         url = ("{}/operations/org-openroadm-service:service-create"
1249                .format(self.restconf_baseurl))
1250         data = {
1251             "input": {
1252                 "sdnc-request-header": {
1253                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1254                     "rpc-action": "service-create",
1255                     "request-system-id": "appname",
1256                     "notification-url":
1257                         "http://localhost:8585/NotificationServer/notify"
1258                 },
1259                 "service-name": "service1",
1260                 "common-id": "ASATT1234567",
1261                 "connection-type": "roadm-line",
1262                 "service-a-end": {
1263                     "service-rate": "100",
1264                     "node-id": "ROADMA01",
1265                     "service-format": "OC",
1266                     "clli": "SNJSCAMCJP8",
1267                     "tx-direction": {
1268                         "port": {
1269                             "port-device-name":
1270                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1271                             "port-type": "router",
1272                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1273                             "port-rack": "000000.00",
1274                             "port-shelf": "00"
1275                         },
1276                         "lgx": {
1277                             "lgx-device-name":
1278                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1279                             "lgx-port-name": "LGX Back.3",
1280                             "lgx-port-rack": "000000.00",
1281                             "lgx-port-shelf": "00"
1282                         }
1283                     },
1284                     "rx-direction": {
1285                         "port": {
1286                             "port-device-name":
1287                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1288                             "port-type": "router",
1289                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1290                             "port-rack": "000000.00",
1291                             "port-shelf": "00"
1292                         },
1293                         "lgx": {
1294                             "lgx-device-name":
1295                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1296                             "lgx-port-name": "LGX Back.4",
1297                             "lgx-port-rack": "000000.00",
1298                             "lgx-port-shelf": "00"
1299                         }
1300                     },
1301                     "optic-type": "gray"
1302                 },
1303                 "service-z-end": {
1304                     "service-rate": "100",
1305                     "node-id": "ROADMC01",
1306                     "service-format": "OC",
1307                     "clli": "SNJSCAMCJT4",
1308                     "tx-direction": {
1309                         "port": {
1310                             "port-device-name":
1311                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1312                             "port-type": "router",
1313                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1314                             "port-rack": "000000.00",
1315                             "port-shelf": "00"
1316                         },
1317                         "lgx": {
1318                             "lgx-device-name":
1319                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1320                             "lgx-port-name": "LGX Back.29",
1321                             "lgx-port-rack": "000000.00",
1322                             "lgx-port-shelf": "00"
1323                         }
1324                     },
1325                     "rx-direction": {
1326                         "port": {
1327                             "port-device-name":
1328                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1329                             "port-type": "router",
1330                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1331                             "port-rack": "000000.00",
1332                             "port-shelf": "00"
1333                         },
1334                         "lgx": {
1335                             "lgx-device-name":
1336                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1337                             "lgx-port-name": "LGX Back.30",
1338                             "lgx-port-rack": "000000.00",
1339                             "lgx-port-shelf": "00"
1340                         }
1341                     },
1342                     "optic-type": "gray"
1343                 },
1344                 "due-date": "2016-11-28T00:00:01Z",
1345                 "operator-contact": "pw1234"
1346             }
1347         }
1348         headers = {'content-type': 'application/json',
1349                    "Accept": "application/json"}
1350         response = requests.request(
1351             "POST", url, data=json.dumps(data), headers=headers,
1352             auth=('admin', 'admin'))
1353         self.assertEqual(response.status_code, requests.codes.ok)
1354         res = response.json()
1355         self.assertIn('PCE calculation in progress',
1356                       res['output']['configuration-response-common'][
1357                           'response-message'])
1358         time.sleep(self.WAITING)
1359
1360     def test_37_get_oc_service1(self):
1361         url = ("{}/operational/org-openroadm-service:"
1362                "service-list/services/service1"
1363                .format(self.restconf_baseurl))
1364         headers = {'content-type': 'application/json',
1365                    "Accept": "application/json"}
1366         response = requests.request(
1367             "GET", url, headers=headers, auth=('admin', 'admin'))
1368         self.assertEqual(response.status_code, requests.codes.ok)
1369         res = response.json()
1370         self.assertEqual(
1371             res['services'][0]['administrative-state'],
1372             'inService')
1373         self.assertEqual(
1374             res['services'][0]['service-name'], 'service1')
1375         self.assertEqual(
1376             res['services'][0]['connection-type'], 'roadm-line')
1377         self.assertEqual(
1378             res['services'][0]['lifecycle-state'], 'planned')
1379         time.sleep(1)
1380
1381     def test_38_check_xc1_ROADMA(self):
1382         url = (
1383             "{}/config/network-topology:"
1384             "network-topology/topology/topology-netconf/"
1385             "node/ROADMA01/yang-ext:"
1386             "mount/org-openroadm-device:org-openroadm-device/"
1387             "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1388             .format(self.restconf_baseurl))
1389         headers = {'content-type': 'application/json'}
1390         response = requests.request(
1391             "GET", url, headers=headers, auth=('admin', 'admin'))
1392         self.assertEqual(response.status_code, requests.codes.ok)
1393         res = response.json()
1394         self.assertDictContainsSubset(
1395             {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1396              'wavelength-number': 1,
1397              'opticalControlMode': 'gainLoss',
1398              'target-output-power': -3.0},
1399             res['roadm-connections'][0])
1400         self.assertDictEqual(
1401             {'src-if': 'SRG1-PP1-TXRX-1'},
1402             res['roadm-connections'][0]['source'])
1403         self.assertDictEqual(
1404             {'dst-if': 'DEG1-TTP-TXRX-1'},
1405             res['roadm-connections'][0]['destination'])
1406         time.sleep(7)
1407
1408     def test_39_check_xc1_ROADMC(self):
1409         url = (
1410             "{}/config/network-topology:"
1411             "network-topology/topology/topology-netconf/"
1412             "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
1413             "org-openroadm-device/"
1414             "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1415             .format(self.restconf_baseurl))
1416         headers = {'content-type': 'application/json'}
1417         response = requests.request(
1418             "GET", url, headers=headers, auth=('admin', 'admin'))
1419         self.assertEqual(response.status_code, requests.codes.ok)
1420         res = response.json()
1421         self.assertDictContainsSubset(
1422             {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1423              'wavelength-number': 1,
1424              'opticalControlMode': 'gainLoss',
1425              'target-output-power': 2.0},
1426             res['roadm-connections'][0])
1427         self.assertDictEqual(
1428             {'src-if': 'SRG1-PP1-TXRX-1'},
1429             res['roadm-connections'][0]['source'])
1430         self.assertDictEqual(
1431             {'dst-if': 'DEG2-TTP-TXRX-1'},
1432             res['roadm-connections'][0]['destination'])
1433         time.sleep(7)
1434
1435     def test_40_create_oc_service2(self):
1436         url = ("{}/operations/org-openroadm-service:service-create"
1437                .format(self.restconf_baseurl))
1438         data = {
1439             "input": {
1440                 "sdnc-request-header": {
1441                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1442                     "rpc-action": "service-create",
1443                     "request-system-id": "appname",
1444                     "notification-url":
1445                         "http://localhost:8585/NotificationServer/notify"
1446                 },
1447                 "service-name": "service2",
1448                 "common-id": "ASATT1234567",
1449                 "connection-type": "roadm-line",
1450                 "service-a-end": {
1451                     "service-rate": "100",
1452                     "node-id": "ROADMA01",
1453                     "service-format": "OC",
1454                     "clli": "SNJSCAMCJP8",
1455                     "tx-direction": {
1456                         "port": {
1457                             "port-device-name":
1458                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1459                             "port-type": "router",
1460                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1461                             "port-rack": "000000.00",
1462                             "port-shelf": "00"
1463                         },
1464                         "lgx": {
1465                             "lgx-device-name":
1466                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1467                             "lgx-port-name": "LGX Back.3",
1468                             "lgx-port-rack": "000000.00",
1469                             "lgx-port-shelf": "00"
1470                         }
1471                     },
1472                     "rx-direction": {
1473                         "port": {
1474                             "port-device-name":
1475                                 "ROUTER_SNJSCAMCJP8_000000.00_00",
1476                             "port-type": "router",
1477                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1478                             "port-rack": "000000.00",
1479                             "port-shelf": "00"
1480                         },
1481                         "lgx": {
1482                             "lgx-device-name":
1483                                 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1484                             "lgx-port-name": "LGX Back.4",
1485                             "lgx-port-rack": "000000.00",
1486                             "lgx-port-shelf": "00"
1487                         }
1488                     },
1489                     "optic-type": "gray"
1490                 },
1491                 "service-z-end": {
1492                     "service-rate": "100",
1493                     "node-id": "ROADMC01",
1494                     "service-format": "OC",
1495                     "clli": "SNJSCAMCJT4",
1496                     "tx-direction": {
1497                         "port": {
1498                             "port-device-name":
1499                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1500                             "port-type": "router",
1501                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1502                             "port-rack": "000000.00",
1503                             "port-shelf": "00"
1504                         },
1505                         "lgx": {
1506                             "lgx-device-name":
1507                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1508                             "lgx-port-name": "LGX Back.29",
1509                             "lgx-port-rack": "000000.00",
1510                             "lgx-port-shelf": "00"
1511                         }
1512                     },
1513                     "rx-direction": {
1514                         "port": {
1515                             "port-device-name":
1516                                 "ROUTER_SNJSCAMCJT4_000000.00_00",
1517                             "port-type": "router",
1518                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1519                             "port-rack": "000000.00",
1520                             "port-shelf": "00"
1521                         },
1522                         "lgx": {
1523                             "lgx-device-name":
1524                                 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1525                             "lgx-port-name": "LGX Back.30",
1526                             "lgx-port-rack": "000000.00",
1527                             "lgx-port-shelf": "00"
1528                         }
1529                     },
1530                     "optic-type": "gray"
1531                 },
1532                 "due-date": "2016-11-28T00:00:01Z",
1533                 "operator-contact": "pw1234"
1534             }
1535         }
1536         headers = {'content-type': 'application/json',
1537                    "Accept": "application/json"}
1538         response = requests.request(
1539             "POST", url, data=json.dumps(data), headers=headers,
1540             auth=('admin', 'admin'))
1541         self.assertEqual(response.status_code, requests.codes.ok)
1542         res = response.json()
1543         self.assertIn('PCE calculation in progress',
1544                       res['output']['configuration-response-common'][
1545                           'response-message'])
1546         time.sleep(self.WAITING)
1547
1548     def test_41_get_oc_service2(self):
1549         url = ("{}/operational/org-openroadm-service:"
1550                "service-list/services/service2"
1551                .format(self.restconf_baseurl))
1552         headers = {'content-type': 'application/json',
1553                    "Accept": "application/json"}
1554         response = requests.request(
1555             "GET", url, headers=headers, auth=('admin', 'admin'))
1556         self.assertEqual(response.status_code, requests.codes.ok)
1557         res = response.json()
1558         self.assertEqual(
1559             res['services'][0]['administrative-state'],
1560             'inService')
1561         self.assertEqual(
1562             res['services'][0]['service-name'], 'service2')
1563         self.assertEqual(
1564             res['services'][0]['connection-type'], 'roadm-line')
1565         self.assertEqual(
1566             res['services'][0]['lifecycle-state'], 'planned')
1567         time.sleep(2)
1568
1569     def test_42_check_xc2_ROADMA(self):
1570         url = (
1571             "{}/config/network-topology:"
1572             "network-topology/topology/topology-netconf/"
1573             "node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1574             "org-openroadm-device/"
1575             "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1576             .format(self.restconf_baseurl))
1577         headers = {'content-type': 'application/json'}
1578         response = requests.request(
1579             "GET", url, headers=headers, auth=('admin', 'admin'))
1580         self.assertEqual(response.status_code, requests.codes.ok)
1581         res = response.json()
1582         self.assertDictContainsSubset(
1583             {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1584              'wavelength-number': 2,
1585              'opticalControlMode': 'gainLoss',
1586              'target-output-power': -3.0},
1587             res['roadm-connections'][0])
1588         self.assertDictEqual(
1589             {'src-if': 'SRG1-PP2-TXRX-2'},
1590             res['roadm-connections'][0]['source'])
1591         self.assertDictEqual(
1592             {'dst-if': 'DEG1-TTP-TXRX-2'},
1593             res['roadm-connections'][0]['destination'])
1594         time.sleep(2)
1595
1596     def test_43_check_topo_ROADMA(self):
1597         self.test_26_check_topo_ROADMA_SRG1()
1598         self.test_27_check_topo_ROADMA_DEG1()
1599         time.sleep(3)
1600
1601     def test_44_delete_oc_service1(self):
1602         url = ("{}/operations/org-openroadm-service:service-delete"
1603                .format(self.restconf_baseurl))
1604         data = {"input": {
1605             "sdnc-request-header": {
1606                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1607                 "rpc-action": "service-delete",
1608                 "request-system-id": "appname",
1609                 "notification-url":
1610                     "http://localhost:8585/NotificationServer/notify"
1611             },
1612             "service-delete-req-info": {
1613                 "service-name": "service1",
1614                 "tail-retention": "no"
1615             }
1616         }
1617         }
1618         headers = {'content-type': 'application/json'}
1619         response = requests.request(
1620             "POST", url, data=json.dumps(data), headers=headers,
1621             auth=('admin', 'admin'))
1622         self.assertEqual(response.status_code, requests.codes.ok)
1623         res = response.json()
1624         self.assertIn('Renderer service delete in progress',
1625                       res['output']['configuration-response-common'][
1626                           'response-message'])
1627         time.sleep(20)
1628
1629     def test_45_delete_oc_service2(self):
1630         url = ("{}/operations/org-openroadm-service:service-delete"
1631                .format(self.restconf_baseurl))
1632         data = {"input": {
1633             "sdnc-request-header": {
1634                 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1635                 "rpc-action": "service-delete",
1636                 "request-system-id": "appname",
1637                 "notification-url":
1638                     "http://localhost:8585/NotificationServer/notify"
1639             },
1640             "service-delete-req-info": {
1641                 "service-name": "service2",
1642                 "tail-retention": "no"
1643             }
1644         }
1645         }
1646         headers = {'content-type': 'application/json'}
1647         response = requests.request(
1648             "POST", url, data=json.dumps(data), headers=headers,
1649             auth=('admin', 'admin'))
1650         self.assertEqual(response.status_code, requests.codes.ok)
1651         res = response.json()
1652         self.assertIn('Renderer service delete in progress',
1653                       res['output']['configuration-response-common'][
1654                           'response-message'])
1655         time.sleep(20)
1656
1657     def test_46_get_no_oc_services(self):
1658         print("start test")
1659         url = ("{}/operational/org-openroadm-service:service-list"
1660                .format(self.restconf_baseurl))
1661         headers = {'content-type': 'application/json',
1662                    "Accept": "application/json"}
1663         response = requests.request(
1664             "GET", url, headers=headers, auth=('admin', 'admin'))
1665         self.assertEqual(response.status_code, requests.codes.not_found)
1666         res = response.json()
1667         self.assertIn(
1668             {
1669                 "error-type": "application",
1670                 "error-tag": "data-missing",
1671                 "error-message":
1672                     "Request could not be completed because the relevant data "
1673                     "model content does not exist"
1674             },
1675             res['errors']['error'])
1676         time.sleep(1)
1677
1678     def test_47_get_no_xc_ROADMA(self):
1679         url = (
1680             "{}/config/network-topology:"
1681             "network-topology/topology/topology-netconf"
1682             "/node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1683             "org-openroadm-device/"
1684             .format(self.restconf_baseurl))
1685         headers = {'content-type': 'application/json',
1686                    "Accept": "application/json"}
1687         response = requests.request(
1688             "GET", url, headers=headers, auth=('admin', 'admin'))
1689         self.assertEqual(response.status_code, requests.codes.ok)
1690         res = response.json()
1691         self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1692         time.sleep(1)
1693
1694     def test_48_check_topo_ROADMA(self):
1695         self.test_34_check_topo_ROADMA_SRG1()
1696         self.test_35_check_topo_ROADMA_DEG1()
1697
1698     def test_49_loop_create_eth_service(self):
1699         for i in range(1, 6):
1700             print("trial number {}".format(i))
1701             print("eth service creation")
1702             self.test_11_create_eth_service1()
1703             print("check xc in ROADMA01")
1704             self.test_13_check_xc1_ROADMA()
1705             print("check xc in ROADMC01")
1706             self.test_14_check_xc1_ROADMC()
1707             print("eth service deletion\n")
1708             self.test_30_delete_eth_service1()
1709
1710     def test_50_loop_create_oc_service(self):
1711         url = ("{}/operational/org-openroadm-service:"
1712                "service-list/services/service1"
1713                .format(self.restconf_baseurl))
1714         response = requests.request("GET", url, auth=('admin', 'admin'))
1715         if response.status_code != 404:
1716             url = ("{}/operations/org-openroadm-service:service-delete"
1717                    .format(self.restconf_baseurl))
1718             data = {"input": {
1719                 "sdnc-request-header": {
1720                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1721                     "rpc-action": "service-delete",
1722                     "request-system-id": "appname",
1723                     "notification-url":
1724                         "http://localhost:8585/NotificationServer/notify"
1725                 },
1726                 "service-delete-req-info": {
1727                     "service-name": "service1",
1728                     "tail-retention": "no"
1729                 }
1730             }
1731             }
1732             headers = {'content-type': 'application/json'}
1733             requests.request("POST", url, data=json.dumps(data),
1734                              headers=headers,
1735                              auth=('admin', 'admin')
1736                              )
1737             time.sleep(5)
1738
1739         for i in range(1, 6):
1740             print("trial number {}".format(i))
1741             print("oc service creation")
1742             self.test_36_create_oc_service1()
1743             print("check xc in ROADMA01")
1744             self.test_38_check_xc1_ROADMA()
1745             print("check xc in ROADMC01")
1746             self.test_39_check_xc1_ROADMC()
1747             print("oc service deletion\n")
1748             self.test_44_delete_oc_service1()
1749
1750     def test_51_disconnect_XPDRA(self):
1751         url = ("{}/config/network-topology:"
1752                "network-topology/topology/topology-netconf/node/XPDRA01"
1753                .format(self.restconf_baseurl))
1754         headers = {'content-type': 'application/json'}
1755         response = requests.request(
1756             "DELETE", url, headers=headers,
1757             auth=('admin', 'admin'))
1758         self.assertEqual(response.status_code, requests.codes.ok)
1759         time.sleep(10)
1760
1761     def test_52_disconnect_XPDRC(self):
1762         url = ("{}/config/network-topology:"
1763                "network-topology/topology/topology-netconf/node/XPDRC01"
1764                .format(self.restconf_baseurl))
1765         headers = {'content-type': 'application/json'}
1766         response = requests.request(
1767             "DELETE", url, headers=headers,
1768             auth=('admin', 'admin'))
1769         self.assertEqual(response.status_code, requests.codes.ok)
1770         time.sleep(10)
1771
1772     def test_53_disconnect_ROADMA(self):
1773         url = ("{}/config/network-topology:"
1774                "network-topology/topology/topology-netconf/node/ROADMA01"
1775                .format(self.restconf_baseurl))
1776         headers = {'content-type': 'application/json'}
1777         response = requests.request(
1778             "DELETE", url, headers=headers,
1779             auth=('admin', 'admin'))
1780         self.assertEqual(response.status_code, requests.codes.ok)
1781         time.sleep(10)
1782
1783     def test_54_disconnect_ROADMC(self):
1784         url = ("{}/config/network-topology:"
1785                "network-topology/topology/topology-netconf/node/ROADMC01"
1786                .format(self.restconf_baseurl))
1787         headers = {'content-type': 'application/json'}
1788         response = requests.request(
1789             "DELETE", url, headers=headers,
1790             auth=('admin', 'admin'))
1791         self.assertEqual(response.status_code, requests.codes.ok)
1792         time.sleep(10)
1793
1794
1795 if __name__ == "__main__":
1796     unittest.main(verbosity=2)