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