tests/transportpce_tests/2.2.1/test_end2end.py

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