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