tests/transportpce_tests/1.2.1/test_end2end.py

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