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