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