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
21 sys.path.append('transportpce_tests/common/')
25 class TransportPCEtesting(unittest.TestCase):
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'})]
95 NODE_VERSION = '2.2.1'
99 cls.processes = test_utils.start_tpce()
100 cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
101 ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
104 def tearDownClass(cls):
105 # pylint: disable=not-an-iterable
106 for process in cls.processes:
107 test_utils.shutdown_process(process)
108 print("all processes killed")
113 def test_01_connect_ROADM_A1(self):
114 response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
115 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
117 def test_02_getClliNetwork(self):
118 response = test_utils.get_clli_net_request()
119 self.assertEqual(response.status_code, requests.codes.ok)
120 res = response.json()
122 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
123 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
125 def test_03_getOpenRoadmNetwork(self):
126 response = test_utils.get_ordm_net_request()
127 self.assertEqual(response.status_code, requests.codes.ok)
128 res = response.json()
129 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
130 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
131 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
132 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
133 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
135 def test_04_getLinks_OpenroadmTopology(self):
136 # pylint: disable=redundant-unittest-assert
137 response = test_utils.get_ordm_topo_request("")
138 self.assertEqual(response.status_code, requests.codes.ok)
139 res = response.json()
140 # Tests related to links
141 nbLink = len(res['network'][0]['ietf-network-topology:link'])
142 self.assertEqual(nbLink, 10)
143 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
144 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
145 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
146 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
147 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
148 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
149 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
150 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
151 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
152 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
154 for i in range(0, nbLink):
155 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
156 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
157 if linkType in check_list:
158 find = linkId in check_list[linkType]
159 self.assertEqual(find, True)
160 (check_list[linkType]).remove(linkId)
162 self.assertFalse(True)
163 for link_type in check_list:
164 self.assertEqual(len(check_list[link_type]), 0)
166 def test_05_getNodes_OpenRoadmTopology(self):
167 # pylint: disable=redundant-unittest-assert
168 response = test_utils.get_ordm_topo_request("")
169 res = response.json()
170 # Tests related to nodes
171 self.assertEqual(response.status_code, requests.codes.ok)
172 nbNode = len(res['network'][0]['node'])
173 self.assertEqual(nbNode, 4)
174 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
175 for i in range(0, nbNode):
176 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
177 res['network'][0]['node'][i]['supporting-node'])
178 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
179 nodeId = res['network'][0]['node'][i]['node-id']
180 if nodeId in self.CHECK_DICT1:
181 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
182 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
183 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
184 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
185 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
186 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
187 res['network'][0]['node'][i]['supporting-node'])
188 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
189 res['network'][0]['node'][i]['supporting-node'])
190 listNode.remove(nodeId)
192 self.assertFalse(True)
193 self.assertEqual(len(listNode), 0)
195 def test_06_connect_XPDRA(self):
196 response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
197 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
199 def test_07_getClliNetwork(self):
200 response = test_utils.get_clli_net_request()
201 self.assertEqual(response.status_code, requests.codes.ok)
202 res = response.json()
203 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
204 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
206 def test_08_getOpenRoadmNetwork(self):
207 # pylint: disable=redundant-unittest-assert
208 response = test_utils.get_ordm_net_request()
209 self.assertEqual(response.status_code, requests.codes.ok)
210 res = response.json()
211 nbNode = len(res['network'][0]['node'])
212 self.assertEqual(nbNode, 2)
213 for i in range(0, nbNode):
214 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
215 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
216 nodeId = res['network'][0]['node'][i]['node-id']
217 if nodeId == 'XPDR-A1':
218 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
219 elif nodeId == 'ROADM-A1':
220 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
222 self.assertFalse(True)
224 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
226 def test_09_getNodes_OpenRoadmTopology(self):
227 # pylint: disable=redundant-unittest-assert
228 response = test_utils.get_ordm_topo_request("")
229 res = response.json()
230 # Tests related to nodes
231 self.assertEqual(response.status_code, requests.codes.ok)
232 nbNode = len(res['network'][0]['node'])
233 self.assertEqual(nbNode, 5)
234 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
235 for i in range(0, nbNode):
236 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
237 nodeId = res['network'][0]['node'][i]['node-id']
238 # Tests related to XPDRA nodes
239 if nodeId == 'XPDR-A1-XPDR1':
240 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
241 res['network'][0]['node'][i]['supporting-node'])
242 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
243 res['network'][0]['node'][i]['supporting-node'])
244 self.assertEqual(nodeType, 'XPONDER')
245 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
248 for j in range(0, nbTps):
249 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
250 ['org-openroadm-common-network:tp-type'])
251 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
252 if tpType == 'XPONDER-CLIENT':
254 elif tpType == 'XPONDER-NETWORK':
256 if tpId == 'XPDR1-NETWORK2':
257 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
258 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
259 if tpId == 'XPDR1-CLIENT2':
260 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
261 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
263 self.assertTrue(client == 2)
264 self.assertTrue(network == 2)
265 listNode.remove(nodeId)
266 elif nodeId in self.CHECK_DICT1:
267 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
268 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
269 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
270 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
271 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
272 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
273 res['network'][0]['node'][i]['supporting-node'])
274 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
275 res['network'][0]['node'][i]['supporting-node'])
276 listNode.remove(nodeId)
278 self.assertFalse(True)
279 self.assertEqual(len(listNode), 0)
281 # Connect the tail XPDRA to ROADMA and vice versa
282 def test_10_connect_tail_xpdr_rdm(self):
283 # Connect the tail: XPDRA to ROADMA
284 response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "1",
285 "ROADM-A1", "1", "SRG1-PP1-TXRX")
286 self.assertEqual(response.status_code, requests.codes.ok)
288 def test_11_connect_tail_rdm_xpdr(self):
289 response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "1",
290 "ROADM-A1", "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': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
302 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
303 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
304 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
305 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
306 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
307 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
308 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
309 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
310 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX'],
311 'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
312 'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-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("ROADM-C1", ('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 ROADMA-ROADMC 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("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
341 self.assertEqual(response.status_code, requests.codes.created)
343 def test_15_omsAttributes_ROADMC_ROADMA(self):
344 # Config ROADM-C1-ROADM-A1 oms-attributes
346 "auto-spanloss": "true",
347 "engineered-spanloss": 12.2,
348 "link-concatenation": [{
351 "SRLG-length": 100000,
354 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
355 self.assertEqual(response.status_code, requests.codes.created)
357 def test_16_getClliNetwork(self):
358 # pylint: disable=redundant-unittest-assert
359 response = test_utils.get_clli_net_request()
360 self.assertEqual(response.status_code, requests.codes.ok)
361 res = response.json()
362 nbNode = len(res['network'][0]['node'])
363 listNode = ['NodeA', 'NodeC']
364 for i in range(0, nbNode):
365 nodeId = res['network'][0]['node'][i]['node-id']
366 if nodeId in listNode:
367 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
368 listNode.remove(nodeId)
370 self.assertFalse(True)
371 self.assertEqual(len(listNode), 0)
373 def test_17_getOpenRoadmNetwork(self):
374 # pylint: disable=redundant-unittest-assert
375 response = test_utils.get_ordm_net_request()
376 self.assertEqual(response.status_code, requests.codes.ok)
377 res = response.json()
378 nbNode = len(res['network'][0]['node'])
379 self.assertEqual(nbNode, 3)
380 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
381 CHECK_LIST = {'XPDR-A1': {'node-ref': 'NodeA', 'node-type': 'XPONDER'},
382 'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
383 'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
385 for i in range(0, nbNode):
386 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
387 nodeId = res['network'][0]['node'][i]['node-id']
388 if nodeId in CHECK_LIST:
389 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],
390 CHECK_LIST[nodeId]['node-ref'])
391 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
392 CHECK_LIST[nodeId]['node-type'])
393 listNode.remove(nodeId)
395 self.assertFalse(True)
397 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
398 self.assertEqual(len(listNode), 0)
400 def test_18_getROADMLinkOpenRoadmTopology(self):
401 # pylint: disable=redundant-unittest-assert
402 response = test_utils.get_ordm_topo_request("")
403 self.assertEqual(response.status_code, requests.codes.ok)
404 res = response.json()
405 # Tests related to links
406 nbLink = len(res['network'][0]['ietf-network-topology:link'])
407 self.assertEqual(nbLink, 20)
408 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
409 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
410 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX',
411 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX'],
412 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
413 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
414 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
415 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
416 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX',
417 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX'],
418 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
419 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
420 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
421 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
422 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX',
423 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX'],
424 'ROADM-TO-ROADM': ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
425 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'],
426 'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
427 'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
429 for i in range(0, nbLink):
430 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
431 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
432 if linkType in check_list:
433 find = linkId in check_list[linkType]
434 self.assertEqual(find, True)
435 (check_list[linkType]).remove(linkId)
437 self.assertFalse(True)
438 for link_type in check_list:
439 self.assertEqual(len(check_list[link_type]), 0)
441 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
442 response = test_utils.get_ordm_topo_request("")
443 self.assertEqual(response.status_code, requests.codes.ok)
444 res = response.json()
445 # Tests related to links
446 nbLink = len(res['network'][0]['ietf-network-topology:link'])
447 self.assertEqual(nbLink, 20)
448 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
449 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
450 for i in range(0, nbLink):
451 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
452 if link_id in R2RLink:
454 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
455 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
456 length = res['network'][0]['ietf-network-topology:link'][i][
457 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
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 = ['XPDR-A1-XPDR1',
473 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
474 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
475 # Tests related to XPDRA nodes
476 for i in range(0, nbNode):
477 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
478 nodeId = res['network'][0]['node'][i]['node-id']
479 if nodeId == 'XPDR-A1-XPDR1':
480 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
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 >= 4)
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 == 2)
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']), 5)
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': 'ROADM-A1'},
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 ROADMA 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']), 5)
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': 'ROADM-C1'},
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)
525 self.assertEqual(len(listNode), 0)
527 def test_21_connect_ROADMB(self):
528 response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
529 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
531 def test_22_omsAttributes_ROADMA_ROADMB(self):
532 # Config ROADM-A1-ROADM-B1 oms-attributes
534 "auto-spanloss": "true",
535 "engineered-spanloss": 12.2,
536 "spanloss-current": 12,
537 "spanloss-base": 11.4,
538 "link-concatenation": [{
541 "SRLG-length": 100000,
543 response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
544 self.assertEqual(response.status_code, requests.codes.created)
546 def test_23_omsAttributes_ROADMB_ROADMA(self):
547 # Config ROADM-B1-ROADM-A1 oms-attributes
549 "auto-spanloss": "true",
550 "engineered-spanloss": 12.2,
551 "spanloss-current": 12,
552 "spanloss-base": 11.4,
553 "link-concatenation": [{
556 "SRLG-length": 100000,
558 response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
559 self.assertEqual(response.status_code, requests.codes.created)
561 def test_24_omsAttributes_ROADMB_ROADMC(self):
562 # Config ROADM-B1-ROADM-C1 oms-attributes
564 "auto-spanloss": "true",
565 "engineered-spanloss": 12.2,
566 "spanloss-current": 12,
567 "spanloss-base": 11.4,
568 "link-concatenation": [{
571 "SRLG-length": 100000,
573 response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
574 self.assertEqual(response.status_code, requests.codes.created)
576 def test_25_omsAttributes_ROADMC_ROADMB(self):
577 # Config ROADM-C1-ROADM-B1 oms-attributes
579 "auto-spanloss": "true",
580 "engineered-spanloss": 12.2,
581 "link-concatenation": [{
584 "SRLG-length": 100000,
586 response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
587 self.assertEqual(response.status_code, requests.codes.created)
589 def test_26_getClliNetwork(self):
590 # pylint: disable=redundant-unittest-assert
591 response = test_utils.get_clli_net_request()
592 self.assertEqual(response.status_code, requests.codes.ok)
593 res = response.json()
594 nbNode = len(res['network'][0]['node'])
595 listNode = ['NodeA', 'NodeB', 'NodeC']
596 for i in range(0, nbNode):
597 nodeId = res['network'][0]['node'][i]['node-id']
598 if nodeId in listNode:
599 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
600 listNode.remove(nodeId)
602 self.assertFalse(True)
603 self.assertEqual(len(listNode), 0)
605 def test_27_verifyDegree(self):
606 response = test_utils.get_ordm_topo_request("")
607 self.assertEqual(response.status_code, requests.codes.ok)
608 res = response.json()
609 # Tests related to links
610 nbLink = len(res['network'][0]['ietf-network-topology:link'])
611 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
612 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
613 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
614 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
615 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
616 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
617 for i in range(0, nbLink):
618 if (res['network'][0]['ietf-network-topology:link'][i]
619 ['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM'):
620 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
621 find = link_id in listR2RLink
622 self.assertEqual(find, True)
623 listR2RLink.remove(link_id)
624 self.assertEqual(len(listR2RLink), 0)
626 def test_28_verifyOppositeLinkTopology(self):
627 response = test_utils.get_ordm_topo_request("")
628 self.assertEqual(response.status_code, requests.codes.ok)
629 res = response.json()
630 # Tests related to links
631 nbLink = len(res['network'][0]['ietf-network-topology:link'])
632 self.assertEqual(nbLink, 26)
633 for i in range(0, nbLink):
634 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
635 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
636 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
637 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
638 oppLink_id = (res['network'][0]['ietf-network-topology:link'][i]
639 ['org-openroadm-common-network:opposite-link'])
640 # Find the opposite link
641 response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
642 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
643 res_oppLink = response_oppLink.json()
644 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
645 ['org-openroadm-common-network:opposite-link'], link_id)
646 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
647 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
648 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
649 CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
650 'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
651 'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
652 if link_type in CHECK_DICT:
653 self.assertEqual(oppLink_type, CHECK_DICT[link_type])
655 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
656 response = test_utils.get_ordm_topo_request("")
657 self.assertEqual(response.status_code, requests.codes.ok)
658 res = response.json()
659 nbLink = len(res['network'][0]['ietf-network-topology:link'])
660 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
661 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
662 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
663 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
664 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
665 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
666 for i in range(0, nbLink):
667 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
668 if link_id in R2RLink:
670 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
671 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
672 length = res['network'][0]['ietf-network-topology:link'][i][
673 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
674 if (spanLoss is not None) & (length is not None):
676 self.assertTrue(find)
677 R2RLink.remove(link_id)
678 self.assertEqual(len(R2RLink), 0)
680 def test_30_disconnect_ROADMB(self):
681 # Delete in the topology-netconf
682 response = test_utils.unmount_device("ROADM-B1")
683 # Delete in the clli-network
684 response = test_utils.del_node_request("NodeB")
685 self.assertEqual(response.status_code, requests.codes.ok)
687 def test_31_disconnect_ROADMC(self):
688 # Delete in the topology-netconf
689 response = test_utils.unmount_device("ROADM-C1")
690 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
691 # Delete in the clli-network
692 response = test_utils.del_node_request("NodeC")
693 self.assertEqual(response.status_code, requests.codes.ok)
695 def test_32_getNodes_OpenRoadmTopology(self):
696 # pylint: disable=redundant-unittest-assert
697 response = test_utils.get_ordm_topo_request("")
698 res = response.json()
699 # Tests related to nodes
700 self.assertEqual(response.status_code, requests.codes.ok)
701 nbNode = len(res['network'][0]['node'])
702 self.assertEqual(nbNode, 5)
703 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
704 for i in range(0, nbNode):
705 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
706 nodeId = res['network'][0]['node'][i]['node-id']
707 # Tests related to XPDRA nodes
708 if nodeId == 'XPDR-A1-XPDR1':
709 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
710 for j in range(0, nbTp):
711 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
712 if tpid == 'XPDR1-CLIENT1':
713 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
714 ['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
715 if tpid == 'XPDR1-NETWORK1':
716 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
717 ['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
718 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
719 ['org-openroadm-network-topology:xpdr-network-attributes']
720 ['tail-equipment-id']),
721 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
722 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
723 res['network'][0]['node'][i]['supporting-node'])
724 listNode.remove(nodeId)
725 # Tests related to ROADMA nodes
726 elif nodeId in self.CHECK_DICT1:
727 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
728 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
729 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
730 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
731 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
732 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
733 res['network'][0]['node'][i]['supporting-node'])
734 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
735 res['network'][0]['node'][i]['supporting-node'])
736 listNode.remove(nodeId)
738 self.assertFalse(True)
739 self.assertEqual(len(listNode), 0)
740 # Test related to SRG1 of ROADMC
741 for i in range(0, nbNode):
742 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
743 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
744 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
746 def test_33_getOpenRoadmNetwork(self):
747 response = test_utils.get_ordm_net_request()
748 self.assertEqual(response.status_code, requests.codes.ok)
749 res = response.json()
750 nbNode = len(res['network'][0]['node'])
751 self.assertEqual(nbNode, 2)
752 for i in range(0, nbNode-1):
753 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
754 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
756 def test_34_getClliNetwork(self):
757 response = test_utils.get_clli_net_request()
758 self.assertEqual(response.status_code, requests.codes.ok)
759 res = response.json()
760 nbNode = len(res['network'][0]['node'])
761 self.assertEqual(nbNode, 1)
762 for i in range(0, nbNode-1):
763 self.assertNotEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
765 def test_35_disconnect_XPDRA(self):
766 response = test_utils.unmount_device("XPDR-A1")
767 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
769 def test_36_getClliNetwork(self):
770 response = test_utils.get_clli_net_request()
771 self.assertEqual(response.status_code, requests.codes.ok)
772 res = response.json()
773 nbNode = len(res['network'][0]['node'])
774 self.assertEqual(nbNode, 1)
775 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
777 def test_37_getOpenRoadmNetwork(self):
778 response = test_utils.get_ordm_net_request()
779 self.assertEqual(response.status_code, requests.codes.ok)
780 res = response.json()
781 nbNode = len(res['network'][0]['node'])
782 self.assertEqual(nbNode, 1)
783 for i in range(0, nbNode):
784 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
786 def test_38_getNodes_OpenRoadmTopology(self):
787 # pylint: disable=redundant-unittest-assert
788 response = test_utils.get_ordm_topo_request("")
789 res = response.json()
790 # Tests related to nodes
791 self.assertEqual(response.status_code, requests.codes.ok)
792 nbNode = len(res['network'][0]['node'])
793 self.assertEqual(nbNode, 4)
794 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
795 for i in range(0, nbNode):
796 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
797 res['network'][0]['node'][i]['supporting-node'])
798 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
799 nodeId = res['network'][0]['node'][i]['node-id']
800 if nodeId in self.CHECK_DICT1:
801 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
802 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
803 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
804 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
805 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
806 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
807 res['network'][0]['node'][i]['supporting-node'])
808 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
809 res['network'][0]['node'][i]['supporting-node'])
810 listNode.remove(nodeId)
812 self.assertFalse(True)
813 self.assertEqual(len(listNode), 0)
815 def test_39_disconnect_ROADM_XPDRA_link(self):
817 response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
818 self.assertEqual(response.status_code, requests.codes.ok)
820 response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
821 self.assertEqual(response.status_code, requests.codes.ok)
823 def test_40_getLinks_OpenRoadmTopology(self):
824 response = test_utils.get_ordm_topo_request("")
825 self.assertEqual(response.status_code, requests.codes.ok)
826 res = response.json()
827 nbLink = len(res['network'][0]['ietf-network-topology:link'])
828 self.assertEqual(nbLink, 16)
829 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
830 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
831 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
832 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
833 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
834 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
835 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
836 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
837 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
838 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
841 for i in range(0, nbLink):
842 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
843 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
844 if linkType in check_list:
845 find = linkId in check_list[linkType]
846 self.assertEqual(find, True)
847 (check_list[linkType]).remove(linkId)
849 roadmtoroadmLink += 1
850 for link_type in check_list:
851 self.assertEqual(len(check_list[link_type]), 0)
852 self.assertEqual(roadmtoroadmLink, 6)
853 for i in range(0, nbLink):
854 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
855 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
856 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
857 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
859 def test_41_disconnect_ROADMA(self):
860 response = test_utils.unmount_device("ROADM-A1")
861 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
862 # Delete in the clli-network
863 response = test_utils.del_node_request("NodeA")
864 self.assertEqual(response.status_code, requests.codes.ok)
866 def test_42_getClliNetwork(self):
867 response = test_utils.get_clli_net_request()
868 self.assertEqual(response.status_code, requests.codes.ok)
869 res = response.json()
870 self.assertNotIn('node', res['network'][0])
872 def test_43_getOpenRoadmNetwork(self):
873 response = test_utils.get_ordm_net_request()
874 self.assertEqual(response.status_code, requests.codes.ok)
875 res = response.json()
876 self.assertNotIn('node', res['network'][0])
878 def test_44_check_roadm2roadm_link_persistence(self):
879 response = test_utils.get_ordm_topo_request("")
880 self.assertEqual(response.status_code, requests.codes.ok)
881 res = response.json()
882 nbLink = len(res['network'][0]['ietf-network-topology:link'])
883 self.assertNotIn('node', res['network'][0])
884 self.assertEqual(nbLink, 6)
887 if __name__ == "__main__":
888 unittest.main(verbosity=2)