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/XPDRA01"
  98               .format(self.restconf_baseurl))
  99         data = {"node": [{
 100             "node-id": "XPDRA01",
 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/XPDRC01"
 117               .format(self.restconf_baseurl))
 118         data = {"node": [{
 119             "node-id": "XPDRC01",
 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/ROADMA01"
 136                .format(self.restconf_baseurl))
 137         data = {"node": [{
 138              "node-id": "ROADMA01",
 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/ROADMC01"
 155                .format(self.restconf_baseurl))
 156         data = {"node": [{
 157              "node-id": "ROADMC01",
 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": "XPDRA01",
 177                     "networkutils:xpdr-num": "1",
 178                     "networkutils:network-num": "1",
 179                     "networkutils:rdm-node": "ROADMA01",
 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": "XPDRA01",
 200                     "networkutils:xpdr-num": "1",
 201                     "networkutils:network-num": "1",
 202                     "networkutils:rdm-node": "ROADMA01",
 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": "XPDRC01",
 223                     "networkutils:xpdr-num": "1",
 224                     "networkutils:network-num": "1",
 225                     "networkutils:rdm-node": "ROADMC01",
 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": "XPDRC01",
 246                     "networkutils:xpdr-num": "1",
 247                     "networkutils:network-num": "1",
 248                     "networkutils:rdm-node": "ROADMC01",
 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/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-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/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-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": "XPDRA01",
 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": "XPDRC01",
 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'],
 421             'inService')
 422         self.assertEqual(
 423             res['services'][0]['service-name'], 'service1')
 424         self.assertEqual(
 425             res['services'][0]['connection-type'], 'service')
 426         self.assertEqual(
 427             res['services'][0]['lifecycle-state'], 'planned')
 428         time.sleep(2)
 429
 430     def test_13_check_xc1_ROADMA(self):
 431         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 432                "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 433                "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
 434                .format(self.restconf_baseurl))
 435         headers = {'content-type': 'application/json'}
 436         response = requests.request(
 437              "GET", url, headers=headers, auth=('admin', 'admin'))
 438         self.assertEqual(response.status_code, requests.codes.ok)
 439         res = response.json()
 440         self.assertDictContainsSubset(
 441              {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
 442               'wavelength-number': 1,
 443               'opticalControlMode': 'gainLoss',
 444               'target-output-power': -3.0},
 445              res['roadm-connections'][0])
 446         self.assertDictEqual(
 447              {'src-if': 'SRG1-PP1-TXRX-1'},
 448              res['roadm-connections'][0]['source'])
 449         self.assertDictEqual(
 450              {'dst-if': 'DEG1-TTP-TXRX-1'},
 451              res['roadm-connections'][0]['destination'])
 452         time.sleep(5)
 453
 454     def test_14_check_xc1_ROADMC(self):
 455         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 456                "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 457                "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
 458                .format(self.restconf_baseurl))
 459         headers = {'content-type': 'application/json'}
 460         response = requests.request(
 461              "GET", url, headers=headers, auth=('admin', 'admin'))
 462         self.assertEqual(response.status_code, requests.codes.ok)
 463         res = response.json()
 464         self.assertDictContainsSubset(
 465              {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
 466               'wavelength-number': 1,
 467               'opticalControlMode': 'gainLoss',
 468               'target-output-power': 2.0},
 469              res['roadm-connections'][0])
 470         self.assertDictEqual(
 471              {'src-if': 'SRG1-PP1-TXRX-1'},
 472              res['roadm-connections'][0]['source'])
 473         self.assertDictEqual(
 474              {'dst-if': 'DEG2-TTP-TXRX-1'},
 475              res['roadm-connections'][0]['destination'])
 476         time.sleep(5)
 477
 478     def test_15_check_topo_XPDRA(self):
 479         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
 480                .format(self.restconf_baseurl))
 481         response = requests.request(
 482              "GET", url1, auth=('admin', 'admin'))
 483         self.assertEqual(response.status_code, requests.codes.ok)
 484         res = response.json()
 485         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 486         for ele in liste_tp:
 487             if ele['tp-id'] == 'XPDR1-NETWORK1':
 488                 self.assertEqual({u'frequency': 196.1, u'width': 40},
 489                                  ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 490             if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
 491                 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
 492             if ele['tp-id'] == 'XPDR1-NETWORK2':
 493                 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
 494         time.sleep(3)
 495
 496     def test_16_check_topo_ROADMA_SRG1(self):
 497         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 498                .format(self.restconf_baseurl))
 499         response = requests.request(
 500              "GET", url1, auth=('admin', 'admin'))
 501         self.assertEqual(response.status_code, requests.codes.ok)
 502         res = response.json()
 503         self.assertNotIn({u'index': 1},
 504                           res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
 505         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 506         for ele in liste_tp:
 507             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 508                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 509                                ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
 510             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 511                 self.assertNotIn('used-wavelength', dict.keys(ele))
 512         time.sleep(3)
 513
 514     def test_17_check_topo_ROADMA_DEG1(self):
 515         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 516                .format(self.restconf_baseurl))
 517         response = requests.request(
 518              "GET", url1, auth=('admin', 'admin'))
 519         self.assertEqual(response.status_code, requests.codes.ok)
 520         res = response.json()
 521         self.assertNotIn({u'index': 1},
 522                           res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
 523         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 524         for ele in liste_tp:
 525             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 526                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 527                                ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
 528             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 529                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 530                                ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
 531         time.sleep(3)
 532
 533     def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
 534         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
 535         data = {
 536             "networkutils:input": {
 537                 "networkutils:links-input": {
 538                     "networkutils:xpdr-node": "XPDRA01",
 539                     "networkutils:xpdr-num": "1",
 540                     "networkutils:network-num": "2",
 541                     "networkutils:rdm-node": "ROADMA01",
 542                     "networkutils:srg-num": "1",
 543                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 544                 }
 545             }
 546         }
 547         headers = {'content-type': 'application/json'}
 548         response = requests.request(
 549              "POST", url, data=json.dumps(data),
 550              headers=headers, auth=('admin', 'admin'))
 551         self.assertEqual(response.status_code, requests.codes.ok)
 552         res = response.json()
 553         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
 554         time.sleep(2)
 555
 556     def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
 557         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
 558         data = {
 559             "networkutils:input": {
 560                 "networkutils:links-input": {
 561                     "networkutils:xpdr-node": "XPDRA01",
 562                     "networkutils:xpdr-num": "1",
 563                     "networkutils:network-num": "2",
 564                     "networkutils:rdm-node": "ROADMA01",
 565                     "networkutils:srg-num": "1",
 566                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 567                 }
 568             }
 569         }
 570         headers = {'content-type': 'application/json'}
 571         response = requests.request(
 572              "POST", url, data=json.dumps(data),
 573              headers=headers, auth=('admin', 'admin'))
 574         self.assertEqual(response.status_code, requests.codes.ok)
 575         res = response.json()
 576         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
 577         time.sleep(2)
 578
 579     def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
 580         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
 581         data = {
 582             "networkutils:input": {
 583                 "networkutils:links-input": {
 584                     "networkutils:xpdr-node": "XPDRC01",
 585                     "networkutils:xpdr-num": "1",
 586                     "networkutils:network-num": "2",
 587                     "networkutils:rdm-node": "ROADMC01",
 588                     "networkutils:srg-num": "1",
 589                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 590                 }
 591             }
 592         }
 593         headers = {'content-type': 'application/json'}
 594         response = requests.request(
 595              "POST", url, data=json.dumps(data),
 596              headers=headers, auth=('admin', 'admin'))
 597         self.assertEqual(response.status_code, requests.codes.ok)
 598         res = response.json()
 599         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
 600         time.sleep(2)
 601
 602     def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
 603         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
 604         data = {
 605             "networkutils:input": {
 606                 "networkutils:links-input": {
 607                     "networkutils:xpdr-node": "XPDRC01",
 608                     "networkutils:xpdr-num": "1",
 609                     "networkutils:network-num": "2",
 610                     "networkutils:rdm-node": "ROADMC01",
 611                     "networkutils:srg-num": "1",
 612                     "networkutils:termination-point-num": "SRG1-PP2-TXRX"
 613                 }
 614             }
 615         }
 616         headers = {'content-type': 'application/json'}
 617         response = requests.request(
 618              "POST", url, data=json.dumps(data),
 619              headers=headers, auth=('admin', 'admin'))
 620         self.assertEqual(response.status_code, requests.codes.ok)
 621         res = response.json()
 622         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
 623         time.sleep(2)
 624
 625     def test_22_create_eth_service2(self):
 626         url = ("{}/operations/org-openroadm-service:service-create"
 627               .format(self.restconf_baseurl))
 628         data = {"input": {
 629                 "sdnc-request-header": {
 630                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 631                     "rpc-action": "service-create",
 632                     "request-system-id": "appname",
 633                     "notification-url": "http://localhost:8585/NotificationServer/notify"
 634                 },
 635                 "service-name": "service2",
 636                 "common-id": "ASATT1234567",
 637                 "connection-type": "service",
 638                 "service-a-end": {
 639                     "service-rate": "100",
 640                     "node-id": "XPDRA01",
 641                     "service-format": "Ethernet",
 642                     "clli": "SNJSCAMCJP8",
 643                     "tx-direction": {
 644                         "port": {
 645                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
 646                             "port-type": "router",
 647                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 648                             "port-rack": "000000.00",
 649                             "port-shelf": "00"
 650                         },
 651                         "lgx": {
 652                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
 653                             "lgx-port-name": "LGX Back.3",
 654                             "lgx-port-rack": "000000.00",
 655                             "lgx-port-shelf": "00"
 656                         }
 657                     },
 658                     "rx-direction": {
 659                         "port": {
 660                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
 661                             "port-type": "router",
 662                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 663                             "port-rack": "000000.00",
 664                             "port-shelf": "00"
 665                         },
 666                         "lgx": {
 667                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
 668                             "lgx-port-name": "LGX Back.4",
 669                             "lgx-port-rack": "000000.00",
 670                             "lgx-port-shelf": "00"
 671                         }
 672                     },
 673                     "optic-type": "gray"
 674                 },
 675                 "service-z-end": {
 676                     "service-rate": "100",
 677                     "node-id": "XPDRC01",
 678                     "service-format": "Ethernet",
 679                     "clli": "SNJSCAMCJT4",
 680                     "tx-direction": {
 681                         "port": {
 682                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
 683                             "port-type": "router",
 684                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 685                             "port-rack": "000000.00",
 686                             "port-shelf": "00"
 687                         },
 688                         "lgx": {
 689                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
 690                             "lgx-port-name": "LGX Back.29",
 691                             "lgx-port-rack": "000000.00",
 692                             "lgx-port-shelf": "00"
 693                         }
 694                     },
 695                     "rx-direction": {
 696                         "port": {
 697                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
 698                             "port-type": "router",
 699                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 700                             "port-rack": "000000.00",
 701                             "port-shelf": "00"
 702                         },
 703                         "lgx": {
 704                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
 705                             "lgx-port-name": "LGX Back.30",
 706                             "lgx-port-rack": "000000.00",
 707                             "lgx-port-shelf": "00"
 708                         }
 709                     },
 710                     "optic-type": "gray"
 711                 },
 712                 "due-date": "2016-11-28T00:00:01Z",
 713                 "operator-contact": "pw1234"
 714             }
 715         }
 716         headers = {'content-type': 'application/json',
 717         "Accept": "application/json"}
 718         response = requests.request(
 719             "POST", url, data=json.dumps(data), headers=headers,
 720             auth=('admin', 'admin'))
 721         self.assertEqual(response.status_code, requests.codes.ok)
 722         res = response.json()
 723         self.assertIn('PCE calculation in progress',
 724             res['output']['configuration-response-common']['response-message'])
 725         time.sleep(self.WAITING)
 726
 727     def test_23_get_eth_service2(self):
 728         url = ("{}/operational/org-openroadm-service:service-list/services/service2"
 729               .format(self.restconf_baseurl))
 730         headers = {'content-type': 'application/json',
 731         "Accept": "application/json"}
 732         response = requests.request(
 733             "GET", url, headers=headers, auth=('admin', 'admin'))
 734         self.assertEqual(response.status_code, requests.codes.ok)
 735         res = response.json()
 736         self.assertEqual(
 737             res['services'][0]['administrative-state'],
 738             'inService')
 739         self.assertEqual(
 740             res['services'][0]['service-name'], 'service2')
 741         self.assertEqual(
 742             res['services'][0]['connection-type'], 'service')
 743         self.assertEqual(
 744             res['services'][0]['lifecycle-state'], 'planned')
 745         time.sleep(1)
 746
 747     def test_24_check_xc2_ROADMA(self):
 748         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 749                "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 750                "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
 751                .format(self.restconf_baseurl))
 752         headers = {'content-type': 'application/json'}
 753         response = requests.request(
 754              "GET", url, headers=headers, auth=('admin', 'admin'))
 755         self.assertEqual(response.status_code, requests.codes.ok)
 756         res = response.json()
 757         self.assertDictContainsSubset(
 758              {'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
 759               'wavelength-number': 2,
 760               'opticalControlMode': 'power'},
 761              res['roadm-connections'][0])
 762         self.assertDictEqual(
 763              {'src-if': 'DEG1-TTP-TXRX-2'},
 764              res['roadm-connections'][0]['source'])
 765         self.assertDictEqual(
 766              {'dst-if': 'SRG1-PP2-TXRX-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/XPDRA01-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, u'width': 40},
 780                                   ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 781             if ele['tp-id'] == 'XPDR1-NETWORK2':
 782                 self.assertEqual({u'frequency': 196.05, u'width': 40},
 783                                   ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 784             if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
 785                 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
 786         time.sleep(10)
 787
 788     def test_26_check_topo_ROADMA_SRG1(self):
 789         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 790                .format(self.restconf_baseurl))
 791         response = requests.request(
 792              "GET", url1, auth=('admin', 'admin'))
 793         self.assertEqual(response.status_code, requests.codes.ok)
 794         res = response.json()
 795         self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
 796         self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
 797         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 798         for ele in liste_tp:
 799             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 800                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 801                                ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
 802                 self.assertNotIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 803                                   ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
 804             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 805                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 806                               ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
 807                 self.assertNotIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 808                                   ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
 809             if ele['tp-id'] == 'SRG1-PP3-TXRX':
 810                 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
 811         time.sleep(10)
 812
 813     def test_27_check_topo_ROADMA_DEG1(self):
 814         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
 815                .format(self.restconf_baseurl))
 816         response = requests.request(
 817              "GET", url1, auth=('admin', 'admin'))
 818         self.assertEqual(response.status_code, requests.codes.ok)
 819         res = response.json()
 820         self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
 821         self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
 822         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 823         for ele in liste_tp:
 824             if ele['tp-id'] == 'DEG1-CTP-TXRX':
 825                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 826                                ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
 827                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 828                               ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
 829             if ele['tp-id'] == 'DEG1-TTP-TXRX':
 830                 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
 831                                ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
 832                 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
 833                               ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
 834         time.sleep(10)
 835
 836 #     creation service test on a non-available resource
 837     def test_28_create_eth_service3(self):
 838         url = ("{}/operations/org-openroadm-service:service-create"
 839               .format(self.restconf_baseurl))
 840         data = {"input": {
 841                 "sdnc-request-header": {
 842                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 843                     "rpc-action": "service-create",
 844                     "request-system-id": "appname",
 845                     "notification-url": "http://localhost:8585/NotificationServer/notify"
 846                 },
 847                 "service-name": "service3",
 848                 "common-id": "ASATT1234567",
 849                 "connection-type": "service",
 850                 "service-a-end": {
 851                     "service-rate": "100",
 852                     "node-id": "XPDRA01",
 853                     "service-format": "Ethernet",
 854                     "clli": "SNJSCAMCJP8",
 855                     "tx-direction": {
 856                         "port": {
 857                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
 858                             "port-type": "router",
 859                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
 860                             "port-rack": "000000.00",
 861                             "port-shelf": "00"
 862                         },
 863                         "lgx": {
 864                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
 865                             "lgx-port-name": "LGX Back.3",
 866                             "lgx-port-rack": "000000.00",
 867                             "lgx-port-shelf": "00"
 868                         }
 869                     },
 870                     "rx-direction": {
 871                         "port": {
 872                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
 873                             "port-type": "router",
 874                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
 875                             "port-rack": "000000.00",
 876                             "port-shelf": "00"
 877                         },
 878                         "lgx": {
 879                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
 880                             "lgx-port-name": "LGX Back.4",
 881                             "lgx-port-rack": "000000.00",
 882                             "lgx-port-shelf": "00"
 883                         }
 884                     },
 885                     "optic-type": "gray"
 886                 },
 887                 "service-z-end": {
 888                     "service-rate": "100",
 889                     "node-id": "XPDRC01",
 890                     "service-format": "Ethernet",
 891                     "clli": "SNJSCAMCJT4",
 892                     "tx-direction": {
 893                         "port": {
 894                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
 895                             "port-type": "router",
 896                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
 897                             "port-rack": "000000.00",
 898                             "port-shelf": "00"
 899                         },
 900                         "lgx": {
 901                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
 902                             "lgx-port-name": "LGX Back.29",
 903                             "lgx-port-rack": "000000.00",
 904                             "lgx-port-shelf": "00"
 905                         }
 906                     },
 907                     "rx-direction": {
 908                         "port": {
 909                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
 910                             "port-type": "router",
 911                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
 912                             "port-rack": "000000.00",
 913                             "port-shelf": "00"
 914                         },
 915                         "lgx": {
 916                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
 917                             "lgx-port-name": "LGX Back.30",
 918                             "lgx-port-rack": "000000.00",
 919                             "lgx-port-shelf": "00"
 920                         }
 921                     },
 922                     "optic-type": "gray"
 923                 },
 924                 "due-date": "2016-11-28T00:00:01Z",
 925                 "operator-contact": "pw1234"
 926             }
 927         }
 928         headers = {'content-type': 'application/json',
 929         "Accept": "application/json"}
 930         response = requests.request(
 931             "POST", url, data=json.dumps(data), headers=headers,
 932             auth=('admin', 'admin'))
 933         self.assertEqual(response.status_code, requests.codes.ok)
 934         res = response.json()
 935         self.assertIn('PCE calculation in progress',
 936             res['output']['configuration-response-common']['response-message'])
 937         self.assertIn('200', res['output']['configuration-response-common']['response-code'])
 938         time.sleep(self.WAITING)
 939
 940 # add a test that check the openroadm-service-list still only contains 2 elements
 941
 942     def test_29_delete_eth_service3(self):
 943         url = ("{}/operations/org-openroadm-service:service-delete"
 944               .format(self.restconf_baseurl))
 945         data = {"input": {
 946                 "sdnc-request-header": {
 947                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 948                     "rpc-action": "service-delete",
 949                     "request-system-id": "appname",
 950                     "notification-url": "http://localhost:8585/NotificationServer/notify"
 951                 },
 952                 "service-delete-req-info": {
 953                     "service-name": "service3",
 954                     "tail-retention": "no"
 955                 }
 956             }
 957         }
 958         headers = {'content-type': 'application/json'}
 959         response = requests.request(
 960             "POST", url, data=json.dumps(data), headers=headers,
 961             auth=('admin', 'admin'))
 962         self.assertEqual(response.status_code, requests.codes.ok)
 963         res = response.json()
 964         self.assertIn('Service \'service3\' does not exist in datastore',
 965             res['output']['configuration-response-common']['response-message'])
 966         self.assertIn('500', res['output']['configuration-response-common']['response-code'])
 967         time.sleep(20)
 968
 969     def test_30_delete_eth_service1(self):
 970         url = ("{}/operations/org-openroadm-service:service-delete"
 971               .format(self.restconf_baseurl))
 972         data = {"input": {
 973                 "sdnc-request-header": {
 974                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 975                     "rpc-action": "service-delete",
 976                     "request-system-id": "appname",
 977                     "notification-url": "http://localhost:8585/NotificationServer/notify"
 978                 },
 979                 "service-delete-req-info": {
 980                     "service-name": "service1",
 981                     "tail-retention": "no"
 982                 }
 983             }
 984         }
 985         headers = {'content-type': 'application/json'}
 986         response = requests.request(
 987             "POST", url, data=json.dumps(data), headers=headers,
 988             auth=('admin', 'admin'))
 989         self.assertEqual(response.status_code, requests.codes.ok)
 990         res = response.json()
 991         self.assertIn('Renderer service delete in progress',
 992             res['output']['configuration-response-common']['response-message'])
 993         time.sleep(20)
 994
 995     def test_31_delete_eth_service2(self):
 996         url = ("{}/operations/org-openroadm-service:service-delete"
 997               .format(self.restconf_baseurl))
 998         data = {"input": {
 999                 "sdnc-request-header": {
1000                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1001                     "rpc-action": "service-delete",
1002                     "request-system-id": "appname",
1003                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1004                 },
1005                 "service-delete-req-info": {
1006                     "service-name": "service2",
1007                     "tail-retention": "no"
1008                 }
1009             }
1010         }
1011         headers = {'content-type': 'application/json'}
1012         response = requests.request(
1013             "POST", url, data=json.dumps(data), headers=headers,
1014             auth=('admin', 'admin'))
1015         self.assertEqual(response.status_code, requests.codes.ok)
1016         res = response.json()
1017         self.assertIn('Renderer service delete in progress',
1018             res['output']['configuration-response-common']['response-message'])
1019         time.sleep(20)
1020
1021     def test_32_check_no_xc_ROADMA(self):
1022         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1023                "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1024                .format(self.restconf_baseurl))
1025         response = requests.request(
1026              "GET", url, auth=('admin', 'admin'))
1027         res = response.json()
1028         self.assertEqual(response.status_code, requests.codes.ok)
1029         self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1030         time.sleep(2)
1031
1032     def test_33_check_topo_XPDRA(self):
1033         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1034                .format(self.restconf_baseurl))
1035         response = requests.request(
1036              "GET", url1, auth=('admin', 'admin'))
1037         self.assertEqual(response.status_code, requests.codes.ok)
1038         res = response.json()
1039         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1040         for ele in liste_tp:
1041             if ((ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT')
1042                 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1043                 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
1044             elif (ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK'):
1045                 self.assertIn(u'tail-equipment-id', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1046                 self.assertNotIn('wavelength', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1047         time.sleep(10)
1048
1049     def test_34_check_topo_ROADMA_SRG1(self):
1050         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
1051                .format(self.restconf_baseurl))
1052         response = requests.request(
1053              "GET", url1, auth=('admin', 'admin'))
1054         self.assertEqual(response.status_code, requests.codes.ok)
1055         res = response.json()
1056         self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1057         self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1058         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1059         for ele in liste_tp:
1060             if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1061                 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1062             else:
1063                 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1064         time.sleep(10)
1065
1066     def test_35_check_topo_ROADMA_DEG1(self):
1067         url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
1068                .format(self.restconf_baseurl))
1069         response = requests.request(
1070              "GET", url1, auth=('admin', 'admin'))
1071         self.assertEqual(response.status_code, requests.codes.ok)
1072         res = response.json()
1073         self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1074         self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1075         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1076         for ele in liste_tp:
1077             if ele['tp-id'] == 'DEG1-CTP-TXRX':
1078                 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1079             if ele['tp-id'] == 'DEG1-TTP-TXRX':
1080                 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1081         time.sleep(10)
1082
1083
1084 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1085     def test_36_create_oc_service1(self):
1086         url = ("{}/operations/org-openroadm-service:service-create"
1087               .format(self.restconf_baseurl))
1088         data = {"input": {
1089                 "sdnc-request-header": {
1090                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1091                     "rpc-action": "service-create",
1092                     "request-system-id": "appname",
1093                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1094                 },
1095                 "service-name": "service1",
1096                 "common-id": "ASATT1234567",
1097                 "connection-type": "roadm-line",
1098                 "service-a-end": {
1099                     "service-rate": "100",
1100                     "node-id": "ROADMA01",
1101                     "service-format": "OC",
1102                     "clli": "SNJSCAMCJP8",
1103                     "tx-direction": {
1104                         "port": {
1105                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1106                             "port-type": "router",
1107                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1108                             "port-rack": "000000.00",
1109                             "port-shelf": "00"
1110                         },
1111                         "lgx": {
1112                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1113                             "lgx-port-name": "LGX Back.3",
1114                             "lgx-port-rack": "000000.00",
1115                             "lgx-port-shelf": "00"
1116                         }
1117                     },
1118                     "rx-direction": {
1119                         "port": {
1120                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1121                             "port-type": "router",
1122                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1123                             "port-rack": "000000.00",
1124                             "port-shelf": "00"
1125                         },
1126                         "lgx": {
1127                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1128                             "lgx-port-name": "LGX Back.4",
1129                             "lgx-port-rack": "000000.00",
1130                             "lgx-port-shelf": "00"
1131                         }
1132                     },
1133                     "optic-type": "gray"
1134                 },
1135                 "service-z-end": {
1136                     "service-rate": "100",
1137                     "node-id": "ROADMC01",
1138                     "service-format": "OC",
1139                     "clli": "SNJSCAMCJT4",
1140                     "tx-direction": {
1141                         "port": {
1142                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1143                             "port-type": "router",
1144                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1145                             "port-rack": "000000.00",
1146                             "port-shelf": "00"
1147                         },
1148                         "lgx": {
1149                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1150                             "lgx-port-name": "LGX Back.29",
1151                             "lgx-port-rack": "000000.00",
1152                             "lgx-port-shelf": "00"
1153                         }
1154                     },
1155                     "rx-direction": {
1156                         "port": {
1157                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1158                             "port-type": "router",
1159                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1160                             "port-rack": "000000.00",
1161                             "port-shelf": "00"
1162                         },
1163                         "lgx": {
1164                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1165                             "lgx-port-name": "LGX Back.30",
1166                             "lgx-port-rack": "000000.00",
1167                             "lgx-port-shelf": "00"
1168                         }
1169                     },
1170                     "optic-type": "gray"
1171                 },
1172                 "due-date": "2016-11-28T00:00:01Z",
1173                 "operator-contact": "pw1234"
1174             }
1175         }
1176         headers = {'content-type': 'application/json',
1177         "Accept": "application/json"}
1178         response = requests.request(
1179             "POST", url, data=json.dumps(data), headers=headers,
1180             auth=('admin', 'admin'))
1181         self.assertEqual(response.status_code, requests.codes.ok)
1182         res = response.json()
1183         self.assertIn('PCE calculation in progress',
1184             res['output']['configuration-response-common']['response-message'])
1185         time.sleep(self.WAITING)
1186
1187     def test_37_get_oc_service1(self):
1188         url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1189               .format(self.restconf_baseurl))
1190         headers = {'content-type': 'application/json',
1191         "Accept": "application/json"}
1192         response = requests.request(
1193             "GET", url, headers=headers, auth=('admin', 'admin'))
1194         self.assertEqual(response.status_code, requests.codes.ok)
1195         res = response.json()
1196         self.assertEqual(
1197             res['services'][0]['administrative-state'],
1198             'inService')
1199         self.assertEqual(
1200             res['services'][0]['service-name'], 'service1')
1201         self.assertEqual(
1202             res['services'][0]['connection-type'], 'roadm-line')
1203         self.assertEqual(
1204             res['services'][0]['lifecycle-state'], 'planned')
1205         time.sleep(1)
1206
1207     def test_38_check_xc1_ROADMA(self):
1208         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1209                "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1210                "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1211                .format(self.restconf_baseurl))
1212         headers = {'content-type': 'application/json'}
1213         response = requests.request(
1214              "GET", url, headers=headers, auth=('admin', 'admin'))
1215         self.assertEqual(response.status_code, requests.codes.ok)
1216         res = response.json()
1217         self.assertDictContainsSubset(
1218              {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1219               'wavelength-number': 1,
1220               'opticalControlMode': 'gainLoss',
1221               'target-output-power': -3.0},
1222              res['roadm-connections'][0])
1223         self.assertDictEqual(
1224              {'src-if': 'SRG1-PP1-TXRX-1'},
1225              res['roadm-connections'][0]['source'])
1226         self.assertDictEqual(
1227              {'dst-if': 'DEG1-TTP-TXRX-1'},
1228              res['roadm-connections'][0]['destination'])
1229         time.sleep(7)
1230
1231     def test_39_check_xc1_ROADMC(self):
1232         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1233                "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1234                "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1235                .format(self.restconf_baseurl))
1236         headers = {'content-type': 'application/json'}
1237         response = requests.request(
1238              "GET", url, headers=headers, auth=('admin', 'admin'))
1239         self.assertEqual(response.status_code, requests.codes.ok)
1240         res = response.json()
1241         self.assertDictContainsSubset(
1242              {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1243               'wavelength-number': 1,
1244               'opticalControlMode': 'gainLoss',
1245               'target-output-power': 2.0},
1246              res['roadm-connections'][0])
1247         self.assertDictEqual(
1248              {'src-if': 'SRG1-PP1-TXRX-1'},
1249              res['roadm-connections'][0]['source'])
1250         self.assertDictEqual(
1251              {'dst-if': 'DEG2-TTP-TXRX-1'},
1252              res['roadm-connections'][0]['destination'])
1253         time.sleep(7)
1254
1255     def test_40_create_oc_service2(self):
1256         url = ("{}/operations/org-openroadm-service:service-create"
1257               .format(self.restconf_baseurl))
1258         data = {"input": {
1259                 "sdnc-request-header": {
1260                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1261                     "rpc-action": "service-create",
1262                     "request-system-id": "appname",
1263                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1264                 },
1265                 "service-name": "service2",
1266                 "common-id": "ASATT1234567",
1267                 "connection-type": "roadm-line",
1268                 "service-a-end": {
1269                     "service-rate": "100",
1270                     "node-id": "ROADMA01",
1271                     "service-format": "OC",
1272                     "clli": "SNJSCAMCJP8",
1273                     "tx-direction": {
1274                         "port": {
1275                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1276                             "port-type": "router",
1277                             "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1278                             "port-rack": "000000.00",
1279                             "port-shelf": "00"
1280                         },
1281                         "lgx": {
1282                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1283                             "lgx-port-name": "LGX Back.3",
1284                             "lgx-port-rack": "000000.00",
1285                             "lgx-port-shelf": "00"
1286                         }
1287                     },
1288                     "rx-direction": {
1289                         "port": {
1290                             "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1291                             "port-type": "router",
1292                             "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1293                             "port-rack": "000000.00",
1294                             "port-shelf": "00"
1295                         },
1296                         "lgx": {
1297                             "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1298                             "lgx-port-name": "LGX Back.4",
1299                             "lgx-port-rack": "000000.00",
1300                             "lgx-port-shelf": "00"
1301                         }
1302                     },
1303                     "optic-type": "gray"
1304                 },
1305                 "service-z-end": {
1306                     "service-rate": "100",
1307                     "node-id": "ROADMC01",
1308                     "service-format": "OC",
1309                     "clli": "SNJSCAMCJT4",
1310                     "tx-direction": {
1311                         "port": {
1312                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1313                             "port-type": "router",
1314                             "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1315                             "port-rack": "000000.00",
1316                             "port-shelf": "00"
1317                         },
1318                         "lgx": {
1319                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1320                             "lgx-port-name": "LGX Back.29",
1321                             "lgx-port-rack": "000000.00",
1322                             "lgx-port-shelf": "00"
1323                         }
1324                     },
1325                     "rx-direction": {
1326                         "port": {
1327                             "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1328                             "port-type": "router",
1329                             "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1330                             "port-rack": "000000.00",
1331                             "port-shelf": "00"
1332                         },
1333                         "lgx": {
1334                             "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1335                             "lgx-port-name": "LGX Back.30",
1336                             "lgx-port-rack": "000000.00",
1337                             "lgx-port-shelf": "00"
1338                         }
1339                     },
1340                     "optic-type": "gray"
1341                 },
1342                 "due-date": "2016-11-28T00:00:01Z",
1343                 "operator-contact": "pw1234"
1344             }
1345         }
1346         headers = {'content-type': 'application/json',
1347         "Accept": "application/json"}
1348         response = requests.request(
1349             "POST", url, data=json.dumps(data), headers=headers,
1350             auth=('admin', 'admin'))
1351         self.assertEqual(response.status_code, requests.codes.ok)
1352         res = response.json()
1353         self.assertIn('PCE calculation in progress',
1354             res['output']['configuration-response-common']['response-message'])
1355         time.sleep(self.WAITING)
1356
1357     def test_41_get_oc_service2(self):
1358         url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1359               .format(self.restconf_baseurl))
1360         headers = {'content-type': 'application/json',
1361         "Accept": "application/json"}
1362         response = requests.request(
1363             "GET", url, headers=headers, auth=('admin', 'admin'))
1364         self.assertEqual(response.status_code, requests.codes.ok)
1365         res = response.json()
1366         self.assertEqual(
1367             res['services'][0]['administrative-state'],
1368             'inService')
1369         self.assertEqual(
1370             res['services'][0]['service-name'], 'service2')
1371         self.assertEqual(
1372             res['services'][0]['connection-type'], 'roadm-line')
1373         self.assertEqual(
1374             res['services'][0]['lifecycle-state'], 'planned')
1375         time.sleep(2)
1376
1377     def test_42_check_xc2_ROADMA(self):
1378         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1379                "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1380                "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1381                .format(self.restconf_baseurl))
1382         headers = {'content-type': 'application/json'}
1383         response = requests.request(
1384              "GET", url, headers=headers, auth=('admin', 'admin'))
1385         self.assertEqual(response.status_code, requests.codes.ok)
1386         res = response.json()
1387         self.assertDictContainsSubset(
1388              {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1389               'wavelength-number': 2,
1390               'opticalControlMode': 'gainLoss',
1391               'target-output-power': -3.0},
1392              res['roadm-connections'][0])
1393         self.assertDictEqual(
1394              {'src-if': 'SRG1-PP2-TXRX-2'},
1395              res['roadm-connections'][0]['source'])
1396         self.assertDictEqual(
1397              {'dst-if': 'DEG1-TTP-TXRX-2'},
1398              res['roadm-connections'][0]['destination'])
1399         time.sleep(2)
1400
1401     def test_43_check_topo_ROADMA(self):
1402         self.test_26_check_topo_ROADMA_SRG1()
1403         self.test_27_check_topo_ROADMA_DEG1()
1404         time.sleep(3)
1405
1406     def test_44_delete_oc_service1(self):
1407         url = ("{}/operations/org-openroadm-service:service-delete"
1408               .format(self.restconf_baseurl))
1409         data = {"input": {
1410                 "sdnc-request-header": {
1411                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1412                     "rpc-action": "service-delete",
1413                     "request-system-id": "appname",
1414                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1415                 },
1416                 "service-delete-req-info": {
1417                     "service-name": "service1",
1418                     "tail-retention": "no"
1419                 }
1420             }
1421         }
1422         headers = {'content-type': 'application/json'}
1423         response = requests.request(
1424             "POST", url, data=json.dumps(data), headers=headers,
1425             auth=('admin', 'admin'))
1426         self.assertEqual(response.status_code, requests.codes.ok)
1427         res = response.json()
1428         self.assertIn('Renderer service delete in progress',
1429             res['output']['configuration-response-common']['response-message'])
1430         time.sleep(20)
1431
1432     def test_45_delete_oc_service2(self):
1433         url = ("{}/operations/org-openroadm-service:service-delete"
1434               .format(self.restconf_baseurl))
1435         data = {"input": {
1436                 "sdnc-request-header": {
1437                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1438                     "rpc-action": "service-delete",
1439                     "request-system-id": "appname",
1440                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1441                 },
1442                 "service-delete-req-info": {
1443                     "service-name": "service2",
1444                     "tail-retention": "no"
1445                 }
1446             }
1447         }
1448         headers = {'content-type': 'application/json'}
1449         response = requests.request(
1450             "POST", url, data=json.dumps(data), headers=headers,
1451             auth=('admin', 'admin'))
1452         self.assertEqual(response.status_code, requests.codes.ok)
1453         res = response.json()
1454         self.assertIn('Renderer service delete in progress',
1455             res['output']['configuration-response-common']['response-message'])
1456         time.sleep(20)
1457
1458     def test_46_get_no_oc_services(self):
1459         print ("start test")
1460         url = ("{}/operational/org-openroadm-service:service-list"
1461               .format(self.restconf_baseurl))
1462         headers = {'content-type': 'application/json',
1463         "Accept": "application/json"}
1464         response = requests.request(
1465             "GET", url, headers=headers, auth=('admin', 'admin'))
1466         self.assertEqual(response.status_code, requests.codes.not_found)
1467         res = response.json()
1468         self.assertIn(
1469             {"error-type":"application", "error-tag":"data-missing",
1470              "error-message":"Request could not be completed because the relevant data model content does not exist"},
1471             res['errors']['error'])
1472         time.sleep(1)
1473
1474     def test_47_get_no_xc_ROADMA(self):
1475         url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1476                "/node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1477               .format(self.restconf_baseurl))
1478         headers = {'content-type': 'application/json',
1479         "Accept": "application/json"}
1480         response = requests.request(
1481             "GET", url, headers=headers, auth=('admin', 'admin'))
1482         self.assertEqual(response.status_code, requests.codes.ok)
1483         res = response.json()
1484         self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1485         time.sleep(1)
1486
1487     def test_48_check_topo_ROADMA(self):
1488         self.test_34_check_topo_ROADMA_SRG1()
1489         self.test_35_check_topo_ROADMA_DEG1()
1490
1491     def test_49_loop_create_eth_service(self):
1492         for i in range(1,6):
1493             print ("trial number {}".format(i))
1494             print("eth service creation")
1495             self.test_11_create_eth_service1()
1496             print ("check xc in ROADMA01")
1497             self.test_13_check_xc1_ROADMA()
1498             print ("check xc in ROADMC01")
1499             self.test_14_check_xc1_ROADMC()
1500             print ("eth service deletion\n")
1501             self.test_30_delete_eth_service1()
1502
1503     def test_50_loop_create_oc_service(self):
1504         url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1505                .format(self.restconf_baseurl))
1506         response = requests.request("GET", url, auth=('admin', 'admin'))
1507         if response.status_code != 404:
1508             url = ("{}/operations/org-openroadm-service:service-delete"
1509                    .format(self.restconf_baseurl))
1510             data = {"input": {
1511                 "sdnc-request-header": {
1512                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1513                     "rpc-action": "service-delete",
1514                     "request-system-id": "appname",
1515                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1516             },
1517                 "service-delete-req-info": {
1518                     "service-name": "service1",
1519                     "tail-retention": "no"
1520             }
1521                 }
1522             }
1523             headers = {'content-type': 'application/json'}
1524             requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1525             time.sleep(5)
1526
1527         for i in range(1,6):
1528             print ("trial number {}".format(i))
1529             print("oc service creation")
1530             self.test_36_create_oc_service1()
1531             print ("check xc in ROADMA01")
1532             self.test_38_check_xc1_ROADMA()
1533             print ("check xc in ROADMC01")
1534             self.test_39_check_xc1_ROADMC()
1535             print ("oc service deletion\n")
1536             self.test_44_delete_oc_service1()
1537
1538     def test_51_disconnect_XPDRA(self):
1539         url = ("{}/config/network-topology:"
1540                 "network-topology/topology/topology-netconf/node/XPDRA01"
1541                .format(self.restconf_baseurl))
1542         headers = {'content-type': 'application/json'}
1543         response = requests.request(
1544              "DELETE", url, headers=headers,
1545              auth=('admin', 'admin'))
1546         self.assertEqual(response.status_code, requests.codes.ok)
1547         time.sleep(10)
1548
1549     def test_52_disconnect_XPDRC(self):
1550         url = ("{}/config/network-topology:"
1551                 "network-topology/topology/topology-netconf/node/XPDRC01"
1552                .format(self.restconf_baseurl))
1553         headers = {'content-type': 'application/json'}
1554         response = requests.request(
1555              "DELETE", url, headers=headers,
1556              auth=('admin', 'admin'))
1557         self.assertEqual(response.status_code, requests.codes.ok)
1558         time.sleep(10)
1559
1560     def test_53_disconnect_ROADMA(self):
1561         url = ("{}/config/network-topology:"
1562                 "network-topology/topology/topology-netconf/node/ROADMA01"
1563                .format(self.restconf_baseurl))
1564         headers = {'content-type': 'application/json'}
1565         response = requests.request(
1566              "DELETE", url, headers=headers,
1567              auth=('admin', 'admin'))
1568         self.assertEqual(response.status_code, requests.codes.ok)
1569         time.sleep(10)
1570
1571     def test_54_disconnect_ROADMC(self):
1572         url = ("{}/config/network-topology:"
1573                 "network-topology/topology/topology-netconf/node/ROADMC01"
1574                .format(self.restconf_baseurl))
1575         headers = {'content-type': 'application/json'}
1576         response = requests.request(
1577              "DELETE", url, headers=headers,
1578              auth=('admin', 'admin'))
1579         self.assertEqual(response.status_code, requests.codes.ok)
1580         time.sleep(10)
1581
1582
1583 if __name__ == "__main__":
1584     unittest.main(verbosity=2)