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 ##############################################################################
17 from common import test_utils
20 class TransportPCEtesting(unittest.TestCase):
26 cls.processes = test_utils.start_tpce()
27 cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
30 def tearDownClass(cls):
31 for process in cls.processes:
32 test_utils.shutdown_process(process)
33 print("all processes killed")
38 def test_01_connect_ROADM_A1(self):
39 response = test_utils.mount_device("ROADM-A1", 'roadma')
40 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
42 def test_02_getClliNetwork(self):
43 response = test_utils.get_clli_net_request()
44 self.assertEqual(response.status_code, requests.codes.ok)
47 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
48 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
50 def test_03_getOpenRoadmNetwork(self):
51 response = test_utils.get_ordm_net_request()
52 self.assertEqual(response.status_code, requests.codes.ok)
54 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
55 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
56 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
57 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
58 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
60 def test_04_getLinks_OpenroadmTopology(self):
61 response = test_utils.get_ordm_topo_request("")
62 self.assertEqual(response.status_code, requests.codes.ok)
64 # Tests related to links
65 nbLink = len(res['network'][0]['ietf-network-topology:link'])
66 self.assertEqual(nbLink, 10)
67 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
68 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
69 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
70 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
71 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
72 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
73 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
74 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
75 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
76 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
77 for i in range(0, nbLink):
78 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
79 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
80 find = linkId in expressLink
81 self.assertEqual(find, True)
82 expressLink.remove(linkId)
83 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
84 find = linkId in addLink
85 self.assertEqual(find, True)
86 addLink.remove(linkId)
87 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
88 find = linkId in dropLink
89 self.assertEqual(find, True)
90 dropLink.remove(linkId)
92 self.assertFalse(True)
93 self.assertEqual(len(expressLink), 0)
94 self.assertEqual(len(addLink), 0)
95 self.assertEqual(len(dropLink), 0)
97 def test_05_getNodes_OpenRoadmTopology(self):
98 response = test_utils.get_ordm_topo_request("")
100 # Tests related to nodes
101 self.assertEqual(response.status_code, requests.codes.ok)
102 nbNode = len(res['network'][0]['node'])
103 self.assertEqual(nbNode, 4)
104 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
105 for i in range(0, nbNode):
106 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
107 res['network'][0]['node'][i]['supporting-node'])
108 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
109 nodeId = res['network'][0]['node'][i]['node-id']
110 if(nodeId == 'ROADM-A1-SRG1'):
111 # Test related to SRG1
112 self.assertEqual(nodeType, 'SRG')
113 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
114 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
115 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
116 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
117 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
118 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
119 res['network'][0]['node'][i]['supporting-node'])
120 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
121 res['network'][0]['node'][i]['supporting-node'])
122 listNode.remove(nodeId)
123 elif(nodeId == 'ROADM-A1-SRG3'):
124 # Test related to SRG1
125 self.assertEqual(nodeType, 'SRG')
126 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
127 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
128 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
129 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
130 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
131 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
132 res['network'][0]['node'][i]['supporting-node'])
133 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
134 res['network'][0]['node'][i]['supporting-node'])
135 listNode.remove(nodeId)
136 elif(nodeId == 'ROADM-A1-DEG1'):
137 # Test related to DEG1
138 self.assertEqual(nodeType, 'DEGREE')
139 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
140 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
141 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
142 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
143 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
144 res['network'][0]['node'][i]['supporting-node'])
145 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
146 res['network'][0]['node'][i]['supporting-node'])
147 listNode.remove(nodeId)
148 elif(nodeId == 'ROADM-A1-DEG2'):
149 # Test related to DEG2
150 self.assertEqual(nodeType, 'DEGREE')
151 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
152 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
153 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
154 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
155 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
156 res['network'][0]['node'][i]['supporting-node'])
157 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
158 res['network'][0]['node'][i]['supporting-node'])
159 listNode.remove(nodeId)
161 self.assertFalse(True)
162 self.assertEqual(len(listNode), 0)
164 def test_06_connect_XPDRA(self):
165 response = test_utils.mount_device("XPDR-A1", 'xpdra')
166 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
168 def test_07_getClliNetwork(self):
169 response = test_utils.get_clli_net_request()
170 self.assertEqual(response.status_code, requests.codes.ok)
171 res = response.json()
172 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
173 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
175 def test_08_getOpenRoadmNetwork(self):
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 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
188 elif(nodeId == 'ROADM-A1'):
189 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
190 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
192 self.assertFalse(True)
194 def test_09_getNodes_OpenRoadmTopology(self):
195 response = test_utils.get_ordm_topo_request("")
196 res = response.json()
197 # Tests related to nodes
198 self.assertEqual(response.status_code, requests.codes.ok)
199 nbNode = len(res['network'][0]['node'])
200 self.assertEqual(nbNode, 5)
201 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
202 for i in range(0, nbNode):
203 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
204 nodeId = res['network'][0]['node'][i]['node-id']
205 # Tests related to XPDRA nodes
206 if(nodeId == 'XPDR-A1-XPDR1'):
207 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
208 res['network'][0]['node'][i]['supporting-node'])
209 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
210 res['network'][0]['node'][i]['supporting-node'])
211 self.assertEqual(nodeType, 'XPONDER')
212 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
215 for j in range(0, nbTps):
216 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
217 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
218 if (tpType == 'XPONDER-CLIENT'):
220 elif (tpType == 'XPONDER-NETWORK'):
222 if (tpId == 'XPDR1-NETWORK2'):
223 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
224 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
225 if (tpId == 'XPDR1-CLIENT2'):
226 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
227 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
229 self.assertTrue(client == 2)
230 self.assertTrue(network == 2)
231 listNode.remove(nodeId)
232 elif(nodeId == 'ROADM-A1-SRG1'):
233 # Test related to SRG1
234 self.assertEqual(nodeType, 'SRG')
235 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
236 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
237 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
238 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
239 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
240 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
241 res['network'][0]['node'][i]['supporting-node'])
242 listNode.remove(nodeId)
243 elif(nodeId == 'ROADM-A1-SRG3'):
244 # Test related to SRG1
245 self.assertEqual(nodeType, 'SRG')
246 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
247 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
248 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
249 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
250 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
251 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
252 res['network'][0]['node'][i]['supporting-node'])
253 listNode.remove(nodeId)
254 elif(nodeId == 'ROADM-A1-DEG1'):
255 # Test related to DEG1
256 self.assertEqual(nodeType, 'DEGREE')
257 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
258 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
259 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
260 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
261 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
262 res['network'][0]['node'][i]['supporting-node'])
263 listNode.remove(nodeId)
264 elif(nodeId == 'ROADM-A1-DEG2'):
265 # Test related to DEG2
266 self.assertEqual(nodeType, 'DEGREE')
267 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
268 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
269 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
270 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
271 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
272 res['network'][0]['node'][i]['supporting-node'])
273 listNode.remove(nodeId)
275 self.assertFalse(True)
276 self.assertEqual(len(listNode), 0)
278 # Connect the tail XPDRA to ROADMA and vice versa
279 def test_10_connect_tail_xpdr_rdm(self):
280 # Connect the tail: XPDRA to ROADMA
281 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
282 data = {"networkutils:input": {
283 "networkutils:links-input": {
284 "networkutils:xpdr-node": "XPDR-A1",
285 "networkutils:xpdr-num": "1",
286 "networkutils:network-num": "1",
287 "networkutils:rdm-node": "ROADM-A1",
288 "networkutils:srg-num": "1",
289 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
293 response = test_utils.post_request(url, data)
294 self.assertEqual(response.status_code, requests.codes.ok)
296 def test_11_connect_tail_rdm_xpdr(self):
297 # Connect the tail: ROADMA to XPDRA
298 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
299 data = {"networkutils:input": {
300 "networkutils:links-input": {
301 "networkutils:xpdr-node": "XPDR-A1",
302 "networkutils:xpdr-num": "1",
303 "networkutils:network-num": "1",
304 "networkutils:rdm-node": "ROADM-A1",
305 "networkutils:srg-num": "1",
306 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
310 response = test_utils.post_request(url, data)
311 self.assertEqual(response.status_code, requests.codes.ok)
313 def test_12_getLinks_OpenRoadmTopology(self):
314 response = test_utils.get_ordm_topo_request("")
315 self.assertEqual(response.status_code, requests.codes.ok)
316 res = response.json()
317 # Tests related to links
318 nbLink = len(res['network'][0]['ietf-network-topology:link'])
319 self.assertEqual(nbLink, 12)
320 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
321 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
322 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
323 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
324 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
325 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
326 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
327 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
328 for i in range(0, nbLink):
329 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
330 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
331 if(nodeType == 'EXPRESS-LINK'):
332 find = linkId in expressLink
333 self.assertEqual(find, True)
334 expressLink.remove(linkId)
335 elif(nodeType == 'ADD-LINK'):
336 find = linkId in addLink
337 self.assertEqual(find, True)
338 addLink.remove(linkId)
339 elif(nodeType == 'DROP-LINK'):
340 find = linkId in dropLink
341 self.assertEqual(find, True)
342 dropLink.remove(linkId)
343 elif(nodeType == 'XPONDER-INPUT'):
344 find = linkId in XPDR_IN
345 self.assertEqual(find, True)
346 XPDR_IN.remove(linkId)
347 elif(nodeType == 'XPONDER-OUTPUT'):
348 find = linkId in XPDR_OUT
349 self.assertEqual(find, True)
350 XPDR_OUT.remove(linkId)
352 self.assertFalse(True)
353 self.assertEqual(len(expressLink), 0)
354 self.assertEqual(len(addLink), 0)
355 self.assertEqual(len(dropLink), 0)
356 self.assertEqual(len(XPDR_IN), 0)
357 self.assertEqual(len(XPDR_OUT), 0)
359 def test_13_connect_ROADMC(self):
360 response = test_utils.mount_device("ROADM-C1", 'roadmc')
361 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
363 def test_14_omsAttributes_ROADMA_ROADMC(self):
364 # Config ROADMA-ROADMC oms-attributes
366 "auto-spanloss": "true",
367 "engineered-spanloss": 12.2,
368 "link-concatenation": [{
371 "SRLG-length": 100000,
373 response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
374 self.assertEqual(response.status_code, requests.codes.created)
376 def test_15_omsAttributes_ROADMC_ROADMA(self):
377 # Config ROADM-C1-ROADM-A1 oms-attributes
379 "auto-spanloss": "true",
380 "engineered-spanloss": 12.2,
381 "link-concatenation": [{
384 "SRLG-length": 100000,
387 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
388 self.assertEqual(response.status_code, requests.codes.created)
390 def test_16_getClliNetwork(self):
391 response = test_utils.get_clli_net_request()
392 self.assertEqual(response.status_code, requests.codes.ok)
393 res = response.json()
394 nbNode = len(res['network'][0]['node'])
395 listNode = ['NodeA', 'NodeC']
396 for i in range(0, nbNode):
397 nodeId = res['network'][0]['node'][i]['node-id']
398 find = nodeId in listNode
399 self.assertEqual(find, True)
400 if(nodeId == 'NodeA'):
401 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
403 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
404 listNode.remove(nodeId)
405 self.assertEqual(len(listNode), 0)
407 def test_17_getOpenRoadmNetwork(self):
408 response = test_utils.get_ordm_net_request()
409 self.assertEqual(response.status_code, requests.codes.ok)
410 res = response.json()
411 nbNode = len(res['network'][0]['node'])
412 self.assertEqual(nbNode, 3)
413 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
414 for i in range(0, nbNode):
415 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
416 nodeId = res['network'][0]['node'][i]['node-id']
417 if(nodeId == 'XPDR-A1'):
418 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
419 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
420 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
421 listNode.remove(nodeId)
422 elif(nodeId == 'ROADM-A1'):
423 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
424 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
425 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
426 listNode.remove(nodeId)
427 elif(nodeId == 'ROADM-C1'):
428 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
429 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
430 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
431 listNode.remove(nodeId)
433 self.assertFalse(True)
434 self.assertEqual(len(listNode), 0)
436 def test_18_getROADMLinkOpenRoadmTopology(self):
437 response = test_utils.get_ordm_topo_request("")
438 self.assertEqual(response.status_code, requests.codes.ok)
439 res = response.json()
440 # Tests related to links
441 nbLink = len(res['network'][0]['ietf-network-topology:link'])
442 self.assertEqual(nbLink, 20)
443 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
444 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
445 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
446 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
447 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
448 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
449 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
450 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
451 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
452 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
453 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
454 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
455 for i in range(0, nbLink):
456 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
457 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
458 if(nodeType == 'EXPRESS-LINK'):
459 find = linkId in expressLink
460 self.assertEqual(find, True)
461 expressLink.remove(linkId)
462 elif(nodeType == 'ADD-LINK'):
463 find = linkId in addLink
464 self.assertEqual(find, True)
465 addLink.remove(linkId)
466 elif(nodeType == 'DROP-LINK'):
467 find = linkId in dropLink
468 self.assertEqual(find, True)
469 dropLink.remove(linkId)
470 elif(nodeType == 'ROADM-TO-ROADM'):
471 find = linkId in R2RLink
472 self.assertEqual(find, True)
473 R2RLink.remove(linkId)
474 elif(nodeType == 'XPONDER-INPUT'):
475 find = linkId in XPDR_IN
476 self.assertEqual(find, True)
477 XPDR_IN.remove(linkId)
478 elif(nodeType == 'XPONDER-OUTPUT'):
479 find = linkId in XPDR_OUT
480 self.assertEqual(find, True)
481 XPDR_OUT.remove(linkId)
483 self.assertFalse(True)
484 self.assertEqual(len(expressLink), 0)
485 self.assertEqual(len(addLink), 0)
486 self.assertEqual(len(dropLink), 0)
487 self.assertEqual(len(R2RLink), 0)
488 self.assertEqual(len(XPDR_IN), 0)
489 self.assertEqual(len(XPDR_OUT), 0)
491 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
492 response = test_utils.get_ordm_topo_request("")
493 self.assertEqual(response.status_code, requests.codes.ok)
494 res = response.json()
495 # Tests related to links
496 nbLink = len(res['network'][0]['ietf-network-topology:link'])
497 self.assertEqual(nbLink, 20)
498 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
499 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
500 for i in range(0, nbLink):
501 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
502 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
503 if(link_id in R2RLink):
505 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
506 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
507 length = res['network'][0]['ietf-network-topology:link'][i][
508 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
509 if((spanLoss != None) & (length != None)):
511 self.assertTrue(find)
512 R2RLink.remove(link_id)
513 self.assertEqual(len(R2RLink), 0)
515 def test_20_getNodes_OpenRoadmTopology(self):
516 response = test_utils.get_ordm_topo_request("")
517 res = response.json()
518 # Tests related to nodes
519 self.assertEqual(response.status_code, requests.codes.ok)
520 nbNode = len(res['network'][0]['node'])
521 self.assertEqual(nbNode, 8)
522 listNode = ['XPDR-A1-XPDR1',
523 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
524 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
525 # ************************Tests related to XPDRA nodes
526 for i in range(0, nbNode):
527 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
528 nodeId = res['network'][0]['node'][i]['node-id']
529 if(nodeId == 'XPDR-A1-XPDR1'):
530 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
531 res['network'][0]['node'][i]['supporting-node'])
532 self.assertEqual(nodeType, 'XPONDER')
533 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
534 self.assertTrue(nbTps >= 4)
537 for j in range(0, nbTps):
538 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
539 if (tpType == 'XPONDER-CLIENT'):
541 elif (tpType == 'XPONDER-NETWORK'):
543 self.assertTrue(client == 2)
544 self.assertTrue(network == 2)
545 listNode.remove(nodeId)
546 elif(nodeId == 'ROADM-A1-SRG1'):
547 # Test related to SRG1
548 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
549 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
550 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
551 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
552 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
553 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
554 res['network'][0]['node'][i]['supporting-node'])
555 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
556 listNode.remove(nodeId)
557 elif(nodeId == 'ROADM-A1-SRG3'):
558 # Test related to SRG1
559 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
560 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
561 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
562 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
563 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
564 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
565 res['network'][0]['node'][i]['supporting-node'])
566 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
567 listNode.remove(nodeId)
568 elif(nodeId == 'ROADM-A1-DEG1'):
569 # Test related to DEG1
570 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
571 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
572 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
573 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
574 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
575 res['network'][0]['node'][i]['supporting-node'])
576 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
577 listNode.remove(nodeId)
578 elif(nodeId == 'ROADM-A1-DEG2'):
579 # Test related to DEG2
580 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
581 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
582 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
583 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
584 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
585 res['network'][0]['node'][i]['supporting-node'])
586 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
587 listNode.remove(nodeId)
588 elif(nodeId == 'ROADM-C1-SRG1'):
589 # Test related to SRG1
590 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
591 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
592 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
593 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
594 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
595 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
596 res['network'][0]['node'][i]['supporting-node'])
597 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
598 listNode.remove(nodeId)
599 elif(nodeId == 'ROADM-C1-DEG1'):
600 # Test related to DEG1
601 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
602 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
603 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
604 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
605 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
606 res['network'][0]['node'][i]['supporting-node'])
607 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
608 listNode.remove(nodeId)
609 elif(nodeId == 'ROADM-C1-DEG2'):
610 # Test related to DEG1
611 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
612 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
613 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
614 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
615 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
616 res['network'][0]['node'][i]['supporting-node'])
617 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
618 listNode.remove(nodeId)
620 self.assertFalse(True)
621 self.assertEqual(len(listNode), 0)
623 def test_21_connect_ROADMB(self):
624 response = test_utils.mount_device("ROADM-B1", 'roadmb')
625 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
627 def test_22_omsAttributes_ROADMA_ROADMB(self):
628 # Config ROADM-A1-ROADM-B1 oms-attributes
630 "auto-spanloss": "true",
631 "engineered-spanloss": 12.2,
632 "spanloss-current": 12,
633 "spanloss-base": 11.4,
634 "link-concatenation": [{
637 "SRLG-length": 100000,
639 response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
640 self.assertEqual(response.status_code, requests.codes.created)
642 def test_23_omsAttributes_ROADMB_ROADMA(self):
643 # Config ROADM-B1-ROADM-A1 oms-attributes
645 "auto-spanloss": "true",
646 "engineered-spanloss": 12.2,
647 "spanloss-current": 12,
648 "spanloss-base": 11.4,
649 "link-concatenation": [{
652 "SRLG-length": 100000,
654 response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
655 self.assertEqual(response.status_code, requests.codes.created)
657 def test_24_omsAttributes_ROADMB_ROADMC(self):
658 # Config ROADM-B1-ROADM-C1 oms-attributes
660 "auto-spanloss": "true",
661 "engineered-spanloss": 12.2,
662 "spanloss-current": 12,
663 "spanloss-base": 11.4,
664 "link-concatenation": [{
667 "SRLG-length": 100000,
669 response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
670 self.assertEqual(response.status_code, requests.codes.created)
672 def test_25_omsAttributes_ROADMC_ROADMB(self):
673 # Config ROADM-C1-ROADM-B1 oms-attributes
675 "auto-spanloss": "true",
676 "engineered-spanloss": 12.2,
677 "link-concatenation": [{
680 "SRLG-length": 100000,
682 response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
683 self.assertEqual(response.status_code, requests.codes.created)
685 def test_26_getClliNetwork(self):
686 response = test_utils.get_clli_net_request()
687 self.assertEqual(response.status_code, requests.codes.ok)
688 res = response.json()
689 nbNode = len(res['network'][0]['node'])
690 listNode = ['NodeA', 'NodeB', 'NodeC']
691 for i in range(0, nbNode):
692 nodeId = res['network'][0]['node'][i]['node-id']
693 find = nodeId in listNode
694 self.assertEqual(find, True)
695 if(nodeId == 'NodeA'):
696 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
697 elif(nodeId == 'NodeB'):
698 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
700 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
701 listNode.remove(nodeId)
702 self.assertEqual(len(listNode), 0)
704 def test_27_verifyDegree(self):
705 response = test_utils.get_ordm_topo_request("")
706 self.assertEqual(response.status_code, requests.codes.ok)
707 res = response.json()
708 # Tests related to links
709 nbLink = len(res['network'][0]['ietf-network-topology:link'])
710 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
711 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
712 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
713 for i in range(0, nbLink):
714 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
715 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
716 find = link_id in listR2RLink
717 self.assertEqual(find, True)
718 listR2RLink.remove(link_id)
719 self.assertEqual(len(listR2RLink), 0)
721 def test_28_verifyOppositeLinkTopology(self):
722 response = test_utils.get_ordm_topo_request("")
723 self.assertEqual(response.status_code, requests.codes.ok)
724 res = response.json()
725 # Tests related to links
726 nbLink = len(res['network'][0]['ietf-network-topology:link'])
727 self.assertEqual(nbLink, 26)
728 for i in range(0, nbLink):
729 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
730 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
731 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
732 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
733 oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['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 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
769 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
770 if(link_id in R2RLink):
772 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
773 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
774 length = res['network'][0]['ietf-network-topology:link'][i][
775 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
776 if((spanLoss != None) & (length != None)):
778 self.assertTrue(find)
779 R2RLink.remove(link_id)
780 self.assertEqual(len(R2RLink), 0)
782 def test_30_disconnect_ROADMB(self):
783 # Delete in the topology-netconf
784 response = test_utils.unmount_device("ROADM-B1")
785 # Delete in the clli-network
786 response = test_utils.del_node_request("NodeB")
787 self.assertEqual(response.status_code, requests.codes.ok)
789 def test_31_disconnect_ROADMC(self):
790 # Delete in the topology-netconf
791 response = test_utils.unmount_device("ROADM-C1")
792 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
793 # Delete in the clli-network
794 response = test_utils.del_node_request("NodeC")
795 self.assertEqual(response.status_code, requests.codes.ok)
797 # def test_24_check_roadm2roadm_links_deletion(self):
798 # response = test_utils.get_ordm_topo_request("")
799 # self.assertEqual(response.status_code, requests.codes.ok)
800 # res = response.json()
801 # #Write the response in the log
802 # with open('./transportpce_tests/log/response.log', 'a') as outfile1:
803 # outfile1.write(str(res))
804 # #Tests related to links
805 # nbLink=len(res['network'][0]['ietf-network-topology:link'])
806 # self.assertEqual(nbLink,8)
807 # expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
808 # addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
809 # dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
810 # XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
811 # XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
812 # for i in range(0,nbLink):
813 # nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
814 # linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
815 # if(nodeType=='EXPRESS-LINK'):
816 # find= linkId in expressLink
817 # self.assertEqual(find, True)
818 # expressLink.remove(linkId)
819 # elif(nodeType=='ADD-LINK'):
820 # find= linkId in addLink
821 # self.assertEqual(find, True)
822 # addLink.remove(linkId)
823 # elif(nodeType=='DROP-LINK'):
824 # find= linkId in dropLink
825 # self.assertEqual(find, True)
826 # dropLink.remove(linkId)
827 # elif(nodeType=='XPONDER-INPUT'):
828 # find= linkId in XPDR_IN
829 # self.assertEqual(find, True)
830 # XPDR_IN.remove(linkId)
831 # elif(nodeType=='XPONDER-OUTPUT'):
832 # find= linkId in XPDR_OUT
833 # self.assertEqual(find, True)
834 # XPDR_OUT.remove(linkId)
836 # self.assertFalse(True)
837 # self.assertEqual(len(expressLink),0)
838 # self.assertEqual(len(addLink),0)
839 # self.assertEqual(len(dropLink),0)
840 # self.assertEqual(len(XPDR_IN),0)
841 # self.assertEqual(len(XPDR_OUT),0)
843 # for i in range(0,nbLink):
844 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
845 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
846 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
847 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
848 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
849 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
850 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
852 def test_32_getNodes_OpenRoadmTopology(self):
853 response = test_utils.get_ordm_topo_request("")
854 res = response.json()
855 # Tests related to nodes
856 self.assertEqual(response.status_code, requests.codes.ok)
857 nbNode = len(res['network'][0]['node'])
858 self.assertEqual(nbNode, 5)
859 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
860 for i in range(0, nbNode):
861 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
862 nodeId = res['network'][0]['node'][i]['node-id']
863 # Tests related to XPDRA nodes
864 if(nodeId == 'XPDR-A1-XPDR1'):
865 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
866 for j in range(0, nbTp):
867 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
868 if (tpid == 'XPDR1-CLIENT1'):
869 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
870 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
871 if (tpid == 'XPDR1-NETWORK1'):
872 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
873 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
874 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
875 ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
876 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
877 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
878 res['network'][0]['node'][i]['supporting-node'])
879 listNode.remove(nodeId)
880 elif(nodeId == 'ROADM-A1-SRG1'):
881 # Test related to SRG1
882 self.assertEqual(nodeType, 'SRG')
883 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
884 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
885 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
886 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
887 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
888 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
889 res['network'][0]['node'][i]['supporting-node'])
890 listNode.remove(nodeId)
891 elif(nodeId == 'ROADM-A1-SRG3'):
892 # Test related to SRG1
893 self.assertEqual(nodeType, 'SRG')
894 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
895 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
896 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
897 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
898 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
899 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
900 res['network'][0]['node'][i]['supporting-node'])
901 listNode.remove(nodeId)
902 elif(nodeId == 'ROADM-A1-DEG1'):
903 # Test related to DEG1
904 self.assertEqual(nodeType, 'DEGREE')
905 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
906 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
907 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
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-DEG2'):
913 # Test related to DEG2
914 self.assertEqual(nodeType, 'DEGREE')
915 self.assertIn({'tp-id': 'DEG2-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': 'DEG2-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)
923 self.assertFalse(True)
924 self.assertEqual(len(listNode), 0)
925 # Test related to SRG1 of ROADMC
926 for i in range(0, nbNode):
927 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
928 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
929 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
931 def test_33_getOpenRoadmNetwork(self):
932 response = test_utils.get_ordm_net_request()
933 self.assertEqual(response.status_code, requests.codes.ok)
934 res = response.json()
935 nbNode = len(res['network'][0]['node'])
936 self.assertEqual(nbNode, 2)
937 for i in range(0, nbNode-1):
938 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
939 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
941 def test_34_getClliNetwork(self):
942 response = test_utils.get_clli_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, 1)
947 for i in range(0, nbNode-1):
948 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
950 def test_35_disconnect_XPDRA(self):
951 response = test_utils.unmount_device("XPDR-A1")
952 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
954 def test_36_getClliNetwork(self):
955 response = test_utils.get_clli_net_request()
956 self.assertEqual(response.status_code, requests.codes.ok)
957 res = response.json()
958 nbNode = len(res['network'][0]['node'])
959 self.assertEqual(nbNode, 1)
960 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
962 def test_37_getOpenRoadmNetwork(self):
963 response = test_utils.get_ordm_net_request()
964 self.assertEqual(response.status_code, requests.codes.ok)
965 res = response.json()
966 nbNode = len(res['network'][0]['node'])
967 self.assertEqual(nbNode, 1)
968 for i in range(0, nbNode):
969 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
971 def test_38_getNodes_OpenRoadmTopology(self):
972 response = test_utils.get_ordm_topo_request("")
973 res = response.json()
974 # Tests related to nodes
975 self.assertEqual(response.status_code, requests.codes.ok)
976 nbNode = len(res['network'][0]['node'])
977 self.assertEqual(nbNode, 4)
978 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
979 for i in range(0, nbNode):
980 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
981 res['network'][0]['node'][i]['supporting-node'])
982 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
983 nodeId = res['network'][0]['node'][i]['node-id']
984 if(nodeId == 'ROADM-A1-SRG1'):
985 # Test related to SRG1
986 self.assertEqual(nodeType, 'SRG')
987 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
988 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
989 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
990 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
991 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
992 listNode.remove(nodeId)
993 elif(nodeId == 'ROADM-A1-SRG3'):
994 # Test related to SRG1
995 self.assertEqual(nodeType, 'SRG')
996 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
997 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
998 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
999 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1000 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1001 listNode.remove(nodeId)
1002 elif(nodeId == 'ROADM-A1-DEG1'):
1003 # Test related to DEG1
1004 self.assertEqual(nodeType, 'DEGREE')
1005 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1006 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1007 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1008 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1009 listNode.remove(nodeId)
1010 elif(nodeId == 'ROADM-A1-DEG2'):
1011 # Test related to DEG2
1012 self.assertEqual(nodeType, 'DEGREE')
1013 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1014 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1015 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1016 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1017 listNode.remove(nodeId)
1019 self.assertFalse(True)
1020 self.assertEqual(len(listNode), 0)
1022 def test_39_disconnect_ROADM_XPDRA_link(self):
1024 response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
1025 self.assertEqual(response.status_code, requests.codes.ok)
1027 response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
1028 self.assertEqual(response.status_code, requests.codes.ok)
1030 def test_40_getLinks_OpenRoadmTopology(self):
1031 response = test_utils.get_ordm_topo_request("")
1032 self.assertEqual(response.status_code, requests.codes.ok)
1033 res = response.json()
1034 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1035 self.assertEqual(nbLink, 16)
1036 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1037 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1038 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1039 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1040 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1041 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1042 roadmtoroadmLink = 0
1043 for i in range(0, nbLink):
1044 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1045 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1046 find = link_id in expressLink
1047 self.assertEqual(find, True)
1048 expressLink.remove(link_id)
1049 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1050 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1051 find = link_id in addLink
1052 self.assertEqual(find, True)
1053 addLink.remove(link_id)
1054 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1055 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1056 find = link_id in dropLink
1057 self.assertEqual(find, True)
1058 dropLink.remove(link_id)
1060 roadmtoroadmLink += 1
1061 self.assertEqual(len(expressLink), 0)
1062 self.assertEqual(len(addLink), 0)
1063 self.assertEqual(len(dropLink), 0)
1064 self.assertEqual(roadmtoroadmLink, 6)
1065 for i in range(0, nbLink):
1066 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1067 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1068 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1069 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1071 def test_41_disconnect_ROADMA(self):
1072 response = test_utils.unmount_device("ROADM-A1")
1073 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1074 # Delete in the clli-network
1075 response = test_utils.del_node_request("NodeA")
1076 self.assertEqual(response.status_code, requests.codes.ok)
1078 def test_42_getClliNetwork(self):
1079 response = test_utils.get_clli_net_request()
1080 self.assertEqual(response.status_code, requests.codes.ok)
1081 res = response.json()
1082 self.assertNotIn('node', res['network'][0])
1084 def test_43_getOpenRoadmNetwork(self):
1085 response = test_utils.get_ordm_net_request()
1086 self.assertEqual(response.status_code, requests.codes.ok)
1087 res = response.json()
1088 self.assertNotIn('node', res['network'][0])
1090 def test_44_check_roadm2roadm_link_persistence(self):
1091 response = test_utils.get_ordm_topo_request("")
1092 self.assertEqual(response.status_code, requests.codes.ok)
1093 res = response.json()
1094 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1095 self.assertNotIn('node', res['network'][0])
1096 self.assertEqual(nbLink, 6)
1099 if __name__ == "__main__":
1100 unittest.main(verbosity=2)