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 ROADMA-ROADMC 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             "clfi": "fiber1",
 504             "auto-spanloss": "true",
 505             "engineered-spanloss": 12.2,
 506             "link-concatenation": [{
 507                 "SRLG-Id": 0,
 508                 "fiber-type": "smf",
 509                 "SRLG-length": 100000,
 510                 "pmd": 0.5}]}}
 511         headers = {'content-type': 'application/json'}
 512         response = requests.request(
 513             "PUT", url, data=json.dumps(data), headers=headers,
 514             auth=('admin', 'admin'))
 515         self.assertEqual(response.status_code, requests.codes.created)
 516
 517     def test_15_omsAttributes_ROADMC_ROADMA(self):
 518         # Config ROADMC01-ROADMA oms-attributes
 519         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 520                "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
 521                "OMS-attributes/span"
 522                .format(self.restconf_baseurl))
 523         data = {"span": {
 524             "clfi": "fiber1",
 525             "auto-spanloss": "true",
 526             "engineered-spanloss": 12.2,
 527             "link-concatenation": [{
 528                 "SRLG-Id": 0,
 529                 "fiber-type": "smf",
 530                 "SRLG-length": 100000,
 531                 "pmd": 0.5}]}}
 532         headers = {'content-type': 'application/json'}
 533         response = requests.request(
 534             "PUT", url, data=json.dumps(data), headers=headers,
 535             auth=('admin', 'admin'))
 536         self.assertEqual(response.status_code, requests.codes.created)
 537
 538     def test_16_getClliNetwork(self):
 539         url = ("{}/config/ietf-network:networks/network/clli-network"
 540               .format(self.restconf_baseurl))
 541         headers = {'content-type': 'application/json'}
 542         response = requests.request(
 543             "GET", url, headers=headers, auth=('admin', 'admin'))
 544         self.assertEqual(response.status_code, requests.codes.ok)
 545         res = response.json()
 546         nbNode=len(res['network'][0]['node'])
 547         listNode=['NodeA','NodeC']
 548         for i in range(0,nbNode):
 549             nodeId = res['network'][0]['node'][i]['node-id']
 550             find= nodeId in listNode
 551             self.assertEqual(find, True)
 552             if(nodeId=='NodeA'):
 553                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
 554             else:
 555                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
 556             listNode.remove(nodeId)
 557
 558         self.assertEqual(len(listNode),0)
 559
 560     def test_17_getOpenRoadmNetwork(self):
 561         url = ("{}/config/ietf-network:networks/network/openroadm-network"
 562               .format(self.restconf_baseurl))
 563         headers = {'content-type': 'application/json'}
 564         response = requests.request(
 565             "GET", url, headers=headers, auth=('admin', 'admin'))
 566         self.assertEqual(response.status_code, requests.codes.ok)
 567         res = response.json()
 568         nbNode=len(res['network'][0]['node'])
 569         self.assertEqual(nbNode,3)
 570         listNode=['XPDRA01','ROADMA01','ROADMC01']
 571         for i in range(0,nbNode):
 572             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
 573             nodeId=res['network'][0]['node'][i]['node-id']
 574             if(nodeId=='XPDRA01'):
 575                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
 576                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
 577                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
 578                 listNode.remove(nodeId)
 579             elif(nodeId=='ROADMA01'):
 580                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
 581                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
 582                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
 583                 listNode.remove(nodeId)
 584             elif(nodeId=='ROADMC01'):
 585                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
 586                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
 587                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
 588                 listNode.remove(nodeId)
 589             else:
 590                 self.assertFalse(True)
 591         self.assertEqual(len(listNode),0)
 592
 593     def test_18_getROADMLinkOpenRoadmTopology(self):
 594         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 595               .format(self.restconf_baseurl))
 596         headers = {'content-type': 'application/json'}
 597         response = requests.request(
 598             "GET", url, headers=headers, auth=('admin', 'admin'))
 599         self.assertEqual(response.status_code, requests.codes.ok)
 600         res = response.json()
 601         #Tests related to links
 602         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 603         self.assertEqual(nbLink,20)
 604         expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
 605                      'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX','ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
 606         addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
 607                  'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
 608                  'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX','ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
 609         dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
 610                   'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
 611                   'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX','ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
 612         R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
 613         XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
 614         XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
 615         for i in range(0,nbLink):
 616             nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 617             linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 618             if(nodeType=='EXPRESS-LINK'):
 619                 find= linkId in expressLink
 620                 self.assertEqual(find, True)
 621                 expressLink.remove(linkId)
 622             elif(nodeType=='ADD-LINK'):
 623                 find= linkId in addLink
 624                 self.assertEqual(find, True)
 625                 addLink.remove(linkId)
 626             elif(nodeType=='DROP-LINK'):
 627                 find= linkId in dropLink
 628                 self.assertEqual(find, True)
 629                 dropLink.remove(linkId)
 630             elif(nodeType=='ROADM-TO-ROADM'):
 631                 find= linkId in R2RLink
 632                 self.assertEqual(find, True)
 633                 R2RLink.remove(linkId)
 634             elif(nodeType=='XPONDER-INPUT'):
 635                 find= linkId in XPDR_IN
 636                 self.assertEqual(find, True)
 637                 XPDR_IN.remove(linkId)
 638             elif(nodeType=='XPONDER-OUTPUT'):
 639                 find= linkId in XPDR_OUT
 640                 self.assertEqual(find, True)
 641                 XPDR_OUT.remove(linkId)
 642             else:
 643                 self.assertFalse(True)
 644         self.assertEqual(len(expressLink),0)
 645         self.assertEqual(len(addLink),0)
 646         self.assertEqual(len(dropLink),0)
 647         self.assertEqual(len(R2RLink),0)
 648         self.assertEqual(len(XPDR_IN),0)
 649         self.assertEqual(len(XPDR_OUT),0)
 650
 651     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
 652         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 653               .format(self.restconf_baseurl))
 654         headers = {'content-type': 'application/json'}
 655         response = requests.request(
 656             "GET", url, headers=headers, auth=('admin', 'admin'))
 657         self.assertEqual(response.status_code, requests.codes.ok)
 658         res = response.json()
 659         #Tests related to links
 660         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 661         self.assertEqual(nbLink,20)
 662         R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
 663                  'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
 664         for i in range(0,nbLink):
 665             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 666             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 667             if(link_id in R2RLink):
 668                 find = False
 669                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 670                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 671                 length = res['network'][0]['ietf-network-topology:link'][i][
 672                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 673                 if((spanLoss!=None)&(length!=None)):
 674                     find = True
 675                 self.assertTrue(find)
 676                 R2RLink.remove(link_id)
 677         self.assertEqual(len(R2RLink),0)
 678
 679     def test_20_getNodes_OpenRoadmTopology(self):
 680          url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 681                .format(self.restconf_baseurl))
 682          headers = {'content-type': 'application/json'}
 683          response = requests.request(
 684              "GET", url, headers=headers, auth=('admin', 'admin'))
 685          res = response.json()
 686          #Tests related to nodes
 687          self.assertEqual(response.status_code, requests.codes.ok)
 688          nbNode=len(res['network'][0]['node'])
 689          self.assertEqual(nbNode,8)
 690          listNode=['XPDRA01-XPDR1',
 691                    'ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2',
 692                    'ROADMC01-SRG1','ROADMC01-DEG1','ROADMC01-DEG2']
 693          #************************Tests related to XPDRA nodes
 694          for i in range(0,nbNode):
 695              nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 696              nodeId=res['network'][0]['node'][i]['node-id']
 697              if(nodeId=='XPDRA01-XPDR1'):
 698                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
 699                                res['network'][0]['node'][i]['supporting-node'])
 700                  self.assertEqual(nodeType,'XPONDER')
 701                  nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 702                  self.assertTrue(nbTps == 6)
 703                  client = 0
 704                  network = 0
 705                  for j in range(0,nbTps):
 706                      tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
 707                      if (tpType=='XPONDER-CLIENT'):
 708                          client += 1
 709                      elif (tpType=='XPONDER-NETWORK'):
 710                          network += 1
 711                  self.assertTrue(client == 4)
 712                  self.assertTrue(network == 2)
 713                  listNode.remove(nodeId)
 714              elif(nodeId=='ROADMA01-SRG1'):
 715                  #Test related to SRG1
 716                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 717                  self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 718                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 719                  self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 720                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 721                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 722                                res['network'][0]['node'][i]['supporting-node'])
 723                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
 724                  listNode.remove(nodeId)
 725              elif(nodeId=='ROADMA01-SRG3'):
 726                  #Test related to SRG1
 727                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 728                  self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 729                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 730                  self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 731                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 732                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 733                                res['network'][0]['node'][i]['supporting-node'])
 734                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
 735                  listNode.remove(nodeId)
 736              elif(nodeId=='ROADMA01-DEG1'):
 737                  #Test related to DEG1
 738                  self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 739                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 740                  self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 741                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 742                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 743                                res['network'][0]['node'][i]['supporting-node'])
 744                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
 745                  listNode.remove(nodeId)
 746              elif(nodeId=='ROADMA01-DEG2'):
 747                  #Test related to DEG2
 748                  self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 749                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 750                  self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 751                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 752                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 753                                res['network'][0]['node'][i]['supporting-node'])
 754                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
 755                  listNode.remove(nodeId)
 756              elif(nodeId=='ROADMC01-SRG1'):
 757                  #Test related to SRG1
 758                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
 759                  self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 760                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 761                  self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 762                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 763                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
 764                                res['network'][0]['node'][i]['supporting-node'])
 765                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
 766                  listNode.remove(nodeId)
 767              elif(nodeId=='ROADMC01-DEG1'):
 768                  #Test related to DEG1
 769                  self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 770                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 771                  self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 772                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 773                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
 774                                res['network'][0]['node'][i]['supporting-node'])
 775                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
 776                  listNode.remove(nodeId)
 777              elif(nodeId=='ROADMC01-DEG2'):
 778                  #Test related to DEG2
 779                  self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 780                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 781                  self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 782                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 783                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
 784                                res['network'][0]['node'][i]['supporting-node'])
 785                  self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
 786                  listNode.remove(nodeId)
 787              else:
 788                 self.assertFalse(True)
 789          self.assertEqual(len(listNode),0)
 790
 791     def test_21_connect_ROADMB(self):
 792         url = ("{}/config/network-topology:"
 793                 "network-topology/topology/topology-netconf/node/ROADMB"
 794                .format(self.restconf_baseurl))
 795         data = {"node": [{
 796              "node-id": "ROADMB",
 797              "netconf-node-topology:username": "admin",
 798              "netconf-node-topology:password": "admin",
 799              "netconf-node-topology:host": "127.0.0.1",
 800              "netconf-node-topology:port": "17832",
 801              "netconf-node-topology:tcp-only": "false",
 802              "netconf-node-topology:pass-through": {}}]}
 803         headers = {'content-type': 'application/json'}
 804         response = requests.request(
 805              "PUT", url, data=json.dumps(data), headers=headers,
 806              auth=('admin', 'admin'))
 807         self.assertEqual(response.status_code, requests.codes.created)
 808         time.sleep(20)
 809
 810     def test_22_omsAttributes_ROADMA_ROADMB(self):
 811         # Config ROADMA-ROADMB oms-attributes
 812         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 813                "link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
 814                "OMS-attributes/span"
 815                .format(self.restconf_baseurl))
 816         data = {"span": {
 817                 "clfi": "fiber1",
 818                 "auto-spanloss": "true",
 819                 "engineered-spanloss": 12.2,
 820                 "link-concatenation": [{
 821                     "SRLG-Id": 0,
 822                     "fiber-type": "smf",
 823                     "SRLG-length": 100000,
 824                     "pmd": 0.5}]}}
 825         headers = {'content-type': 'application/json'}
 826         response = requests.request(
 827                 "PUT", url, data=json.dumps(data), headers=headers,
 828                 auth=('admin', 'admin'))
 829         self.assertEqual(response.status_code, requests.codes.created)
 830
 831     def test_23_omsAttributes_ROADMB_ROADMA(self):
 832         # Config ROADMB-ROADMA oms-attributes
 833         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 834                "link/ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
 835                "OMS-attributes/span"
 836                .format(self.restconf_baseurl))
 837         data = {"span": {
 838                 "clfi": "fiber1",
 839                 "auto-spanloss": "true",
 840                 "engineered-spanloss": 12.2,
 841                 "link-concatenation": [{
 842                     "SRLG-Id": 0,
 843                     "fiber-type": "smf",
 844                     "SRLG-length": 100000,
 845                     "pmd": 0.5}]}}
 846         headers = {'content-type': 'application/json'}
 847         response = requests.request(
 848                 "PUT", url, data=json.dumps(data), headers=headers,
 849                 auth=('admin', 'admin'))
 850         self.assertEqual(response.status_code, requests.codes.created)
 851
 852     def test_24_omsAttributes_ROADMB_ROADMC(self):
 853         # Config ROADMB-ROADMC oms-attributes
 854         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 855                "link/ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
 856                "OMS-attributes/span"
 857                .format(self.restconf_baseurl))
 858         data = {"span": {
 859                 "clfi": "fiber1",
 860                 "auto-spanloss": "true",
 861                 "engineered-spanloss": 12.2,
 862                 "link-concatenation": [{
 863                     "SRLG-Id": 0,
 864                     "fiber-type": "smf",
 865                     "SRLG-length": 100000,
 866                     "pmd": 0.5}]}}
 867         headers = {'content-type': 'application/json'}
 868         response = requests.request(
 869                 "PUT", url, data=json.dumps(data), headers=headers,
 870                 auth=('admin', 'admin'))
 871         self.assertEqual(response.status_code, requests.codes.created)
 872
 873     def test_25_omsAttributes_ROADMC_ROADMB(self):
 874         # Config ROADMC01-ROADMB oms-attributes
 875         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
 876                "link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
 877                "OMS-attributes/span"
 878                .format(self.restconf_baseurl))
 879         data = {"span": {
 880                 "clfi": "fiber1",
 881                 "auto-spanloss": "true",
 882                 "engineered-spanloss": 12.2,
 883                 "link-concatenation": [{
 884                     "SRLG-Id": 0,
 885                     "fiber-type": "smf",
 886                     "SRLG-length": 100000,
 887                     "pmd": 0.5}]}}
 888         headers = {'content-type': 'application/json'}
 889         response = requests.request(
 890                 "PUT", url, data=json.dumps(data), headers=headers,
 891                 auth=('admin', 'admin'))
 892         self.assertEqual(response.status_code, requests.codes.created)
 893
 894     def test_26_getClliNetwork(self):
 895         url = ("{}/config/ietf-network:networks/network/clli-network"
 896               .format(self.restconf_baseurl))
 897         headers = {'content-type': 'application/json'}
 898         response = requests.request(
 899             "GET", url, headers=headers, auth=('admin', 'admin'))
 900         self.assertEqual(response.status_code, requests.codes.ok)
 901         res = response.json()
 902         nbNode=len(res['network'][0]['node'])
 903         listNode=['NodeA','NodeB','NodeC']
 904         for i in range(0,nbNode):
 905             nodeId = res['network'][0]['node'][i]['node-id']
 906             find= nodeId in listNode
 907             self.assertEqual(find, True)
 908             if(nodeId=='NodeA'):
 909                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
 910             elif(nodeId=='NodeB'):
 911                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
 912             else:
 913                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
 914             listNode.remove(nodeId)
 915         self.assertEqual(len(listNode),0)
 916
 917     def test_27_verifyDegree(self):
 918         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 919               .format(self.restconf_baseurl))
 920         headers = {'content-type': 'application/json'}
 921         response = requests.request(
 922             "GET", url, headers=headers, auth=('admin', 'admin'))
 923         self.assertEqual(response.status_code, requests.codes.ok)
 924         res = response.json()
 925         #Tests related to links
 926         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 927         listR2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
 928            'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
 929            'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
 930         for i in range(0,nbLink):
 931             if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
 932                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 933                 find= link_id in listR2RLink
 934                 self.assertEqual(find, True)
 935                 listR2RLink.remove(link_id)
 936         self.assertEqual(len(listR2RLink),0)
 937
 938     def test_28_verifyOppositeLinkTopology(self):
 939         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 940                .format(self.restconf_baseurl))
 941         headers = {'content-type': 'application/json'}
 942         response = requests.request(
 943              "GET", url, headers=headers, auth=('admin', 'admin'))
 944         self.assertEqual(response.status_code, requests.codes.ok)
 945         res = response.json()
 946         #Tests related to links
 947         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 948         self.assertEqual(nbLink,34)
 949         for i in range(0,nbLink):
 950             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 951             link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 952             link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
 953             link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
 954             oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
 955             #Find the opposite link
 956             url_oppLink="{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
 957             url = (url_oppLink.format(self.restconf_baseurl))
 958             headers = {'content-type': 'application/json'}
 959             response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
 960             self.assertEqual(response_oppLink.status_code, requests.codes.ok)
 961             res_oppLink = response_oppLink.json()
 962             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
 963             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
 964             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
 965             oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
 966             if link_type=='ADD-LINK':
 967                 self.assertEqual(oppLink_type, 'DROP-LINK')
 968             elif link_type=='DROP-LINK':
 969                 self.assertEqual(oppLink_type, 'ADD-LINK')
 970             elif link_type=='EXPRESS-LINK':
 971                 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
 972             elif link_type=='ROADM-TO-ROADM':
 973                 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
 974             elif link_type=='XPONDER-INPUT':
 975                 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
 976             elif link_type=='XPONDER-OUTPUT':
 977                 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
 978
 979     def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
 980         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 981               .format(self.restconf_baseurl))
 982         headers = {'content-type': 'application/json'}
 983         response = requests.request(
 984             "GET", url, headers=headers, auth=('admin', 'admin'))
 985         self.assertEqual(response.status_code, requests.codes.ok)
 986         res = response.json()
 987         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 988         R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
 989                        'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
 990                        'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX',
 991                        'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
 992                        'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
 993                        'ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
 994         for i in range(0,nbLink):
 995             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 996             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 997             if(link_id in R2RLink):
 998                 find = False
 999                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
1000                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
1001                 length = res['network'][0]['ietf-network-topology:link'][i][
1002                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
1003                 if((spanLoss!=None)&(length!=None)):
1004                     find = True
1005                 self.assertTrue(find)
1006                 R2RLink.remove(link_id)
1007         self.assertEqual(len(R2RLink),0)
1008
1009     def test_30_disconnect_ROADMB(self):
1010         #Delete in the topology-netconf
1011         url = ("{}/config/network-topology:"
1012                 "network-topology/topology/topology-netconf/node/ROADMB"
1013                .format(self.restconf_baseurl))
1014         data = {}
1015         headers = {'content-type': 'application/json'}
1016         response = requests.request(
1017              "DELETE", url, data=json.dumps(data), headers=headers,
1018              auth=('admin', 'admin'))
1019         self.assertEqual(response.status_code, requests.codes.ok)
1020         #Delete in the clli-network
1021         url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
1022                .format(self.restconf_baseurl))
1023         data = {}
1024         headers = {'content-type': 'application/json'}
1025         response = requests.request(
1026              "DELETE", url, data=json.dumps(data), headers=headers,
1027              auth=('admin', 'admin'))
1028         self.assertEqual(response.status_code, requests.codes.ok)
1029
1030     def test_31_disconnect_ROADMC(self):
1031         #Delete in the topology-netconf
1032         url = ("{}/config/network-topology:"
1033                 "network-topology/topology/topology-netconf/node/ROADMC01"
1034                .format(self.restconf_baseurl))
1035         data = {}
1036         headers = {'content-type': 'application/json'}
1037         response = requests.request(
1038              "DELETE", url, data=json.dumps(data), headers=headers,
1039              auth=('admin', 'admin'))
1040         self.assertEqual(response.status_code, requests.codes.ok)
1041         #Delete in the clli-network
1042         url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
1043                .format(self.restconf_baseurl))
1044         data = {}
1045         headers = {'content-type': 'application/json'}
1046         response = requests.request(
1047              "DELETE", url, data=json.dumps(data), headers=headers,
1048              auth=('admin', 'admin'))
1049         self.assertEqual(response.status_code, requests.codes.ok)
1050
1051     def test_32_getNodes_OpenRoadmTopology(self):
1052         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1053               .format(self.restconf_baseurl))
1054         headers = {'content-type': 'application/json'}
1055         response = requests.request(
1056             "GET", url, headers=headers, auth=('admin', 'admin'))
1057         res = response.json()
1058         #Tests related to nodes
1059         self.assertEqual(response.status_code, requests.codes.ok)
1060         nbNode=len(res['network'][0]['node'])
1061         self.assertEqual(nbNode,5)
1062         listNode=['XPDRA01-XPDR1','ROADMA01-SRG1', 'ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
1063         for i in range(0,nbNode):
1064             nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1065             nodeId=res['network'][0]['node'][i]['node-id']
1066             #Tests related to XPDRA nodes
1067             if(nodeId=='XPDRA01-XPDR1'):
1068                 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1069                 for j in range(0, nbTp):
1070                     tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
1071                     if (tpid == 'XPDR1-CLIENT1'):
1072                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1073                                          ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
1074                     if (tpid == 'XPDR1-NETWORK1'):
1075                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1076                                          ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
1077                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1078                                          ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
1079                                          'ROADMA01-SRG1--SRG1-PP1-TXRX')
1080                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
1081                     res['network'][0]['node'][i]['supporting-node'])
1082                 listNode.remove(nodeId)
1083             elif(nodeId=='ROADMA01-SRG1'):
1084                 #Test related to SRG1
1085                 self.assertEqual(nodeType,'SRG')
1086                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1087                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1088                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1089                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1090                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1091                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1092                               res['network'][0]['node'][i]['supporting-node'])
1093                 listNode.remove(nodeId)
1094             elif(nodeId=='ROADMA01-SRG3'):
1095                 #Test related to SRG1
1096                 self.assertEqual(nodeType,'SRG')
1097                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1098                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1099                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1100                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1101                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1102                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1103                               res['network'][0]['node'][i]['supporting-node'])
1104                 listNode.remove(nodeId)
1105             elif(nodeId=='ROADMA01-DEG1'):
1106                 #Test related to DEG1
1107                 self.assertEqual(nodeType,'DEGREE')
1108                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1109                     res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1110                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1111                     res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1112                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1113                     res['network'][0]['node'][i]['supporting-node'])
1114                 listNode.remove(nodeId)
1115             elif(nodeId=='ROADMA01-DEG2'):
1116                 #Test related to DEG2
1117                 self.assertEqual(nodeType,'DEGREE')
1118                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1119                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1120                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1121                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1122                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1123                               res['network'][0]['node'][i]['supporting-node'])
1124                 listNode.remove(nodeId)
1125             else:
1126                 self.assertFalse(True)
1127         self.assertEqual(len(listNode),0)
1128         #Test related to SRG1 of ROADMC
1129         for i in range(0,nbNode):
1130             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-SRG1')
1131             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG1')
1132             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG2')
1133
1134     def test_33_getOpenRoadmNetwork(self):
1135         url = ("{}/config/ietf-network:networks/network/openroadm-network"
1136               .format(self.restconf_baseurl))
1137         headers = {'content-type': 'application/json'}
1138         response = requests.request(
1139             "GET", url, headers=headers, auth=('admin', 'admin'))
1140         self.assertEqual(response.status_code, requests.codes.ok)
1141         res = response.json()
1142         nbNode=len(res['network'][0]['node'])
1143         self.assertEqual(nbNode,2)
1144         for i in range(0,nbNode-1):
1145             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01')
1146             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB')
1147
1148     def test_34_getClliNetwork(self):
1149         url = ("{}/config/ietf-network:networks/network/clli-network"
1150               .format(self.restconf_baseurl))
1151         headers = {'content-type': 'application/json'}
1152         response = requests.request(
1153             "GET", url, headers=headers, auth=('admin', 'admin'))
1154         self.assertEqual(response.status_code, requests.codes.ok)
1155         res = response.json()
1156         nbNode=len(res['network'][0]['node'])
1157         self.assertEqual(nbNode,1)
1158         for i in range(0,nbNode-1):
1159             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
1160
1161     def test_35_disconnect_XPDRA(self):
1162         url = ("{}/config/network-topology:"
1163                "network-topology/topology/topology-netconf/node/XPDRA01"
1164               .format(self.restconf_baseurl))
1165         data = {}
1166         headers = {'content-type': 'application/json'}
1167         response = requests.request(
1168             "DELETE", url, data=json.dumps(data), headers=headers,
1169             auth=('admin', 'admin'))
1170         self.assertEqual(response.status_code, requests.codes.ok)
1171
1172     def test_36_getClliNetwork(self):
1173         url = ("{}/config/ietf-network:networks/network/clli-network"
1174               .format(self.restconf_baseurl))
1175         headers = {'content-type': 'application/json'}
1176         response = requests.request(
1177             "GET", url, headers=headers, auth=('admin', 'admin'))
1178         self.assertEqual(response.status_code, requests.codes.ok)
1179         res = response.json()
1180         nbNode=len(res['network'][0]['node'])
1181         self.assertEqual(nbNode,1)
1182         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
1183
1184     def test_37_getOpenRoadmNetwork(self):
1185         url = ("{}/config/ietf-network:networks/network/openroadm-network"
1186               .format(self.restconf_baseurl))
1187         headers = {'content-type': 'application/json'}
1188         response = requests.request(
1189             "GET", url, headers=headers, auth=('admin', 'admin'))
1190         self.assertEqual(response.status_code, requests.codes.ok)
1191         res = response.json()
1192         nbNode=len(res['network'][0]['node'])
1193         self.assertEqual(nbNode,1)
1194         for i in range(0,nbNode):
1195             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA01')
1196
1197     def test_38_getNodes_OpenRoadmTopology(self):
1198         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1199               .format(self.restconf_baseurl))
1200         headers = {'content-type': 'application/json'}
1201         response = requests.request(
1202             "GET", url, headers=headers, auth=('admin', 'admin'))
1203         res = response.json()
1204         #Tests related to nodes
1205         self.assertEqual(response.status_code, requests.codes.ok)
1206         nbNode=len(res['network'][0]['node'])
1207         self.assertEqual(nbNode,4)
1208         listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
1209         for i in range(0,nbNode):
1210             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1211                           res['network'][0]['node'][i]['supporting-node'])
1212             nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1213             nodeId=res['network'][0]['node'][i]['node-id']
1214             if(nodeId=='ROADMA01-SRG1'):
1215                 #Test related to SRG1
1216                 self.assertEqual(nodeType,'SRG')
1217                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1218                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1219                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1220                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1221                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1222                 listNode.remove(nodeId)
1223             elif(nodeId=='ROADMA01-SRG3'):
1224                 #Test related to SRG1
1225                 self.assertEqual(nodeType,'SRG')
1226                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1227                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1228                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1229                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1230                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1231                 listNode.remove(nodeId)
1232             elif(nodeId=='ROADMA01-DEG1'):
1233                 #Test related to DEG1
1234                 self.assertEqual(nodeType,'DEGREE')
1235                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1236                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1237                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1238                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1239                 listNode.remove(nodeId)
1240             elif(nodeId=='ROADMA01-DEG2'):
1241                 #Test related to DEG2
1242                 self.assertEqual(nodeType,'DEGREE')
1243                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1244                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1245                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1246                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1247                 listNode.remove(nodeId)
1248             else:
1249                 self.assertFalse(True)
1250         self.assertEqual(len(listNode),0)
1251
1252     def test_39_disconnect_ROADM_XPDRA_link(self):
1253         #Link-1
1254         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1255                "link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
1256                 .format(self.restconf_baseurl))
1257         data = {}
1258         headers = {'content-type': 'application/json'}
1259         response = requests.request(
1260              "DELETE", url, data=json.dumps(data), headers=headers,
1261              auth=('admin', 'admin'))
1262         self.assertEqual(response.status_code, requests.codes.ok)
1263         #Link-2
1264         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1265                "link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
1266                 .format(self.restconf_baseurl))
1267         data = {}
1268         headers = {'content-type': 'application/json'}
1269         response = requests.request(
1270              "DELETE", url, data=json.dumps(data), headers=headers,
1271              auth=('admin', 'admin'))
1272         self.assertEqual(response.status_code, requests.codes.ok)
1273
1274     def test_40_getLinks_OpenRoadmTopology(self):
1275         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1276               .format(self.restconf_baseurl))
1277         headers = {'content-type': 'application/json'}
1278         response = requests.request(
1279             "GET", url, headers=headers, auth=('admin', 'admin'))
1280         self.assertEqual(response.status_code, requests.codes.ok)
1281         res = response.json()
1282         nbLink=len(res['network'][0]['ietf-network-topology:link'])
1283         self.assertEqual(nbLink,16)
1284         expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
1285         addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
1286                  'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
1287         dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
1288                   'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
1289         roadmtoroadmLink = 0
1290         for i in range(0,nbLink):
1291             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
1292                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1293                 find= link_id in expressLink
1294                 self.assertEqual(find, True)
1295                 expressLink.remove(link_id)
1296             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
1297                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1298                 find= link_id in addLink
1299                 self.assertEqual(find, True)
1300                 addLink.remove(link_id)
1301             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
1302                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1303                 find= link_id in dropLink
1304                 self.assertEqual(find, True)
1305                 dropLink.remove(link_id)
1306             else:
1307                 roadmtoroadmLink += 1
1308         self.assertEqual(len(expressLink),0)
1309         self.assertEqual(len(addLink),0)
1310         self.assertEqual(len(dropLink),0)
1311         self.assertEqual(roadmtoroadmLink, 6)
1312         for i in range(0,nbLink):
1313             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
1314             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
1315
1316     def test_41_disconnect_ROADMA(self):
1317         url = ("{}/config/network-topology:"
1318                 "network-topology/topology/topology-netconf/node/ROADMA01"
1319                .format(self.restconf_baseurl))
1320         data = {}
1321         headers = {'content-type': 'application/json'}
1322         response = requests.request(
1323              "DELETE", url, data=json.dumps(data), headers=headers,
1324              auth=('admin', 'admin'))
1325         self.assertEqual(response.status_code, requests.codes.ok)
1326         #Delete in the clli-network
1327         url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1328                .format(self.restconf_baseurl))
1329         data = {}
1330         headers = {'content-type': 'application/json'}
1331         response = requests.request(
1332              "DELETE", url, data=json.dumps(data), headers=headers,
1333              auth=('admin', 'admin'))
1334         self.assertEqual(response.status_code, requests.codes.ok)
1335
1336     def test_42_getClliNetwork(self):
1337         url = ("{}/config/ietf-network:networks/network/clli-network"
1338               .format(self.restconf_baseurl))
1339         headers = {'content-type': 'application/json'}
1340         response = requests.request(
1341             "GET", url, headers=headers, auth=('admin', 'admin'))
1342         self.assertEqual(response.status_code, requests.codes.ok)
1343         res = response.json()
1344         self.assertNotIn('node', res['network'][0])
1345
1346     def test_43_getOpenRoadmNetwork(self):
1347         url = ("{}/config/ietf-network:networks/network/openroadm-network"
1348               .format(self.restconf_baseurl))
1349         headers = {'content-type': 'application/json'}
1350         response = requests.request(
1351             "GET", url, headers=headers, auth=('admin', 'admin'))
1352         self.assertEqual(response.status_code, requests.codes.ok)
1353         res = response.json()
1354         self.assertNotIn('node', res['network'][0])
1355
1356     def test_44_check_roadm2roadm_link_persistence(self):
1357         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1358               .format(self.restconf_baseurl))
1359         headers = {'content-type': 'application/json'}
1360         response = requests.request(
1361             "GET", url, headers=headers, auth=('admin', 'admin'))
1362         self.assertEqual(response.status_code, requests.codes.ok)
1363         res = response.json()
1364         nbLink=len(res['network'][0]['ietf-network-topology:link'])
1365         self.assertNotIn('node', res['network'][0])
1366         self.assertEqual(nbLink, 6)
1367
1368 if __name__ == "__main__":
1369     unittest.main(verbosity=2)