tests/transportpce_tests/1.2.1/test_topology.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 #Copyright (c) 2017 Orange, Inc. and others.  All rights reserved.
   5 #
   6 # All rights reserved. This program and the accompanying materials
   7 # are made available under the terms of the Apache License, Version 2.0
   8 # which accompanies this distribution, and is available at
   9 # http://www.apache.org/licenses/LICENSE-2.0
  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 logging
  22 import test_utils
  23
  24 class TransportPCETopologyTesting(unittest.TestCase):
  25
  26     honeynode_process1 = None
  27     honeynode_process2 = None
  28     honeynode_process3 = None
  29     honeynode_process4 = None
  30     odl_process = None
  31     restconf_baseurl = "http://localhost:8181/restconf"
  32
  33 #START_IGNORE_XTESTING
  34
  35     @classmethod
  36     def setUpClass(cls):
  37         print ("starting honeynode1...")
  38         cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
  39         time.sleep(20)
  40
  41         print ("starting honeynode2...")
  42         cls.honeynode_process2 = test_utils.start_roadma_honeynode()
  43         time.sleep(20)
  44
  45         print ("starting honeynode3...")
  46         cls.honeynode_process3 = test_utils.start_roadmb_honeynode()
  47         time.sleep(20)
  48
  49         print ("starting honeynode4...")
  50         cls.honeynode_process4 = test_utils.start_roadmc_honeynode()
  51         time.sleep(20)
  52         print ("all honeynodes started")
  53
  54         print ("starting opendaylight...")
  55         cls.odl_process = test_utils.start_tpce()
  56         time.sleep(60)
  57         print ("opendaylight started")
  58
  59     @classmethod
  60     def tearDownClass(cls):
  61         for child in psutil.Process(cls.odl_process.pid).children():
  62             child.send_signal(signal.SIGINT)
  63             child.wait()
  64         cls.odl_process.send_signal(signal.SIGINT)
  65         cls.odl_process.wait()
  66         for child in psutil.Process(cls.honeynode_process1.pid).children():
  67             child.send_signal(signal.SIGINT)
  68             child.wait()
  69         cls.honeynode_process1.send_signal(signal.SIGINT)
  70         cls.honeynode_process1.wait()
  71         for child in psutil.Process(cls.honeynode_process2.pid).children():
  72             child.send_signal(signal.SIGINT)
  73             child.wait()
  74         cls.honeynode_process2.send_signal(signal.SIGINT)
  75         cls.honeynode_process2.wait()
  76
  77         for child in psutil.Process(cls.honeynode_process3.pid).children():
  78             child.send_signal(signal.SIGINT)
  79             child.wait()
  80         cls.honeynode_process3.send_signal(signal.SIGINT)
  81         cls.honeynode_process3.wait()
  82
  83         for child in psutil.Process(cls.honeynode_process4.pid).children():
  84             child.send_signal(signal.SIGINT)
  85             child.wait()
  86         cls.honeynode_process4.send_signal(signal.SIGINT)
  87         cls.honeynode_process4.wait()
  88
  89     def setUp(self):
  90         time.sleep(30)
  91
  92 #END_IGNORE_XTESTING
  93
  94     def test_01_connect_ROADMA(self):
  95         #Config ROADMA
  96         url = ("{}/config/network-topology:"
  97                 "network-topology/topology/topology-netconf/node/ROADMA"
  98                .format(self.restconf_baseurl))
  99         data = {"node": [{
 100              "node-id": "ROADMA",
 101              "netconf-node-topology:username": "admin",
 102              "netconf-node-topology:password": "admin",
 103              "netconf-node-topology:host": "127.0.0.1",
 104              "netconf-node-topology:port": "17831",
 105              "netconf-node-topology:tcp-only": "false",
 106              "netconf-node-topology:pass-through": {}}]}
 107         headers = {'content-type': 'application/json'}
 108         response = requests.request(
 109              "PUT", url, data=json.dumps(data), headers=headers,
 110              auth=('admin', 'admin'))
 111         self.assertEqual(response.status_code, requests.codes.created)
 112         time.sleep(20)
 113
 114     def test_02_getClliNetwork(self):
 115         url = ("{}/config/ietf-network:networks/network/clli-network"
 116               .format(self.restconf_baseurl))
 117         headers = {'content-type': 'application/json'}
 118         response = requests.request(
 119             "GET", url, headers=headers, auth=('admin', 'admin'))
 120         self.assertEqual(response.status_code, requests.codes.ok)
 121         res = response.json()
 122         self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
 123         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
 124
 125     def test_03_getOpenRoadmNetwork(self):
 126         url = ("{}/config/ietf-network:networks/network/openroadm-network"
 127               .format(self.restconf_baseurl))
 128         headers = {'content-type': 'application/json'}
 129         response = requests.request(
 130             "GET", url, headers=headers, auth=('admin', 'admin'))
 131         self.assertEqual(response.status_code, requests.codes.ok)
 132         res = response.json()
 133         self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA')
 134         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
 135         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
 136         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:node-type'],'ROADM')
 137         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'2')
 138
 139     def test_04_getLinks_OpenroadmTopology(self):
 140         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 141               .format(self.restconf_baseurl))
 142         headers = {'content-type': 'application/json'}
 143         response = requests.request(
 144             "GET", url, headers=headers, auth=('admin', 'admin'))
 145         self.assertEqual(response.status_code, requests.codes.ok)
 146         res = response.json()
 147         #Tests related to links
 148         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 149         self.assertEqual(nbLink,10)
 150         expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
 151         addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
 152                  'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
 153         dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
 154                   'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX']
 155         for i in range(0,nbLink):
 156             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 157             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='EXPRESS-LINK'):
 158                 find= linkId in expressLink
 159                 self.assertEqual(find, True)
 160                 expressLink.remove(linkId)
 161             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='ADD-LINK'):
 162                 find= linkId in addLink
 163                 self.assertEqual(find, True)
 164                 addLink.remove(linkId)
 165             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='DROP-LINK'):
 166                 find= linkId in dropLink
 167                 self.assertEqual(find, True)
 168                 dropLink.remove(linkId)
 169             else:
 170                 self.assertFalse(True)
 171         self.assertEqual(len(expressLink),0)
 172         self.assertEqual(len(addLink),0)
 173         self.assertEqual(len(dropLink),0)
 174
 175     def test_05_getNodes_OpenRoadmTopology(self):
 176         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 177               .format(self.restconf_baseurl))
 178         headers = {'content-type': 'application/json'}
 179         response = requests.request(
 180             "GET", url, headers=headers, auth=('admin', 'admin'))
 181         res = response.json()
 182         #Tests related to nodes
 183         self.assertEqual(response.status_code, requests.codes.ok)
 184         nbNode=len(res['network'][0]['node'])
 185         self.assertEqual(nbNode,4)
 186         listNode=['ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
 187         for i in range(0,nbNode):
 188             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 189                           res['network'][0]['node'][i]['supporting-node'])
 190             nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
 191             nodeId=res['network'][0]['node'][i]['node-id']
 192             if(nodeId=='ROADMA-SRG1'):
 193                 #Test related to SRG1
 194                 self.assertEqual(nodeType,'SRG')
 195                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 196                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 197                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 198                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 199                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 200                 listNode.remove(nodeId)
 201             elif(nodeId=='ROADMA-SRG3'):
 202                 #Test related to SRG1
 203                 self.assertEqual(nodeType,'SRG')
 204                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 205                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 206                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 207                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 208                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 209                 listNode.remove(nodeId)
 210             elif(nodeId=='ROADMA-DEG1'):
 211                 #Test related to DEG1
 212                 self.assertEqual(nodeType,'DEGREE')
 213                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 214                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 215                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 216                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 217                 listNode.remove(nodeId)
 218             elif(nodeId=='ROADMA-DEG2'):
 219                 #Test related to DEG2
 220                 self.assertEqual(nodeType,'DEGREE')
 221                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 222                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 223                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 224                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 225                 listNode.remove(nodeId)
 226             else:
 227                 self.assertFalse(True)
 228         self.assertEqual(len(listNode),0)
 229
 230     def test_06_connect_XPDRA(self):
 231          url = ("{}/config/network-topology:"
 232                  "network-topology/topology/topology-netconf/node/XPDRA"
 233                 .format(self.restconf_baseurl))
 234          data = {"node": [{
 235               "node-id": "XPDRA",
 236               "netconf-node-topology:username": "admin",
 237               "netconf-node-topology:password": "admin",
 238               "netconf-node-topology:host": "127.0.0.1",
 239               "netconf-node-topology:port": "17830",
 240               "netconf-node-topology:tcp-only": "false",
 241               "netconf-node-topology:pass-through": {}}]}
 242          headers = {'content-type': 'application/json'}
 243          response = requests.request(
 244               "PUT", url, data=json.dumps(data), headers=headers,
 245               auth=('admin', 'admin'))
 246          self.assertEqual(response.status_code, requests.codes.created)
 247          time.sleep(30)
 248
 249     def test_07_getClliNetwork(self):
 250          url = ("{}/config/ietf-network:networks/network/clli-network"
 251                .format(self.restconf_baseurl))
 252          headers = {'content-type': 'application/json'}
 253          response = requests.request(
 254              "GET", url, headers=headers, auth=('admin', 'admin'))
 255          self.assertEqual(response.status_code, requests.codes.ok)
 256          res = response.json()
 257          self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
 258          self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
 259
 260     def test_08_getOpenRoadmNetwork(self):
 261          url = ("{}/config/ietf-network:networks/network/openroadm-network"
 262                .format(self.restconf_baseurl))
 263          headers = {'content-type': 'application/json'}
 264          response = requests.request(
 265              "GET", url, headers=headers, auth=('admin', 'admin'))
 266          self.assertEqual(response.status_code, requests.codes.ok)
 267          res = response.json()
 268          nbNode=len(res['network'][0]['node'])
 269          self.assertEqual(nbNode,2)
 270          for i in range(0,nbNode):
 271              self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
 272              self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
 273              nodeId=res['network'][0]['node'][i]['node-id']
 274              if(nodeId=='XPDRA'):
 275                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'XPONDER')
 276                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
 277              elif(nodeId=='ROADMA'):
 278                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
 279                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
 280              else:
 281                 self.assertFalse(True)
 282
 283     def test_09_getNodes_OpenRoadmTopology(self):
 284          url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 285                .format(self.restconf_baseurl))
 286          headers = {'content-type': 'application/json'}
 287          response = requests.request(
 288              "GET", url, headers=headers, auth=('admin', 'admin'))
 289          res = response.json()
 290          #Tests related to nodes
 291          self.assertEqual(response.status_code, requests.codes.ok)
 292          nbNode=len(res['network'][0]['node'])
 293          self.assertEqual(nbNode,5)
 294          listNode=['XPDRA-XPDR1','ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
 295          for i in range(0,nbNode):
 296              nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
 297              nodeId=res['network'][0]['node'][i]['node-id']
 298              #Tests related to XPDRA nodes
 299              if(nodeId=='XPDRA-XPDR1'):
 300                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
 301                                res['network'][0]['node'][i]['supporting-node'])
 302                  self.assertEqual(nodeType,'XPONDER')
 303                  nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 304                  client = 0
 305                  network = 0
 306                  for j in range(0,nbTps):
 307                      tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-network-topology:tp-type']
 308                      tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
 309                      if (tpType=='XPONDER-CLIENT'):
 310                          client += 1
 311                      elif (tpType=='XPONDER-NETWORK'):
 312                          network += 1
 313                      if (tpId == 'XPDR1-NETWORK2'):
 314                          self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT3')
 315                      if (tpId == 'XPDR1-CLIENT3'):
 316                          self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
 317                  self.assertTrue(client == 4)
 318                  self.assertTrue(network == 2)
 319                  listNode.remove(nodeId)
 320              elif(nodeId=='ROADMA-SRG1'):
 321                  #Test related to SRG1
 322                  self.assertEqual(nodeType,'SRG')
 323                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 324                  self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 325                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 326                  self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 327                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 328                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 329                                res['network'][0]['node'][i]['supporting-node'])
 330                  listNode.remove(nodeId)
 331              elif(nodeId=='ROADMA-SRG3'):
 332                  #Test related to SRG1
 333                  self.assertEqual(nodeType,'SRG')
 334                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 335                  self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 336                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 337                  self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 338                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 339                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 340                                res['network'][0]['node'][i]['supporting-node'])
 341                  listNode.remove(nodeId)
 342              elif(nodeId=='ROADMA-DEG1'):
 343                 #Test related to DEG1
 344                 self.assertEqual(nodeType,'DEGREE')
 345                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 346                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 347                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 348                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 349                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 350                               res['network'][0]['node'][i]['supporting-node'])
 351                 listNode.remove(nodeId)
 352              elif(nodeId=='ROADMA-DEG2'):
 353                 #Test related to DEG2
 354                 self.assertEqual(nodeType,'DEGREE')
 355                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 356                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 357                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 358                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 359                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 360                               res['network'][0]['node'][i]['supporting-node'])
 361                 listNode.remove(nodeId)
 362              else:
 363                 self.assertFalse(True)
 364          self.assertEqual(len(listNode),0)
 365
 366     #Connect the tail XPDRA to ROADMA and vice versa
 367     def test_10_connect_tail_xpdr_rdm(self):
 368          #Connect the tail: XPDRA to ROADMA
 369         url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
 370                 .format(self.restconf_baseurl))
 371         data = {"networkutils:input": {
 372              "networkutils:links-input": {
 373                "networkutils:xpdr-node": "XPDRA",
 374                "networkutils:xpdr-num": "1",
 375                "networkutils:network-num": "1",
 376                "networkutils:rdm-node": "ROADMA",
 377                "networkutils:srg-num": "1",
 378                "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 379             }
 380           }
 381         }
 382         headers = {'content-type': 'application/json'}
 383         response = requests.request(
 384               "POST", url, data=json.dumps(data), headers=headers,
 385               auth=('admin', 'admin'))
 386         self.assertEqual(response.status_code, requests.codes.ok)
 387         time.sleep(10)
 388
 389     def test_11_connect_tail_rdm_xpdr(self):
 390          #Connect the tail: ROADMA to XPDRA
 391          url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
 392                  .format(self.restconf_baseurl))
 393          data = {"networkutils:input": {
 394               "networkutils:links-input": {
 395                 "networkutils:xpdr-node": "XPDRA",
 396                 "networkutils:xpdr-num": "1",
 397                 "networkutils:network-num": "1",
 398                 "networkutils:rdm-node": "ROADMA",
 399                 "networkutils:srg-num": "1",
 400                 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 401              }
 402             }
 403          }
 404          headers = {'content-type': 'application/json'}
 405          response = requests.request(
 406                "POST", url, data=json.dumps(data), headers=headers,
 407                auth=('admin', 'admin'))
 408          self.assertEqual(response.status_code, requests.codes.ok)
 409          time.sleep(10)
 410
 411     def test_12_getLinks_OpenRoadmTopology(self):
 412         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 413                .format(self.restconf_baseurl))
 414         headers = {'content-type': '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         #Tests related to links
 420         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 421         self.assertEqual(nbLink,12)
 422         expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
 423         addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
 424                  'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
 425         dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
 426                   'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX']
 427         XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
 428         XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
 429         for i in range(0,nbLink):
 430             nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
 431             linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 432             if(nodeType=='EXPRESS-LINK'):
 433                 find= linkId in expressLink
 434                 self.assertEqual(find, True)
 435                 expressLink.remove(linkId)
 436             elif(nodeType=='ADD-LINK'):
 437                 find= linkId in addLink
 438                 self.assertEqual(find, True)
 439                 addLink.remove(linkId)
 440             elif(nodeType=='DROP-LINK'):
 441                 find= linkId in dropLink
 442                 self.assertEqual(find, True)
 443                 dropLink.remove(linkId)
 444             elif(nodeType=='XPONDER-INPUT'):
 445                 find= linkId in XPDR_IN
 446                 self.assertEqual(find, True)
 447                 XPDR_IN.remove(linkId)
 448             elif(nodeType=='XPONDER-OUTPUT'):
 449                 find= linkId in XPDR_OUT
 450                 self.assertEqual(find, True)
 451                 XPDR_OUT.remove(linkId)
 452             else:
 453                 self.assertFalse(True)
 454         self.assertEqual(len(expressLink),0)
 455         self.assertEqual(len(addLink),0)
 456         self.assertEqual(len(dropLink),0)
 457         self.assertEqual(len(XPDR_IN),0)
 458         self.assertEqual(len(XPDR_OUT),0)
 459
 460     def test_13_connect_ROADMC(self):
 461         #Config ROADMC
 462         url = ("{}/config/network-topology:"
 463                 "network-topology/topology/topology-netconf/node/ROADMC"
 464                 .format(self.restconf_baseurl))
 465         data = {"node": [{
 466              "node-id": "ROADMC",
 467              "netconf-node-topology:username": "admin",
 468              "netconf-node-topology:password": "admin",
 469              "netconf-node-topology:host": "127.0.0.1",
 470              "netconf-node-topology:port": "17833",
 471              "netconf-node-topology:tcp-only": "false",
 472              "netconf-node-topology:pass-through": {}}]}
 473         headers = {'content-type': 'application/json'}
 474         response = requests.request(
 475              "PUT", url, data=json.dumps(data), headers=headers,
 476              auth=('admin', 'admin'))
 477         self.assertEqual(response.status_code, requests.codes.created)
 478         time.sleep(30)
 479
 480     def test_14_omsAttributes_ROADMA_ROADMC(self):
 481         # Config ROADMA-ROADMC oms-attributes
 482         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 483                "link/ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
 484                "OMS-attributes/span"
 485                .format(self.restconf_baseurl))
 486         data = {"span": {
 487             "clfi": "fiber1",
 488             "auto-spanloss": "true",
 489             "engineered-spanloss": 12.2,
 490             "link-concatenation": [{
 491                 "SRLG-Id": 0,
 492                 "fiber-type": "smf",
 493                 "SRLG-length": 100000,
 494                 "pmd": 0.5}]}}
 495         headers = {'content-type': 'application/json'}
 496         response = requests.request(
 497             "PUT", url, data=json.dumps(data), headers=headers,
 498             auth=('admin', 'admin'))
 499         self.assertEqual(response.status_code, requests.codes.created)
 500
 501     def test_15_omsAttributes_ROADMC_ROADMA(self):
 502         # Config ROADMC-ROADMA oms-attributes
 503         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 504                "link/ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
 505                "OMS-attributes/span"
 506                .format(self.restconf_baseurl))
 507         data = {"span": {
 508             "clfi": "fiber1",
 509             "auto-spanloss": "true",
 510             "engineered-spanloss": 12.2,
 511             "link-concatenation": [{
 512                 "SRLG-Id": 0,
 513                 "fiber-type": "smf",
 514                 "SRLG-length": 100000,
 515                 "pmd": 0.5}]}}
 516         headers = {'content-type': 'application/json'}
 517         response = requests.request(
 518             "PUT", url, data=json.dumps(data), headers=headers,
 519             auth=('admin', 'admin'))
 520         self.assertEqual(response.status_code, requests.codes.created)
 521
 522     def test_16_getClliNetwork(self):
 523         url = ("{}/config/ietf-network:networks/network/clli-network"
 524               .format(self.restconf_baseurl))
 525         headers = {'content-type': 'application/json'}
 526         response = requests.request(
 527             "GET", url, headers=headers, auth=('admin', 'admin'))
 528         self.assertEqual(response.status_code, requests.codes.ok)
 529         res = response.json()
 530         nbNode=len(res['network'][0]['node'])
 531         listNode=['NodeA','NodeC']
 532         for i in range(0,nbNode):
 533             nodeId = res['network'][0]['node'][i]['node-id']
 534             find= nodeId in listNode
 535             self.assertEqual(find, True)
 536             if(nodeId=='NodeA'):
 537                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
 538             else:
 539                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
 540             listNode.remove(nodeId)
 541
 542         self.assertEqual(len(listNode),0)
 543
 544     def test_17_getOpenRoadmNetwork(self):
 545         url = ("{}/config/ietf-network:networks/network/openroadm-network"
 546               .format(self.restconf_baseurl))
 547         headers = {'content-type': 'application/json'}
 548         response = requests.request(
 549             "GET", url, headers=headers, auth=('admin', 'admin'))
 550         self.assertEqual(response.status_code, requests.codes.ok)
 551         res = response.json()
 552         nbNode=len(res['network'][0]['node'])
 553         self.assertEqual(nbNode,3)
 554         listNode=['XPDRA','ROADMA','ROADMC']
 555         for i in range(0,nbNode):
 556             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
 557             nodeId=res['network'][0]['node'][i]['node-id']
 558             if(nodeId=='XPDRA'):
 559                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
 560                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'XPONDER')
 561                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
 562                 listNode.remove(nodeId)
 563             elif(nodeId=='ROADMA'):
 564                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
 565                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
 566                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
 567                 listNode.remove(nodeId)
 568             elif(nodeId=='ROADMC'):
 569                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
 570                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
 571                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
 572                 listNode.remove(nodeId)
 573             else:
 574                 self.assertFalse(True)
 575         self.assertEqual(len(listNode),0)
 576
 577     def test_18_getROADMLinkOpenRoadmTopology(self):
 578         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 579               .format(self.restconf_baseurl))
 580         headers = {'content-type': 'application/json'}
 581         response = requests.request(
 582             "GET", url, headers=headers, auth=('admin', 'admin'))
 583         self.assertEqual(response.status_code, requests.codes.ok)
 584         res = response.json()
 585         #Tests related to links
 586         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 587         self.assertEqual(nbLink,20)
 588         expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX',
 589                      'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX','ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX']
 590         addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
 591                  'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
 592                  'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX','ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX']
 593         dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
 594                   'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX',
 595                   'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX','ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX']
 596         R2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX']
 597         XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
 598         XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
 599         for i in range(0,nbLink):
 600             nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
 601             linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 602             if(nodeType=='EXPRESS-LINK'):
 603                 find= linkId in expressLink
 604                 self.assertEqual(find, True)
 605                 expressLink.remove(linkId)
 606             elif(nodeType=='ADD-LINK'):
 607                 find= linkId in addLink
 608                 self.assertEqual(find, True)
 609                 addLink.remove(linkId)
 610             elif(nodeType=='DROP-LINK'):
 611                 find= linkId in dropLink
 612                 self.assertEqual(find, True)
 613                 dropLink.remove(linkId)
 614             elif(nodeType=='ROADM-TO-ROADM'):
 615                 find= linkId in R2RLink
 616                 self.assertEqual(find, True)
 617                 R2RLink.remove(linkId)
 618             elif(nodeType=='XPONDER-INPUT'):
 619                 find= linkId in XPDR_IN
 620                 self.assertEqual(find, True)
 621                 XPDR_IN.remove(linkId)
 622             elif(nodeType=='XPONDER-OUTPUT'):
 623                 find= linkId in XPDR_OUT
 624                 self.assertEqual(find, True)
 625                 XPDR_OUT.remove(linkId)
 626             else:
 627                 self.assertFalse(True)
 628         self.assertEqual(len(expressLink),0)
 629         self.assertEqual(len(addLink),0)
 630         self.assertEqual(len(dropLink),0)
 631         self.assertEqual(len(R2RLink),0)
 632         self.assertEqual(len(XPDR_IN),0)
 633         self.assertEqual(len(XPDR_OUT),0)
 634
 635     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
 636         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 637               .format(self.restconf_baseurl))
 638         headers = {'content-type': 'application/json'}
 639         response = requests.request(
 640             "GET", url, headers=headers, auth=('admin', 'admin'))
 641         self.assertEqual(response.status_code, requests.codes.ok)
 642         res = response.json()
 643         #Tests related to links
 644         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 645         self.assertEqual(nbLink,20)
 646         R2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX',
 647                  'ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX']
 648         for i in range(0,nbLink):
 649             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
 650             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 651             if(link_id in R2RLink):
 652                 find = False
 653                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 654                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 655                 length = res['network'][0]['ietf-network-topology:link'][i][
 656                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 657                 if((spanLoss!=None)&(length!=None)):
 658                     find = True
 659                 self.assertTrue(find)
 660                 R2RLink.remove(link_id)
 661         self.assertEqual(len(R2RLink),0)
 662
 663     def test_20_getNodes_OpenRoadmTopology(self):
 664          url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 665                .format(self.restconf_baseurl))
 666          headers = {'content-type': 'application/json'}
 667          response = requests.request(
 668              "GET", url, headers=headers, auth=('admin', 'admin'))
 669          res = response.json()
 670          #Tests related to nodes
 671          self.assertEqual(response.status_code, requests.codes.ok)
 672          nbNode=len(res['network'][0]['node'])
 673          self.assertEqual(nbNode,8)
 674          listNode=['XPDRA-XPDR1',
 675                    'ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2',
 676                    'ROADMC-SRG1','ROADMC-DEG1','ROADMC-DEG2']
 677          #************************Tests related to XPDRA nodes
 678          for i in range(0,nbNode):
 679              nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
 680              nodeId=res['network'][0]['node'][i]['node-id']
 681              if(nodeId=='XPDRA-XPDR1'):
 682                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
 683                                res['network'][0]['node'][i]['supporting-node'])
 684                  self.assertEqual(nodeType,'XPONDER')
 685                  nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 686                  self.assertTrue(nbTps == 6)
 687                  client = 0
 688                  network = 0
 689                  for j in range(0,nbTps):
 690                      tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-network-topology:tp-type']
 691                      if (tpType=='XPONDER-CLIENT'):
 692                          client += 1
 693                      elif (tpType=='XPONDER-NETWORK'):
 694                          network += 1
 695                  self.assertTrue(client == 4)
 696                  self.assertTrue(network == 2)
 697                  listNode.remove(nodeId)
 698              elif(nodeId=='ROADMA-SRG1'):
 699                  #Test related to SRG1
 700                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 701                  self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 702                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 703                  self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 704                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 705                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 706                                res['network'][0]['node'][i]['supporting-node'])
 707                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
 708                  listNode.remove(nodeId)
 709              elif(nodeId=='ROADMA-SRG3'):
 710                  #Test related to SRG1
 711                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 712                  self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 713                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 714                  self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 715                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 716                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 717                                res['network'][0]['node'][i]['supporting-node'])
 718                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
 719                  listNode.remove(nodeId)
 720              elif(nodeId=='ROADMA-DEG1'):
 721                  #Test related to DEG1
 722                  self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 723                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 724                  self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 725                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 726                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 727                                res['network'][0]['node'][i]['supporting-node'])
 728                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
 729                  listNode.remove(nodeId)
 730              elif(nodeId=='ROADMA-DEG2'):
 731                  #Test related to DEG2
 732                  self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 733                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 734                  self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 735                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 736                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 737                                res['network'][0]['node'][i]['supporting-node'])
 738                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
 739                  listNode.remove(nodeId)
 740              elif(nodeId=='ROADMC-SRG1'):
 741                  #Test related to SRG1
 742                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 743                  self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 744                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 745                  self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 746                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 747                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
 748                                res['network'][0]['node'][i]['supporting-node'])
 749                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
 750                  listNode.remove(nodeId)
 751              elif(nodeId=='ROADMC-DEG1'):
 752                  #Test related to DEG1
 753                  self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 754                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 755                  self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 756                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 757                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
 758                                res['network'][0]['node'][i]['supporting-node'])
 759                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
 760                  listNode.remove(nodeId)
 761              elif(nodeId=='ROADMC-DEG2'):
 762                  #Test related to DEG2
 763                  self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 764                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 765                  self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 766                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 767                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
 768                                res['network'][0]['node'][i]['supporting-node'])
 769                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
 770                  listNode.remove(nodeId)
 771              else:
 772                 self.assertFalse(True)
 773          self.assertEqual(len(listNode),0)
 774
 775     def test_21_connect_ROADMB(self):
 776         url = ("{}/config/network-topology:"
 777                 "network-topology/topology/topology-netconf/node/ROADMB"
 778                .format(self.restconf_baseurl))
 779         data = {"node": [{
 780              "node-id": "ROADMB",
 781              "netconf-node-topology:username": "admin",
 782              "netconf-node-topology:password": "admin",
 783              "netconf-node-topology:host": "127.0.0.1",
 784              "netconf-node-topology:port": "17832",
 785              "netconf-node-topology:tcp-only": "false",
 786              "netconf-node-topology:pass-through": {}}]}
 787         headers = {'content-type': 'application/json'}
 788         response = requests.request(
 789              "PUT", url, data=json.dumps(data), headers=headers,
 790              auth=('admin', 'admin'))
 791         self.assertEqual(response.status_code, requests.codes.created)
 792         time.sleep(30)
 793
 794     def test_22_omsAttributes_ROADMA_ROADMB(self):
 795         # Config ROADMA-ROADMB oms-attributes
 796         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 797                "link/ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
 798                "OMS-attributes/span"
 799                .format(self.restconf_baseurl))
 800         data = {"span": {
 801                 "clfi": "fiber1",
 802                 "auto-spanloss": "true",
 803                 "engineered-spanloss": 12.2,
 804                 "link-concatenation": [{
 805                     "SRLG-Id": 0,
 806                     "fiber-type": "smf",
 807                     "SRLG-length": 100000,
 808                     "pmd": 0.5}]}}
 809         headers = {'content-type': 'application/json'}
 810         response = requests.request(
 811                 "PUT", url, data=json.dumps(data), headers=headers,
 812                 auth=('admin', 'admin'))
 813         self.assertEqual(response.status_code, requests.codes.created)
 814
 815     def test_23_omsAttributes_ROADMB_ROADMA(self):
 816         # Config ROADMB-ROADMA oms-attributes
 817         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 818                "link/ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
 819                "OMS-attributes/span"
 820                .format(self.restconf_baseurl))
 821         data = {"span": {
 822                 "clfi": "fiber1",
 823                 "auto-spanloss": "true",
 824                 "engineered-spanloss": 12.2,
 825                 "link-concatenation": [{
 826                     "SRLG-Id": 0,
 827                     "fiber-type": "smf",
 828                     "SRLG-length": 100000,
 829                     "pmd": 0.5}]}}
 830         headers = {'content-type': 'application/json'}
 831         response = requests.request(
 832                 "PUT", url, data=json.dumps(data), headers=headers,
 833                 auth=('admin', 'admin'))
 834         self.assertEqual(response.status_code, requests.codes.created)
 835
 836     def test_24_omsAttributes_ROADMB_ROADMC(self):
 837         # Config ROADMB-ROADMC oms-attributes
 838         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 839                "link/ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
 840                "OMS-attributes/span"
 841                .format(self.restconf_baseurl))
 842         data = {"span": {
 843                 "clfi": "fiber1",
 844                 "auto-spanloss": "true",
 845                 "engineered-spanloss": 12.2,
 846                 "link-concatenation": [{
 847                     "SRLG-Id": 0,
 848                     "fiber-type": "smf",
 849                     "SRLG-length": 100000,
 850                     "pmd": 0.5}]}}
 851         headers = {'content-type': 'application/json'}
 852         response = requests.request(
 853                 "PUT", url, data=json.dumps(data), headers=headers,
 854                 auth=('admin', 'admin'))
 855         self.assertEqual(response.status_code, requests.codes.created)
 856
 857     def test_25_omsAttributes_ROADMC_ROADMB(self):
 858         # Config ROADMC-ROADMB oms-attributes
 859         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 860                "link/ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
 861                "OMS-attributes/span"
 862                .format(self.restconf_baseurl))
 863         data = {"span": {
 864                 "clfi": "fiber1",
 865                 "auto-spanloss": "true",
 866                 "engineered-spanloss": 12.2,
 867                 "link-concatenation": [{
 868                     "SRLG-Id": 0,
 869                     "fiber-type": "smf",
 870                     "SRLG-length": 100000,
 871                     "pmd": 0.5}]}}
 872         headers = {'content-type': 'application/json'}
 873         response = requests.request(
 874                 "PUT", url, data=json.dumps(data), headers=headers,
 875                 auth=('admin', 'admin'))
 876         self.assertEqual(response.status_code, requests.codes.created)
 877
 878     def test_26_getClliNetwork(self):
 879         url = ("{}/config/ietf-network:networks/network/clli-network"
 880               .format(self.restconf_baseurl))
 881         headers = {'content-type': 'application/json'}
 882         response = requests.request(
 883             "GET", url, headers=headers, auth=('admin', 'admin'))
 884         self.assertEqual(response.status_code, requests.codes.ok)
 885         res = response.json()
 886         nbNode=len(res['network'][0]['node'])
 887         listNode=['NodeA','NodeB','NodeC']
 888         for i in range(0,nbNode):
 889             nodeId = res['network'][0]['node'][i]['node-id']
 890             find= nodeId in listNode
 891             self.assertEqual(find, True)
 892             if(nodeId=='NodeA'):
 893                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
 894             elif(nodeId=='NodeB'):
 895                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
 896             else:
 897                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
 898             listNode.remove(nodeId)
 899
 900         self.assertEqual(len(listNode),0)
 901
 902     def test_27_verifyDegree(self):
 903         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 904               .format(self.restconf_baseurl))
 905         headers = {'content-type': 'application/json'}
 906         response = requests.request(
 907             "GET", url, headers=headers, auth=('admin', 'admin'))
 908         self.assertEqual(response.status_code, requests.codes.ok)
 909         res = response.json()
 910         #Tests related to links
 911         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 912         listR2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX',
 913            'ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
 914            'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX']
 915         for i in range(0,nbLink):
 916             if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'] == 'ROADM-TO-ROADM':
 917                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 918                 find= link_id in listR2RLink
 919                 self.assertEqual(find, True)
 920                 listR2RLink.remove(link_id)
 921         self.assertEqual(len(listR2RLink),0)
 922
 923     def test_28_verifyOppositeLinkTopology(self):
 924         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 925                .format(self.restconf_baseurl))
 926         headers = {'content-type': 'application/json'}
 927         response = requests.request(
 928              "GET", url, headers=headers, auth=('admin', 'admin'))
 929         self.assertEqual(response.status_code, requests.codes.ok)
 930         res = response.json()
 931         #Tests related to links
 932         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 933         self.assertEqual(nbLink,34)
 934         for i in range(0,nbLink):
 935             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 936             link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
 937             link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
 938             link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
 939             oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
 940             #Find the opposite link
 941             url_oppLink="{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
 942             url = (url_oppLink.format(self.restconf_baseurl))
 943             headers = {'content-type': 'application/json'}
 944             response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
 945             self.assertEqual(response_oppLink.status_code, requests.codes.ok)
 946             res_oppLink = response_oppLink.json()
 947             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
 948             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
 949             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
 950             oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type']
 951             if link_type=='ADD-LINK':
 952                 self.assertEqual(oppLink_type, 'DROP-LINK')
 953             elif link_type=='DROP-LINK':
 954                 self.assertEqual(oppLink_type, 'ADD-LINK')
 955             elif link_type=='EXPRESS-LINK':
 956                 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
 957             elif link_type=='ROADM-TO-ROADM':
 958                 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
 959             elif link_type=='XPONDER-INPUT':
 960                 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
 961             elif link_type=='XPONDER-OUTPUT':
 962                 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
 963         time.sleep(5)
 964
 965     def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
 966         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 967               .format(self.restconf_baseurl))
 968         headers = {'content-type': 'application/json'}
 969         response = requests.request(
 970             "GET", url, headers=headers, auth=('admin', 'admin'))
 971         self.assertEqual(response.status_code, requests.codes.ok)
 972         res = response.json()
 973         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 974         R2RLink = ['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX',
 975                        'ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX',
 976                        'ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX',
 977                        'ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
 978                        'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX',
 979                        'ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX']
 980         for i in range(0,nbLink):
 981             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
 982             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 983             if(link_id in R2RLink):
 984                 find = False
 985                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 986                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 987                 length = res['network'][0]['ietf-network-topology:link'][i][
 988                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 989                 if((spanLoss!=None)&(length!=None)):
 990                     find = True
 991                 self.assertTrue(find)
 992                 R2RLink.remove(link_id)
 993         self.assertEqual(len(R2RLink),0)
 994
 995     def test_30_disconnect_ROADMB(self):
 996         #Delete in the topology-netconf
 997         url = ("{}/config/network-topology:"
 998                 "network-topology/topology/topology-netconf/node/ROADMB"
 999                .format(self.restconf_baseurl))
1000         data = {}
1001         headers = {'content-type': 'application/json'}
1002         response = requests.request(
1003              "DELETE", url, data=json.dumps(data), headers=headers,
1004              auth=('admin', 'admin'))
1005         self.assertEqual(response.status_code, requests.codes.ok)
1006         #Delete in the clli-network
1007         url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
1008                .format(self.restconf_baseurl))
1009         data = {}
1010         headers = {'content-type': 'application/json'}
1011         response = requests.request(
1012              "DELETE", url, data=json.dumps(data), headers=headers,
1013              auth=('admin', 'admin'))
1014         self.assertEqual(response.status_code, requests.codes.ok)
1015
1016     def test_31_disconnect_ROADMC(self):
1017         #Delete in the topology-netconf
1018         url = ("{}/config/network-topology:"
1019                 "network-topology/topology/topology-netconf/node/ROADMC"
1020                .format(self.restconf_baseurl))
1021         data = {}
1022         headers = {'content-type': 'application/json'}
1023         response = requests.request(
1024              "DELETE", url, data=json.dumps(data), headers=headers,
1025              auth=('admin', 'admin'))
1026         self.assertEqual(response.status_code, requests.codes.ok)
1027         #Delete in the clli-network
1028         url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
1029                .format(self.restconf_baseurl))
1030         data = {}
1031         headers = {'content-type': 'application/json'}
1032         response = requests.request(
1033              "DELETE", url, data=json.dumps(data), headers=headers,
1034              auth=('admin', 'admin'))
1035         self.assertEqual(response.status_code, requests.codes.ok)
1036
1037     def test_32_getNodes_OpenRoadmTopology(self):
1038         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1039               .format(self.restconf_baseurl))
1040         headers = {'content-type': 'application/json'}
1041         response = requests.request(
1042             "GET", url, headers=headers, auth=('admin', 'admin'))
1043         res = response.json()
1044         #Tests related to nodes
1045         self.assertEqual(response.status_code, requests.codes.ok)
1046         nbNode=len(res['network'][0]['node'])
1047         self.assertEqual(nbNode,5)
1048         listNode=['XPDRA-XPDR1','ROADMA-SRG1', 'ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
1049         for i in range(0,nbNode):
1050             nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
1051             nodeId=res['network'][0]['node'][i]['node-id']
1052             #Tests related to XPDRA nodes
1053             if(nodeId=='XPDRA-XPDR1'):
1054                 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1055                 for j in range(0, nbTp):
1056                     tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
1057                     if (tpid == 'XPDR1-CLIENT1'):
1058                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1059                                          ['org-openroadm-network-topology:tp-type'], 'XPONDER-CLIENT')
1060                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1061                                          ['org-openroadm-network-topology:xpdr-client-attributes']['tail-equipment-id'],
1062                                          'XPDR1-NETWORK1')
1063                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
1064                     res['network'][0]['node'][i]['supporting-node'])
1065                 listNode.remove(nodeId)
1066             elif(nodeId=='ROADMA-SRG1'):
1067                 #Test related to SRG1
1068                 self.assertEqual(nodeType,'SRG')
1069                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1070                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1071                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1072                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1073                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1074                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1075                               res['network'][0]['node'][i]['supporting-node'])
1076                 listNode.remove(nodeId)
1077             elif(nodeId=='ROADMA-SRG3'):
1078                 #Test related to SRG1
1079                 self.assertEqual(nodeType,'SRG')
1080                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1081                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1082                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1083                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1084                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1085                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1086                               res['network'][0]['node'][i]['supporting-node'])
1087                 listNode.remove(nodeId)
1088             elif(nodeId=='ROADMA-DEG1'):
1089                 #Test related to DEG1
1090                 self.assertEqual(nodeType,'DEGREE')
1091                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1092                     res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1093                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1094                     res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1095                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1096                     res['network'][0]['node'][i]['supporting-node'])
1097                 listNode.remove(nodeId)
1098             elif(nodeId=='ROADMA-DEG2'):
1099                 #Test related to DEG2
1100                 self.assertEqual(nodeType,'DEGREE')
1101                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1102                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1103                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1104                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1105                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1106                               res['network'][0]['node'][i]['supporting-node'])
1107                 listNode.remove(nodeId)
1108             else:
1109                 self.assertFalse(True)
1110         self.assertEqual(len(listNode),0)
1111         #Test related to SRG1 of ROADMC
1112         for i in range(0,nbNode):
1113             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-SRG1')
1114             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG1')
1115             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG2')
1116
1117     def test_33_getOpenRoadmNetwork(self):
1118         url = ("{}/config/ietf-network:networks/network/openroadm-network"
1119               .format(self.restconf_baseurl))
1120         headers = {'content-type': 'application/json'}
1121         response = requests.request(
1122             "GET", url, headers=headers, auth=('admin', 'admin'))
1123         self.assertEqual(response.status_code, requests.codes.ok)
1124         res = response.json()
1125         nbNode=len(res['network'][0]['node'])
1126         self.assertEqual(nbNode,2)
1127         for i in range(0,nbNode-1):
1128             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC')
1129             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB')
1130
1131     def test_34_getClliNetwork(self):
1132         url = ("{}/config/ietf-network:networks/network/clli-network"
1133               .format(self.restconf_baseurl))
1134         headers = {'content-type': 'application/json'}
1135         response = requests.request(
1136             "GET", url, headers=headers, auth=('admin', 'admin'))
1137         self.assertEqual(response.status_code, requests.codes.ok)
1138         res = response.json()
1139         nbNode=len(res['network'][0]['node'])
1140         self.assertEqual(nbNode,1)
1141         for i in range(0,nbNode-1):
1142             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
1143
1144     def test_35_disconnect_XPDRA(self):
1145         url = ("{}/config/network-topology:"
1146                "network-topology/topology/topology-netconf/node/XPDRA"
1147               .format(self.restconf_baseurl))
1148         data = {}
1149         headers = {'content-type': 'application/json'}
1150         response = requests.request(
1151             "DELETE", url, data=json.dumps(data), headers=headers,
1152             auth=('admin', 'admin'))
1153         self.assertEqual(response.status_code, requests.codes.ok)
1154
1155     def test_36_getClliNetwork(self):
1156         url = ("{}/config/ietf-network:networks/network/clli-network"
1157               .format(self.restconf_baseurl))
1158         headers = {'content-type': 'application/json'}
1159         response = requests.request(
1160             "GET", url, headers=headers, auth=('admin', 'admin'))
1161         self.assertEqual(response.status_code, requests.codes.ok)
1162         res = response.json()
1163         nbNode=len(res['network'][0]['node'])
1164         self.assertEqual(nbNode,1)
1165         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
1166
1167     def test_37_getOpenRoadmNetwork(self):
1168         url = ("{}/config/ietf-network:networks/network/openroadm-network"
1169               .format(self.restconf_baseurl))
1170         headers = {'content-type': 'application/json'}
1171         response = requests.request(
1172             "GET", url, headers=headers, auth=('admin', 'admin'))
1173         self.assertEqual(response.status_code, requests.codes.ok)
1174         res = response.json()
1175         nbNode=len(res['network'][0]['node'])
1176         self.assertEqual(nbNode,1)
1177         for i in range(0,nbNode):
1178             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA')
1179
1180     def test_38_getNodes_OpenRoadmTopology(self):
1181         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1182               .format(self.restconf_baseurl))
1183         headers = {'content-type': 'application/json'}
1184         response = requests.request(
1185             "GET", url, headers=headers, auth=('admin', 'admin'))
1186         res = response.json()
1187         #Tests related to nodes
1188         self.assertEqual(response.status_code, requests.codes.ok)
1189         nbNode=len(res['network'][0]['node'])
1190         self.assertEqual(nbNode,4)
1191         listNode=['ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
1192         for i in range(0,nbNode):
1193             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1194                           res['network'][0]['node'][i]['supporting-node'])
1195             nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
1196             nodeId=res['network'][0]['node'][i]['node-id']
1197             if(nodeId=='ROADMA-SRG1'):
1198                 #Test related to SRG1
1199                 self.assertEqual(nodeType,'SRG')
1200                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1201                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1202                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1203                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1204                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1205                 listNode.remove(nodeId)
1206             elif(nodeId=='ROADMA-SRG3'):
1207                 #Test related to SRG1
1208                 self.assertEqual(nodeType,'SRG')
1209                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1210                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1211                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1212                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1213                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1214                 listNode.remove(nodeId)
1215             elif(nodeId=='ROADMA-DEG1'):
1216                 #Test related to DEG1
1217                 self.assertEqual(nodeType,'DEGREE')
1218                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1219                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1220                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1221                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1222                 listNode.remove(nodeId)
1223             elif(nodeId=='ROADMA-DEG2'):
1224                 #Test related to DEG2
1225                 self.assertEqual(nodeType,'DEGREE')
1226                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1227                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1228                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1229                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1230                 listNode.remove(nodeId)
1231             else:
1232                 self.assertFalse(True)
1233         self.assertEqual(len(listNode),0)
1234
1235     def test_39_disconnect_ROADM_XPDRA_link(self):
1236         #Link-1
1237         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1238                "link/XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX"
1239                 .format(self.restconf_baseurl))
1240         data = {}
1241         headers = {'content-type': 'application/json'}
1242         response = requests.request(
1243              "DELETE", url, data=json.dumps(data), headers=headers,
1244              auth=('admin', 'admin'))
1245         self.assertEqual(response.status_code, requests.codes.ok)
1246         #Link-2
1247         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1248                "link/ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1"
1249                 .format(self.restconf_baseurl))
1250         data = {}
1251         headers = {'content-type': 'application/json'}
1252         response = requests.request(
1253              "DELETE", url, data=json.dumps(data), headers=headers,
1254              auth=('admin', 'admin'))
1255         self.assertEqual(response.status_code, requests.codes.ok)
1256
1257     def test_40_getLinks_OpenRoadmTopology(self):
1258         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1259               .format(self.restconf_baseurl))
1260         headers = {'content-type': 'application/json'}
1261         response = requests.request(
1262             "GET", url, headers=headers, auth=('admin', 'admin'))
1263         self.assertEqual(response.status_code, requests.codes.ok)
1264         res = response.json()
1265         nbLink=len(res['network'][0]['ietf-network-topology:link'])
1266         self.assertEqual(nbLink,16)
1267         expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
1268         addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
1269                  'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
1270         dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
1271                   'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX']
1272         roadmtoroadmLink = 0
1273         for i in range(0,nbLink):
1274             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='EXPRESS-LINK'):
1275                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1276                 find= link_id in expressLink
1277                 self.assertEqual(find, True)
1278                 expressLink.remove(link_id)
1279             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='ADD-LINK'):
1280                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1281                 find= link_id in addLink
1282                 self.assertEqual(find, True)
1283                 addLink.remove(link_id)
1284             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='DROP-LINK'):
1285                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1286                 find= link_id in dropLink
1287                 self.assertEqual(find, True)
1288                 dropLink.remove(link_id)
1289             else:
1290                 roadmtoroadmLink += 1
1291         self.assertEqual(len(expressLink),0)
1292         self.assertEqual(len(addLink),0)
1293         self.assertEqual(len(dropLink),0)
1294         self.assertEqual(roadmtoroadmLink, 6)
1295         for i in range(0,nbLink):
1296             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
1297             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
1298
1299     def test_41_disconnect_ROADMA(self):
1300         url = ("{}/config/network-topology:"
1301                 "network-topology/topology/topology-netconf/node/ROADMA"
1302                .format(self.restconf_baseurl))
1303         data = {}
1304         headers = {'content-type': 'application/json'}
1305         response = requests.request(
1306              "DELETE", url, data=json.dumps(data), headers=headers,
1307              auth=('admin', 'admin'))
1308         self.assertEqual(response.status_code, requests.codes.ok)
1309         #Delete in the clli-network
1310         url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1311                .format(self.restconf_baseurl))
1312         data = {}
1313         headers = {'content-type': 'application/json'}
1314         response = requests.request(
1315              "DELETE", url, data=json.dumps(data), headers=headers,
1316              auth=('admin', 'admin'))
1317         self.assertEqual(response.status_code, requests.codes.ok)
1318
1319     def test_42_getClliNetwork(self):
1320         url = ("{}/config/ietf-network:networks/network/clli-network"
1321               .format(self.restconf_baseurl))
1322         headers = {'content-type': 'application/json'}
1323         response = requests.request(
1324             "GET", url, headers=headers, auth=('admin', 'admin'))
1325         self.assertEqual(response.status_code, requests.codes.ok)
1326         res = response.json()
1327         self.assertNotIn('node', res['network'][0])
1328
1329     def test_43_getOpenRoadmNetwork(self):
1330         url = ("{}/config/ietf-network:networks/network/openroadm-network"
1331               .format(self.restconf_baseurl))
1332         headers = {'content-type': 'application/json'}
1333         response = requests.request(
1334             "GET", url, headers=headers, auth=('admin', 'admin'))
1335         self.assertEqual(response.status_code, requests.codes.ok)
1336         res = response.json()
1337         self.assertNotIn('node', res['network'][0])
1338
1339     def test_44_check_roadm2roadm_link_persistence(self):
1340         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1341               .format(self.restconf_baseurl))
1342         headers = {'content-type': 'application/json'}
1343         response = requests.request(
1344             "GET", url, headers=headers, auth=('admin', 'admin'))
1345         self.assertEqual(response.status_code, requests.codes.ok)
1346         res = response.json()
1347         nbLink=len(res['network'][0]['ietf-network-topology:link'])
1348         self.assertNotIn('node', res['network'][0])
1349         self.assertEqual(nbLink, 6)
1350
1351 if __name__ == "__main__":
1352     unittest.main(verbosity=2)