tests/transportpce_tests/1.2.1/test_end2end.py

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