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 from common import test_utils
23 class TransportPCEtesting(unittest.TestCase):
29 'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'}),
30 ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'})]
34 'checks_tp': [({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'}),
35 ({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'})]
38 'node_type': 'DEGREE',
39 'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'}),
40 ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'})]
43 'node_type': 'DEGREE',
44 'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'}),
45 ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'})]
51 'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'}),
52 ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'})]
55 'node_type': 'DEGREE',
56 'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'}),
57 ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'})]
60 'node_type': 'DEGREE',
61 'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'}),
62 ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'})]
68 cls.processes = test_utils.start_tpce()
69 cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
72 def tearDownClass(cls):
73 # pylint: disable=not-an-iterable
74 for process in cls.processes:
75 test_utils.shutdown_process(process)
76 print("all processes killed")
81 def test_01_connect_ROADM_A1(self):
82 response = test_utils.mount_device("ROADM-A1", 'roadma')
83 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
85 def test_02_getClliNetwork(self):
86 response = test_utils.get_clli_net_request()
87 self.assertEqual(response.status_code, requests.codes.ok)
90 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
91 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
93 def test_03_getOpenRoadmNetwork(self):
94 response = test_utils.get_ordm_net_request()
95 self.assertEqual(response.status_code, requests.codes.ok)
97 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
98 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
99 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
100 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
101 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
103 def test_04_getLinks_OpenroadmTopology(self):
104 # pylint: disable=redundant-unittest-assert
105 response = test_utils.get_ordm_topo_request("")
106 self.assertEqual(response.status_code, requests.codes.ok)
107 res = response.json()
108 # Tests related to links
109 nbLink = len(res['network'][0]['ietf-network-topology:link'])
110 self.assertEqual(nbLink, 10)
111 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
112 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
113 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
114 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
115 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
116 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
117 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
118 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
119 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
120 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
122 for i in range(0, nbLink):
123 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
124 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
125 if linkType in check_list:
126 find = linkId in check_list[linkType]
127 self.assertEqual(find, True)
128 (check_list[linkType]).remove(linkId)
130 self.assertFalse(True)
131 for link_type in check_list:
132 self.assertEqual(len(check_list[link_type]), 0)
134 def test_05_getNodes_OpenRoadmTopology(self):
135 # pylint: disable=redundant-unittest-assert
136 response = test_utils.get_ordm_topo_request("")
137 res = response.json()
138 # Tests related to nodes
139 self.assertEqual(response.status_code, requests.codes.ok)
140 nbNode = len(res['network'][0]['node'])
141 self.assertEqual(nbNode, 4)
142 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
143 for i in range(0, nbNode):
144 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
145 res['network'][0]['node'][i]['supporting-node'])
146 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
147 nodeId = res['network'][0]['node'][i]['node-id']
148 if nodeId in self.CHECK_DICT1:
149 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
150 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
151 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
152 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
153 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
154 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
155 res['network'][0]['node'][i]['supporting-node'])
156 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
157 res['network'][0]['node'][i]['supporting-node'])
158 listNode.remove(nodeId)
160 self.assertFalse(True)
161 self.assertEqual(len(listNode), 0)
163 def test_06_connect_XPDRA(self):
164 response = test_utils.mount_device("XPDR-A1", 'xpdra')
165 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
167 def test_07_getClliNetwork(self):
168 response = test_utils.get_clli_net_request()
169 self.assertEqual(response.status_code, requests.codes.ok)
170 res = response.json()
171 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
172 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
174 def test_08_getOpenRoadmNetwork(self):
175 # pylint: disable=redundant-unittest-assert
176 response = test_utils.get_ordm_net_request()
177 self.assertEqual(response.status_code, requests.codes.ok)
178 res = response.json()
179 nbNode = len(res['network'][0]['node'])
180 self.assertEqual(nbNode, 2)
181 for i in range(0, nbNode):
182 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
183 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
184 nodeId = res['network'][0]['node'][i]['node-id']
185 if nodeId == 'XPDR-A1':
186 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
187 elif nodeId == 'ROADM-A1':
188 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
190 self.assertFalse(True)
192 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
194 def test_09_getNodes_OpenRoadmTopology(self):
195 # pylint: disable=redundant-unittest-assert
196 response = test_utils.get_ordm_topo_request("")
197 res = response.json()
198 # Tests related to nodes
199 self.assertEqual(response.status_code, requests.codes.ok)
200 nbNode = len(res['network'][0]['node'])
201 self.assertEqual(nbNode, 5)
202 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
203 for i in range(0, nbNode):
204 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
205 nodeId = res['network'][0]['node'][i]['node-id']
206 # Tests related to XPDRA nodes
207 if nodeId == 'XPDR-A1-XPDR1':
208 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
209 res['network'][0]['node'][i]['supporting-node'])
210 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
211 res['network'][0]['node'][i]['supporting-node'])
212 self.assertEqual(nodeType, 'XPONDER')
213 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
216 for j in range(0, nbTps):
217 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
218 ['org-openroadm-common-network:tp-type'])
219 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
220 if tpType == 'XPONDER-CLIENT':
222 elif tpType == 'XPONDER-NETWORK':
224 if tpId == 'XPDR1-NETWORK2':
225 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
226 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
227 if tpId == 'XPDR1-CLIENT2':
228 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
229 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
231 self.assertTrue(client == 2)
232 self.assertTrue(network == 2)
233 listNode.remove(nodeId)
234 elif nodeId in self.CHECK_DICT1:
235 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
236 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
237 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
238 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
239 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
240 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
241 res['network'][0]['node'][i]['supporting-node'])
242 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
243 res['network'][0]['node'][i]['supporting-node'])
244 listNode.remove(nodeId)
246 self.assertFalse(True)
247 self.assertEqual(len(listNode), 0)
249 # Connect the tail XPDRA to ROADMA and vice versa
250 def test_10_connect_tail_xpdr_rdm(self):
251 # Connect the tail: XPDRA to ROADMA
252 response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "1",
253 "ROADM-A1", "1", "SRG1-PP1-TXRX")
254 self.assertEqual(response.status_code, requests.codes.ok)
256 def test_11_connect_tail_rdm_xpdr(self):
257 response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "1",
258 "ROADM-A1", "1", "SRG1-PP1-TXRX")
259 self.assertEqual(response.status_code, requests.codes.ok)
261 def test_12_getLinks_OpenRoadmTopology(self):
262 # pylint: disable=redundant-unittest-assert
263 response = test_utils.get_ordm_topo_request("")
264 self.assertEqual(response.status_code, requests.codes.ok)
265 res = response.json()
266 # Tests related to links
267 nbLink = len(res['network'][0]['ietf-network-topology:link'])
268 self.assertEqual(nbLink, 12)
269 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
270 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
271 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
272 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
273 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
274 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
275 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
276 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
277 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
278 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX'],
279 'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
280 'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
282 for i in range(0, nbLink):
283 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
284 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
285 if linkType in check_list:
286 find = linkId in check_list[linkType]
287 self.assertEqual(find, True)
288 (check_list[linkType]).remove(linkId)
290 self.assertFalse(True)
291 for link_type in check_list:
292 self.assertEqual(len(check_list[link_type]), 0)
294 def test_13_connect_ROADMC(self):
295 response = test_utils.mount_device("ROADM-C1", 'roadmc')
296 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
298 def test_14_omsAttributes_ROADMA_ROADMC(self):
299 # Config ROADMA-ROADMC oms-attributes
301 "auto-spanloss": "true",
302 "engineered-spanloss": 12.2,
303 "link-concatenation": [{
306 "SRLG-length": 100000,
308 response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
309 self.assertEqual(response.status_code, requests.codes.created)
311 def test_15_omsAttributes_ROADMC_ROADMA(self):
312 # Config ROADM-C1-ROADM-A1 oms-attributes
314 "auto-spanloss": "true",
315 "engineered-spanloss": 12.2,
316 "link-concatenation": [{
319 "SRLG-length": 100000,
322 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
323 self.assertEqual(response.status_code, requests.codes.created)
325 def test_16_getClliNetwork(self):
326 # pylint: disable=redundant-unittest-assert
327 response = test_utils.get_clli_net_request()
328 self.assertEqual(response.status_code, requests.codes.ok)
329 res = response.json()
330 nbNode = len(res['network'][0]['node'])
331 listNode = ['NodeA', 'NodeC']
332 for i in range(0, nbNode):
333 nodeId = res['network'][0]['node'][i]['node-id']
334 if nodeId in listNode:
335 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
336 listNode.remove(nodeId)
338 self.assertFalse(True)
339 self.assertEqual(len(listNode), 0)
341 def test_17_getOpenRoadmNetwork(self):
342 # pylint: disable=redundant-unittest-assert
343 response = test_utils.get_ordm_net_request()
344 self.assertEqual(response.status_code, requests.codes.ok)
345 res = response.json()
346 nbNode = len(res['network'][0]['node'])
347 self.assertEqual(nbNode, 3)
348 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
349 CHECK_LIST = {'XPDR-A1': {'node-ref': 'NodeA', 'node-type': 'XPONDER'},
350 'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
351 'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
353 for i in range(0, nbNode):
354 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
355 nodeId = res['network'][0]['node'][i]['node-id']
356 if nodeId in CHECK_LIST:
357 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],
358 CHECK_LIST[nodeId]['node-ref'])
359 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
360 CHECK_LIST[nodeId]['node-type'])
361 listNode.remove(nodeId)
363 self.assertFalse(True)
365 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
366 self.assertEqual(len(listNode), 0)
368 def test_18_getROADMLinkOpenRoadmTopology(self):
369 # pylint: disable=redundant-unittest-assert
370 response = test_utils.get_ordm_topo_request("")
371 self.assertEqual(response.status_code, requests.codes.ok)
372 res = response.json()
373 # Tests related to links
374 nbLink = len(res['network'][0]['ietf-network-topology:link'])
375 self.assertEqual(nbLink, 20)
376 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
377 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
378 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX',
379 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX'],
380 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
381 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
382 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
383 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
384 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX',
385 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX'],
386 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
387 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
388 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
389 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
390 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX',
391 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX'],
392 'ROADM-TO-ROADM': ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
393 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'],
394 'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
395 'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
397 for i in range(0, nbLink):
398 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
399 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
400 if linkType in check_list:
401 find = linkId in check_list[linkType]
402 self.assertEqual(find, True)
403 (check_list[linkType]).remove(linkId)
405 self.assertFalse(True)
406 for link_type in check_list:
407 self.assertEqual(len(check_list[link_type]), 0)
409 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
410 response = test_utils.get_ordm_topo_request("")
411 self.assertEqual(response.status_code, requests.codes.ok)
412 res = response.json()
413 # Tests related to links
414 nbLink = len(res['network'][0]['ietf-network-topology:link'])
415 self.assertEqual(nbLink, 20)
416 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
417 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
418 for i in range(0, nbLink):
419 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
420 if link_id in R2RLink:
422 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
423 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
424 length = res['network'][0]['ietf-network-topology:link'][i][
425 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
426 if (spanLoss is not None) & (length is not None):
428 self.assertTrue(find)
429 R2RLink.remove(link_id)
430 self.assertEqual(len(R2RLink), 0)
432 def test_20_getNodes_OpenRoadmTopology(self):
433 # pylint: disable=redundant-unittest-assert
434 response = test_utils.get_ordm_topo_request("")
435 res = response.json()
436 # Tests related to nodes
437 self.assertEqual(response.status_code, requests.codes.ok)
438 nbNode = len(res['network'][0]['node'])
439 self.assertEqual(nbNode, 8)
440 listNode = ['XPDR-A1-XPDR1',
441 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
442 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
443 # Tests related to XPDRA nodes
444 for i in range(0, nbNode):
445 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
446 nodeId = res['network'][0]['node'][i]['node-id']
447 if nodeId == 'XPDR-A1-XPDR1':
448 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
449 res['network'][0]['node'][i]['supporting-node'])
450 self.assertEqual(nodeType, 'XPONDER')
451 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
452 self.assertTrue(nbTps >= 4)
455 for j in range(0, nbTps):
456 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
457 ['org-openroadm-common-network:tp-type'])
458 if tpType == 'XPONDER-CLIENT':
460 elif tpType == 'XPONDER-NETWORK':
462 self.assertTrue(client == 2)
463 self.assertTrue(network == 2)
464 listNode.remove(nodeId)
465 # Tests related to ROADMA nodes
466 elif nodeId in self.CHECK_DICT1:
467 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
468 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
469 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
470 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
471 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
472 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
473 res['network'][0]['node'][i]['supporting-node'])
474 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
475 res['network'][0]['node'][i]['supporting-node'])
476 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
477 self.CHECK_DICT1[nodeId]['node_type'])
478 listNode.remove(nodeId)
479 # Tests related to ROADMA nodes
480 elif nodeId in self.CHECK_DICT2:
481 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
482 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
483 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
484 for item in self.CHECK_DICT2[nodeId]['checks_tp']:
485 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
486 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'},
487 res['network'][0]['node'][i]['supporting-node'])
488 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
489 res['network'][0]['node'][i]['supporting-node'])
490 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
491 self.CHECK_DICT2[nodeId]['node_type'])
492 listNode.remove(nodeId)
493 self.assertEqual(len(listNode), 0)
495 def test_21_connect_ROADMB(self):
496 response = test_utils.mount_device("ROADM-B1", 'roadmb')
497 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
499 def test_22_omsAttributes_ROADMA_ROADMB(self):
500 # Config ROADM-A1-ROADM-B1 oms-attributes
502 "auto-spanloss": "true",
503 "engineered-spanloss": 12.2,
504 "spanloss-current": 12,
505 "spanloss-base": 11.4,
506 "link-concatenation": [{
509 "SRLG-length": 100000,
511 response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
512 self.assertEqual(response.status_code, requests.codes.created)
514 def test_23_omsAttributes_ROADMB_ROADMA(self):
515 # Config ROADM-B1-ROADM-A1 oms-attributes
517 "auto-spanloss": "true",
518 "engineered-spanloss": 12.2,
519 "spanloss-current": 12,
520 "spanloss-base": 11.4,
521 "link-concatenation": [{
524 "SRLG-length": 100000,
526 response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
527 self.assertEqual(response.status_code, requests.codes.created)
529 def test_24_omsAttributes_ROADMB_ROADMC(self):
530 # Config ROADM-B1-ROADM-C1 oms-attributes
532 "auto-spanloss": "true",
533 "engineered-spanloss": 12.2,
534 "spanloss-current": 12,
535 "spanloss-base": 11.4,
536 "link-concatenation": [{
539 "SRLG-length": 100000,
541 response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
542 self.assertEqual(response.status_code, requests.codes.created)
544 def test_25_omsAttributes_ROADMC_ROADMB(self):
545 # Config ROADM-C1-ROADM-B1 oms-attributes
547 "auto-spanloss": "true",
548 "engineered-spanloss": 12.2,
549 "link-concatenation": [{
552 "SRLG-length": 100000,
554 response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
555 self.assertEqual(response.status_code, requests.codes.created)
557 def test_26_getClliNetwork(self):
558 # pylint: disable=redundant-unittest-assert
559 response = test_utils.get_clli_net_request()
560 self.assertEqual(response.status_code, requests.codes.ok)
561 res = response.json()
562 nbNode = len(res['network'][0]['node'])
563 listNode = ['NodeA', 'NodeB', 'NodeC']
564 for i in range(0, nbNode):
565 nodeId = res['network'][0]['node'][i]['node-id']
566 if nodeId in listNode:
567 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
568 listNode.remove(nodeId)
570 self.assertFalse(True)
571 self.assertEqual(len(listNode), 0)
573 def test_27_verifyDegree(self):
574 response = test_utils.get_ordm_topo_request("")
575 self.assertEqual(response.status_code, requests.codes.ok)
576 res = response.json()
577 # Tests related to links
578 nbLink = len(res['network'][0]['ietf-network-topology:link'])
579 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
580 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
581 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
582 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
583 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
584 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
585 for i in range(0, nbLink):
586 if (res['network'][0]['ietf-network-topology:link'][i]
587 ['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM'):
588 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
589 find = link_id in listR2RLink
590 self.assertEqual(find, True)
591 listR2RLink.remove(link_id)
592 self.assertEqual(len(listR2RLink), 0)
594 def test_28_verifyOppositeLinkTopology(self):
595 response = test_utils.get_ordm_topo_request("")
596 self.assertEqual(response.status_code, requests.codes.ok)
597 res = response.json()
598 # Tests related to links
599 nbLink = len(res['network'][0]['ietf-network-topology:link'])
600 self.assertEqual(nbLink, 26)
601 for i in range(0, nbLink):
602 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
603 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
604 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
605 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
606 oppLink_id = (res['network'][0]['ietf-network-topology:link'][i]
607 ['org-openroadm-common-network:opposite-link'])
608 # Find the opposite link
609 response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
610 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
611 res_oppLink = response_oppLink.json()
612 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
613 ['org-openroadm-common-network:opposite-link'], link_id)
614 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
615 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
616 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
617 CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
618 'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
619 'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
620 if link_type in CHECK_DICT:
621 self.assertEqual(oppLink_type, CHECK_DICT[link_type])
623 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
624 response = test_utils.get_ordm_topo_request("")
625 self.assertEqual(response.status_code, requests.codes.ok)
626 res = response.json()
627 nbLink = len(res['network'][0]['ietf-network-topology:link'])
628 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
629 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
630 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
631 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
632 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
633 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
634 for i in range(0, nbLink):
635 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
636 if link_id in R2RLink:
638 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
639 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
640 length = res['network'][0]['ietf-network-topology:link'][i][
641 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
642 if (spanLoss is not None) & (length is not None):
644 self.assertTrue(find)
645 R2RLink.remove(link_id)
646 self.assertEqual(len(R2RLink), 0)
648 def test_30_disconnect_ROADMB(self):
649 # Delete in the topology-netconf
650 response = test_utils.unmount_device("ROADM-B1")
651 # Delete in the clli-network
652 response = test_utils.del_node_request("NodeB")
653 self.assertEqual(response.status_code, requests.codes.ok)
655 def test_31_disconnect_ROADMC(self):
656 # Delete in the topology-netconf
657 response = test_utils.unmount_device("ROADM-C1")
658 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
659 # Delete in the clli-network
660 response = test_utils.del_node_request("NodeC")
661 self.assertEqual(response.status_code, requests.codes.ok)
663 def test_32_getNodes_OpenRoadmTopology(self):
664 # pylint: disable=redundant-unittest-assert
665 response = test_utils.get_ordm_topo_request("")
666 res = response.json()
667 # Tests related to nodes
668 self.assertEqual(response.status_code, requests.codes.ok)
669 nbNode = len(res['network'][0]['node'])
670 self.assertEqual(nbNode, 5)
671 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
672 for i in range(0, nbNode):
673 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
674 nodeId = res['network'][0]['node'][i]['node-id']
675 # Tests related to XPDRA nodes
676 if nodeId == 'XPDR-A1-XPDR1':
677 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
678 for j in range(0, nbTp):
679 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
680 if tpid == 'XPDR1-CLIENT1':
681 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
682 ['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
683 if tpid == 'XPDR1-NETWORK1':
684 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
685 ['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
686 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
687 ['org-openroadm-network-topology:xpdr-network-attributes']
688 ['tail-equipment-id']),
689 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
690 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
691 res['network'][0]['node'][i]['supporting-node'])
692 listNode.remove(nodeId)
693 # Tests related to ROADMA nodes
694 elif nodeId in self.CHECK_DICT1:
695 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
696 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
697 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
698 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
699 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
700 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
701 res['network'][0]['node'][i]['supporting-node'])
702 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
703 res['network'][0]['node'][i]['supporting-node'])
704 listNode.remove(nodeId)
706 self.assertFalse(True)
707 self.assertEqual(len(listNode), 0)
708 # Test related to SRG1 of ROADMC
709 for i in range(0, nbNode):
710 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
711 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
712 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
714 def test_33_getOpenRoadmNetwork(self):
715 response = test_utils.get_ordm_net_request()
716 self.assertEqual(response.status_code, requests.codes.ok)
717 res = response.json()
718 nbNode = len(res['network'][0]['node'])
719 self.assertEqual(nbNode, 2)
720 for i in range(0, nbNode-1):
721 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
722 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
724 def test_34_getClliNetwork(self):
725 response = test_utils.get_clli_net_request()
726 self.assertEqual(response.status_code, requests.codes.ok)
727 res = response.json()
728 nbNode = len(res['network'][0]['node'])
729 self.assertEqual(nbNode, 1)
730 for i in range(0, nbNode-1):
731 self.assertNotEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
733 def test_35_disconnect_XPDRA(self):
734 response = test_utils.unmount_device("XPDR-A1")
735 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
737 def test_36_getClliNetwork(self):
738 response = test_utils.get_clli_net_request()
739 self.assertEqual(response.status_code, requests.codes.ok)
740 res = response.json()
741 nbNode = len(res['network'][0]['node'])
742 self.assertEqual(nbNode, 1)
743 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
745 def test_37_getOpenRoadmNetwork(self):
746 response = test_utils.get_ordm_net_request()
747 self.assertEqual(response.status_code, requests.codes.ok)
748 res = response.json()
749 nbNode = len(res['network'][0]['node'])
750 self.assertEqual(nbNode, 1)
751 for i in range(0, nbNode):
752 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
754 def test_38_getNodes_OpenRoadmTopology(self):
755 # pylint: disable=redundant-unittest-assert
756 response = test_utils.get_ordm_topo_request("")
757 res = response.json()
758 # Tests related to nodes
759 self.assertEqual(response.status_code, requests.codes.ok)
760 nbNode = len(res['network'][0]['node'])
761 self.assertEqual(nbNode, 4)
762 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
763 for i in range(0, nbNode):
764 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
765 res['network'][0]['node'][i]['supporting-node'])
766 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
767 nodeId = res['network'][0]['node'][i]['node-id']
768 if nodeId in self.CHECK_DICT1:
769 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
770 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
771 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
772 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
773 self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
774 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
775 res['network'][0]['node'][i]['supporting-node'])
776 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
777 res['network'][0]['node'][i]['supporting-node'])
778 listNode.remove(nodeId)
780 self.assertFalse(True)
781 self.assertEqual(len(listNode), 0)
783 def test_39_disconnect_ROADM_XPDRA_link(self):
785 response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
786 self.assertEqual(response.status_code, requests.codes.ok)
788 response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
789 self.assertEqual(response.status_code, requests.codes.ok)
791 def test_40_getLinks_OpenRoadmTopology(self):
792 response = test_utils.get_ordm_topo_request("")
793 self.assertEqual(response.status_code, requests.codes.ok)
794 res = response.json()
795 nbLink = len(res['network'][0]['ietf-network-topology:link'])
796 self.assertEqual(nbLink, 16)
797 check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
798 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
799 'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
800 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
801 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
802 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
803 'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
804 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
805 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
806 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
809 for i in range(0, nbLink):
810 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
811 linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
812 if linkType in check_list:
813 find = linkId in check_list[linkType]
814 self.assertEqual(find, True)
815 (check_list[linkType]).remove(linkId)
817 roadmtoroadmLink += 1
818 for link_type in check_list:
819 self.assertEqual(len(check_list[link_type]), 0)
820 self.assertEqual(roadmtoroadmLink, 6)
821 for i in range(0, nbLink):
822 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
823 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
824 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
825 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
827 def test_41_disconnect_ROADMA(self):
828 response = test_utils.unmount_device("ROADM-A1")
829 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
830 # Delete in the clli-network
831 response = test_utils.del_node_request("NodeA")
832 self.assertEqual(response.status_code, requests.codes.ok)
834 def test_42_getClliNetwork(self):
835 response = test_utils.get_clli_net_request()
836 self.assertEqual(response.status_code, requests.codes.ok)
837 res = response.json()
838 self.assertNotIn('node', res['network'][0])
840 def test_43_getOpenRoadmNetwork(self):
841 response = test_utils.get_ordm_net_request()
842 self.assertEqual(response.status_code, requests.codes.ok)
843 res = response.json()
844 self.assertNotIn('node', res['network'][0])
846 def test_44_check_roadm2roadm_link_persistence(self):
847 response = test_utils.get_ordm_topo_request("")
848 self.assertEqual(response.status_code, requests.codes.ok)
849 res = response.json()
850 nbLink = len(res['network'][0]['ietf-network-topology:link'])
851 self.assertNotIn('node', res['network'][0])
852 self.assertEqual(nbLink, 6)
855 if __name__ == "__main__":
856 unittest.main(verbosity=2)