Improve some func. tests variables naming

JIRA: TRNSPRTPCE-567
Signed-off-by: guillaume.lambert <guillaume.lambert@orange.com>
Change-Id: I26dad4b37aee51934d7c90379eccf44105828098

diff --git a/tests/transportpce_tests/1.2.1/test02_topo_portmapping.py b/tests/transportpce_tests/1.2.1/test02_topo_portmapping.py
index b975fdca95f07e3ee719d606fd5c5df8b22d1546..653ae84555ea42df5b59d77c6e953a74b3278a5c 100644 (file)
--- a/tests/transportpce_tests/1.2.1/test02_topo_portmapping.py
+++ b/tests/transportpce_tests/1.2.1/test02_topo_portmapping.py
@@ -54,13 +54,13 @@ class TransportPCEtesting(unittest.TestCase):
     def test_02_compare_Openroadm_topology_portmapping_rdm(self):
         resTopo = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(resTopo['status_code'], requests.codes.ok)
-        for val in resTopo['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in resTopo['network'][0]['node']:
+            nodeId = node['node-id']
             nodeMapId = nodeId.split("-")[0]
             response = test_utils_rfc8040.get_portmapping_node_info(nodeMapId)
             self.assertEqual(response['status_code'], requests.codes.ok)
-            for val2 in val['ietf-network-topology:termination-point']:
-                tpId = val2['tp-id']
+            for tp in node['ietf-network-topology:termination-point']:
+                tpId = tp['tp-id']
                 if (not "CP" in tpId) and (not "CTP" in tpId):
                     response2 = test_utils_rfc8040.portmapping_request(nodeMapId, tpId)
                     self.assertEqual(response2['status_code'], requests.codes.ok)

diff --git a/tests/transportpce_tests/1.2.1/test03_topology.py b/tests/transportpce_tests/1.2.1/test03_topology.py
index c58557b3806f1398b2b81c7ebd421f9d82ec52f2..f9c4d1f2756acdf5ce7fdf3f354d8bd58ef33dc2 100644 (file)
--- a/tests/transportpce_tests/1.2.1/test03_topology.py
+++ b/tests/transportpce_tests/1.2.1/test03_topology.py
@@ -147,33 +147,33 @@ class TransportPCETopologyTesting(unittest.TestCase):
                                     'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
                                     'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_05_getNodes_OpenRoadmTopology(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 4)
         listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             self.assertIn(nodeId, self.CHECK_DICT1)
             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 17)
-            for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                self.assertIn(item, val['ietf-network-topology:termination-point'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
+            for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                self.assertIn(tp, node['ietf-network-topology:termination-point'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
             listNode.remove(nodeId)
 
         self.assertEqual(len(listNode), 0)
@@ -193,16 +193,16 @@ class TransportPCETopologyTesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 2)
-        for val in response['network'][0]['node']:
-            self.assertEqual(val['supporting-node'][0]['network-ref'], 'clli-network')
-            self.assertEqual(val['supporting-node'][0]['node-ref'], 'NodeA')
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
+            self.assertEqual(node['supporting-node'][0]['node-ref'], 'NodeA')
+            nodeId = node['node-id']
             if nodeId == 'XPDRA01':
-                self.assertEqual(val['org-openroadm-common-network:node-type'], 'XPONDER')
-                self.assertEqual(val['org-openroadm-network:model'], '1')
+                self.assertEqual(node['org-openroadm-common-network:node-type'], 'XPONDER')
+                self.assertEqual(node['org-openroadm-network:model'], '1')
             elif nodeId == 'ROADMA01':
-                self.assertEqual(val['org-openroadm-common-network:node-type'], 'ROADM')
-                self.assertEqual(val['org-openroadm-network:model'], '2')
+                self.assertEqual(node['org-openroadm-common-network:node-type'], 'ROADM')
+                self.assertEqual(node['org-openroadm-network:model'], '2')
             else:
                 self.assertFalse(True)
 
@@ -212,27 +212,27 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 5)
         listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDRA01-XPDR1':
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
                 self.assertEqual(nodeType, 'XPONDER')
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = val2['org-openroadm-common-network:tp-type']
-                    tpId = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = tp['org-openroadm-common-network:tp-type']
+                    tpId = tp['tp-id']
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                     elif tpType == 'XPONDER-NETWORK':
                         network += 1
                     if tpId == 'XPDR1-NETWORK2':
-                        self.assertEqual(val2['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT3')
+                        self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT3')
                     elif tpId == 'XPDR1-CLIENT3':
-                        self.assertEqual(val2['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
+                        self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
                 self.assertTrue(client == 4)
                 self.assertTrue(network == 2)
                 listNode.remove(nodeId)
@@ -240,11 +240,11 @@ class TransportPCETopologyTesting(unittest.TestCase):
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 17)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
@@ -282,15 +282,15 @@ class TransportPCETopologyTesting(unittest.TestCase):
                       'XPONDER-INPUT': ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1'],
                       'XPONDER-OUTPUT': ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_13_connect_ROADMC(self):
         response = test_utils_rfc8040.mount_device("ROADMC01", ('roadmc', self.NODE_VERSION))
@@ -328,10 +328,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         listNode = ['NodeA', 'NodeC']
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             self.assertIn(nodeId, listNode)
-            self.assertEqual(val['org-openroadm-clli-network:clli'], nodeId)
+            self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -344,15 +344,15 @@ class TransportPCETopologyTesting(unittest.TestCase):
                       'ROADMA01': {'node-ref': 'NodeA', 'node-type': 'ROADM', 'model': '2'},
                       'ROADMC01': {'node-ref': 'NodeC', 'node-type': 'ROADM', 'model': '2'}
                       }
-        for val in response['network'][0]['node']:
-            self.assertEqual(val['supporting-node'][0]['network-ref'], 'clli-network')
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
+            nodeId = node['node-id']
             self.assertIn(nodeId, CHECK_LIST)
-            self.assertEqual(val['supporting-node'][0]['node-ref'],
+            self.assertEqual(node['supporting-node'][0]['node-ref'],
                              CHECK_LIST[nodeId]['node-ref'])
-            self.assertEqual(val['org-openroadm-common-network:node-type'],
+            self.assertEqual(node['org-openroadm-common-network:node-type'],
                              CHECK_LIST[nodeId]['node-type'])
-            self.assertEqual(val['org-openroadm-network:model'],
+            self.assertEqual(node['org-openroadm-network:model'],
                              CHECK_LIST[nodeId]['model'])
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
@@ -382,15 +382,15 @@ class TransportPCETopologyTesting(unittest.TestCase):
                       'XPONDER-INPUT': ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1'],
                       'XPONDER-OUTPUT': ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
@@ -398,13 +398,13 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
         R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
                    'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
             if link_id in R2RLink:
                 find = False
-                spanLoss = val['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
+                spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
                 # pylint: disable=line-too-long
-                length = val['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
                 if (spanLoss is not None) & (length is not None):
                     find = True
                 self.assertTrue(find)
@@ -419,18 +419,18 @@ class TransportPCETopologyTesting(unittest.TestCase):
         listNode = ['XPDRA01-XPDR1',
                     'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2',
                     'ROADMC01-SRG1', 'ROADMC01-DEG1', 'ROADMC01-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDRA01-XPDR1':
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, node['supporting-node'])
                 self.assertEqual(nodeType, 'XPONDER')
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 6)
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 6)
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = val2['org-openroadm-common-network:tp-type']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = tp['org-openroadm-common-network:tp-type']
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                     elif tpType == 'XPONDER-NETWORK':
@@ -442,23 +442,23 @@ class TransportPCETopologyTesting(unittest.TestCase):
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 17)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
                 listNode.remove(nodeId)
             # Tests related to ROADMC nodes
             elif nodeId in self.CHECK_DICT2:
                 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
                 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 17)
-                for item in self.CHECK_DICT2[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'}, val['supporting-node'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
+                for tp in self.CHECK_DICT2[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'}, node['supporting-node'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
@@ -528,10 +528,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         listNode = ['NodeA', 'NodeB', 'NodeC']
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             self.assertIn(nodeId, listNode)
-            self.assertEqual(val['org-openroadm-clli-network:clli'], nodeId)
+            self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -544,9 +544,9 @@ class TransportPCETopologyTesting(unittest.TestCase):
                        'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
                        'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
                        'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
-        for val in response['network'][0]['ietf-network-topology:link']:
-            if val['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
-                link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            if link['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
+                link_id = link['link-id']
                 find = link_id in listR2RLink
                 self.assertEqual(find, True)
                 listR2RLink.remove(link_id)
@@ -556,12 +556,12 @@ class TransportPCETopologyTesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 34)
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
-            link_type = val['org-openroadm-common-network:link-type']
-            link_src = val['source']['source-node']
-            link_dest = val['destination']['dest-node']
-            oppLink_id = val['org-openroadm-common-network:opposite-link']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
+            link_type = link['org-openroadm-common-network:link-type']
+            link_src = link['source']['source-node']
+            link_dest = link['destination']['dest-node']
+            oppLink_id = link['org-openroadm-common-network:opposite-link']
             # Find the opposite link
             res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
             self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
@@ -584,13 +584,13 @@ class TransportPCETopologyTesting(unittest.TestCase):
                    'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
                    'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
                    'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
             if link_id in R2RLink:
                 find = False
-                spanLoss = val['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
+                spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
                 # pylint: disable=line-too-long
-                length = val['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
                 if (spanLoss is not None) & (length is not None):
                     find = True
                 self.assertTrue(find)
@@ -618,48 +618,48 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 5)
         listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDRA01-XPDR1':
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpid = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpid = tp['tp-id']
                     if tpid == 'XPDR1-CLIENT1':
-                        self.assertEqual(val2['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
+                        self.assertEqual(tp['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
                     if tpid == 'XPDR1-NETWORK1':
-                        self.assertEqual(val2['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
+                        self.assertEqual(tp['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
                         # pylint: disable=line-too-long
-                        self.assertEqual(val2['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
+                        self.assertEqual(tp['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
                                          'ROADMA01-SRG1--SRG1-PP1-TXRX')
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, node['supporting-node'])
                 listNode.remove(nodeId)
             # Tests related to ROADMA nodes
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 17)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
         self.assertEqual(len(listNode), 0)
         # Test related to SRG1 of ROADMC
-        for val in response['network'][0]['node']:
-            self.assertNotEqual(val['node-id'], 'ROADMC01-SRG1')
-            self.assertNotEqual(val['node-id'], 'ROADMC01-DEG1')
-            self.assertNotEqual(val['node-id'], 'ROADMC01-DEG2')
+        for node in response['network'][0]['node']:
+            self.assertNotEqual(node['node-id'], 'ROADMC01-SRG1')
+            self.assertNotEqual(node['node-id'], 'ROADMC01-DEG1')
+            self.assertNotEqual(node['node-id'], 'ROADMC01-DEG2')
 
     def test_33_getOpenRoadmNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 2)
-        for val in response['network'][0]['node']:
-            self.assertNotEqual(val['node-id'], 'ROADMC01')
-            self.assertNotEqual(val['node-id'], 'ROADMB01')
+        for node in response['network'][0]['node']:
+            self.assertNotEqual(node['node-id'], 'ROADMC01')
+            self.assertNotEqual(node['node-id'], 'ROADMB01')
 
     def test_34_getClliNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
@@ -688,18 +688,18 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 4)
         listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             self.assertIn(nodeId, self.CHECK_DICT1)
             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 17)
-            for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                self.assertIn(item, val['ietf-network-topology:termination-point'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, val['supporting-node'])
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
+            for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                self.assertIn(tp, node['ietf-network-topology:termination-point'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -733,21 +733,21 @@ class TransportPCETopologyTesting(unittest.TestCase):
                                     'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
                       }
         roadmtoroadmLink = 0
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             if linkType in check_list:
                 find = linkId in check_list[linkType]
                 self.assertEqual(find, True)
                 (check_list[linkType]).remove(linkId)
             else:
                 roadmtoroadmLink += 1
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
         self.assertEqual(roadmtoroadmLink, 6)
-        for val in response['network'][0]['ietf-network-topology:link']:
-            self.assertNotEqual(val['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
-            self.assertNotEqual(val['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
+        for link in response['network'][0]['ietf-network-topology:link']:
+            self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
+            self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
 
     def test_41_disconnect_ROADMA(self):
         response = test_utils_rfc8040.unmount_device("ROADMA01")

diff --git a/tests/transportpce_tests/2.2.1/test02_topo_portmapping.py b/tests/transportpce_tests/2.2.1/test02_topo_portmapping.py
index cc00c8eb16ad98520fc594b021a69a31c943e9b0..586b882f1868933b174bae4144b0974485f0f862 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test02_topo_portmapping.py
+++ b/tests/transportpce_tests/2.2.1/test02_topo_portmapping.py
@@ -54,8 +54,8 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(resTopo['status_code'], requests.codes.ok)
         nbMapCumul = 0
         nbMappings = 0
-        for val in resTopo['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in resTopo['network'][0]['node']:
+            nodeId = node['node-id']
             # pylint: disable=consider-using-f-string
             print("nodeId={}".format(nodeId))
             nodeMapId = nodeId.split("-")[0] + "-" + nodeId.split("-")[1]
@@ -65,8 +65,8 @@ class TransportPCEtesting(unittest.TestCase):
             responseMapList = test_utils_rfc8040.get_portmapping(nodeMapId)
             nbMappings = len(responseMapList['nodes'][0]['mapping']) - nbMapCumul
             nbMapCurrent = 0
-            for val2 in val['ietf-network-topology:termination-point']:
-                tpId = val2['tp-id']
+            for tp in node['ietf-network-topology:termination-point']:
+                tpId = tp['tp-id']
                 if (not "CP" in tpId) and (not "CTP" in tpId):
                     responseMap = test_utils_rfc8040.portmapping_request(nodeMapId, tpId)
                     self.assertEqual(responseMap['status_code'], requests.codes.ok)

diff --git a/tests/transportpce_tests/2.2.1/test03_topology.py b/tests/transportpce_tests/2.2.1/test03_topology.py
index c03f8ed30e3ff288bedde77402b6adf7551ee2bd..24f628ed7b754600f367c4c99bc0eccc1d007824 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test03_topology.py
+++ b/tests/transportpce_tests/2.2.1/test03_topology.py
@@ -149,15 +149,15 @@ class TransportPCEtesting(unittest.TestCase):
                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_05_getNodes_OpenRoadmTopology(self):
         # pylint: disable=redundant-unittest-assert
@@ -165,18 +165,18 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 4)
         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             self.assertIn(nodeId, self.CHECK_DICT1)
             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-            for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                self.assertIn(item, val['ietf-network-topology:termination-point'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+            for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                self.assertIn(tp, node['ietf-network-topology:termination-point'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -196,18 +196,18 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         nbNode = len(response['network'][0]['node'])
         self.assertEqual(nbNode, 2)
-        for val in response['network'][0]['node']:
-            self.assertEqual(val['supporting-node'][0]['network-ref'], 'clli-network')
-            self.assertEqual(val['supporting-node'][0]['node-ref'], 'NodeA')
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
+            self.assertEqual(node['supporting-node'][0]['node-ref'], 'NodeA')
+            nodeId = node['node-id']
             if nodeId == 'XPDR-A1':
-                self.assertEqual(val['org-openroadm-common-network:node-type'], 'XPONDER')
+                self.assertEqual(node['org-openroadm-common-network:node-type'], 'XPONDER')
             elif nodeId == 'ROADM-A1':
-                self.assertEqual(val['org-openroadm-common-network:node-type'], 'ROADM')
+                self.assertEqual(node['org-openroadm-common-network:node-type'], 'ROADM')
             else:
                 self.assertFalse(True)
                 continue
-            self.assertEqual(val['org-openroadm-network:model'], 'model2')
+            self.assertEqual(node['org-openroadm-network:model'], 'model2')
 
     def test_09_getNodes_OpenRoadmTopology(self):
         # pylint: disable=redundant-unittest-assert
@@ -215,38 +215,38 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 5)
         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDR-A1-XPDR1':
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
                 self.assertEqual(nodeType, 'XPONDER')
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = (val2['org-openroadm-common-network:tp-type'])
-                    tpId = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = (tp['org-openroadm-common-network:tp-type'])
+                    tpId = tp['tp-id']
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                     elif tpType == 'XPONDER-NETWORK':
                         network += 1
                     if tpId == 'XPDR1-NETWORK2':
-                        self.assertEqual(val2['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
+                        self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
                     if tpId == 'XPDR1-CLIENT2':
-                        self.assertEqual(val2['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
+                        self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
                 self.assertEqual(client, 2)
                 self.assertEqual(network, 2)
                 listNode.remove(nodeId)
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
@@ -284,15 +284,15 @@ class TransportPCEtesting(unittest.TestCase):
                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_13_connect_ROADMC(self):
         response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
@@ -332,10 +332,10 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         listNode = ['NodeA', 'NodeC']
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             self.assertIn(nodeId, listNode)
-            self.assertEqual(val['org-openroadm-clli-network:clli'], nodeId)
+            self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -350,17 +350,17 @@ class TransportPCEtesting(unittest.TestCase):
                       'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
                       'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
                       }
-        for val in response['network'][0]['node']:
-            self.assertEqual(val['supporting-node'][0]['network-ref'], 'clli-network')
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
+            nodeId = node['node-id']
             if nodeId in CHECK_LIST:
-                self.assertEqual(val['supporting-node'][0]['node-ref'], CHECK_LIST[nodeId]['node-ref'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
+                self.assertEqual(node['supporting-node'][0]['node-ref'], CHECK_LIST[nodeId]['node-ref'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
                 continue
-            self.assertEqual(val['org-openroadm-network:model'], 'model2')
+            self.assertEqual(node['org-openroadm-network:model'], 'model2')
         self.assertEqual(len(listNode), 0)
 
     def test_18_getROADMLinkOpenRoadmTopology(self):
@@ -389,15 +389,15 @@ class TransportPCEtesting(unittest.TestCase):
                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
@@ -405,13 +405,13 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
             if link_id in R2RLink:
                 find = False
-                spanLoss = val['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
+                spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
                 # pylint: disable=line-too-long
-                length = val['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
                 if (spanLoss is not None) & (length is not None):
                     find = True
                 self.assertTrue(find)
@@ -427,18 +427,18 @@ class TransportPCEtesting(unittest.TestCase):
                     'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
                     'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
         # Tests related to XPDRA nodes
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             if nodeId == 'XPDR-A1-XPDR1':
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
                 self.assertEqual(nodeType, 'XPONDER')
-                nbTps = len(val['ietf-network-topology:termination-point'])
+                nbTps = len(node['ietf-network-topology:termination-point'])
                 self.assertTrue(nbTps >= 4)
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = (val2['org-openroadm-common-network:tp-type'])
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = (tp['org-openroadm-common-network:tp-type'])
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                     elif tpType == 'XPONDER-NETWORK':
@@ -450,23 +450,23 @@ class TransportPCEtesting(unittest.TestCase):
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
                 listNode.remove(nodeId)
         # Tests related to ROADMA nodes
             elif nodeId in self.CHECK_DICT2:
                 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
                 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT2[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'}, val['supporting-node'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT2[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'}, node['supporting-node'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
                 listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -541,10 +541,10 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         listNode = ['NodeA', 'NodeB', 'NodeC']
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             self.assertIn(nodeId, listNode)
-            self.assertEqual(val['org-openroadm-clli-network:clli'], nodeId)
+            self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -557,9 +557,9 @@ class TransportPCEtesting(unittest.TestCase):
                        'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
                        'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
                        'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
-        for val in response['network'][0]['ietf-network-topology:link']:
-            if val['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
-                link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            if link['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
+                link_id = link['link-id']
                 find = link_id in listR2RLink
                 self.assertEqual(find, True)
                 listR2RLink.remove(link_id)
@@ -569,12 +569,12 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 30)
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
-            link_type = val['org-openroadm-common-network:link-type']
-            link_src = val['source']['source-node']
-            link_dest = val['destination']['dest-node']
-            oppLink_id = val['org-openroadm-common-network:opposite-link']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
+            link_type = link['org-openroadm-common-network:link-type']
+            link_src = link['source']['source-node']
+            link_dest = link['destination']['dest-node']
+            oppLink_id = link['org-openroadm-common-network:opposite-link']
             # Find the opposite link
             res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
             self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
@@ -597,13 +597,13 @@ class TransportPCEtesting(unittest.TestCase):
                    'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
                    'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
                    'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
             if link_id in R2RLink:
                 find = False
-                spanLoss = val['org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
+                spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
                 # pylint: disable=line-too-long
-                length = val['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
                 if (spanLoss is not None) & (length is not None):
                     find = True
                 self.assertTrue(find)
@@ -632,49 +632,49 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 5)
         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDR-A1-XPDR1':
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpid = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpid = tp['tp-id']
                     if tpid == 'XPDR1-CLIENT1':
-                        self.assertEqual((val2['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
+                        self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
                     elif tpid == 'XPDR1-NETWORK1':
-                        self.assertEqual((val2['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
+                        self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
                         # pylint: disable=line-too-long
-                        self.assertEqual((val2['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']),
+                        self.assertEqual((tp['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']),
                                          'ROADM-A1-SRG1--SRG1-PP1-TXRX')
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
                 listNode.remove(nodeId)
             # Tests related to ROADMA nodes
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
         self.assertEqual(len(listNode), 0)
         # Test related to SRG1 of ROADMC
-        for val in response['network'][0]['node']:
-            self.assertNotEqual(val['node-id'], 'ROADM-C1-SRG1')
-            self.assertNotEqual(val['node-id'], 'ROADM-C1-DEG1')
-            self.assertNotEqual(val['node-id'], 'ROADM-C1-DEG2')
+        for node in response['network'][0]['node']:
+            self.assertNotEqual(node['node-id'], 'ROADM-C1-SRG1')
+            self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG1')
+            self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG2')
 
     def test_33_getOpenRoadmNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         nbNode = len(response['network'][0]['node'])
         self.assertEqual(nbNode, 2)
-        for val in response['network'][0]['node']:
-            self.assertNotEqual(val['node-id'], 'ROADM-C1')
-            self.assertNotEqual(val['node-id'], 'ROADM-B1')
+        for node in response['network'][0]['node']:
+            self.assertNotEqual(node['node-id'], 'ROADM-C1')
+            self.assertNotEqual(node['node-id'], 'ROADM-B1')
 
     def test_34_getClliNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
@@ -703,18 +703,18 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 4)
         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             self.assertIn(nodeId, self.CHECK_DICT1)
             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-            for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                self.assertIn(item, val['ietf-network-topology:termination-point'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+            for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                self.assertIn(tp, node['ietf-network-topology:termination-point'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -748,21 +748,21 @@ class TransportPCEtesting(unittest.TestCase):
                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
                       }
         roadmtoroadmLink = 0
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             if linkType in check_list:
                 find = linkId in check_list[linkType]
                 self.assertEqual(find, True)
                 (check_list[linkType]).remove(linkId)
             else:
                 roadmtoroadmLink += 1
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
         self.assertEqual(roadmtoroadmLink, 6)
-        for val in response['network'][0]['ietf-network-topology:link']:
-            self.assertNotEqual(val['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
-            self.assertNotEqual(val['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
+        for link in response['network'][0]['ietf-network-topology:link']:
+            self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
+            self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
 
     def test_41_disconnect_ROADMA(self):
         response = test_utils_rfc8040.unmount_device("ROADM-A1")

diff --git a/tests/transportpce_tests/2.2.1/test04_otn_topology.py b/tests/transportpce_tests/2.2.1/test04_otn_topology.py
index e87ef6aab0858d44e3c7eb5ae5abceda47242d15..9156c21c79374338a81282b74761e0186cfb608b 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test04_otn_topology.py
+++ b/tests/transportpce_tests/2.2.1/test04_otn_topology.py
@@ -83,19 +83,19 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertIn('node', response['network'][0])
         self.assertEqual(len(response['network'][0]['node']), 3)
         listNode = ['SPDR-SA1-XPDR1', 'SPDR-SA1-XPDR2', 'SPDR-SA1-XPDR3']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'SPDR-SA1'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeSA'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'SPDR-SA1'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeSA'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             if nodeId not in listNode:
                 self.assertFalse(True)
                 continue
             self.assertEqual(nodeType, 'XPONDER')
             client = 0
             network = 0
-            for item in val['ietf-network-topology:termination-point']:
-                tpType = item['org-openroadm-common-network:tp-type']
+            for tp in node['ietf-network-topology:termination-point']:
+                tpType = tp['org-openroadm-common-network:tp-type']
                 if tpType == 'XPONDER-CLIENT':
                     client += 1
                 elif tpType == 'XPONDER-NETWORK':
@@ -144,51 +144,51 @@ class TransportPCEtesting(unittest.TestCase):
                 'tp-unchecklist': []
             }
         }
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             if nodeId in CHECK_LIST:
-                self.assertEqual(val['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'SPDR-SA1'},
-                              val['supporting-node'])
+                              node['supporting-node'])
                 self.assertIn({'network-ref': 'openroadm-topology', 'node-ref': nodeId},
-                              val['supporting-node'])
+                              node['supporting-node'])
                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeSA'},
-                              val['supporting-node'])
-                self.assertEqual(val['org-openroadm-otn-network-topology:xpdr-attributes']['xpdr-number'],
+                              node['supporting-node'])
+                self.assertEqual(node['org-openroadm-otn-network-topology:xpdr-attributes']['xpdr-number'],
                                  CHECK_LIST[nodeId]['xpdr-number'])
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = val2['org-openroadm-common-network:tp-type']
-                    tpId = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = tp['org-openroadm-common-network:tp-type']
+                    tpId = tp['tp-id']
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                         # pylint: disable=consider-using-f-string
                         print("tpId = {}".format(tpId))
-                        print("tp= {}".format(val2))
+                        print("tp= {}".format(tp))
                         # pylint: disable=line-too-long
-                        for val3 in val2['org-openroadm-otn-network-topology:tp-supported-interfaces']['supported-interface-capability']:
-                            self.assertIn((val3['if-cap-type']), CHECK_LIST[nodeId]['port-types'])
+                        for capa in tp['org-openroadm-otn-network-topology:tp-supported-interfaces']['supported-interface-capability']:
+                            self.assertIn((capa['if-cap-type']), CHECK_LIST[nodeId]['port-types'])
                     elif tpType == 'XPONDER-NETWORK':
                         network += 1
-                        self.assertEqual((val2['org-openroadm-otn-network-topology:tp-supported-interfaces']
+                        self.assertEqual((tp['org-openroadm-otn-network-topology:tp-supported-interfaces']
                                           ['supported-interface-capability'][0]['if-cap-type']),
                                          'org-openroadm-port-types:if-OCH-OTU4-ODU4')
-                        self.assertEqual((val2['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
+                        self.assertEqual((tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
                                           ['rate']),
                                          'org-openroadm-otn-common-types:ODU4')
-                        self.assertEqual((val2['supporting-termination-point'][0]['network-ref']), 'openroadm-topology')
-                        self.assertEqual((val2['supporting-termination-point'][0]['node-ref']), nodeId)
-                        self.assertEqual((val2['supporting-termination-point'][0]['tp-ref']), tpId)
+                        self.assertEqual((tp['supporting-termination-point'][0]['network-ref']), 'openroadm-topology')
+                        self.assertEqual((tp['supporting-termination-point'][0]['node-ref']), nodeId)
+                        self.assertEqual((tp['supporting-termination-point'][0]['tp-ref']), tpId)
                 self.assertTrue(client == 4)
                 self.assertTrue(network == CHECK_LIST[nodeId]['network_nb'])
                 listNode.remove(nodeId)
                 self.assertEqual(
-                    len(val['org-openroadm-otn-network-topology:switching-pools']
-                           ['odu-switching-pools'][0]['non-blocking-list']),
+                    len(node['org-openroadm-otn-network-topology:switching-pools']
+                        ['odu-switching-pools'][0]['non-blocking-list']),
                     CHECK_LIST[nodeId]['nbl_nb'])
                 # pylint: disable=line-too-long
-                for nbl in val['org-openroadm-otn-network-topology:switching-pools']['odu-switching-pools'][0]['non-blocking-list']:
+                for nbl in node['org-openroadm-otn-network-topology:switching-pools']['odu-switching-pools'][0]['non-blocking-list']:
                     if nbl['nbl-number'] == 1:
                         if nodeId == 'SPDR-SA1-XPDR1':
                             self.assertEqual(nbl['available-interconnect-bandwidth'], 10)