tests/transportpce_tests/2.2.1/test_end2end.py

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