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
19 from common import test_utils
22 class TransportPCEtesting(unittest.TestCase):
28 cls.processes = test_utils.start_tpce()
29 cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
32 def tearDownClass(cls):
33 for process in cls.processes:
34 test_utils.shutdown_process(process)
35 print("all processes killed")
40 def test_01_connect_ROADM_A1(self):
41 response = test_utils.mount_device("ROADM-A1", 'roadma')
42 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
44 def test_02_getClliNetwork(self):
45 response = test_utils.get_clli_net_request()
46 self.assertEqual(response.status_code, requests.codes.ok)
49 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
50 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
52 def test_03_getOpenRoadmNetwork(self):
53 response = test_utils.get_ordm_net_request()
54 self.assertEqual(response.status_code, requests.codes.ok)
56 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
57 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
58 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
59 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
60 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
62 def test_04_getLinks_OpenroadmTopology(self):
63 response = test_utils.get_ordm_topo_request("")
64 self.assertEqual(response.status_code, requests.codes.ok)
66 # Tests related to links
67 nbLink = len(res['network'][0]['ietf-network-topology:link'])
68 self.assertEqual(nbLink, 10)
69 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
70 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
71 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
72 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
73 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
74 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
75 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
76 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
77 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
78 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
79 for i in range(0, nbLink):
80 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
81 if (res['network'][0]['ietf-network-topology:link'][i]
82 ['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
83 find = linkId in expressLink
84 self.assertEqual(find, True)
85 expressLink.remove(linkId)
86 elif (res['network'][0]['ietf-network-topology:link'][i]
87 ['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
88 find = linkId in addLink
89 self.assertEqual(find, True)
90 addLink.remove(linkId)
91 elif (res['network'][0]['ietf-network-topology:link'][i]
92 ['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
93 find = linkId in dropLink
94 self.assertEqual(find, True)
95 dropLink.remove(linkId)
97 self.assertFalse(True)
98 self.assertEqual(len(expressLink), 0)
99 self.assertEqual(len(addLink), 0)
100 self.assertEqual(len(dropLink), 0)
102 def test_05_getNodes_OpenRoadmTopology(self):
103 response = test_utils.get_ordm_topo_request("")
104 res = response.json()
105 # Tests related to nodes
106 self.assertEqual(response.status_code, requests.codes.ok)
107 nbNode = len(res['network'][0]['node'])
108 self.assertEqual(nbNode, 4)
109 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
110 for i in range(0, nbNode):
111 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
112 res['network'][0]['node'][i]['supporting-node'])
113 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
114 nodeId = res['network'][0]['node'][i]['node-id']
115 if(nodeId == 'ROADM-A1-SRG1'):
116 # Test related to SRG1
117 self.assertEqual(nodeType, 'SRG')
118 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
119 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
120 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
121 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
122 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
123 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
124 res['network'][0]['node'][i]['supporting-node'])
125 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
126 res['network'][0]['node'][i]['supporting-node'])
127 listNode.remove(nodeId)
128 elif(nodeId == 'ROADM-A1-SRG3'):
129 # Test related to SRG1
130 self.assertEqual(nodeType, 'SRG')
131 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
132 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
133 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
134 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
135 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
136 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
137 res['network'][0]['node'][i]['supporting-node'])
138 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
139 res['network'][0]['node'][i]['supporting-node'])
140 listNode.remove(nodeId)
141 elif(nodeId == 'ROADM-A1-DEG1'):
142 # Test related to DEG1
143 self.assertEqual(nodeType, 'DEGREE')
144 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
145 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
146 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
147 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
148 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
149 res['network'][0]['node'][i]['supporting-node'])
150 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
151 res['network'][0]['node'][i]['supporting-node'])
152 listNode.remove(nodeId)
153 elif(nodeId == 'ROADM-A1-DEG2'):
154 # Test related to DEG2
155 self.assertEqual(nodeType, 'DEGREE')
156 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
157 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
158 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
159 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
160 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
161 res['network'][0]['node'][i]['supporting-node'])
162 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
163 res['network'][0]['node'][i]['supporting-node'])
164 listNode.remove(nodeId)
166 self.assertFalse(True)
167 self.assertEqual(len(listNode), 0)
169 def test_06_connect_XPDRA(self):
170 response = test_utils.mount_device("XPDR-A1", 'xpdra')
171 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
173 def test_07_getClliNetwork(self):
174 response = test_utils.get_clli_net_request()
175 self.assertEqual(response.status_code, requests.codes.ok)
176 res = response.json()
177 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
178 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
180 def test_08_getOpenRoadmNetwork(self):
181 response = test_utils.get_ordm_net_request()
182 self.assertEqual(response.status_code, requests.codes.ok)
183 res = response.json()
184 nbNode = len(res['network'][0]['node'])
185 self.assertEqual(nbNode, 2)
186 for i in range(0, nbNode):
187 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
188 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
189 nodeId = res['network'][0]['node'][i]['node-id']
190 if(nodeId == 'XPDR-A1'):
191 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
192 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
193 elif(nodeId == 'ROADM-A1'):
194 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
195 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
197 self.assertFalse(True)
199 def test_09_getNodes_OpenRoadmTopology(self):
200 response = test_utils.get_ordm_topo_request("")
201 res = response.json()
202 # Tests related to nodes
203 self.assertEqual(response.status_code, requests.codes.ok)
204 nbNode = len(res['network'][0]['node'])
205 self.assertEqual(nbNode, 5)
206 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
207 for i in range(0, nbNode):
208 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
209 nodeId = res['network'][0]['node'][i]['node-id']
210 # Tests related to XPDRA nodes
211 if(nodeId == 'XPDR-A1-XPDR1'):
212 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
213 res['network'][0]['node'][i]['supporting-node'])
214 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
215 res['network'][0]['node'][i]['supporting-node'])
216 self.assertEqual(nodeType, 'XPONDER')
217 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
220 for j in range(0, nbTps):
221 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
222 ['org-openroadm-common-network:tp-type'])
223 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
224 if (tpType == 'XPONDER-CLIENT'):
226 elif (tpType == 'XPONDER-NETWORK'):
228 if (tpId == 'XPDR1-NETWORK2'):
229 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
230 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
231 if (tpId == 'XPDR1-CLIENT2'):
232 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
233 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
235 self.assertTrue(client == 2)
236 self.assertTrue(network == 2)
237 listNode.remove(nodeId)
238 elif(nodeId == 'ROADM-A1-SRG1'):
239 # Test related to SRG1
240 self.assertEqual(nodeType, 'SRG')
241 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
242 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
243 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
244 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
245 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
246 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
247 res['network'][0]['node'][i]['supporting-node'])
248 listNode.remove(nodeId)
249 elif(nodeId == 'ROADM-A1-SRG3'):
250 # Test related to SRG1
251 self.assertEqual(nodeType, 'SRG')
252 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
253 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
254 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
255 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
256 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
257 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
258 res['network'][0]['node'][i]['supporting-node'])
259 listNode.remove(nodeId)
260 elif(nodeId == 'ROADM-A1-DEG1'):
261 # Test related to DEG1
262 self.assertEqual(nodeType, 'DEGREE')
263 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
264 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
265 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
266 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
267 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
268 res['network'][0]['node'][i]['supporting-node'])
269 listNode.remove(nodeId)
270 elif(nodeId == 'ROADM-A1-DEG2'):
271 # Test related to DEG2
272 self.assertEqual(nodeType, 'DEGREE')
273 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
274 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
275 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
276 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
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 response = test_utils.get_ordm_topo_request("")
298 self.assertEqual(response.status_code, requests.codes.ok)
299 res = response.json()
300 # Tests related to links
301 nbLink = len(res['network'][0]['ietf-network-topology:link'])
302 self.assertEqual(nbLink, 12)
303 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
304 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
305 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
306 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
307 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
308 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
309 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
310 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
311 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
312 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
313 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
314 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
315 for i in range(0, nbLink):
316 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
317 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
318 if(nodeType == 'EXPRESS-LINK'):
319 find = linkId in expressLink
320 self.assertEqual(find, True)
321 expressLink.remove(linkId)
322 elif(nodeType == 'ADD-LINK'):
323 find = linkId in addLink
324 self.assertEqual(find, True)
325 addLink.remove(linkId)
326 elif(nodeType == 'DROP-LINK'):
327 find = linkId in dropLink
328 self.assertEqual(find, True)
329 dropLink.remove(linkId)
330 elif(nodeType == 'XPONDER-INPUT'):
331 find = linkId in XPDR_IN
332 self.assertEqual(find, True)
333 XPDR_IN.remove(linkId)
334 elif(nodeType == 'XPONDER-OUTPUT'):
335 find = linkId in XPDR_OUT
336 self.assertEqual(find, True)
337 XPDR_OUT.remove(linkId)
339 self.assertFalse(True)
340 self.assertEqual(len(expressLink), 0)
341 self.assertEqual(len(addLink), 0)
342 self.assertEqual(len(dropLink), 0)
343 self.assertEqual(len(XPDR_IN), 0)
344 self.assertEqual(len(XPDR_OUT), 0)
346 def test_13_connect_ROADMC(self):
347 response = test_utils.mount_device("ROADM-C1", 'roadmc')
348 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
350 def test_14_omsAttributes_ROADMA_ROADMC(self):
351 # Config ROADMA-ROADMC oms-attributes
353 "auto-spanloss": "true",
354 "engineered-spanloss": 12.2,
355 "link-concatenation": [{
358 "SRLG-length": 100000,
360 response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
361 self.assertEqual(response.status_code, requests.codes.created)
363 def test_15_omsAttributes_ROADMC_ROADMA(self):
364 # Config ROADM-C1-ROADM-A1 oms-attributes
366 "auto-spanloss": "true",
367 "engineered-spanloss": 12.2,
368 "link-concatenation": [{
371 "SRLG-length": 100000,
374 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
375 self.assertEqual(response.status_code, requests.codes.created)
377 def test_16_getClliNetwork(self):
378 response = test_utils.get_clli_net_request()
379 self.assertEqual(response.status_code, requests.codes.ok)
380 res = response.json()
381 nbNode = len(res['network'][0]['node'])
382 listNode = ['NodeA', 'NodeC']
383 for i in range(0, nbNode):
384 nodeId = res['network'][0]['node'][i]['node-id']
385 find = nodeId in listNode
386 self.assertEqual(find, True)
387 if(nodeId == 'NodeA'):
388 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
390 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
391 listNode.remove(nodeId)
392 self.assertEqual(len(listNode), 0)
394 def test_17_getOpenRoadmNetwork(self):
395 response = test_utils.get_ordm_net_request()
396 self.assertEqual(response.status_code, requests.codes.ok)
397 res = response.json()
398 nbNode = len(res['network'][0]['node'])
399 self.assertEqual(nbNode, 3)
400 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
401 for i in range(0, nbNode):
402 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
403 nodeId = res['network'][0]['node'][i]['node-id']
404 if(nodeId == 'XPDR-A1'):
405 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
406 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
407 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
408 listNode.remove(nodeId)
409 elif(nodeId == 'ROADM-A1'):
410 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
411 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
412 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
413 listNode.remove(nodeId)
414 elif(nodeId == 'ROADM-C1'):
415 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
416 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
417 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
418 listNode.remove(nodeId)
420 self.assertFalse(True)
421 self.assertEqual(len(listNode), 0)
423 def test_18_getROADMLinkOpenRoadmTopology(self):
424 response = test_utils.get_ordm_topo_request("")
425 self.assertEqual(response.status_code, requests.codes.ok)
426 res = response.json()
427 # Tests related to links
428 nbLink = len(res['network'][0]['ietf-network-topology:link'])
429 self.assertEqual(nbLink, 20)
430 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
431 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
432 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX',
433 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
434 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
435 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
436 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
437 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
438 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX',
439 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
440 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
441 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
442 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
443 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
444 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX',
445 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
446 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
447 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
448 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
449 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
450 for i in range(0, nbLink):
451 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
452 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
453 if(nodeType == 'EXPRESS-LINK'):
454 find = linkId in expressLink
455 self.assertEqual(find, True)
456 expressLink.remove(linkId)
457 elif(nodeType == 'ADD-LINK'):
458 find = linkId in addLink
459 self.assertEqual(find, True)
460 addLink.remove(linkId)
461 elif(nodeType == 'DROP-LINK'):
462 find = linkId in dropLink
463 self.assertEqual(find, True)
464 dropLink.remove(linkId)
465 elif(nodeType == 'ROADM-TO-ROADM'):
466 find = linkId in R2RLink
467 self.assertEqual(find, True)
468 R2RLink.remove(linkId)
469 elif(nodeType == 'XPONDER-INPUT'):
470 find = linkId in XPDR_IN
471 self.assertEqual(find, True)
472 XPDR_IN.remove(linkId)
473 elif(nodeType == 'XPONDER-OUTPUT'):
474 find = linkId in XPDR_OUT
475 self.assertEqual(find, True)
476 XPDR_OUT.remove(linkId)
478 self.assertFalse(True)
479 self.assertEqual(len(expressLink), 0)
480 self.assertEqual(len(addLink), 0)
481 self.assertEqual(len(dropLink), 0)
482 self.assertEqual(len(R2RLink), 0)
483 self.assertEqual(len(XPDR_IN), 0)
484 self.assertEqual(len(XPDR_OUT), 0)
486 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
487 response = test_utils.get_ordm_topo_request("")
488 self.assertEqual(response.status_code, requests.codes.ok)
489 res = response.json()
490 # Tests related to links
491 nbLink = len(res['network'][0]['ietf-network-topology:link'])
492 self.assertEqual(nbLink, 20)
493 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
494 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
495 for i in range(0, nbLink):
496 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
497 if(link_id in R2RLink):
499 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
500 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
501 length = res['network'][0]['ietf-network-topology:link'][i][
502 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
503 if((spanLoss != None) & (length != None)):
505 self.assertTrue(find)
506 R2RLink.remove(link_id)
507 self.assertEqual(len(R2RLink), 0)
509 def test_20_getNodes_OpenRoadmTopology(self):
510 response = test_utils.get_ordm_topo_request("")
511 res = response.json()
512 # Tests related to nodes
513 self.assertEqual(response.status_code, requests.codes.ok)
514 nbNode = len(res['network'][0]['node'])
515 self.assertEqual(nbNode, 8)
516 listNode = ['XPDR-A1-XPDR1',
517 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
518 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
519 # ************************Tests related to XPDRA nodes
520 for i in range(0, nbNode):
521 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
522 nodeId = res['network'][0]['node'][i]['node-id']
523 if(nodeId == 'XPDR-A1-XPDR1'):
524 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
525 res['network'][0]['node'][i]['supporting-node'])
526 self.assertEqual(nodeType, 'XPONDER')
527 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
528 self.assertTrue(nbTps >= 4)
531 for j in range(0, nbTps):
532 tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
533 ['org-openroadm-common-network:tp-type'])
534 if (tpType == 'XPONDER-CLIENT'):
536 elif (tpType == 'XPONDER-NETWORK'):
538 self.assertTrue(client == 2)
539 self.assertTrue(network == 2)
540 listNode.remove(nodeId)
541 elif(nodeId == 'ROADM-A1-SRG1'):
542 # Test related to SRG1
543 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
544 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
545 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
546 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
547 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
548 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
549 res['network'][0]['node'][i]['supporting-node'])
550 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
551 listNode.remove(nodeId)
552 elif(nodeId == 'ROADM-A1-SRG3'):
553 # Test related to SRG1
554 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
555 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
556 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
557 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
558 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
559 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
560 res['network'][0]['node'][i]['supporting-node'])
561 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
562 listNode.remove(nodeId)
563 elif(nodeId == 'ROADM-A1-DEG1'):
564 # Test related to DEG1
565 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
566 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
567 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
568 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
569 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
570 res['network'][0]['node'][i]['supporting-node'])
571 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
572 listNode.remove(nodeId)
573 elif(nodeId == 'ROADM-A1-DEG2'):
574 # Test related to DEG2
575 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
576 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
577 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
578 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
579 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
580 res['network'][0]['node'][i]['supporting-node'])
581 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
582 listNode.remove(nodeId)
583 elif(nodeId == 'ROADM-C1-SRG1'):
584 # Test related to SRG1
585 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
586 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
587 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
588 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
589 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
590 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
591 res['network'][0]['node'][i]['supporting-node'])
592 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
593 listNode.remove(nodeId)
594 elif(nodeId == 'ROADM-C1-DEG1'):
595 # Test related to DEG1
596 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
597 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
598 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
599 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
600 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
601 res['network'][0]['node'][i]['supporting-node'])
602 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
603 listNode.remove(nodeId)
604 elif(nodeId == 'ROADM-C1-DEG2'):
605 # Test related to DEG1
606 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
607 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
608 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
609 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
610 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
611 res['network'][0]['node'][i]['supporting-node'])
612 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
613 listNode.remove(nodeId)
615 self.assertFalse(True)
616 self.assertEqual(len(listNode), 0)
618 def test_21_connect_ROADMB(self):
619 response = test_utils.mount_device("ROADM-B1", 'roadmb')
620 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
622 def test_22_omsAttributes_ROADMA_ROADMB(self):
623 # Config ROADM-A1-ROADM-B1 oms-attributes
625 "auto-spanloss": "true",
626 "engineered-spanloss": 12.2,
627 "spanloss-current": 12,
628 "spanloss-base": 11.4,
629 "link-concatenation": [{
632 "SRLG-length": 100000,
634 response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
635 self.assertEqual(response.status_code, requests.codes.created)
637 def test_23_omsAttributes_ROADMB_ROADMA(self):
638 # Config ROADM-B1-ROADM-A1 oms-attributes
640 "auto-spanloss": "true",
641 "engineered-spanloss": 12.2,
642 "spanloss-current": 12,
643 "spanloss-base": 11.4,
644 "link-concatenation": [{
647 "SRLG-length": 100000,
649 response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
650 self.assertEqual(response.status_code, requests.codes.created)
652 def test_24_omsAttributes_ROADMB_ROADMC(self):
653 # Config ROADM-B1-ROADM-C1 oms-attributes
655 "auto-spanloss": "true",
656 "engineered-spanloss": 12.2,
657 "spanloss-current": 12,
658 "spanloss-base": 11.4,
659 "link-concatenation": [{
662 "SRLG-length": 100000,
664 response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
665 self.assertEqual(response.status_code, requests.codes.created)
667 def test_25_omsAttributes_ROADMC_ROADMB(self):
668 # Config ROADM-C1-ROADM-B1 oms-attributes
670 "auto-spanloss": "true",
671 "engineered-spanloss": 12.2,
672 "link-concatenation": [{
675 "SRLG-length": 100000,
677 response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
678 self.assertEqual(response.status_code, requests.codes.created)
680 def test_26_getClliNetwork(self):
681 response = test_utils.get_clli_net_request()
682 self.assertEqual(response.status_code, requests.codes.ok)
683 res = response.json()
684 nbNode = len(res['network'][0]['node'])
685 listNode = ['NodeA', 'NodeB', 'NodeC']
686 for i in range(0, nbNode):
687 nodeId = res['network'][0]['node'][i]['node-id']
688 find = nodeId in listNode
689 self.assertEqual(find, True)
690 if(nodeId == 'NodeA'):
691 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
692 elif(nodeId == 'NodeB'):
693 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
695 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
696 listNode.remove(nodeId)
697 self.assertEqual(len(listNode), 0)
699 def test_27_verifyDegree(self):
700 response = test_utils.get_ordm_topo_request("")
701 self.assertEqual(response.status_code, requests.codes.ok)
702 res = response.json()
703 # Tests related to links
704 nbLink = len(res['network'][0]['ietf-network-topology:link'])
705 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
706 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
707 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
708 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
709 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
710 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
711 for i in range(0, nbLink):
712 if (res['network'][0]['ietf-network-topology:link'][i]
713 ['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM'):
714 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
715 find = link_id in listR2RLink
716 self.assertEqual(find, True)
717 listR2RLink.remove(link_id)
718 self.assertEqual(len(listR2RLink), 0)
720 def test_28_verifyOppositeLinkTopology(self):
721 response = test_utils.get_ordm_topo_request("")
722 self.assertEqual(response.status_code, requests.codes.ok)
723 res = response.json()
724 # Tests related to links
725 nbLink = len(res['network'][0]['ietf-network-topology:link'])
726 self.assertEqual(nbLink, 26)
727 for i in range(0, nbLink):
728 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
729 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
730 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
731 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
732 oppLink_id = (res['network'][0]['ietf-network-topology:link'][i]
733 ['org-openroadm-common-network:opposite-link'])
734 # Find the opposite link
735 response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
736 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
737 res_oppLink = response_oppLink.json()
738 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
739 ['org-openroadm-common-network:opposite-link'], link_id)
740 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
741 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
742 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
743 if link_type == 'ADD-LINK':
744 self.assertEqual(oppLink_type, 'DROP-LINK')
745 elif link_type == 'DROP-LINK':
746 self.assertEqual(oppLink_type, 'ADD-LINK')
747 elif link_type == 'EXPRESS-LINK':
748 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
749 elif link_type == 'ROADM-TO-ROADM':
750 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
751 elif link_type == 'XPONDER-INPUT':
752 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
753 elif link_type == 'XPONDER-OUTPUT':
754 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
756 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
757 response = test_utils.get_ordm_topo_request("")
758 self.assertEqual(response.status_code, requests.codes.ok)
759 res = response.json()
760 nbLink = len(res['network'][0]['ietf-network-topology:link'])
761 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
762 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
763 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
764 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
765 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
766 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
767 for i in range(0, nbLink):
768 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
769 if(link_id in R2RLink):
771 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
772 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
773 length = res['network'][0]['ietf-network-topology:link'][i][
774 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
775 if((spanLoss != None) & (length != None)):
777 self.assertTrue(find)
778 R2RLink.remove(link_id)
779 self.assertEqual(len(R2RLink), 0)
781 def test_30_disconnect_ROADMB(self):
782 # Delete in the topology-netconf
783 response = test_utils.unmount_device("ROADM-B1")
784 # Delete in the clli-network
785 response = test_utils.del_node_request("NodeB")
786 self.assertEqual(response.status_code, requests.codes.ok)
788 def test_31_disconnect_ROADMC(self):
789 # Delete in the topology-netconf
790 response = test_utils.unmount_device("ROADM-C1")
791 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
792 # Delete in the clli-network
793 response = test_utils.del_node_request("NodeC")
794 self.assertEqual(response.status_code, requests.codes.ok)
796 # def test_24_check_roadm2roadm_links_deletion(self):
797 # response = test_utils.get_ordm_topo_request("")
798 # self.assertEqual(response.status_code, requests.codes.ok)
799 # res = response.json()
800 # #Write the response in the log
801 # with open('./transportpce_tests/log/response.log', 'a') as outfile1:
802 # outfile1.write(str(res))
803 # #Tests related to links
804 # nbLink=len(res['network'][0]['ietf-network-topology:link'])
805 # self.assertEqual(nbLink,8)
806 # expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
807 # 'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
808 # addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX',
809 # 'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
810 # dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
811 # 'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
812 # XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
813 # XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
814 # for i in range(0,nbLink):
815 # nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
816 # linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
817 # if(nodeType=='EXPRESS-LINK'):
818 # find= linkId in expressLink
819 # self.assertEqual(find, True)
820 # expressLink.remove(linkId)
821 # elif(nodeType=='ADD-LINK'):
822 # find= linkId in addLink
823 # self.assertEqual(find, True)
824 # addLink.remove(linkId)
825 # elif(nodeType=='DROP-LINK'):
826 # find= linkId in dropLink
827 # self.assertEqual(find, True)
828 # dropLink.remove(linkId)
829 # elif(nodeType=='XPONDER-INPUT'):
830 # find= linkId in XPDR_IN
831 # self.assertEqual(find, True)
832 # XPDR_IN.remove(linkId)
833 # elif(nodeType=='XPONDER-OUTPUT'):
834 # find= linkId in XPDR_OUT
835 # self.assertEqual(find, True)
836 # XPDR_OUT.remove(linkId)
838 # self.assertFalse(True)
839 # self.assertEqual(len(expressLink),0)
840 # self.assertEqual(len(addLink),0)
841 # self.assertEqual(len(dropLink),0)
842 # self.assertEqual(len(XPDR_IN),0)
843 # self.assertEqual(len(XPDR_OUT),0)
845 # for i in range(0,nbLink):
846 # self.assertNotEqual((res['network'][0]['ietf-network-topology:link'][i]
847 # ['org-openroadm-common-network:link-type']),'ROADM-TO-ROADM')
848 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],
849 # 'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
850 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],
851 # 'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
852 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],
853 # 'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
854 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],
855 # 'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
856 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],
857 # 'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
858 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],
859 # 'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
861 def test_32_getNodes_OpenRoadmTopology(self):
862 response = test_utils.get_ordm_topo_request("")
863 res = response.json()
864 # Tests related to nodes
865 self.assertEqual(response.status_code, requests.codes.ok)
866 nbNode = len(res['network'][0]['node'])
867 self.assertEqual(nbNode, 5)
868 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
869 for i in range(0, nbNode):
870 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
871 nodeId = res['network'][0]['node'][i]['node-id']
872 # Tests related to XPDRA nodes
873 if(nodeId == 'XPDR-A1-XPDR1'):
874 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
875 for j in range(0, nbTp):
876 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
877 if (tpid == 'XPDR1-CLIENT1'):
878 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
879 ['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
880 if (tpid == 'XPDR1-NETWORK1'):
881 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
882 ['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
883 self.assertEqual((res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
884 ['org-openroadm-network-topology:xpdr-network-attributes']
885 ['tail-equipment-id']),
886 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
887 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
888 res['network'][0]['node'][i]['supporting-node'])
889 listNode.remove(nodeId)
890 elif(nodeId == 'ROADM-A1-SRG1'):
891 # Test related to SRG1
892 self.assertEqual(nodeType, 'SRG')
893 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
894 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
895 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
896 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
897 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
898 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
899 res['network'][0]['node'][i]['supporting-node'])
900 listNode.remove(nodeId)
901 elif(nodeId == 'ROADM-A1-SRG3'):
902 # Test related to SRG1
903 self.assertEqual(nodeType, 'SRG')
904 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
905 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
906 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
907 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
908 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
909 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
910 res['network'][0]['node'][i]['supporting-node'])
911 listNode.remove(nodeId)
912 elif(nodeId == 'ROADM-A1-DEG1'):
913 # Test related to DEG1
914 self.assertEqual(nodeType, 'DEGREE')
915 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
916 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
917 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
918 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
919 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
920 res['network'][0]['node'][i]['supporting-node'])
921 listNode.remove(nodeId)
922 elif(nodeId == 'ROADM-A1-DEG2'):
923 # Test related to DEG2
924 self.assertEqual(nodeType, 'DEGREE')
925 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
926 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
927 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
928 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
929 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
930 res['network'][0]['node'][i]['supporting-node'])
931 listNode.remove(nodeId)
933 self.assertFalse(True)
934 self.assertEqual(len(listNode), 0)
935 # Test related to SRG1 of ROADMC
936 for i in range(0, nbNode):
937 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
938 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
939 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
941 def test_33_getOpenRoadmNetwork(self):
942 response = test_utils.get_ordm_net_request()
943 self.assertEqual(response.status_code, requests.codes.ok)
944 res = response.json()
945 nbNode = len(res['network'][0]['node'])
946 self.assertEqual(nbNode, 2)
947 for i in range(0, nbNode-1):
948 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
949 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
951 def test_34_getClliNetwork(self):
952 response = test_utils.get_clli_net_request()
953 self.assertEqual(response.status_code, requests.codes.ok)
954 res = response.json()
955 nbNode = len(res['network'][0]['node'])
956 self.assertEqual(nbNode, 1)
957 for i in range(0, nbNode-1):
958 self.assertNotEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
960 def test_35_disconnect_XPDRA(self):
961 response = test_utils.unmount_device("XPDR-A1")
962 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
964 def test_36_getClliNetwork(self):
965 response = test_utils.get_clli_net_request()
966 self.assertEqual(response.status_code, requests.codes.ok)
967 res = response.json()
968 nbNode = len(res['network'][0]['node'])
969 self.assertEqual(nbNode, 1)
970 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
972 def test_37_getOpenRoadmNetwork(self):
973 response = test_utils.get_ordm_net_request()
974 self.assertEqual(response.status_code, requests.codes.ok)
975 res = response.json()
976 nbNode = len(res['network'][0]['node'])
977 self.assertEqual(nbNode, 1)
978 for i in range(0, nbNode):
979 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
981 def test_38_getNodes_OpenRoadmTopology(self):
982 response = test_utils.get_ordm_topo_request("")
983 res = response.json()
984 # Tests related to nodes
985 self.assertEqual(response.status_code, requests.codes.ok)
986 nbNode = len(res['network'][0]['node'])
987 self.assertEqual(nbNode, 4)
988 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
989 for i in range(0, nbNode):
990 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
991 res['network'][0]['node'][i]['supporting-node'])
992 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
993 nodeId = res['network'][0]['node'][i]['node-id']
994 if(nodeId == 'ROADM-A1-SRG1'):
995 # Test related to SRG1
996 self.assertEqual(nodeType, 'SRG')
997 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
998 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
999 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1000 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1001 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1002 listNode.remove(nodeId)
1003 elif(nodeId == 'ROADM-A1-SRG3'):
1004 # Test related to SRG1
1005 self.assertEqual(nodeType, 'SRG')
1006 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1007 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1008 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1009 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1010 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1011 listNode.remove(nodeId)
1012 elif(nodeId == 'ROADM-A1-DEG1'):
1013 # Test related to DEG1
1014 self.assertEqual(nodeType, 'DEGREE')
1015 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1016 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1017 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1018 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1019 listNode.remove(nodeId)
1020 elif(nodeId == 'ROADM-A1-DEG2'):
1021 # Test related to DEG2
1022 self.assertEqual(nodeType, 'DEGREE')
1023 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1024 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1025 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1026 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1027 listNode.remove(nodeId)
1029 self.assertFalse(True)
1030 self.assertEqual(len(listNode), 0)
1032 def test_39_disconnect_ROADM_XPDRA_link(self):
1034 response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
1035 self.assertEqual(response.status_code, requests.codes.ok)
1037 response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
1038 self.assertEqual(response.status_code, requests.codes.ok)
1040 def test_40_getLinks_OpenRoadmTopology(self):
1041 response = test_utils.get_ordm_topo_request("")
1042 self.assertEqual(response.status_code, requests.codes.ok)
1043 res = response.json()
1044 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1045 self.assertEqual(nbLink, 16)
1046 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1047 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1048 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
1049 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1050 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
1051 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1052 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1053 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1054 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
1055 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1056 roadmtoroadmLink = 0
1057 for i in range(0, nbLink):
1058 if (res['network'][0]['ietf-network-topology:link'][i]
1059 ['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1060 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1061 find = link_id in expressLink
1062 self.assertEqual(find, True)
1063 expressLink.remove(link_id)
1064 elif (res['network'][0]['ietf-network-topology:link'][i]
1065 ['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1066 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1067 find = link_id in addLink
1068 self.assertEqual(find, True)
1069 addLink.remove(link_id)
1070 elif (res['network'][0]['ietf-network-topology:link'][i]
1071 ['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1072 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1073 find = link_id in dropLink
1074 self.assertEqual(find, True)
1075 dropLink.remove(link_id)
1077 roadmtoroadmLink += 1
1078 self.assertEqual(len(expressLink), 0)
1079 self.assertEqual(len(addLink), 0)
1080 self.assertEqual(len(dropLink), 0)
1081 self.assertEqual(roadmtoroadmLink, 6)
1082 for i in range(0, nbLink):
1083 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1084 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1085 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1086 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1088 def test_41_disconnect_ROADMA(self):
1089 response = test_utils.unmount_device("ROADM-A1")
1090 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1091 # Delete in the clli-network
1092 response = test_utils.del_node_request("NodeA")
1093 self.assertEqual(response.status_code, requests.codes.ok)
1095 def test_42_getClliNetwork(self):
1096 response = test_utils.get_clli_net_request()
1097 self.assertEqual(response.status_code, requests.codes.ok)
1098 res = response.json()
1099 self.assertNotIn('node', res['network'][0])
1101 def test_43_getOpenRoadmNetwork(self):
1102 response = test_utils.get_ordm_net_request()
1103 self.assertEqual(response.status_code, requests.codes.ok)
1104 res = response.json()
1105 self.assertNotIn('node', res['network'][0])
1107 def test_44_check_roadm2roadm_link_persistence(self):
1108 response = test_utils.get_ordm_topo_request("")
1109 self.assertEqual(response.status_code, requests.codes.ok)
1110 res = response.json()
1111 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1112 self.assertNotIn('node', res['network'][0])
1113 self.assertEqual(nbLink, 6)
1116 if __name__ == "__main__":
1117 unittest.main(verbosity=2)