tests/transportpce_tests/2.2.1/test_end2end.py

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