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