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 # pylint: disable=wrong-import-order
22 sys.path.append('transportpce_tests/common/')
23 # pylint: disable=wrong-import-position
24 # pylint: disable=import-error
25 import test_utils # nopep8
28 class TransportPCEtesting(unittest.TestCase):
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'})]
98 NODE_VERSION = '2.2.1'
102 cls.processes = test_utils.start_tpce()
103 cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
104 ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
107 def tearDownClass(cls):
108 # pylint: disable=not-an-iterable
109 for process in cls.processes:
110 test_utils.shutdown_process(process)
111 print("all processes killed")
116 def test_01_connect_ROADM_A1(self):
117 response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
118 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
120 def test_02_getClliNetwork(self):
121 response = test_utils.get_clli_net_request()
122 self.assertEqual(response.status_code, requests.codes.ok)
123 res = response.json()
125 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
126 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
128 def test_03_getOpenRoadmNetwork(self):
129 response = test_utils.get_ordm_net_request()
130 self.assertEqual(response.status_code, requests.codes.ok)
131 res = response.json()
132 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
133 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
134 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
135 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
136 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
138 def test_04_getLinks_OpenroadmTopology(self):
139 # pylint: disable=redundant-unittest-assert
140 response = test_utils.get_ordm_topo_request("")
141 self.assertEqual(response.status_code, requests.codes.ok)
142 res = response.json()
143 # Tests related to links
144 nbLink = len(res['network'][0]['ietf-network-topology:link'])
145 self.assertEqual(nbLink, 10)
146 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
147 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
148 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
149 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
150 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
151 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
152 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
153 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
154 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
155 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
157 for i in range(0, nbLink):
158 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
159 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
160 if linkType in check_list:
161 find = linkId in check_list[linkType]
162 self.assertEqual(find, True)
163 (check_list[linkType]).remove(linkId)
165 self.assertFalse(True)
166 for val in check_list.values():
167 self.assertEqual(len(val), 0)
169 def test_05_getNodes_OpenRoadmTopology(self):
170 # pylint: disable=redundant-unittest-assert
171 response = test_utils.get_ordm_topo_request("")
172 res = response.json()
173 # Tests related to nodes
174 self.assertEqual(response.status_code, requests.codes.ok)
175 nbNode = len(res['network'][0]['node'])
176 self.assertEqual(nbNode, 4)
177 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
178 for i in range(0, nbNode):
179 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
180 res['network'][0]['node'][i]['supporting-node'])
181 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
182 nodeId = res['network'][0]['node'][i]['node-id']
183 if nodeId in self.CHECK_DICT1:
184 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
185 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
186 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
187 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
188 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
189 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
190 res['network'][0]['node'][i]['supporting-node'])
191 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
192 res['network'][0]['node'][i]['supporting-node'])
193 listNode.remove(nodeId)
195 self.assertFalse(True)
196 self.assertEqual(len(listNode), 0)
198 def test_06_connect_XPDRA(self):
199 response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
200 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
202 def test_07_getClliNetwork(self):
203 response = test_utils.get_clli_net_request()
204 self.assertEqual(response.status_code, requests.codes.ok)
205 res = response.json()
206 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
207 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
209 def test_08_getOpenRoadmNetwork(self):
210 # pylint: disable=redundant-unittest-assert
211 response = test_utils.get_ordm_net_request()
212 self.assertEqual(response.status_code, requests.codes.ok)
213 res = response.json()
214 nbNode = len(res['network'][0]['node'])
215 self.assertEqual(nbNode, 2)
216 for i in range(0, nbNode):
217 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
218 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
219 nodeId = res['network'][0]['node'][i]['node-id']
220 if nodeId == 'XPDR-A1':
221 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
222 elif nodeId == 'ROADM-A1':
223 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
225 self.assertFalse(True)
227 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
229 def test_09_getNodes_OpenRoadmTopology(self):
230 # pylint: disable=redundant-unittest-assert
231 response = test_utils.get_ordm_topo_request("")
232 res = response.json()
233 # Tests related to nodes
234 self.assertEqual(response.status_code, requests.codes.ok)
235 nbNode = len(res['network'][0]['node'])
236 self.assertEqual(nbNode, 5)
237 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
238 for i in range(0, nbNode):
239 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
240 nodeId = res['network'][0]['node'][i]['node-id']
241 # Tests related to XPDRA nodes
242 if nodeId == 'XPDR-A1-XPDR1':
243 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
244 res['network'][0]['node'][i]['supporting-node'])
245 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
246 res['network'][0]['node'][i]['supporting-node'])
247 self.assertEqual(nodeType, 'XPONDER')
248 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
251 for j in range(0, nbTps):
252 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
253 ['org-openroadm-common-network:tp-type'])
254 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
255 if tpType == 'XPONDER-CLIENT':
257 elif tpType == 'XPONDER-NETWORK':
259 if tpId == 'XPDR1-NETWORK2':
260 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
261 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
262 if tpId == 'XPDR1-CLIENT2':
263 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
264 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
266 self.assertTrue(client == 2)
267 self.assertTrue(network == 2)
268 listNode.remove(nodeId)
269 elif nodeId in self.CHECK_DICT1:
270 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
271 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
272 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
273 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
274 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
275 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
276 res['network'][0]['node'][i]['supporting-node'])
277 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
278 res['network'][0]['node'][i]['supporting-node'])
279 listNode.remove(nodeId)
281 self.assertFalse(True)
282 self.assertEqual(len(listNode), 0)
284 # Connect the tail XPDRA to ROADMA and vice versa
285 def test_10_connect_tail_xpdr_rdm(self):
286 # Connect the tail: XPDRA to ROADMA
287 response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "1",
288 "ROADM-A1", "1", "SRG1-PP1-TXRX")
289 self.assertEqual(response.status_code, requests.codes.ok)
291 def test_11_connect_tail_rdm_xpdr(self):
292 response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "1",
293 "ROADM-A1", "1", "SRG1-PP1-TXRX")
294 self.assertEqual(response.status_code, requests.codes.ok)
296 def test_12_getLinks_OpenRoadmTopology(self):
297 # pylint: disable=redundant-unittest-assert
298 response = test_utils.get_ordm_topo_request("")
299 self.assertEqual(response.status_code, requests.codes.ok)
300 res = response.json()
301 # Tests related to links
302 nbLink = len(res['network'][0]['ietf-network-topology:link'])
303 self.assertEqual(nbLink, 12)
304 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
305 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
306 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
307 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
308 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
309 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
310 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
311 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
312 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
313 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX'],
314 'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
315 'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
317 for i in range(0, nbLink):
318 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
319 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
320 if linkType in check_list:
321 find = linkId in check_list[linkType]
322 self.assertEqual(find, True)
323 (check_list[linkType]).remove(linkId)
325 self.assertFalse(True)
326 for val in check_list.values():
327 self.assertEqual(len(val), 0)
329 def test_13_connect_ROADMC(self):
330 response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
331 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
333 def test_14_omsAttributes_ROADMA_ROADMC(self):
334 # Config ROADMA-ROADMC oms-attributes
336 "auto-spanloss": "true",
337 "engineered-spanloss": 12.2,
338 "link-concatenation": [{
341 "SRLG-length": 100000,
343 response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
344 self.assertEqual(response.status_code, requests.codes.created)
346 def test_15_omsAttributes_ROADMC_ROADMA(self):
347 # Config ROADM-C1-ROADM-A1 oms-attributes
349 "auto-spanloss": "true",
350 "engineered-spanloss": 12.2,
351 "link-concatenation": [{
354 "SRLG-length": 100000,
357 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
358 self.assertEqual(response.status_code, requests.codes.created)
360 def test_16_getClliNetwork(self):
361 # pylint: disable=redundant-unittest-assert
362 response = test_utils.get_clli_net_request()
363 self.assertEqual(response.status_code, requests.codes.ok)
364 res = response.json()
365 nbNode = len(res['network'][0]['node'])
366 listNode = ['NodeA', 'NodeC']
367 for i in range(0, nbNode):
368 nodeId = res['network'][0]['node'][i]['node-id']
369 if nodeId in listNode:
370 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
371 listNode.remove(nodeId)
373 self.assertFalse(True)
374 self.assertEqual(len(listNode), 0)
376 def test_17_getOpenRoadmNetwork(self):
377 # pylint: disable=redundant-unittest-assert
378 response = test_utils.get_ordm_net_request()
379 self.assertEqual(response.status_code, requests.codes.ok)
380 res = response.json()
381 nbNode = len(res['network'][0]['node'])
382 self.assertEqual(nbNode, 3)
383 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
384 CHECK_LIST = {'XPDR-A1': {'node-ref': 'NodeA', 'node-type': 'XPONDER'},
385 'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
386 'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
388 for i in range(0, nbNode):
389 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
390 nodeId = res['network'][0]['node'][i]['node-id']
391 if nodeId in CHECK_LIST:
392 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],
393 CHECK_LIST[nodeId]['node-ref'])
394 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
395 CHECK_LIST[nodeId]['node-type'])
396 listNode.remove(nodeId)
398 self.assertFalse(True)
400 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
401 self.assertEqual(len(listNode), 0)
403 def test_18_getROADMLinkOpenRoadmTopology(self):
404 # pylint: disable=redundant-unittest-assert
405 response = test_utils.get_ordm_topo_request("")
406 self.assertEqual(response.status_code, requests.codes.ok)
407 res = response.json()
408 # Tests related to links
409 nbLink = len(res['network'][0]['ietf-network-topology:link'])
410 self.assertEqual(nbLink, 20)
411 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
412 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
413 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX',
414 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX'],
415 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
416 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
417 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
418 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
419 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX',
420 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX'],
421 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
422 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
423 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
424 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
425 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX',
426 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX'],
427 'ROADM-TO-ROADM': ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
428 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'],
429 'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
430 'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
432 for i in range(0, nbLink):
433 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
434 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
435 if linkType in check_list:
436 find = linkId in check_list[linkType]
437 self.assertEqual(find, True)
438 (check_list[linkType]).remove(linkId)
440 self.assertFalse(True)
441 for val in check_list.values():
442 self.assertEqual(len(val), 0)
444 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
445 response = test_utils.get_ordm_topo_request("")
446 self.assertEqual(response.status_code, requests.codes.ok)
447 res = response.json()
448 # Tests related to links
449 nbLink = len(res['network'][0]['ietf-network-topology:link'])
450 self.assertEqual(nbLink, 20)
451 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
452 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
453 for i in range(0, nbLink):
454 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
455 if link_id in R2RLink:
457 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
458 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
459 length = res['network'][0]['ietf-network-topology:link'][i][
460 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
461 if (spanLoss is not None) & (length is not None):
463 self.assertTrue(find)
464 R2RLink.remove(link_id)
465 self.assertEqual(len(R2RLink), 0)
467 def test_20_getNodes_OpenRoadmTopology(self):
468 # pylint: disable=redundant-unittest-assert
469 response = test_utils.get_ordm_topo_request("")
470 res = response.json()
471 # Tests related to nodes
472 self.assertEqual(response.status_code, requests.codes.ok)
473 nbNode = len(res['network'][0]['node'])
474 self.assertEqual(nbNode, 8)
475 listNode = ['XPDR-A1-XPDR1',
476 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
477 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
478 # Tests related to XPDRA nodes
479 for i in range(0, nbNode):
480 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
481 nodeId = res['network'][0]['node'][i]['node-id']
482 if nodeId == 'XPDR-A1-XPDR1':
483 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
484 res['network'][0]['node'][i]['supporting-node'])
485 self.assertEqual(nodeType, 'XPONDER')
486 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
487 self.assertTrue(nbTps >= 4)
490 for j in range(0, nbTps):
491 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
492 ['org-openroadm-common-network:tp-type'])
493 if tpType == 'XPONDER-CLIENT':
495 elif tpType == 'XPONDER-NETWORK':
497 self.assertTrue(client == 2)
498 self.assertTrue(network == 2)
499 listNode.remove(nodeId)
500 # Tests related to ROADMA nodes
501 elif nodeId in self.CHECK_DICT1:
502 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
503 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
504 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
505 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
506 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
507 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
508 res['network'][0]['node'][i]['supporting-node'])
509 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
510 res['network'][0]['node'][i]['supporting-node'])
511 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
512 self.CHECK_DICT1[nodeId]['node_type'])
513 listNode.remove(nodeId)
514 # Tests related to ROADMA nodes
515 elif nodeId in self.CHECK_DICT2:
516 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
517 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
518 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
519 for item in self.CHECK_DICT2[nodeId]['checks_tp']:
520 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
521 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'},
522 res['network'][0]['node'][i]['supporting-node'])
523 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
524 res['network'][0]['node'][i]['supporting-node'])
525 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
526 self.CHECK_DICT2[nodeId]['node_type'])
527 listNode.remove(nodeId)
528 self.assertEqual(len(listNode), 0)
530 def test_21_connect_ROADMB(self):
531 response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
532 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
534 def test_22_omsAttributes_ROADMA_ROADMB(self):
535 # Config ROADM-A1-ROADM-B1 oms-attributes
537 "auto-spanloss": "true",
538 "engineered-spanloss": 12.2,
539 "spanloss-current": 12,
540 "spanloss-base": 11.4,
541 "link-concatenation": [{
544 "SRLG-length": 100000,
546 response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
547 self.assertEqual(response.status_code, requests.codes.created)
549 def test_23_omsAttributes_ROADMB_ROADMA(self):
550 # Config ROADM-B1-ROADM-A1 oms-attributes
552 "auto-spanloss": "true",
553 "engineered-spanloss": 12.2,
554 "spanloss-current": 12,
555 "spanloss-base": 11.4,
556 "link-concatenation": [{
559 "SRLG-length": 100000,
561 response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
562 self.assertEqual(response.status_code, requests.codes.created)
564 def test_24_omsAttributes_ROADMB_ROADMC(self):
565 # Config ROADM-B1-ROADM-C1 oms-attributes
567 "auto-spanloss": "true",
568 "engineered-spanloss": 12.2,
569 "spanloss-current": 12,
570 "spanloss-base": 11.4,
571 "link-concatenation": [{
574 "SRLG-length": 100000,
576 response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
577 self.assertEqual(response.status_code, requests.codes.created)
579 def test_25_omsAttributes_ROADMC_ROADMB(self):
580 # Config ROADM-C1-ROADM-B1 oms-attributes
582 "auto-spanloss": "true",
583 "engineered-spanloss": 12.2,
584 "link-concatenation": [{
587 "SRLG-length": 100000,
589 response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
590 self.assertEqual(response.status_code, requests.codes.created)
592 def test_26_getClliNetwork(self):
593 # pylint: disable=redundant-unittest-assert
594 response = test_utils.get_clli_net_request()
595 self.assertEqual(response.status_code, requests.codes.ok)
596 res = response.json()
597 nbNode = len(res['network'][0]['node'])
598 listNode = ['NodeA', 'NodeB', 'NodeC']
599 for i in range(0, nbNode):
600 nodeId = res['network'][0]['node'][i]['node-id']
601 if nodeId in listNode:
602 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
603 listNode.remove(nodeId)
605 self.assertFalse(True)
606 self.assertEqual(len(listNode), 0)
608 def test_27_verifyDegree(self):
609 response = test_utils.get_ordm_topo_request("")
610 self.assertEqual(response.status_code, requests.codes.ok)
611 res = response.json()
612 # Tests related to links
613 nbLink = len(res['network'][0]['ietf-network-topology:link'])
614 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
615 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
616 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
617 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
618 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
619 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
620 for i in range(0, nbLink):
621 if (res['network'][0]['ietf-network-topology:link'][i]
622 ['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM'):
623 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
624 find = link_id in listR2RLink
625 self.assertEqual(find, True)
626 listR2RLink.remove(link_id)
627 self.assertEqual(len(listR2RLink), 0)
629 def test_28_verifyOppositeLinkTopology(self):
630 response = test_utils.get_ordm_topo_request("")
631 self.assertEqual(response.status_code, requests.codes.ok)
632 res = response.json()
633 # Tests related to links
634 nbLink = len(res['network'][0]['ietf-network-topology:link'])
635 self.assertEqual(nbLink, 30)
636 for i in range(0, nbLink):
637 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
638 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
639 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
640 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
641 oppLink_id = (res['network'][0]['ietf-network-topology:link'][i]
642 ['org-openroadm-common-network:opposite-link'])
643 # Find the opposite link
644 response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
645 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
646 res_oppLink = response_oppLink.json()
647 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
648 ['org-openroadm-common-network:opposite-link'], link_id)
649 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
650 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
651 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
652 CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
653 'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
654 'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
655 if link_type in CHECK_DICT:
656 self.assertEqual(oppLink_type, CHECK_DICT[link_type])
658 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
659 response = test_utils.get_ordm_topo_request("")
660 self.assertEqual(response.status_code, requests.codes.ok)
661 res = response.json()
662 nbLink = len(res['network'][0]['ietf-network-topology:link'])
663 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
664 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
665 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
666 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
667 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
668 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
669 for i in range(0, nbLink):
670 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
671 if link_id in R2RLink:
673 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
674 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
675 length = res['network'][0]['ietf-network-topology:link'][i][
676 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
677 if (spanLoss is not None) & (length is not None):
679 self.assertTrue(find)
680 R2RLink.remove(link_id)
681 self.assertEqual(len(R2RLink), 0)
683 def test_30_disconnect_ROADMB(self):
684 # Delete in the topology-netconf
685 response = test_utils.unmount_device("ROADM-B1")
686 # Delete in the clli-network
687 response = test_utils.del_node_request("NodeB")
688 self.assertEqual(response.status_code, requests.codes.ok)
690 def test_31_disconnect_ROADMC(self):
691 # Delete in the topology-netconf
692 response = test_utils.unmount_device("ROADM-C1")
693 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
694 # Delete in the clli-network
695 response = test_utils.del_node_request("NodeC")
696 self.assertEqual(response.status_code, requests.codes.ok)
698 def test_32_getNodes_OpenRoadmTopology(self):
699 # pylint: disable=redundant-unittest-assert
700 response = test_utils.get_ordm_topo_request("")
701 res = response.json()
702 # Tests related to nodes
703 self.assertEqual(response.status_code, requests.codes.ok)
704 nbNode = len(res['network'][0]['node'])
705 self.assertEqual(nbNode, 5)
706 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
707 for i in range(0, nbNode):
708 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
709 nodeId = res['network'][0]['node'][i]['node-id']
710 # Tests related to XPDRA nodes
711 if nodeId == 'XPDR-A1-XPDR1':
712 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
713 for j in range(0, nbTp):
714 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
715 if tpid == 'XPDR1-CLIENT1':
716 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
717 ['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
718 if tpid == 'XPDR1-NETWORK1':
719 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
720 ['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
721 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
722 ['org-openroadm-network-topology:xpdr-network-attributes']
723 ['tail-equipment-id']),
724 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
725 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
726 res['network'][0]['node'][i]['supporting-node'])
727 listNode.remove(nodeId)
728 # Tests related to ROADMA nodes
729 elif nodeId in self.CHECK_DICT1:
730 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
731 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
732 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
733 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
734 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
735 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
736 res['network'][0]['node'][i]['supporting-node'])
737 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
738 res['network'][0]['node'][i]['supporting-node'])
739 listNode.remove(nodeId)
741 self.assertFalse(True)
742 self.assertEqual(len(listNode), 0)
743 # Test related to SRG1 of ROADMC
744 for i in range(0, nbNode):
745 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
746 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
747 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
749 def test_33_getOpenRoadmNetwork(self):
750 response = test_utils.get_ordm_net_request()
751 self.assertEqual(response.status_code, requests.codes.ok)
752 res = response.json()
753 nbNode = len(res['network'][0]['node'])
754 self.assertEqual(nbNode, 2)
755 for i in range(0, nbNode-1):
756 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
757 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
759 def test_34_getClliNetwork(self):
760 response = test_utils.get_clli_net_request()
761 self.assertEqual(response.status_code, requests.codes.ok)
762 res = response.json()
763 nbNode = len(res['network'][0]['node'])
764 self.assertEqual(nbNode, 1)
765 for i in range(0, nbNode-1):
766 self.assertNotEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
768 def test_35_disconnect_XPDRA(self):
769 response = test_utils.unmount_device("XPDR-A1")
770 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
772 def test_36_getClliNetwork(self):
773 response = test_utils.get_clli_net_request()
774 self.assertEqual(response.status_code, requests.codes.ok)
775 res = response.json()
776 nbNode = len(res['network'][0]['node'])
777 self.assertEqual(nbNode, 1)
778 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
780 def test_37_getOpenRoadmNetwork(self):
781 response = test_utils.get_ordm_net_request()
782 self.assertEqual(response.status_code, requests.codes.ok)
783 res = response.json()
784 nbNode = len(res['network'][0]['node'])
785 self.assertEqual(nbNode, 1)
786 for i in range(0, nbNode):
787 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
789 def test_38_getNodes_OpenRoadmTopology(self):
790 # pylint: disable=redundant-unittest-assert
791 response = test_utils.get_ordm_topo_request("")
792 res = response.json()
793 # Tests related to nodes
794 self.assertEqual(response.status_code, requests.codes.ok)
795 nbNode = len(res['network'][0]['node'])
796 self.assertEqual(nbNode, 4)
797 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
798 for i in range(0, nbNode):
799 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
800 res['network'][0]['node'][i]['supporting-node'])
801 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
802 nodeId = res['network'][0]['node'][i]['node-id']
803 if nodeId in self.CHECK_DICT1:
804 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
805 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
806 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
807 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
808 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
809 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
810 res['network'][0]['node'][i]['supporting-node'])
811 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
812 res['network'][0]['node'][i]['supporting-node'])
813 listNode.remove(nodeId)
815 self.assertFalse(True)
816 self.assertEqual(len(listNode), 0)
818 def test_39_disconnect_ROADM_XPDRA_link(self):
820 response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
821 self.assertEqual(response.status_code, requests.codes.ok)
823 response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
824 self.assertEqual(response.status_code, requests.codes.ok)
826 def test_40_getLinks_OpenRoadmTopology(self):
827 response = test_utils.get_ordm_topo_request("")
828 self.assertEqual(response.status_code, requests.codes.ok)
829 res = response.json()
830 nbLink = len(res['network'][0]['ietf-network-topology:link'])
831 self.assertEqual(nbLink, 16)
832 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
833 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
834 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
835 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
836 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
837 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
838 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
839 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
840 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
841 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
844 for i in range(0, nbLink):
845 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
846 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
847 if linkType in check_list:
848 find = linkId in check_list[linkType]
849 self.assertEqual(find, True)
850 (check_list[linkType]).remove(linkId)
852 roadmtoroadmLink += 1
853 for val in check_list.values():
854 self.assertEqual(len(val), 0)
855 self.assertEqual(roadmtoroadmLink, 6)
856 for i in range(0, nbLink):
857 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
858 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
859 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
860 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
862 def test_41_disconnect_ROADMA(self):
863 response = test_utils.unmount_device("ROADM-A1")
864 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
865 # Delete in the clli-network
866 response = test_utils.del_node_request("NodeA")
867 self.assertEqual(response.status_code, requests.codes.ok)
869 def test_42_getClliNetwork(self):
870 response = test_utils.get_clli_net_request()
871 self.assertEqual(response.status_code, requests.codes.ok)
872 res = response.json()
873 self.assertNotIn('node', res['network'][0])
875 def test_43_getOpenRoadmNetwork(self):
876 response = test_utils.get_ordm_net_request()
877 self.assertEqual(response.status_code, requests.codes.ok)
878 res = response.json()
879 self.assertNotIn('node', res['network'][0])
881 def test_44_check_roadm2roadm_link_persistence(self):
882 response = test_utils.get_ordm_topo_request("")
883 self.assertEqual(response.status_code, requests.codes.ok)
884 res = response.json()
885 nbLink = len(res['network'][0]['ietf-network-topology:link'])
886 self.assertNotIn('node', res['network'][0])
887 self.assertEqual(nbLink, 6)
890 if __name__ == "__main__":
891 unittest.main(verbosity=2)