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 url = "{}/config/ietf-network:networks/network/clli-network"
44 response = test_utils.get_request(url)
45 self.assertEqual(response.status_code, requests.codes.ok)
48 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
49 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
51 def test_03_getOpenRoadmNetwork(self):
52 url = "{}/config/ietf-network:networks/network/openroadm-network"
53 response = test_utils.get_request(url)
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]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
82 find = linkId in expressLink
83 self.assertEqual(find, True)
84 expressLink.remove(linkId)
85 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
86 find = linkId in addLink
87 self.assertEqual(find, True)
88 addLink.remove(linkId)
89 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
90 find = linkId in dropLink
91 self.assertEqual(find, True)
92 dropLink.remove(linkId)
94 self.assertFalse(True)
95 self.assertEqual(len(expressLink), 0)
96 self.assertEqual(len(addLink), 0)
97 self.assertEqual(len(dropLink), 0)
99 def test_05_getNodes_OpenRoadmTopology(self):
100 response = test_utils.get_ordm_topo_request("")
101 res = response.json()
102 # Tests related to nodes
103 self.assertEqual(response.status_code, requests.codes.ok)
104 nbNode = len(res['network'][0]['node'])
105 self.assertEqual(nbNode, 4)
106 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
107 for i in range(0, nbNode):
108 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
109 res['network'][0]['node'][i]['supporting-node'])
110 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
111 nodeId = res['network'][0]['node'][i]['node-id']
112 if(nodeId == 'ROADM-A1-SRG1'):
113 # Test related to SRG1
114 self.assertEqual(nodeType, 'SRG')
115 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
116 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
117 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
118 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
119 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
120 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
121 res['network'][0]['node'][i]['supporting-node'])
122 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
123 res['network'][0]['node'][i]['supporting-node'])
124 listNode.remove(nodeId)
125 elif(nodeId == 'ROADM-A1-SRG3'):
126 # Test related to SRG1
127 self.assertEqual(nodeType, 'SRG')
128 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
129 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
130 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
131 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
132 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
133 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
134 res['network'][0]['node'][i]['supporting-node'])
135 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
136 res['network'][0]['node'][i]['supporting-node'])
137 listNode.remove(nodeId)
138 elif(nodeId == 'ROADM-A1-DEG1'):
139 # Test related to DEG1
140 self.assertEqual(nodeType, 'DEGREE')
141 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
142 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
143 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
144 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
145 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
146 res['network'][0]['node'][i]['supporting-node'])
147 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
148 res['network'][0]['node'][i]['supporting-node'])
149 listNode.remove(nodeId)
150 elif(nodeId == 'ROADM-A1-DEG2'):
151 # Test related to DEG2
152 self.assertEqual(nodeType, 'DEGREE')
153 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
154 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
155 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
156 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
157 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
158 res['network'][0]['node'][i]['supporting-node'])
159 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
160 res['network'][0]['node'][i]['supporting-node'])
161 listNode.remove(nodeId)
163 self.assertFalse(True)
164 self.assertEqual(len(listNode), 0)
166 def test_06_connect_XPDRA(self):
167 response = test_utils.mount_device("XPDR-A1", 'xpdra')
168 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
170 def test_07_getClliNetwork(self):
171 url = "{}/config/ietf-network:networks/network/clli-network"
172 response = test_utils.get_request(url)
173 self.assertEqual(response.status_code, requests.codes.ok)
174 res = response.json()
175 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
176 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
178 def test_08_getOpenRoadmNetwork(self):
179 url = "{}/config/ietf-network:networks/network/openroadm-network"
180 response = test_utils.get_request(url)
181 self.assertEqual(response.status_code, requests.codes.ok)
182 res = response.json()
183 nbNode = len(res['network'][0]['node'])
184 self.assertEqual(nbNode, 2)
185 for i in range(0, nbNode):
186 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
187 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
188 nodeId = res['network'][0]['node'][i]['node-id']
189 if(nodeId == 'XPDR-A1'):
190 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
191 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
192 elif(nodeId == 'ROADM-A1'):
193 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
194 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
196 self.assertFalse(True)
198 def test_09_getNodes_OpenRoadmTopology(self):
199 response = test_utils.get_ordm_topo_request("")
200 res = response.json()
201 # Tests related to nodes
202 self.assertEqual(response.status_code, requests.codes.ok)
203 nbNode = len(res['network'][0]['node'])
204 self.assertEqual(nbNode, 5)
205 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
206 for i in range(0, nbNode):
207 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
208 nodeId = res['network'][0]['node'][i]['node-id']
209 # Tests related to XPDRA nodes
210 if(nodeId == 'XPDR-A1-XPDR1'):
211 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
212 res['network'][0]['node'][i]['supporting-node'])
213 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
214 res['network'][0]['node'][i]['supporting-node'])
215 self.assertEqual(nodeType, 'XPONDER')
216 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
219 for j in range(0, nbTps):
220 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
221 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
222 if (tpType == 'XPONDER-CLIENT'):
224 elif (tpType == 'XPONDER-NETWORK'):
226 if (tpId == 'XPDR1-NETWORK2'):
227 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
228 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
229 if (tpId == 'XPDR1-CLIENT2'):
230 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
231 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
233 self.assertTrue(client == 2)
234 self.assertTrue(network == 2)
235 listNode.remove(nodeId)
236 elif(nodeId == 'ROADM-A1-SRG1'):
237 # Test related to SRG1
238 self.assertEqual(nodeType, 'SRG')
239 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
240 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
241 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
242 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
243 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
244 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
245 res['network'][0]['node'][i]['supporting-node'])
246 listNode.remove(nodeId)
247 elif(nodeId == 'ROADM-A1-SRG3'):
248 # Test related to SRG1
249 self.assertEqual(nodeType, 'SRG')
250 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
251 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
252 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
253 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
254 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
255 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
256 res['network'][0]['node'][i]['supporting-node'])
257 listNode.remove(nodeId)
258 elif(nodeId == 'ROADM-A1-DEG1'):
259 # Test related to DEG1
260 self.assertEqual(nodeType, 'DEGREE')
261 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
262 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
263 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
264 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
265 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
266 res['network'][0]['node'][i]['supporting-node'])
267 listNode.remove(nodeId)
268 elif(nodeId == 'ROADM-A1-DEG2'):
269 # Test related to DEG2
270 self.assertEqual(nodeType, 'DEGREE')
271 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
272 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
273 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
274 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
275 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
276 res['network'][0]['node'][i]['supporting-node'])
277 listNode.remove(nodeId)
279 self.assertFalse(True)
280 self.assertEqual(len(listNode), 0)
282 # Connect the tail XPDRA to ROADMA and vice versa
283 def test_10_connect_tail_xpdr_rdm(self):
284 # Connect the tail: XPDRA to ROADMA
285 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
286 data = {"networkutils:input": {
287 "networkutils:links-input": {
288 "networkutils:xpdr-node": "XPDR-A1",
289 "networkutils:xpdr-num": "1",
290 "networkutils:network-num": "1",
291 "networkutils:rdm-node": "ROADM-A1",
292 "networkutils:srg-num": "1",
293 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
297 response = test_utils.post_request(url, data)
298 self.assertEqual(response.status_code, requests.codes.ok)
300 def test_11_connect_tail_rdm_xpdr(self):
301 # Connect the tail: ROADMA to XPDRA
302 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
303 data = {"networkutils:input": {
304 "networkutils:links-input": {
305 "networkutils:xpdr-node": "XPDR-A1",
306 "networkutils:xpdr-num": "1",
307 "networkutils:network-num": "1",
308 "networkutils:rdm-node": "ROADM-A1",
309 "networkutils:srg-num": "1",
310 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
314 response = test_utils.post_request(url, data)
315 self.assertEqual(response.status_code, requests.codes.ok)
317 def test_12_getLinks_OpenRoadmTopology(self):
318 response = test_utils.get_ordm_topo_request("")
319 self.assertEqual(response.status_code, requests.codes.ok)
320 res = response.json()
321 # Tests related to links
322 nbLink = len(res['network'][0]['ietf-network-topology:link'])
323 self.assertEqual(nbLink, 12)
324 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
325 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
326 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
327 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
328 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
329 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
330 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
331 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
332 for i in range(0, nbLink):
333 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
334 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
335 if(nodeType == 'EXPRESS-LINK'):
336 find = linkId in expressLink
337 self.assertEqual(find, True)
338 expressLink.remove(linkId)
339 elif(nodeType == 'ADD-LINK'):
340 find = linkId in addLink
341 self.assertEqual(find, True)
342 addLink.remove(linkId)
343 elif(nodeType == 'DROP-LINK'):
344 find = linkId in dropLink
345 self.assertEqual(find, True)
346 dropLink.remove(linkId)
347 elif(nodeType == 'XPONDER-INPUT'):
348 find = linkId in XPDR_IN
349 self.assertEqual(find, True)
350 XPDR_IN.remove(linkId)
351 elif(nodeType == 'XPONDER-OUTPUT'):
352 find = linkId in XPDR_OUT
353 self.assertEqual(find, True)
354 XPDR_OUT.remove(linkId)
356 self.assertFalse(True)
357 self.assertEqual(len(expressLink), 0)
358 self.assertEqual(len(addLink), 0)
359 self.assertEqual(len(dropLink), 0)
360 self.assertEqual(len(XPDR_IN), 0)
361 self.assertEqual(len(XPDR_OUT), 0)
363 def test_13_connect_ROADMC(self):
364 response = test_utils.mount_device("ROADM-C1", 'roadmc')
365 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
367 def test_14_omsAttributes_ROADMA_ROADMC(self):
368 # Config ROADMA-ROADMC oms-attributes
370 "auto-spanloss": "true",
371 "engineered-spanloss": 12.2,
372 "link-concatenation": [{
375 "SRLG-length": 100000,
377 response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
378 self.assertEqual(response.status_code, requests.codes.created)
380 def test_15_omsAttributes_ROADMC_ROADMA(self):
381 # Config ROADM-C1-ROADM-A1 oms-attributes
383 "auto-spanloss": "true",
384 "engineered-spanloss": 12.2,
385 "link-concatenation": [{
388 "SRLG-length": 100000,
391 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
392 self.assertEqual(response.status_code, requests.codes.created)
394 def test_16_getClliNetwork(self):
395 url = "{}/config/ietf-network:networks/network/clli-network"
396 response = test_utils.get_request(url)
397 self.assertEqual(response.status_code, requests.codes.ok)
398 res = response.json()
399 nbNode = len(res['network'][0]['node'])
400 listNode = ['NodeA', 'NodeC']
401 for i in range(0, nbNode):
402 nodeId = res['network'][0]['node'][i]['node-id']
403 find = nodeId in listNode
404 self.assertEqual(find, True)
405 if(nodeId == 'NodeA'):
406 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
408 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
409 listNode.remove(nodeId)
410 self.assertEqual(len(listNode), 0)
412 def test_17_getOpenRoadmNetwork(self):
413 url = "{}/config/ietf-network:networks/network/openroadm-network"
414 response = test_utils.get_request(url)
415 self.assertEqual(response.status_code, requests.codes.ok)
416 res = response.json()
417 nbNode = len(res['network'][0]['node'])
418 self.assertEqual(nbNode, 3)
419 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
420 for i in range(0, nbNode):
421 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
422 nodeId = res['network'][0]['node'][i]['node-id']
423 if(nodeId == 'XPDR-A1'):
424 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
425 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
426 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
427 listNode.remove(nodeId)
428 elif(nodeId == 'ROADM-A1'):
429 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
430 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
431 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
432 listNode.remove(nodeId)
433 elif(nodeId == 'ROADM-C1'):
434 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
435 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
436 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
437 listNode.remove(nodeId)
439 self.assertFalse(True)
440 self.assertEqual(len(listNode), 0)
442 def test_18_getROADMLinkOpenRoadmTopology(self):
443 response = test_utils.get_ordm_topo_request("")
444 self.assertEqual(response.status_code, requests.codes.ok)
445 res = response.json()
446 # Tests related to links
447 nbLink = len(res['network'][0]['ietf-network-topology:link'])
448 self.assertEqual(nbLink, 20)
449 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
450 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
451 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
452 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
453 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
454 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
455 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
456 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
457 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
458 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
459 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
460 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
461 for i in range(0, nbLink):
462 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
463 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
464 if(nodeType == 'EXPRESS-LINK'):
465 find = linkId in expressLink
466 self.assertEqual(find, True)
467 expressLink.remove(linkId)
468 elif(nodeType == 'ADD-LINK'):
469 find = linkId in addLink
470 self.assertEqual(find, True)
471 addLink.remove(linkId)
472 elif(nodeType == 'DROP-LINK'):
473 find = linkId in dropLink
474 self.assertEqual(find, True)
475 dropLink.remove(linkId)
476 elif(nodeType == 'ROADM-TO-ROADM'):
477 find = linkId in R2RLink
478 self.assertEqual(find, True)
479 R2RLink.remove(linkId)
480 elif(nodeType == 'XPONDER-INPUT'):
481 find = linkId in XPDR_IN
482 self.assertEqual(find, True)
483 XPDR_IN.remove(linkId)
484 elif(nodeType == 'XPONDER-OUTPUT'):
485 find = linkId in XPDR_OUT
486 self.assertEqual(find, True)
487 XPDR_OUT.remove(linkId)
489 self.assertFalse(True)
490 self.assertEqual(len(expressLink), 0)
491 self.assertEqual(len(addLink), 0)
492 self.assertEqual(len(dropLink), 0)
493 self.assertEqual(len(R2RLink), 0)
494 self.assertEqual(len(XPDR_IN), 0)
495 self.assertEqual(len(XPDR_OUT), 0)
497 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
498 response = test_utils.get_ordm_topo_request("")
499 self.assertEqual(response.status_code, requests.codes.ok)
500 res = response.json()
501 # Tests related to links
502 nbLink = len(res['network'][0]['ietf-network-topology:link'])
503 self.assertEqual(nbLink, 20)
504 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
505 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
506 for i in range(0, nbLink):
507 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
508 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
509 if(link_id in R2RLink):
511 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
512 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
513 length = res['network'][0]['ietf-network-topology:link'][i][
514 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
515 if((spanLoss != None) & (length != None)):
517 self.assertTrue(find)
518 R2RLink.remove(link_id)
519 self.assertEqual(len(R2RLink), 0)
521 def test_20_getNodes_OpenRoadmTopology(self):
522 response = test_utils.get_ordm_topo_request("")
523 res = response.json()
524 # Tests related to nodes
525 self.assertEqual(response.status_code, requests.codes.ok)
526 nbNode = len(res['network'][0]['node'])
527 self.assertEqual(nbNode, 8)
528 listNode = ['XPDR-A1-XPDR1',
529 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
530 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
531 # ************************Tests related to XPDRA nodes
532 for i in range(0, nbNode):
533 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
534 nodeId = res['network'][0]['node'][i]['node-id']
535 if(nodeId == 'XPDR-A1-XPDR1'):
536 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
537 res['network'][0]['node'][i]['supporting-node'])
538 self.assertEqual(nodeType, 'XPONDER')
539 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
540 self.assertTrue(nbTps >= 4)
543 for j in range(0, nbTps):
544 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
545 if (tpType == 'XPONDER-CLIENT'):
547 elif (tpType == 'XPONDER-NETWORK'):
549 self.assertTrue(client == 2)
550 self.assertTrue(network == 2)
551 listNode.remove(nodeId)
552 elif(nodeId == 'ROADM-A1-SRG1'):
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': 'SRG1-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': 'SRG1-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-SRG3'):
564 # Test related to SRG1
565 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
566 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
567 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
568 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
569 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
570 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
571 res['network'][0]['node'][i]['supporting-node'])
572 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
573 listNode.remove(nodeId)
574 elif(nodeId == 'ROADM-A1-DEG1'):
575 # Test related to DEG1
576 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
577 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
578 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
579 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
580 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
581 res['network'][0]['node'][i]['supporting-node'])
582 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
583 listNode.remove(nodeId)
584 elif(nodeId == 'ROADM-A1-DEG2'):
585 # Test related to DEG2
586 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
587 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
588 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
589 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
590 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
591 res['network'][0]['node'][i]['supporting-node'])
592 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
593 listNode.remove(nodeId)
594 elif(nodeId == 'ROADM-C1-SRG1'):
595 # Test related to SRG1
596 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
597 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
598 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
599 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
600 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
601 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
602 res['network'][0]['node'][i]['supporting-node'])
603 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
604 listNode.remove(nodeId)
605 elif(nodeId == 'ROADM-C1-DEG1'):
606 # Test related to DEG1
607 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
608 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
609 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
610 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
611 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
612 res['network'][0]['node'][i]['supporting-node'])
613 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
614 listNode.remove(nodeId)
615 elif(nodeId == 'ROADM-C1-DEG2'):
616 # Test related to DEG1
617 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
618 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
619 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
620 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
621 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
622 res['network'][0]['node'][i]['supporting-node'])
623 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
624 listNode.remove(nodeId)
626 self.assertFalse(True)
627 self.assertEqual(len(listNode), 0)
629 def test_21_connect_ROADMB(self):
630 response = test_utils.mount_device("ROADM-B1", 'roadmb')
631 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
633 def test_22_omsAttributes_ROADMA_ROADMB(self):
634 # Config ROADM-A1-ROADM-B1 oms-attributes
636 "auto-spanloss": "true",
637 "engineered-spanloss": 12.2,
638 "spanloss-current": 12,
639 "spanloss-base": 11.4,
640 "link-concatenation": [{
643 "SRLG-length": 100000,
645 response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
646 self.assertEqual(response.status_code, requests.codes.created)
648 def test_23_omsAttributes_ROADMB_ROADMA(self):
649 # Config ROADM-B1-ROADM-A1 oms-attributes
651 "auto-spanloss": "true",
652 "engineered-spanloss": 12.2,
653 "spanloss-current": 12,
654 "spanloss-base": 11.4,
655 "link-concatenation": [{
658 "SRLG-length": 100000,
660 response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
661 self.assertEqual(response.status_code, requests.codes.created)
663 def test_24_omsAttributes_ROADMB_ROADMC(self):
664 # Config ROADM-B1-ROADM-C1 oms-attributes
666 "auto-spanloss": "true",
667 "engineered-spanloss": 12.2,
668 "spanloss-current": 12,
669 "spanloss-base": 11.4,
670 "link-concatenation": [{
673 "SRLG-length": 100000,
675 response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
676 self.assertEqual(response.status_code, requests.codes.created)
678 def test_25_omsAttributes_ROADMC_ROADMB(self):
679 # Config ROADM-C1-ROADM-B1 oms-attributes
681 "auto-spanloss": "true",
682 "engineered-spanloss": 12.2,
683 "link-concatenation": [{
686 "SRLG-length": 100000,
688 response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
689 self.assertEqual(response.status_code, requests.codes.created)
691 def test_26_getClliNetwork(self):
692 url = "{}/config/ietf-network:networks/network/clli-network"
693 response = test_utils.get_request(url)
694 self.assertEqual(response.status_code, requests.codes.ok)
695 res = response.json()
696 nbNode = len(res['network'][0]['node'])
697 listNode = ['NodeA', 'NodeB', 'NodeC']
698 for i in range(0, nbNode):
699 nodeId = res['network'][0]['node'][i]['node-id']
700 find = nodeId in listNode
701 self.assertEqual(find, True)
702 if(nodeId == 'NodeA'):
703 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
704 elif(nodeId == 'NodeB'):
705 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
707 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
708 listNode.remove(nodeId)
709 self.assertEqual(len(listNode), 0)
711 def test_27_verifyDegree(self):
712 response = test_utils.get_ordm_topo_request("")
713 self.assertEqual(response.status_code, requests.codes.ok)
714 res = response.json()
715 # Tests related to links
716 nbLink = len(res['network'][0]['ietf-network-topology:link'])
717 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
718 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
719 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
720 for i in range(0, nbLink):
721 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
722 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
723 find = link_id in listR2RLink
724 self.assertEqual(find, True)
725 listR2RLink.remove(link_id)
726 self.assertEqual(len(listR2RLink), 0)
728 def test_28_verifyOppositeLinkTopology(self):
729 response = test_utils.get_ordm_topo_request("")
730 self.assertEqual(response.status_code, requests.codes.ok)
731 res = response.json()
732 # Tests related to links
733 nbLink = len(res['network'][0]['ietf-network-topology:link'])
734 self.assertEqual(nbLink, 26)
735 for i in range(0, nbLink):
736 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
737 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
738 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
739 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
740 oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
741 # Find the opposite link
742 response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
743 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
744 res_oppLink = response_oppLink.json()
745 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
746 ['org-openroadm-common-network:opposite-link'], link_id)
747 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
748 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
749 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
750 if link_type == 'ADD-LINK':
751 self.assertEqual(oppLink_type, 'DROP-LINK')
752 elif link_type == 'DROP-LINK':
753 self.assertEqual(oppLink_type, 'ADD-LINK')
754 elif link_type == 'EXPRESS-LINK':
755 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
756 elif link_type == 'ROADM-TO-ROADM':
757 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
758 elif link_type == 'XPONDER-INPUT':
759 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
760 elif link_type == 'XPONDER-OUTPUT':
761 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
763 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
764 response = test_utils.get_ordm_topo_request("")
765 self.assertEqual(response.status_code, requests.codes.ok)
766 res = response.json()
767 nbLink = len(res['network'][0]['ietf-network-topology:link'])
768 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
769 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
770 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
771 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
772 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
773 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
774 for i in range(0, nbLink):
775 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
776 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
777 if(link_id in R2RLink):
779 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
780 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
781 length = res['network'][0]['ietf-network-topology:link'][i][
782 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
783 if((spanLoss != None) & (length != None)):
785 self.assertTrue(find)
786 R2RLink.remove(link_id)
787 self.assertEqual(len(R2RLink), 0)
789 def test_30_disconnect_ROADMB(self):
790 # Delete in the topology-netconf
791 response = test_utils.unmount_device("ROADM-B1")
792 # Delete in the clli-network
793 url = "{}/config/ietf-network:networks/network/clli-network/node/NodeB"
795 response = test_utils.delete_request(url)
796 self.assertEqual(response.status_code, requests.codes.ok)
798 def test_31_disconnect_ROADMC(self):
799 # Delete in the topology-netconf
800 response = test_utils.unmount_device("ROADM-C1")
801 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
802 # Delete in the clli-network
803 url = "{}/config/ietf-network:networks/network/clli-network/node/NodeC"
805 response = test_utils.delete_request(url)
806 self.assertEqual(response.status_code, requests.codes.ok)
808 # def test_24_check_roadm2roadm_links_deletion(self):
809 # response = test_utils.get_ordm_topo_request("")
810 # self.assertEqual(response.status_code, requests.codes.ok)
811 # res = response.json()
812 # #Write the response in the log
813 # with open('./transportpce_tests/log/response.log', 'a') as outfile1:
814 # outfile1.write(str(res))
815 # #Tests related to links
816 # nbLink=len(res['network'][0]['ietf-network-topology:link'])
817 # self.assertEqual(nbLink,8)
818 # expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
819 # addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
820 # dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
821 # XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
822 # XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
823 # for i in range(0,nbLink):
824 # nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
825 # linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
826 # if(nodeType=='EXPRESS-LINK'):
827 # find= linkId in expressLink
828 # self.assertEqual(find, True)
829 # expressLink.remove(linkId)
830 # elif(nodeType=='ADD-LINK'):
831 # find= linkId in addLink
832 # self.assertEqual(find, True)
833 # addLink.remove(linkId)
834 # elif(nodeType=='DROP-LINK'):
835 # find= linkId in dropLink
836 # self.assertEqual(find, True)
837 # dropLink.remove(linkId)
838 # elif(nodeType=='XPONDER-INPUT'):
839 # find= linkId in XPDR_IN
840 # self.assertEqual(find, True)
841 # XPDR_IN.remove(linkId)
842 # elif(nodeType=='XPONDER-OUTPUT'):
843 # find= linkId in XPDR_OUT
844 # self.assertEqual(find, True)
845 # XPDR_OUT.remove(linkId)
847 # self.assertFalse(True)
848 # self.assertEqual(len(expressLink),0)
849 # self.assertEqual(len(addLink),0)
850 # self.assertEqual(len(dropLink),0)
851 # self.assertEqual(len(XPDR_IN),0)
852 # self.assertEqual(len(XPDR_OUT),0)
854 # for i in range(0,nbLink):
855 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
856 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
857 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
858 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
859 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
860 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
861 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
863 def test_32_getNodes_OpenRoadmTopology(self):
864 response = test_utils.get_ordm_topo_request("")
865 res = response.json()
866 # Tests related to nodes
867 self.assertEqual(response.status_code, requests.codes.ok)
868 nbNode = len(res['network'][0]['node'])
869 self.assertEqual(nbNode, 5)
870 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
871 for i in range(0, nbNode):
872 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
873 nodeId = res['network'][0]['node'][i]['node-id']
874 # Tests related to XPDRA nodes
875 if(nodeId == 'XPDR-A1-XPDR1'):
876 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
877 for j in range(0, nbTp):
878 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
879 if (tpid == 'XPDR1-CLIENT1'):
880 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
881 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
882 if (tpid == 'XPDR1-NETWORK1'):
883 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
884 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
885 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
886 ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
887 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
888 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
889 res['network'][0]['node'][i]['supporting-node'])
890 listNode.remove(nodeId)
891 elif(nodeId == 'ROADM-A1-SRG1'):
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': 'SRG1-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': 'SRG1-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-SRG3'):
903 # Test related to SRG1
904 self.assertEqual(nodeType, 'SRG')
905 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
906 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
907 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
908 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
909 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
910 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
911 res['network'][0]['node'][i]['supporting-node'])
912 listNode.remove(nodeId)
913 elif(nodeId == 'ROADM-A1-DEG1'):
914 # Test related to DEG1
915 self.assertEqual(nodeType, 'DEGREE')
916 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
917 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
918 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
919 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
920 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
921 res['network'][0]['node'][i]['supporting-node'])
922 listNode.remove(nodeId)
923 elif(nodeId == 'ROADM-A1-DEG2'):
924 # Test related to DEG2
925 self.assertEqual(nodeType, 'DEGREE')
926 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
927 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
928 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
929 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
930 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
931 res['network'][0]['node'][i]['supporting-node'])
932 listNode.remove(nodeId)
934 self.assertFalse(True)
935 self.assertEqual(len(listNode), 0)
936 # Test related to SRG1 of ROADMC
937 for i in range(0, nbNode):
938 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
939 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
940 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
942 def test_33_getOpenRoadmNetwork(self):
943 url = "{}/config/ietf-network:networks/network/openroadm-network"
944 response = test_utils.get_request(url)
945 self.assertEqual(response.status_code, requests.codes.ok)
946 res = response.json()
947 nbNode = len(res['network'][0]['node'])
948 self.assertEqual(nbNode, 2)
949 for i in range(0, nbNode-1):
950 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
951 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
953 def test_34_getClliNetwork(self):
954 url = "{}/config/ietf-network:networks/network/clli-network"
955 response = test_utils.get_request(url)
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 for i in range(0, nbNode-1):
961 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
963 def test_35_disconnect_XPDRA(self):
964 response = test_utils.unmount_device("XPDR-A1")
965 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
967 def test_36_getClliNetwork(self):
968 url = "{}/config/ietf-network:networks/network/clli-network"
969 response = test_utils.get_request(url)
970 self.assertEqual(response.status_code, requests.codes.ok)
971 res = response.json()
972 nbNode = len(res['network'][0]['node'])
973 self.assertEqual(nbNode, 1)
974 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
976 def test_37_getOpenRoadmNetwork(self):
977 url = "{}/config/ietf-network:networks/network/openroadm-network"
978 response = test_utils.get_request(url)
979 self.assertEqual(response.status_code, requests.codes.ok)
980 res = response.json()
981 nbNode = len(res['network'][0]['node'])
982 self.assertEqual(nbNode, 1)
983 for i in range(0, nbNode):
984 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
986 def test_38_getNodes_OpenRoadmTopology(self):
987 response = test_utils.get_ordm_topo_request("")
988 res = response.json()
989 # Tests related to nodes
990 self.assertEqual(response.status_code, requests.codes.ok)
991 nbNode = len(res['network'][0]['node'])
992 self.assertEqual(nbNode, 4)
993 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
994 for i in range(0, nbNode):
995 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
996 res['network'][0]['node'][i]['supporting-node'])
997 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
998 nodeId = res['network'][0]['node'][i]['node-id']
999 if(nodeId == 'ROADM-A1-SRG1'):
1000 # Test related to SRG1
1001 self.assertEqual(nodeType, 'SRG')
1002 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1003 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1004 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1005 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1006 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1007 listNode.remove(nodeId)
1008 elif(nodeId == 'ROADM-A1-SRG3'):
1009 # Test related to SRG1
1010 self.assertEqual(nodeType, 'SRG')
1011 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1012 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1013 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1014 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1015 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1016 listNode.remove(nodeId)
1017 elif(nodeId == 'ROADM-A1-DEG1'):
1018 # Test related to DEG1
1019 self.assertEqual(nodeType, 'DEGREE')
1020 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1021 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1022 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1023 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1024 listNode.remove(nodeId)
1025 elif(nodeId == 'ROADM-A1-DEG2'):
1026 # Test related to DEG2
1027 self.assertEqual(nodeType, 'DEGREE')
1028 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1029 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1030 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1031 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1032 listNode.remove(nodeId)
1034 self.assertFalse(True)
1035 self.assertEqual(len(listNode), 0)
1037 def test_39_disconnect_ROADM_XPDRA_link(self):
1039 response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
1040 self.assertEqual(response.status_code, requests.codes.ok)
1042 response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
1043 self.assertEqual(response.status_code, requests.codes.ok)
1045 def test_40_getLinks_OpenRoadmTopology(self):
1046 response = test_utils.get_ordm_topo_request("")
1047 self.assertEqual(response.status_code, requests.codes.ok)
1048 res = response.json()
1049 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1050 self.assertEqual(nbLink, 16)
1051 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1052 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1053 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1054 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1055 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1056 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1057 roadmtoroadmLink = 0
1058 for i in range(0, nbLink):
1059 if (res['network'][0]['ietf-network-topology:link'][i]['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]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1065 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1066 find = link_id in addLink
1067 self.assertEqual(find, True)
1068 addLink.remove(link_id)
1069 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1070 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1071 find = link_id in dropLink
1072 self.assertEqual(find, True)
1073 dropLink.remove(link_id)
1075 roadmtoroadmLink += 1
1076 self.assertEqual(len(expressLink), 0)
1077 self.assertEqual(len(addLink), 0)
1078 self.assertEqual(len(dropLink), 0)
1079 self.assertEqual(roadmtoroadmLink, 6)
1080 for i in range(0, nbLink):
1081 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1082 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1083 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1084 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1086 def test_41_disconnect_ROADMA(self):
1087 response = test_utils.unmount_device("ROADM-A1")
1088 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1089 # Delete in the clli-network
1090 url = "{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1092 response = test_utils.delete_request(url)
1093 self.assertEqual(response.status_code, requests.codes.ok)
1095 def test_42_getClliNetwork(self):
1096 url = "{}/config/ietf-network:networks/network/clli-network"
1097 response = test_utils.get_request(url)
1098 self.assertEqual(response.status_code, requests.codes.ok)
1099 res = response.json()
1100 self.assertNotIn('node', res['network'][0])
1102 def test_43_getOpenRoadmNetwork(self):
1103 url = "{}/config/ietf-network:networks/network/openroadm-network"
1104 response = test_utils.get_request(url)
1105 self.assertEqual(response.status_code, requests.codes.ok)
1106 res = response.json()
1107 self.assertNotIn('node', res['network'][0])
1109 def test_44_check_roadm2roadm_link_persistence(self):
1110 response = test_utils.get_ordm_topo_request("")
1111 self.assertEqual(response.status_code, requests.codes.ok)
1112 res = response.json()
1113 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1114 self.assertNotIn('node', res['network'][0])
1115 self.assertEqual(nbLink, 6)
1118 if __name__ == "__main__":
1119 unittest.main(verbosity=2)