3 ##############################################################################
4 # Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
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 ##############################################################################
12 # pylint: disable=no-member
13 # pylint: disable=too-many-public-methods
14 # pylint: disable=too-many-lines
19 # pylint: disable=wrong-import-order
21 sys.path.append('transportpce_tests/common/')
22 # pylint: disable=wrong-import-position
23 # pylint: disable=import-error
24 import test_utils_rfc8040 # nopep8
27 class TransportPCETopologyTesting(unittest.TestCase):
30 NODE_VERSION = '1.2.1'
34 'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
35 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
36 'org-openroadm-common-network:operational-state': 'inService'}),
37 ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
38 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
39 'org-openroadm-common-network:operational-state': 'inService'})]
43 'checks_tp': [({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
44 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
45 'org-openroadm-common-network:operational-state': 'inService'}),
46 ({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
47 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
48 'org-openroadm-common-network:operational-state': 'inService'})]
51 'node_type': 'DEGREE',
52 'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
53 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
54 'org-openroadm-common-network:operational-state': 'inService'}),
55 ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
56 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
57 'org-openroadm-common-network:operational-state': 'inService'})]
60 'node_type': 'DEGREE',
61 'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
62 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
63 'org-openroadm-common-network:operational-state': 'inService'}),
64 ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
65 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
66 'org-openroadm-common-network:operational-state': 'inService'})]
72 'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
73 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
74 'org-openroadm-common-network:operational-state': 'inService'}),
75 ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
76 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
77 'org-openroadm-common-network:operational-state': 'inService'})]
80 'node_type': 'DEGREE',
81 'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
82 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
83 'org-openroadm-common-network:operational-state': 'inService'}),
84 ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
85 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
86 'org-openroadm-common-network:operational-state': 'inService'})]
89 'node_type': 'DEGREE',
90 'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
91 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
92 'org-openroadm-common-network:operational-state': 'inService'}),
93 ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
94 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
95 'org-openroadm-common-network:operational-state': 'inService'})]
101 cls.processes = test_utils_rfc8040.start_tpce()
102 cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
103 ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
106 def tearDownClass(cls):
107 # pylint: disable=not-an-iterable
108 for process in cls.processes:
109 test_utils_rfc8040.shutdown_process(process)
110 print("all processes killed")
115 def test_01_connect_ROADMA(self):
116 response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
117 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
119 def test_02_getClliNetwork(self):
120 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
121 self.assertEqual(response['status_code'], requests.codes.ok)
122 self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
123 self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
125 def test_03_getOpenRoadmNetwork(self):
126 response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
127 self.assertEqual(response['status_code'], requests.codes.ok)
128 self.assertEqual(response['network'][0]['node'][0]['node-id'], 'ROADMA01')
129 self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
130 self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
131 self.assertEqual(response['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
132 self.assertEqual(response['network'][0]['node'][0]['org-openroadm-network:model'], '2')
134 def test_04_getLinks_OpenroadmTopology(self):
135 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
136 self.assertEqual(response['status_code'], requests.codes.ok)
137 # Tests related to links
138 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 10)
139 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
140 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX'],
141 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
142 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
143 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
144 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX'],
145 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
146 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
147 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
148 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
150 for link in response['network'][0]['ietf-network-topology:link']:
151 linkId = link['link-id']
152 linkType = link['org-openroadm-common-network:link-type']
153 self.assertIn(linkType, check_list)
154 find = linkId in check_list[linkType]
155 self.assertEqual(find, True)
156 (check_list[linkType]).remove(linkId)
157 for link in check_list.values():
158 self.assertEqual(len(link), 0)
160 def test_05_getNodes_OpenRoadmTopology(self):
161 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
162 self.assertEqual(response['status_code'], requests.codes.ok)
163 self.assertEqual(len(response['network'][0]['node']), 4)
164 listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
165 for node in response['network'][0]['node']:
166 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
167 nodeType = node['org-openroadm-common-network:node-type']
168 nodeId = node['node-id']
169 self.assertIn(nodeId, self.CHECK_DICT1)
170 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
171 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
172 self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
173 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
174 self.assertIn(tp, node['ietf-network-topology:termination-point'])
175 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
176 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
177 listNode.remove(nodeId)
179 self.assertEqual(len(listNode), 0)
181 def test_06_connect_XPDRA(self):
182 response = test_utils_rfc8040.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
183 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
185 def test_07_getClliNetwork(self):
186 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
187 self.assertEqual(response['status_code'], requests.codes.ok)
188 self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
189 self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
191 def test_08_getOpenRoadmNetwork(self):
192 # pylint: disable=redundant-unittest-assert
193 response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
194 self.assertEqual(response['status_code'], requests.codes.ok)
195 self.assertEqual(len(response['network'][0]['node']), 2)
196 for node in response['network'][0]['node']:
197 self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
198 self.assertEqual(node['supporting-node'][0]['node-ref'], 'NodeA')
199 nodeId = node['node-id']
200 if nodeId == 'XPDRA01':
201 self.assertEqual(node['org-openroadm-common-network:node-type'], 'XPONDER')
202 self.assertEqual(node['org-openroadm-network:model'], '1')
203 elif nodeId == 'ROADMA01':
204 self.assertEqual(node['org-openroadm-common-network:node-type'], 'ROADM')
205 self.assertEqual(node['org-openroadm-network:model'], '2')
207 self.assertFalse(True)
209 def test_09_getNodes_OpenRoadmTopology(self):
210 # pylint: disable=redundant-unittest-assert
211 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
212 self.assertEqual(response['status_code'], requests.codes.ok)
213 self.assertEqual(len(response['network'][0]['node']), 5)
214 listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
215 for node in response['network'][0]['node']:
216 nodeType = node['org-openroadm-common-network:node-type']
217 nodeId = node['node-id']
218 # Tests related to XPDRA nodes
219 if nodeId == 'XPDRA01-XPDR1':
220 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, node['supporting-node'])
221 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
222 self.assertEqual(nodeType, 'XPONDER')
225 for tp in node['ietf-network-topology:termination-point']:
226 tpType = tp['org-openroadm-common-network:tp-type']
228 if tpType == 'XPONDER-CLIENT':
230 elif tpType == 'XPONDER-NETWORK':
232 if tpId == 'XPDR1-NETWORK2':
234 tp['org-openroadm-common-network:associated-connection-map-tp'], ['XPDR1-CLIENT3'])
235 elif tpId == 'XPDR1-CLIENT3':
237 tp['org-openroadm-common-network:associated-connection-map-tp'], ['XPDR1-NETWORK2'])
238 self.assertTrue(client == 4)
239 self.assertTrue(network == 2)
240 listNode.remove(nodeId)
241 # Tests related to ROADMA nodes
242 elif nodeId in self.CHECK_DICT1:
243 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
244 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
245 self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
246 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
247 self.assertIn(tp, node['ietf-network-topology:termination-point'])
248 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
249 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
250 listNode.remove(nodeId)
252 self.assertFalse(True)
253 self.assertEqual(len(listNode), 0)
255 # Connect the tail XPDRA to ROADMA and vice versa
256 def test_10_connect_tail_xpdr_rdm(self):
257 # Connect the tail: XPDRA to ROADMA
258 response = test_utils_rfc8040.transportpce_api_rpc_request(
259 'transportpce-networkutils', 'init-xpdr-rdm-links',
260 {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
261 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
262 self.assertEqual(response['status_code'], requests.codes.ok)
264 def test_11_connect_tail_rdm_xpdr(self):
265 # Connect the tail: ROADMA to XPDRA
266 response = test_utils_rfc8040.transportpce_api_rpc_request(
267 'transportpce-networkutils', 'init-rdm-xpdr-links',
268 {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
269 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
270 self.assertEqual(response['status_code'], requests.codes.ok)
272 def test_12_getLinks_OpenRoadmTopology(self):
273 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
274 self.assertEqual(response['status_code'], requests.codes.ok)
275 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 12)
276 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
277 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX'],
278 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
279 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
280 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
281 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX'],
282 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
283 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
284 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
285 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX'],
286 'XPONDER-INPUT': ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1'],
287 'XPONDER-OUTPUT': ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
289 for link in response['network'][0]['ietf-network-topology:link']:
290 linkId = link['link-id']
291 linkType = link['org-openroadm-common-network:link-type']
292 self.assertIn(linkType, check_list)
293 find = linkId in check_list[linkType]
294 self.assertEqual(find, True)
295 (check_list[linkType]).remove(linkId)
296 for link in check_list.values():
297 self.assertEqual(len(link), 0)
299 def test_13_connect_ROADMC(self):
300 response = test_utils_rfc8040.mount_device("ROADMC01", ('roadmc', self.NODE_VERSION))
301 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
303 def test_14_omsAttributes_ROADMA_ROADMC(self):
304 # Config ROADMA01-ROADMC01 oms-attributes
306 "auto-spanloss": "true",
307 "engineered-spanloss": 12.2,
308 "link-concatenation": [{
311 "SRLG-length": 100000,
313 response = test_utils_rfc8040.add_oms_attr_request(
314 "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX", data)
315 self.assertEqual(response.status_code, requests.codes.created)
317 def test_15_omsAttributes_ROADMC_ROADMA(self):
318 # Config ROADMC01-ROADMA oms-attributes
320 "auto-spanloss": "true",
321 "engineered-spanloss": 12.2,
322 "link-concatenation": [{
325 "SRLG-length": 100000,
327 response = test_utils_rfc8040.add_oms_attr_request(
328 "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX", data)
329 self.assertEqual(response.status_code, requests.codes.created)
331 def test_16_getClliNetwork(self):
332 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
333 self.assertEqual(response['status_code'], requests.codes.ok)
334 listNode = ['NodeA', 'NodeC']
335 for node in response['network'][0]['node']:
336 nodeId = node['node-id']
337 self.assertIn(nodeId, listNode)
338 self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
339 listNode.remove(nodeId)
340 self.assertEqual(len(listNode), 0)
342 def test_17_getOpenRoadmNetwork(self):
343 response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
344 self.assertEqual(response['status_code'], requests.codes.ok)
345 self.assertEqual(len(response['network'][0]['node']), 3)
346 listNode = ['XPDRA01', 'ROADMA01', 'ROADMC01']
347 CHECK_LIST = {'XPDRA01': {'node-ref': 'NodeA', 'node-type': 'XPONDER', 'model': '1'},
348 'ROADMA01': {'node-ref': 'NodeA', 'node-type': 'ROADM', 'model': '2'},
349 'ROADMC01': {'node-ref': 'NodeC', 'node-type': 'ROADM', 'model': '2'}
351 for node in response['network'][0]['node']:
352 self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
353 nodeId = node['node-id']
354 self.assertIn(nodeId, CHECK_LIST)
355 self.assertEqual(node['supporting-node'][0]['node-ref'],
356 CHECK_LIST[nodeId]['node-ref'])
357 self.assertEqual(node['org-openroadm-common-network:node-type'],
358 CHECK_LIST[nodeId]['node-type'])
359 self.assertEqual(node['org-openroadm-network:model'],
360 CHECK_LIST[nodeId]['model'])
361 listNode.remove(nodeId)
362 self.assertEqual(len(listNode), 0)
364 def test_18_getROADMLinkOpenRoadmTopology(self):
365 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
366 self.assertEqual(response['status_code'], requests.codes.ok)
367 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
368 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
369 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
370 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX',
371 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX'],
372 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
373 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
374 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
375 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
376 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX',
377 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX'],
378 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
379 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
380 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
381 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
382 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX',
383 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX'],
384 'ROADM-TO-ROADM': ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
385 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX'],
386 'XPONDER-INPUT': ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1'],
387 'XPONDER-OUTPUT': ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
389 for link in response['network'][0]['ietf-network-topology:link']:
390 linkId = link['link-id']
391 linkType = link['org-openroadm-common-network:link-type']
392 self.assertIn(linkType, check_list)
393 find = linkId in check_list[linkType]
394 self.assertEqual(find, True)
395 (check_list[linkType]).remove(linkId)
396 for link in check_list.values():
397 self.assertEqual(len(link), 0)
399 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
400 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
401 self.assertEqual(response['status_code'], requests.codes.ok)
402 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
403 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
404 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
405 for link in response['network'][0]['ietf-network-topology:link']:
406 link_id = link['link-id']
407 if link_id in R2RLink:
409 spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
410 # pylint: disable=line-too-long
411 length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
412 if (spanLoss is not None) & (length is not None):
414 self.assertTrue(find)
415 R2RLink.remove(link_id)
416 self.assertEqual(len(R2RLink), 0)
418 def test_20_getNodes_OpenRoadmTopology(self):
419 # pylint: disable=redundant-unittest-assert
420 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
421 self.assertEqual(response['status_code'], requests.codes.ok)
422 self.assertEqual(len(response['network'][0]['node']), 8)
423 listNode = ['XPDRA01-XPDR1',
424 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2',
425 'ROADMC01-SRG1', 'ROADMC01-DEG1', 'ROADMC01-DEG2']
426 for node in response['network'][0]['node']:
427 nodeType = node['org-openroadm-common-network:node-type']
428 nodeId = node['node-id']
429 # Tests related to XPDRA nodes
430 if nodeId == 'XPDRA01-XPDR1':
431 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, node['supporting-node'])
432 self.assertEqual(nodeType, 'XPONDER')
433 self.assertEqual(len(node['ietf-network-topology:termination-point']), 6)
436 for tp in node['ietf-network-topology:termination-point']:
437 tpType = tp['org-openroadm-common-network:tp-type']
438 if tpType == 'XPONDER-CLIENT':
440 elif tpType == 'XPONDER-NETWORK':
442 self.assertTrue(client == 4)
443 self.assertTrue(network == 2)
444 listNode.remove(nodeId)
445 # Tests related to ROADMA nodes
446 elif nodeId in self.CHECK_DICT1:
447 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
448 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
449 self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
450 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
451 self.assertIn(tp, node['ietf-network-topology:termination-point'])
452 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
453 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
454 self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
455 listNode.remove(nodeId)
456 # Tests related to ROADMC nodes
457 elif nodeId in self.CHECK_DICT2:
458 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
459 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
460 self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
461 for tp in self.CHECK_DICT2[nodeId]['checks_tp']:
462 self.assertIn(tp, node['ietf-network-topology:termination-point'])
463 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, node['supporting-node'])
464 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'}, node['supporting-node'])
465 self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
466 listNode.remove(nodeId)
468 self.assertFalse(True)
469 self.assertEqual(len(listNode), 0)
471 def test_21_connect_ROADMB(self):
472 response = test_utils_rfc8040.mount_device("ROADMB01", ('roadmb', self.NODE_VERSION))
473 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
475 def test_22_omsAttributes_ROADMA_ROADMB(self):
476 # Config ROADMA01-ROADMB01 oms-attributes
478 "auto-spanloss": "true",
479 "engineered-spanloss": 12.2,
480 "link-concatenation": [{
483 "SRLG-length": 100000,
485 response = test_utils_rfc8040.add_oms_attr_request(
486 "ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX", data)
487 self.assertEqual(response.status_code, requests.codes.created)
489 def test_23_omsAttributes_ROADMB_ROADMA(self):
490 # Config ROADMB01-ROADMA01 oms-attributes
492 "auto-spanloss": "true",
493 "engineered-spanloss": 12.2,
494 "link-concatenation": [{
497 "SRLG-length": 100000,
499 response = test_utils_rfc8040.add_oms_attr_request(
500 "ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX", data)
501 self.assertEqual(response.status_code, requests.codes.created)
503 def test_24_omsAttributes_ROADMB_ROADMC(self):
504 # Config ROADMB01-ROADMC01 oms-attributes
506 "auto-spanloss": "true",
507 "engineered-spanloss": 12.2,
508 "link-concatenation": [{
511 "SRLG-length": 100000,
513 response = test_utils_rfc8040.add_oms_attr_request(
514 "ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX", data)
515 self.assertEqual(response.status_code, requests.codes.created)
517 def test_25_omsAttributes_ROADMC_ROADMB(self):
518 # Config ROADMC01-ROADMB01 oms-attributes
520 "auto-spanloss": "true",
521 "engineered-spanloss": 12.2,
522 "link-concatenation": [{
525 "SRLG-length": 100000,
527 response = test_utils_rfc8040.add_oms_attr_request(
528 "ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX", data)
529 self.assertEqual(response.status_code, requests.codes.created)
531 def test_26_getClliNetwork(self):
532 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
533 self.assertEqual(response['status_code'], requests.codes.ok)
534 listNode = ['NodeA', 'NodeB', 'NodeC']
535 for node in response['network'][0]['node']:
536 nodeId = node['node-id']
537 self.assertIn(nodeId, listNode)
538 self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
539 listNode.remove(nodeId)
540 self.assertEqual(len(listNode), 0)
542 def test_27_verifyDegree(self):
543 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
544 self.assertEqual(response['status_code'], requests.codes.ok)
545 listR2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
546 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
547 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
548 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
549 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
550 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
551 for link in response['network'][0]['ietf-network-topology:link']:
552 if link['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
553 link_id = link['link-id']
554 find = link_id in listR2RLink
555 self.assertEqual(find, True)
556 listR2RLink.remove(link_id)
557 self.assertEqual(len(listR2RLink), 0)
559 def test_28_verifyOppositeLinkTopology(self):
560 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
561 self.assertEqual(response['status_code'], requests.codes.ok)
562 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 34)
563 for link in response['network'][0]['ietf-network-topology:link']:
564 link_id = link['link-id']
565 link_type = link['org-openroadm-common-network:link-type']
566 link_src = link['source']['source-node']
567 link_dest = link['destination']['dest-node']
568 oppLink_id = link['org-openroadm-common-network:opposite-link']
569 # Find the opposite link
570 res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
571 self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
572 self.assertEqual(res_oppLink['link']['org-openroadm-common-network:opposite-link'], link_id)
573 self.assertEqual(res_oppLink['link']['source']['source-node'], link_dest)
574 self.assertEqual(res_oppLink['link']['destination']['dest-node'], link_src)
575 oppLink_type = res_oppLink['link']['org-openroadm-common-network:link-type']
576 CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
577 'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
578 'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
579 if link_type in CHECK_DICT:
580 self.assertEqual(oppLink_type, CHECK_DICT[link_type])
582 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
583 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
584 self.assertEqual(response['status_code'], requests.codes.ok)
585 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
586 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
587 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
588 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
589 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
590 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
591 for link in response['network'][0]['ietf-network-topology:link']:
592 link_id = link['link-id']
593 if link_id in R2RLink:
595 spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
596 # pylint: disable=line-too-long
597 length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
598 if (spanLoss is not None) & (length is not None):
600 self.assertTrue(find)
601 R2RLink.remove(link_id)
602 self.assertEqual(len(R2RLink), 0)
604 def test_30_disconnect_ROADMB(self):
605 # Delete in the topology-netconf
606 response = test_utils_rfc8040.unmount_device("ROADMB01")
607 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
608 # Delete in the clli-network
609 response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
610 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
612 def test_31_disconnect_ROADMC(self):
613 response = test_utils_rfc8040.unmount_device("ROADMC01")
614 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
615 # Delete in the clli-network
616 response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
617 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
619 def test_32_getNodes_OpenRoadmTopology(self):
620 # pylint: disable=redundant-unittest-assert
621 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
622 self.assertEqual(response['status_code'], requests.codes.ok)
623 self.assertEqual(len(response['network'][0]['node']), 5)
624 listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
625 for node in response['network'][0]['node']:
626 nodeType = node['org-openroadm-common-network:node-type']
627 nodeId = node['node-id']
628 # Tests related to XPDRA nodes
629 if nodeId == 'XPDRA01-XPDR1':
630 for tp in node['ietf-network-topology:termination-point']:
632 if tpid == 'XPDR1-CLIENT1':
633 self.assertEqual(tp['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
634 if tpid == 'XPDR1-NETWORK1':
635 self.assertEqual(tp['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
636 # pylint: disable=line-too-long
637 self.assertEqual(tp['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
638 'ROADMA01-SRG1--SRG1-PP1-TXRX')
639 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'}, node['supporting-node'])
640 listNode.remove(nodeId)
641 # Tests related to ROADMA nodes
642 elif nodeId in self.CHECK_DICT1:
643 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
644 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
645 self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
646 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
647 self.assertIn(tp, node['ietf-network-topology:termination-point'])
648 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
649 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
650 listNode.remove(nodeId)
652 self.assertFalse(True)
653 self.assertEqual(len(listNode), 0)
654 # Test related to SRG1 of ROADMC
655 for node in response['network'][0]['node']:
656 self.assertNotEqual(node['node-id'], 'ROADMC01-SRG1')
657 self.assertNotEqual(node['node-id'], 'ROADMC01-DEG1')
658 self.assertNotEqual(node['node-id'], 'ROADMC01-DEG2')
660 def test_33_getOpenRoadmNetwork(self):
661 response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
662 self.assertEqual(response['status_code'], requests.codes.ok)
663 self.assertEqual(len(response['network'][0]['node']), 2)
664 for node in response['network'][0]['node']:
665 self.assertNotEqual(node['node-id'], 'ROADMC01')
666 self.assertNotEqual(node['node-id'], 'ROADMB01')
668 def test_34_getClliNetwork(self):
669 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
670 self.assertEqual(response['status_code'], requests.codes.ok)
671 self.assertEqual(len(response['network'][0]['node']), 1)
672 self.assertNotEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeC')
674 def test_35_disconnect_XPDRA(self):
675 response = test_utils_rfc8040.unmount_device("XPDRA01")
676 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
678 def test_36_getClliNetwork(self):
679 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
680 self.assertEqual(response['status_code'], requests.codes.ok)
681 self.assertEqual(len(response['network'][0]['node']), 1)
682 self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
684 def test_37_getOpenRoadmNetwork(self):
685 response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
686 self.assertEqual(response['status_code'], requests.codes.ok)
687 self.assertEqual(len(response['network'][0]['node']), 1)
688 self.assertNotEqual(response['network'][0]['node'][0]['node-id'], 'XPDRA01')
690 def test_38_getNodes_OpenRoadmTopology(self):
691 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
692 self.assertEqual(response['status_code'], requests.codes.ok)
693 self.assertEqual(len(response['network'][0]['node']), 4)
694 listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
695 for node in response['network'][0]['node']:
696 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
697 nodeType = node['org-openroadm-common-network:node-type']
698 nodeId = node['node-id']
699 self.assertIn(nodeId, self.CHECK_DICT1)
700 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
701 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
702 self.assertEqual(len(node['ietf-network-topology:termination-point']), 17)
703 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
704 self.assertIn(tp, node['ietf-network-topology:termination-point'])
705 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
706 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'}, node['supporting-node'])
707 listNode.remove(nodeId)
708 self.assertEqual(len(listNode), 0)
710 def test_39_disconnect_ROADM_XPDRA_link(self):
712 response = test_utils_rfc8040.del_ietf_network_link_request(
713 'openroadm-topology',
714 'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX',
717 response2 = test_utils_rfc8040.del_ietf_network_link_request(
718 'openroadm-topology',
719 'ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1',
721 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
722 self.assertIn(response2.status_code, (requests.codes.ok, requests.codes.no_content))
724 def test_40_getLinks_OpenRoadmTopology(self):
725 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
726 self.assertEqual(response['status_code'], requests.codes.ok)
727 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 16)
728 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
729 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX'],
730 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
731 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
732 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
733 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX'],
734 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
735 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
736 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
737 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
740 for link in response['network'][0]['ietf-network-topology:link']:
741 linkId = link['link-id']
742 linkType = link['org-openroadm-common-network:link-type']
743 if linkType in check_list:
744 find = linkId in check_list[linkType]
745 self.assertEqual(find, True)
746 (check_list[linkType]).remove(linkId)
748 roadmtoroadmLink += 1
749 for link in check_list.values():
750 self.assertEqual(len(link), 0)
751 self.assertEqual(roadmtoroadmLink, 6)
752 for link in response['network'][0]['ietf-network-topology:link']:
753 self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
754 self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
756 def test_41_disconnect_ROADMA(self):
757 response = test_utils_rfc8040.unmount_device("ROADMA01")
758 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
759 # Delete in the clli-network
760 response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
761 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
763 def test_42_getClliNetwork(self):
764 response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
765 self.assertEqual(response['status_code'], requests.codes.ok)
766 self.assertNotIn('node', response['network'][0])
768 def test_43_getOpenRoadmNetwork(self):
769 response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
770 self.assertEqual(response['status_code'], requests.codes.ok)
771 self.assertNotIn('node', response['network'][0])
773 def test_44_check_roadm2roadm_link_persistence(self):
774 response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
775 self.assertEqual(response['status_code'], requests.codes.ok)
776 self.assertNotIn('node', response['network'][0])
777 self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
780 if __name__ == "__main__":
781 unittest.main(verbosity=2)