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
20 sys.path.append('transportpce_tests/common/')
24 class TransportPCETopologyTesting(unittest.TestCase):
27 NODE_VERSION = '1.2.1'
31 'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
32 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
33 'org-openroadm-common-network:operational-state': 'inService'}),
34 ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
35 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
36 'org-openroadm-common-network:operational-state': 'inService'})]
40 'checks_tp': [({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
41 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
42 'org-openroadm-common-network:operational-state': 'inService'}),
43 ({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
44 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
45 'org-openroadm-common-network:operational-state': 'inService'})]
48 'node_type': 'DEGREE',
49 'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
50 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
51 'org-openroadm-common-network:operational-state': 'inService'}),
52 ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
53 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
54 'org-openroadm-common-network:operational-state': 'inService'})]
57 'node_type': 'DEGREE',
58 'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
59 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
60 'org-openroadm-common-network:operational-state': 'inService'}),
61 ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
62 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
63 'org-openroadm-common-network:operational-state': 'inService'})]
69 'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
70 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
71 'org-openroadm-common-network:operational-state': 'inService'}),
72 ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
73 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
74 'org-openroadm-common-network:operational-state': 'inService'})]
77 'node_type': 'DEGREE',
78 'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
79 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
80 'org-openroadm-common-network:operational-state': 'inService'}),
81 ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
82 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
83 'org-openroadm-common-network:operational-state': 'inService'})]
86 'node_type': 'DEGREE',
87 'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
88 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
89 'org-openroadm-common-network:operational-state': 'inService'}),
90 ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
91 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
92 'org-openroadm-common-network:operational-state': 'inService'})]
98 cls.processes = test_utils.start_tpce()
99 cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
100 ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
103 def tearDownClass(cls):
104 # pylint: disable=not-an-iterable
105 for process in cls.processes:
106 test_utils.shutdown_process(process)
107 print("all processes killed")
112 def test_01_connect_ROADMA(self):
113 response = test_utils.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
114 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
116 def test_02_getClliNetwork(self):
117 response = test_utils.get_clli_net_request()
118 self.assertEqual(response.status_code, requests.codes.ok)
119 res = response.json()
120 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
121 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
123 def test_03_getOpenRoadmNetwork(self):
124 response = test_utils.get_ordm_net_request()
125 self.assertEqual(response.status_code, requests.codes.ok)
126 res = response.json()
127 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADMA01')
128 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
129 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
130 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
131 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], '2')
133 def test_04_getLinks_OpenroadmTopology(self):
134 # pylint: disable=redundant-unittest-assert
135 response = test_utils.get_ordm_topo_request("")
136 self.assertEqual(response.status_code, requests.codes.ok)
137 res = response.json()
138 # Tests related to links
139 nbLink = len(res['network'][0]['ietf-network-topology:link'])
140 self.assertEqual(nbLink, 10)
141 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
142 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX'],
143 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
144 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
145 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
146 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX'],
147 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
148 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
149 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
150 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
152 for i in range(0, nbLink):
153 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
154 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
155 if linkType in check_list:
156 find = linkId in check_list[linkType]
157 self.assertEqual(find, True)
158 (check_list[linkType]).remove(linkId)
160 self.assertFalse(True)
161 for link_type in check_list:
162 self.assertEqual(len(check_list[link_type]), 0)
164 def test_05_getNodes_OpenRoadmTopology(self):
165 # pylint: disable=redundant-unittest-assert
166 response = test_utils.get_ordm_topo_request("")
167 res = response.json()
168 # Tests related to nodes
169 self.assertEqual(response.status_code, requests.codes.ok)
170 nbNode = len(res['network'][0]['node'])
171 self.assertEqual(nbNode, 4)
172 listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
173 for i in range(0, nbNode):
174 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
175 res['network'][0]['node'][i]['supporting-node'])
176 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
177 nodeId = res['network'][0]['node'][i]['node-id']
178 if nodeId in self.CHECK_DICT1:
179 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
180 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
181 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
182 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
183 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
184 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
185 res['network'][0]['node'][i]['supporting-node'])
186 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
187 res['network'][0]['node'][i]['supporting-node'])
188 listNode.remove(nodeId)
190 self.assertFalse(True)
192 self.assertEqual(len(listNode), 0)
194 def test_06_connect_XPDRA(self):
195 response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
196 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
198 def test_07_getClliNetwork(self):
199 response = test_utils.get_clli_net_request()
200 self.assertEqual(response.status_code, requests.codes.ok)
201 res = response.json()
202 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
203 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
205 def test_08_getOpenRoadmNetwork(self):
206 # pylint: disable=redundant-unittest-assert
207 response = test_utils.get_ordm_net_request()
208 self.assertEqual(response.status_code, requests.codes.ok)
209 res = response.json()
210 nbNode = len(res['network'][0]['node'])
211 self.assertEqual(nbNode, 2)
212 for i in range(0, nbNode):
213 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
214 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
215 nodeId = res['network'][0]['node'][i]['node-id']
216 if nodeId == 'XPDRA01':
217 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
218 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '1')
219 elif nodeId == 'ROADMA01':
220 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
221 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
223 self.assertFalse(True)
225 def test_09_getNodes_OpenRoadmTopology(self):
226 # pylint: disable=redundant-unittest-assert
227 response = test_utils.get_ordm_topo_request("")
228 res = response.json()
229 # Tests related to nodes
230 self.assertEqual(response.status_code, requests.codes.ok)
231 nbNode = len(res['network'][0]['node'])
232 self.assertEqual(nbNode, 5)
233 listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
234 for i in range(0, nbNode):
235 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
236 nodeId = res['network'][0]['node'][i]['node-id']
237 # Tests related to XPDRA nodes
238 if nodeId == 'XPDRA01-XPDR1':
239 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
240 res['network'][0]['node'][i]['supporting-node'])
241 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
242 res['network'][0]['node'][i]['supporting-node'])
243 self.assertEqual(nodeType, 'XPONDER')
244 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
247 for j in range(0, nbTps):
248 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j][
249 'org-openroadm-common-network:tp-type']
250 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
251 if tpType == 'XPONDER-CLIENT':
253 elif tpType == 'XPONDER-NETWORK':
255 if tpId == 'XPDR1-NETWORK2':
256 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
257 [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT3')
258 if tpId == 'XPDR1-CLIENT3':
259 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
260 [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
261 self.assertTrue(client == 4)
262 self.assertTrue(network == 2)
263 listNode.remove(nodeId)
264 # Tests related to ROADMA nodes
265 elif nodeId in self.CHECK_DICT1:
266 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
267 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
268 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
269 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
270 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
271 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
272 res['network'][0]['node'][i]['supporting-node'])
273 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
274 res['network'][0]['node'][i]['supporting-node'])
275 listNode.remove(nodeId)
277 self.assertFalse(True)
278 self.assertEqual(len(listNode), 0)
280 # Connect the tail XPDRA to ROADMA and vice versa
281 def test_10_connect_tail_xpdr_rdm(self):
282 # Connect the tail: XPDRA to ROADMA
283 response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
284 "ROADMA01", "1", "SRG1-PP1-TXRX")
285 self.assertEqual(response.status_code, requests.codes.ok)
287 def test_11_connect_tail_rdm_xpdr(self):
288 # Connect the tail: ROADMA to XPDRA
289 response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
290 "ROADMA01", "1", "SRG1-PP1-TXRX")
291 self.assertEqual(response.status_code, requests.codes.ok)
293 def test_12_getLinks_OpenRoadmTopology(self):
294 # pylint: disable=redundant-unittest-assert
295 response = test_utils.get_ordm_topo_request("")
296 self.assertEqual(response.status_code, requests.codes.ok)
297 res = response.json()
298 # Tests related to links
299 nbLink = len(res['network'][0]['ietf-network-topology:link'])
300 self.assertEqual(nbLink, 12)
301 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
302 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX'],
303 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
304 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
305 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
306 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX'],
307 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
308 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
309 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
310 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX'],
311 'XPONDER-INPUT': ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1'],
312 'XPONDER-OUTPUT': ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
314 for i in range(0, nbLink):
315 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
316 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
317 if linkType in check_list:
318 find = linkId in check_list[linkType]
319 self.assertEqual(find, True)
320 (check_list[linkType]).remove(linkId)
322 self.assertFalse(True)
323 for link_type in check_list:
324 self.assertEqual(len(check_list[link_type]), 0)
326 def test_13_connect_ROADMC(self):
327 response = test_utils.mount_device("ROADMC01", ('roadmc', self.NODE_VERSION))
328 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
330 def test_14_omsAttributes_ROADMA_ROADMC(self):
331 # Config ROADMA01-ROADMC01 oms-attributes
333 "auto-spanloss": "true",
334 "engineered-spanloss": 12.2,
335 "link-concatenation": [{
338 "SRLG-length": 100000,
340 response = test_utils.add_oms_attr_request("ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX", data)
341 self.assertEqual(response.status_code, requests.codes.created)
343 def test_15_omsAttributes_ROADMC_ROADMA(self):
344 # Config ROADMC01-ROADMA oms-attributes
346 "auto-spanloss": "true",
347 "engineered-spanloss": 12.2,
348 "link-concatenation": [{
351 "SRLG-length": 100000,
353 response = test_utils.add_oms_attr_request("ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX", data)
354 self.assertEqual(response.status_code, requests.codes.created)
356 def test_16_getClliNetwork(self):
357 # pylint: disable=redundant-unittest-assert
358 response = test_utils.get_clli_net_request()
359 self.assertEqual(response.status_code, requests.codes.ok)
360 res = response.json()
361 nbNode = len(res['network'][0]['node'])
362 listNode = ['NodeA', 'NodeC']
363 for i in range(0, nbNode):
364 nodeId = res['network'][0]['node'][i]['node-id']
365 if nodeId in listNode:
366 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
367 listNode.remove(nodeId)
369 self.assertFalse(True)
370 self.assertEqual(len(listNode), 0)
372 def test_17_getOpenRoadmNetwork(self):
373 # pylint: disable=redundant-unittest-assert
374 response = test_utils.get_ordm_net_request()
375 self.assertEqual(response.status_code, requests.codes.ok)
376 res = response.json()
377 nbNode = len(res['network'][0]['node'])
378 self.assertEqual(nbNode, 3)
379 listNode = ['XPDRA01', 'ROADMA01', 'ROADMC01']
380 CHECK_LIST = {'XPDRA01': {'node-ref': 'NodeA', 'node-type': 'XPONDER', 'model': '1'},
381 'ROADMA01': {'node-ref': 'NodeA', 'node-type': 'ROADM', 'model': '2'},
382 'ROADMC01': {'node-ref': 'NodeC', 'node-type': 'ROADM', 'model': '2'}
384 for i in range(0, nbNode):
385 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
386 nodeId = res['network'][0]['node'][i]['node-id']
387 if nodeId in CHECK_LIST:
388 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],
389 CHECK_LIST[nodeId]['node-ref'])
390 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
391 CHECK_LIST[nodeId]['node-type'])
392 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],
393 CHECK_LIST[nodeId]['model'])
394 listNode.remove(nodeId)
396 self.assertFalse(True)
397 self.assertEqual(len(listNode), 0)
399 def test_18_getROADMLinkOpenRoadmTopology(self):
400 # pylint: disable=redundant-unittest-assert
401 response = test_utils.get_ordm_topo_request("")
402 self.assertEqual(response.status_code, requests.codes.ok)
403 res = response.json()
404 # Tests related to links
405 nbLink = len(res['network'][0]['ietf-network-topology:link'])
406 self.assertEqual(nbLink, 20)
407 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
408 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
409 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX',
410 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX'],
411 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
412 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
413 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
414 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
415 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX',
416 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX'],
417 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
418 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
419 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
420 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
421 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX',
422 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX'],
423 'ROADM-TO-ROADM': ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
424 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX'],
425 'XPONDER-INPUT': ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1'],
426 'XPONDER-OUTPUT': ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
428 for i in range(0, nbLink):
429 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
430 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
431 if linkType in check_list:
432 find = linkId in check_list[linkType]
433 self.assertEqual(find, True)
434 (check_list[linkType]).remove(linkId)
436 self.assertFalse(True)
437 for link_type in check_list:
438 self.assertEqual(len(check_list[link_type]), 0)
440 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
441 response = test_utils.get_ordm_topo_request("")
442 self.assertEqual(response.status_code, requests.codes.ok)
443 res = response.json()
444 # Tests related to links
445 nbLink = len(res['network'][0]['ietf-network-topology:link'])
446 self.assertEqual(nbLink, 20)
447 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
448 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
449 for i in range(0, nbLink):
450 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
451 if link_id in R2RLink:
453 spanLoss = (res['network'][0]['ietf-network-topology:link'][i]
454 ['org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"])
455 length = (res['network'][0]['ietf-network-topology:link'][i]
456 ['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]
458 if (spanLoss is not None) & (length is not None):
460 self.assertTrue(find)
461 R2RLink.remove(link_id)
462 self.assertEqual(len(R2RLink), 0)
464 def test_20_getNodes_OpenRoadmTopology(self):
465 # pylint: disable=redundant-unittest-assert
466 response = test_utils.get_ordm_topo_request("")
467 res = response.json()
468 # Tests related to nodes
469 self.assertEqual(response.status_code, requests.codes.ok)
470 nbNode = len(res['network'][0]['node'])
471 self.assertEqual(nbNode, 8)
472 listNode = ['XPDRA01-XPDR1',
473 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2',
474 'ROADMC01-SRG1', 'ROADMC01-DEG1', 'ROADMC01-DEG2']
475 for i in range(0, nbNode):
476 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
477 nodeId = res['network'][0]['node'][i]['node-id']
478 # Tests related to XPDRA nodes
479 if nodeId == 'XPDRA01-XPDR1':
480 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
481 res['network'][0]['node'][i]['supporting-node'])
482 self.assertEqual(nodeType, 'XPONDER')
483 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
484 self.assertTrue(nbTps == 6)
487 for j in range(0, nbTps):
488 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j][
489 'org-openroadm-common-network:tp-type']
490 if tpType == 'XPONDER-CLIENT':
492 elif tpType == 'XPONDER-NETWORK':
494 self.assertTrue(client == 4)
495 self.assertTrue(network == 2)
496 listNode.remove(nodeId)
497 # Tests related to ROADMA nodes
498 elif nodeId in self.CHECK_DICT1:
499 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
500 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
501 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
502 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
503 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
504 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
505 res['network'][0]['node'][i]['supporting-node'])
506 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
507 res['network'][0]['node'][i]['supporting-node'])
508 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
509 self.CHECK_DICT1[nodeId]['node_type'])
510 listNode.remove(nodeId)
511 # Tests related to ROADMC nodes
512 elif nodeId in self.CHECK_DICT2:
513 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
514 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
515 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
516 for item in self.CHECK_DICT2[nodeId]['checks_tp']:
517 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
518 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'},
519 res['network'][0]['node'][i]['supporting-node'])
520 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
521 res['network'][0]['node'][i]['supporting-node'])
522 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
523 self.CHECK_DICT2[nodeId]['node_type'])
524 listNode.remove(nodeId)
526 self.assertFalse(True)
527 self.assertEqual(len(listNode), 0)
529 def test_21_connect_ROADMB(self):
530 response = test_utils.mount_device("ROADMB01", ('roadmb', self.NODE_VERSION))
531 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
533 def test_22_omsAttributes_ROADMA_ROADMB(self):
534 # Config ROADMA01-ROADMB01 oms-attributes
536 "auto-spanloss": "true",
537 "engineered-spanloss": 12.2,
538 "link-concatenation": [{
541 "SRLG-length": 100000,
543 response = test_utils.add_oms_attr_request("ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX", data)
544 self.assertEqual(response.status_code, requests.codes.created)
546 def test_23_omsAttributes_ROADMB_ROADMA(self):
547 # Config ROADMB01-ROADMA01 oms-attributes
549 "auto-spanloss": "true",
550 "engineered-spanloss": 12.2,
551 "link-concatenation": [{
554 "SRLG-length": 100000,
556 response = test_utils.add_oms_attr_request("ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX", data)
557 self.assertEqual(response.status_code, requests.codes.created)
559 def test_24_omsAttributes_ROADMB_ROADMC(self):
560 # Config ROADMB01-ROADMC01 oms-attributes
562 "auto-spanloss": "true",
563 "engineered-spanloss": 12.2,
564 "link-concatenation": [{
567 "SRLG-length": 100000,
569 response = test_utils.add_oms_attr_request("ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX", data)
570 self.assertEqual(response.status_code, requests.codes.created)
572 def test_25_omsAttributes_ROADMC_ROADMB(self):
573 # Config ROADMC01-ROADMB01 oms-attributes
575 "auto-spanloss": "true",
576 "engineered-spanloss": 12.2,
577 "link-concatenation": [{
580 "SRLG-length": 100000,
582 response = test_utils.add_oms_attr_request("ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX", data)
583 self.assertEqual(response.status_code, requests.codes.created)
585 def test_26_getClliNetwork(self):
586 # pylint: disable=redundant-unittest-assert
587 response = test_utils.get_clli_net_request()
588 self.assertEqual(response.status_code, requests.codes.ok)
589 res = response.json()
590 nbNode = len(res['network'][0]['node'])
591 listNode = ['NodeA', 'NodeB', 'NodeC']
592 for i in range(0, nbNode):
593 nodeId = res['network'][0]['node'][i]['node-id']
594 if nodeId in listNode:
595 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
596 listNode.remove(nodeId)
598 self.assertFalse(True)
599 self.assertEqual(len(listNode), 0)
601 def test_27_verifyDegree(self):
602 response = test_utils.get_ordm_topo_request("")
603 self.assertEqual(response.status_code, requests.codes.ok)
604 res = response.json()
605 # Tests related to links
606 nbLink = len(res['network'][0]['ietf-network-topology:link'])
607 listR2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
608 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
609 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
610 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
611 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
612 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
613 for i in range(0, nbLink):
614 if (res['network'][0]['ietf-network-topology:link'][i]
615 ['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM'):
616 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
617 find = link_id in listR2RLink
618 self.assertEqual(find, True)
619 listR2RLink.remove(link_id)
620 self.assertEqual(len(listR2RLink), 0)
622 def test_28_verifyOppositeLinkTopology(self):
623 response = test_utils.get_ordm_topo_request("")
624 self.assertEqual(response.status_code, requests.codes.ok)
625 res = response.json()
626 # Tests related to links
627 nbLink = len(res['network'][0]['ietf-network-topology:link'])
628 self.assertEqual(nbLink, 34)
629 for i in range(0, nbLink):
630 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
631 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
632 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
633 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
634 oppLink_id = (res['network'][0]['ietf-network-topology:link'][i]
635 ['org-openroadm-common-network:opposite-link'])
636 # Find the opposite link
637 response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
638 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
639 res_oppLink = response_oppLink.json()
640 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
641 ['org-openroadm-common-network:opposite-link'], link_id)
642 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
643 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
644 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
645 CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
646 'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
647 'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
648 if link_type in CHECK_DICT:
649 self.assertEqual(oppLink_type, CHECK_DICT[link_type])
651 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
652 response = test_utils.get_ordm_topo_request("")
653 self.assertEqual(response.status_code, requests.codes.ok)
654 res = response.json()
655 nbLink = len(res['network'][0]['ietf-network-topology:link'])
656 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
657 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
658 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
659 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
660 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
661 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
662 for i in range(0, nbLink):
663 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
664 if link_id in R2RLink:
666 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
667 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
668 length = res['network'][0]['ietf-network-topology:link'][i][
669 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
670 if (spanLoss is not None) & (length is not None):
672 self.assertTrue(find)
673 R2RLink.remove(link_id)
674 self.assertEqual(len(R2RLink), 0)
676 def test_30_disconnect_ROADMB(self):
677 # Delete in the topology-netconf
678 response = test_utils.unmount_device("ROADMB01")
679 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
680 # Delete in the clli-network
681 response = test_utils.del_node_request("NodeB")
682 self.assertEqual(response.status_code, requests.codes.ok)
684 def test_31_disconnect_ROADMC(self):
685 response = test_utils.unmount_device("ROADMC01")
686 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
687 # Delete in the clli-network
688 response = test_utils.del_node_request("NodeC")
689 self.assertEqual(response.status_code, requests.codes.ok)
691 def test_32_getNodes_OpenRoadmTopology(self):
692 # pylint: disable=redundant-unittest-assert
693 response = test_utils.get_ordm_topo_request("")
694 res = response.json()
695 # Tests related to nodes
696 self.assertEqual(response.status_code, requests.codes.ok)
697 nbNode = len(res['network'][0]['node'])
698 self.assertEqual(nbNode, 5)
699 listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
700 for i in range(0, nbNode):
701 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
702 nodeId = res['network'][0]['node'][i]['node-id']
703 # Tests related to XPDRA nodes
704 if nodeId == 'XPDRA01-XPDR1':
705 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
706 for j in range(0, nbTp):
707 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
708 if tpid == 'XPDR1-CLIENT1':
709 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
710 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
711 if tpid == 'XPDR1-NETWORK1':
712 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
713 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
714 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
715 ['org-openroadm-network-topology:xpdr-network-attributes']
716 ['tail-equipment-id'],
717 'ROADMA01-SRG1--SRG1-PP1-TXRX')
718 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
719 res['network'][0]['node'][i]['supporting-node'])
720 listNode.remove(nodeId)
721 # Tests related to ROADMA nodes
722 elif nodeId in self.CHECK_DICT1:
723 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
724 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
725 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
726 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
727 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
728 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
729 res['network'][0]['node'][i]['supporting-node'])
730 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
731 res['network'][0]['node'][i]['supporting-node'])
732 listNode.remove(nodeId)
734 self.assertFalse(True)
735 self.assertEqual(len(listNode), 0)
736 # Test related to SRG1 of ROADMC
737 for i in range(0, nbNode):
738 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-SRG1')
739 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-DEG1')
740 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-DEG2')
742 def test_33_getOpenRoadmNetwork(self):
743 response = test_utils.get_ordm_net_request()
744 self.assertEqual(response.status_code, requests.codes.ok)
745 res = response.json()
746 nbNode = len(res['network'][0]['node'])
747 self.assertEqual(nbNode, 2)
748 for i in range(0, nbNode-1):
749 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01')
750 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMB01')
752 def test_34_getClliNetwork(self):
753 response = test_utils.get_clli_net_request()
754 self.assertEqual(response.status_code, requests.codes.ok)
755 res = response.json()
756 nbNode = len(res['network'][0]['node'])
757 self.assertEqual(nbNode, 1)
758 for i in range(0, nbNode-1):
759 self.assertNotEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
761 def test_35_disconnect_XPDRA(self):
762 response = test_utils.unmount_device("XPDRA01")
763 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
765 def test_36_getClliNetwork(self):
766 response = test_utils.get_clli_net_request()
767 self.assertEqual(response.status_code, requests.codes.ok)
768 res = response.json()
769 nbNode = len(res['network'][0]['node'])
770 self.assertEqual(nbNode, 1)
771 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
773 def test_37_getOpenRoadmNetwork(self):
774 response = test_utils.get_ordm_net_request()
775 self.assertEqual(response.status_code, requests.codes.ok)
776 res = response.json()
777 nbNode = len(res['network'][0]['node'])
778 self.assertEqual(nbNode, 1)
779 for i in range(0, nbNode):
780 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDRA01')
782 def test_38_getNodes_OpenRoadmTopology(self):
783 # pylint: disable=redundant-unittest-assert
784 response = test_utils.get_ordm_topo_request("")
785 res = response.json()
786 # Tests related to nodes
787 self.assertEqual(response.status_code, requests.codes.ok)
788 nbNode = len(res['network'][0]['node'])
789 self.assertEqual(nbNode, 4)
790 listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
791 for i in range(0, nbNode):
792 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
793 res['network'][0]['node'][i]['supporting-node'])
794 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
795 nodeId = res['network'][0]['node'][i]['node-id']
796 if nodeId in self.CHECK_DICT1:
797 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
798 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
799 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
800 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
801 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
802 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
803 res['network'][0]['node'][i]['supporting-node'])
804 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
805 res['network'][0]['node'][i]['supporting-node'])
806 listNode.remove(nodeId)
808 self.assertFalse(True)
809 self.assertEqual(len(listNode), 0)
811 def test_39_disconnect_ROADM_XPDRA_link(self):
813 response = test_utils.del_link_request("XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX")
814 self.assertEqual(response.status_code, requests.codes.ok)
816 response = test_utils.del_link_request("ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1")
817 self.assertEqual(response.status_code, requests.codes.ok)
819 def test_40_getLinks_OpenRoadmTopology(self):
820 response = test_utils.get_ordm_topo_request("")
821 self.assertEqual(response.status_code, requests.codes.ok)
822 res = response.json()
823 nbLink = len(res['network'][0]['ietf-network-topology:link'])
824 self.assertEqual(nbLink, 16)
825 check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
826 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX'],
827 'ADD-LINK': ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
828 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
829 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
830 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX'],
831 'DROP-LINK': ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
832 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
833 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
834 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
837 for i in range(0, nbLink):
838 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
839 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
840 if linkType in check_list:
841 find = linkId in check_list[linkType]
842 self.assertEqual(find, True)
843 (check_list[linkType]).remove(linkId)
845 roadmtoroadmLink += 1
846 for link_type in check_list:
847 self.assertEqual(len(check_list[link_type]), 0)
848 self.assertEqual(roadmtoroadmLink, 6)
849 for i in range(0, nbLink):
850 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
851 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
852 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
853 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
855 def test_41_disconnect_ROADMA(self):
856 response = test_utils.unmount_device("ROADMA01")
857 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
858 # Delete in the clli-network
859 response = test_utils.del_node_request("NodeA")
860 self.assertEqual(response.status_code, requests.codes.ok)
862 def test_42_getClliNetwork(self):
863 response = test_utils.get_clli_net_request()
864 self.assertEqual(response.status_code, requests.codes.ok)
865 res = response.json()
866 self.assertNotIn('node', res['network'][0])
868 def test_43_getOpenRoadmNetwork(self):
869 response = test_utils.get_ordm_net_request()
870 self.assertEqual(response.status_code, requests.codes.ok)
871 res = response.json()
872 self.assertNotIn('node', res['network'][0])
874 def test_44_check_roadm2roadm_link_persistence(self):
875 response = test_utils.get_ordm_topo_request("")
876 self.assertEqual(response.status_code, requests.codes.ok)
877 res = response.json()
878 nbLink = len(res['network'][0]['ietf-network-topology:link'])
879 self.assertNotIn('node', res['network'][0])
880 self.assertEqual(nbLink, 6)
883 if __name__ == "__main__":
884 unittest.main(verbosity=2)