tests/transportpce_tests/2.2.1/test_end2end.py

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