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