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