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