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