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 url = "{}/config/ietf-network:networks/network/openroadm-topology"
64 response = test_utils.get_request(url)
65 self.assertEqual(response.status_code, requests.codes.ok)
67 # Tests related to links
68 nbLink = len(res['network'][0]['ietf-network-topology:link'])
69 self.assertEqual(nbLink, 10)
70 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
71 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
72 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
73 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
74 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
75 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
76 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
77 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
78 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
79 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
80 for i in range(0, nbLink):
81 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
82 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
83 find = linkId in expressLink
84 self.assertEqual(find, True)
85 expressLink.remove(linkId)
86 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
87 find = linkId in addLink
88 self.assertEqual(find, True)
89 addLink.remove(linkId)
90 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
91 find = linkId in dropLink
92 self.assertEqual(find, True)
93 dropLink.remove(linkId)
95 self.assertFalse(True)
96 self.assertEqual(len(expressLink), 0)
97 self.assertEqual(len(addLink), 0)
98 self.assertEqual(len(dropLink), 0)
100 def test_05_getNodes_OpenRoadmTopology(self):
101 url = "{}/config/ietf-network:networks/network/openroadm-topology"
102 response = test_utils.get_request(url)
103 res = response.json()
104 # Tests related to nodes
105 self.assertEqual(response.status_code, requests.codes.ok)
106 nbNode = len(res['network'][0]['node'])
107 self.assertEqual(nbNode, 4)
108 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
109 for i in range(0, nbNode):
110 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
111 res['network'][0]['node'][i]['supporting-node'])
112 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
113 nodeId = res['network'][0]['node'][i]['node-id']
114 if(nodeId == 'ROADM-A1-SRG1'):
115 # Test related to SRG1
116 self.assertEqual(nodeType, 'SRG')
117 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
118 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
119 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
120 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
121 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
122 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
123 res['network'][0]['node'][i]['supporting-node'])
124 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
125 res['network'][0]['node'][i]['supporting-node'])
126 listNode.remove(nodeId)
127 elif(nodeId == 'ROADM-A1-SRG3'):
128 # Test related to SRG1
129 self.assertEqual(nodeType, 'SRG')
130 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
131 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
132 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
133 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
134 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
135 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
136 res['network'][0]['node'][i]['supporting-node'])
137 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
138 res['network'][0]['node'][i]['supporting-node'])
139 listNode.remove(nodeId)
140 elif(nodeId == 'ROADM-A1-DEG1'):
141 # Test related to DEG1
142 self.assertEqual(nodeType, 'DEGREE')
143 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
144 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
145 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
146 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
147 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
148 res['network'][0]['node'][i]['supporting-node'])
149 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
150 res['network'][0]['node'][i]['supporting-node'])
151 listNode.remove(nodeId)
152 elif(nodeId == 'ROADM-A1-DEG2'):
153 # Test related to DEG2
154 self.assertEqual(nodeType, 'DEGREE')
155 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
156 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
157 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
158 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
159 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
160 res['network'][0]['node'][i]['supporting-node'])
161 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
162 res['network'][0]['node'][i]['supporting-node'])
163 listNode.remove(nodeId)
165 self.assertFalse(True)
166 self.assertEqual(len(listNode), 0)
168 def test_06_connect_XPDRA(self):
169 response = test_utils.mount_device("XPDR-A1", 'xpdra')
170 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
172 def test_07_getClliNetwork(self):
173 url = "{}/config/ietf-network:networks/network/clli-network"
174 response = test_utils.get_request(url)
175 self.assertEqual(response.status_code, requests.codes.ok)
176 res = response.json()
177 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
178 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
180 def test_08_getOpenRoadmNetwork(self):
181 url = "{}/config/ietf-network:networks/network/openroadm-network"
182 response = test_utils.get_request(url)
183 self.assertEqual(response.status_code, requests.codes.ok)
184 res = response.json()
185 nbNode = len(res['network'][0]['node'])
186 self.assertEqual(nbNode, 2)
187 for i in range(0, nbNode):
188 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
189 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
190 nodeId = res['network'][0]['node'][i]['node-id']
191 if(nodeId == 'XPDR-A1'):
192 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
193 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
194 elif(nodeId == 'ROADM-A1'):
195 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
196 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
198 self.assertFalse(True)
200 def test_09_getNodes_OpenRoadmTopology(self):
201 url = "{}/config/ietf-network:networks/network/openroadm-topology"
202 response = test_utils.get_request(url)
203 res = response.json()
204 # Tests related to nodes
205 self.assertEqual(response.status_code, requests.codes.ok)
206 nbNode = len(res['network'][0]['node'])
207 self.assertEqual(nbNode, 5)
208 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
209 for i in range(0, nbNode):
210 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
211 nodeId = res['network'][0]['node'][i]['node-id']
212 # Tests related to XPDRA nodes
213 if(nodeId == 'XPDR-A1-XPDR1'):
214 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
215 res['network'][0]['node'][i]['supporting-node'])
216 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
217 res['network'][0]['node'][i]['supporting-node'])
218 self.assertEqual(nodeType, 'XPONDER')
219 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
222 for j in range(0, nbTps):
223 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
224 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
225 if (tpType == 'XPONDER-CLIENT'):
227 elif (tpType == 'XPONDER-NETWORK'):
229 if (tpId == 'XPDR1-NETWORK2'):
230 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
231 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
232 if (tpId == 'XPDR1-CLIENT2'):
233 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
234 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
236 self.assertTrue(client == 2)
237 self.assertTrue(network == 2)
238 listNode.remove(nodeId)
239 elif(nodeId == 'ROADM-A1-SRG1'):
240 # Test related to SRG1
241 self.assertEqual(nodeType, 'SRG')
242 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
243 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
244 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
245 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
246 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
247 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
248 res['network'][0]['node'][i]['supporting-node'])
249 listNode.remove(nodeId)
250 elif(nodeId == 'ROADM-A1-SRG3'):
251 # Test related to SRG1
252 self.assertEqual(nodeType, 'SRG')
253 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
254 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
255 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
256 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
257 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
258 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
259 res['network'][0]['node'][i]['supporting-node'])
260 listNode.remove(nodeId)
261 elif(nodeId == 'ROADM-A1-DEG1'):
262 # Test related to DEG1
263 self.assertEqual(nodeType, 'DEGREE')
264 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
265 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
266 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
267 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
268 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
269 res['network'][0]['node'][i]['supporting-node'])
270 listNode.remove(nodeId)
271 elif(nodeId == 'ROADM-A1-DEG2'):
272 # Test related to DEG2
273 self.assertEqual(nodeType, 'DEGREE')
274 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
275 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
276 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
277 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
278 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
279 res['network'][0]['node'][i]['supporting-node'])
280 listNode.remove(nodeId)
282 self.assertFalse(True)
283 self.assertEqual(len(listNode), 0)
285 # Connect the tail XPDRA to ROADMA and vice versa
286 def test_10_connect_tail_xpdr_rdm(self):
287 # Connect the tail: XPDRA to ROADMA
288 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
289 data = {"networkutils:input": {
290 "networkutils:links-input": {
291 "networkutils:xpdr-node": "XPDR-A1",
292 "networkutils:xpdr-num": "1",
293 "networkutils:network-num": "1",
294 "networkutils:rdm-node": "ROADM-A1",
295 "networkutils:srg-num": "1",
296 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
300 response = test_utils.post_request(url, data)
301 self.assertEqual(response.status_code, requests.codes.ok)
303 def test_11_connect_tail_rdm_xpdr(self):
304 # Connect the tail: ROADMA to XPDRA
305 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
306 data = {"networkutils:input": {
307 "networkutils:links-input": {
308 "networkutils:xpdr-node": "XPDR-A1",
309 "networkutils:xpdr-num": "1",
310 "networkutils:network-num": "1",
311 "networkutils:rdm-node": "ROADM-A1",
312 "networkutils:srg-num": "1",
313 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
317 response = test_utils.post_request(url, data)
318 self.assertEqual(response.status_code, requests.codes.ok)
320 def test_12_getLinks_OpenRoadmTopology(self):
321 url = "{}/config/ietf-network:networks/network/openroadm-topology"
322 response = test_utils.get_request(url)
323 self.assertEqual(response.status_code, requests.codes.ok)
324 res = response.json()
325 # Tests related to links
326 nbLink = len(res['network'][0]['ietf-network-topology:link'])
327 self.assertEqual(nbLink, 12)
328 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
329 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
330 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
331 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
332 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
333 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
334 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
335 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
336 for i in range(0, nbLink):
337 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
338 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
339 if(nodeType == 'EXPRESS-LINK'):
340 find = linkId in expressLink
341 self.assertEqual(find, True)
342 expressLink.remove(linkId)
343 elif(nodeType == 'ADD-LINK'):
344 find = linkId in addLink
345 self.assertEqual(find, True)
346 addLink.remove(linkId)
347 elif(nodeType == 'DROP-LINK'):
348 find = linkId in dropLink
349 self.assertEqual(find, True)
350 dropLink.remove(linkId)
351 elif(nodeType == 'XPONDER-INPUT'):
352 find = linkId in XPDR_IN
353 self.assertEqual(find, True)
354 XPDR_IN.remove(linkId)
355 elif(nodeType == 'XPONDER-OUTPUT'):
356 find = linkId in XPDR_OUT
357 self.assertEqual(find, True)
358 XPDR_OUT.remove(linkId)
360 self.assertFalse(True)
361 self.assertEqual(len(expressLink), 0)
362 self.assertEqual(len(addLink), 0)
363 self.assertEqual(len(dropLink), 0)
364 self.assertEqual(len(XPDR_IN), 0)
365 self.assertEqual(len(XPDR_OUT), 0)
367 def test_13_connect_ROADMC(self):
368 response = test_utils.mount_device("ROADM-C1", 'roadmc')
369 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
371 def test_14_omsAttributes_ROADMA_ROADMC(self):
372 # Config ROADMA-ROADMC oms-attributes
373 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
374 "link/ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
375 "OMS-attributes/span"
378 "auto-spanloss": "true",
379 "engineered-spanloss": 12.2,
380 "link-concatenation": [{
383 "SRLG-length": 100000,
385 response = test_utils.put_request(url, data)
386 self.assertEqual(response.status_code, requests.codes.created)
388 def test_15_omsAttributes_ROADMC_ROADMA(self):
389 # Config ROADM-C1-ROADM-A1 oms-attributes
390 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
391 "link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
392 "OMS-attributes/span"
395 "auto-spanloss": "true",
396 "engineered-spanloss": 12.2,
397 "link-concatenation": [{
400 "SRLG-length": 100000,
403 response = test_utils.put_request(url, data)
404 self.assertEqual(response.status_code, requests.codes.created)
406 def test_16_getClliNetwork(self):
407 url = "{}/config/ietf-network:networks/network/clli-network"
408 response = test_utils.get_request(url)
409 self.assertEqual(response.status_code, requests.codes.ok)
410 res = response.json()
411 nbNode = len(res['network'][0]['node'])
412 listNode = ['NodeA', 'NodeC']
413 for i in range(0, nbNode):
414 nodeId = res['network'][0]['node'][i]['node-id']
415 find = nodeId in listNode
416 self.assertEqual(find, True)
417 if(nodeId == 'NodeA'):
418 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
420 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
421 listNode.remove(nodeId)
422 self.assertEqual(len(listNode), 0)
424 def test_17_getOpenRoadmNetwork(self):
425 url = "{}/config/ietf-network:networks/network/openroadm-network"
426 response = test_utils.get_request(url)
427 self.assertEqual(response.status_code, requests.codes.ok)
428 res = response.json()
429 nbNode = len(res['network'][0]['node'])
430 self.assertEqual(nbNode, 3)
431 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
432 for i in range(0, nbNode):
433 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
434 nodeId = res['network'][0]['node'][i]['node-id']
435 if(nodeId == 'XPDR-A1'):
436 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
437 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
438 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
439 listNode.remove(nodeId)
440 elif(nodeId == 'ROADM-A1'):
441 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
442 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
443 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
444 listNode.remove(nodeId)
445 elif(nodeId == 'ROADM-C1'):
446 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
447 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
448 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
449 listNode.remove(nodeId)
451 self.assertFalse(True)
452 self.assertEqual(len(listNode), 0)
454 def test_18_getROADMLinkOpenRoadmTopology(self):
455 url = "{}/config/ietf-network:networks/network/openroadm-topology"
456 response = test_utils.get_request(url)
457 self.assertEqual(response.status_code, requests.codes.ok)
458 res = response.json()
459 # Tests related to links
460 nbLink = len(res['network'][0]['ietf-network-topology:link'])
461 self.assertEqual(nbLink, 20)
462 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
463 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
464 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
465 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
466 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
467 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
468 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
469 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
470 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
471 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
472 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
473 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
474 for i in range(0, nbLink):
475 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
476 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
477 if(nodeType == 'EXPRESS-LINK'):
478 find = linkId in expressLink
479 self.assertEqual(find, True)
480 expressLink.remove(linkId)
481 elif(nodeType == 'ADD-LINK'):
482 find = linkId in addLink
483 self.assertEqual(find, True)
484 addLink.remove(linkId)
485 elif(nodeType == 'DROP-LINK'):
486 find = linkId in dropLink
487 self.assertEqual(find, True)
488 dropLink.remove(linkId)
489 elif(nodeType == 'ROADM-TO-ROADM'):
490 find = linkId in R2RLink
491 self.assertEqual(find, True)
492 R2RLink.remove(linkId)
493 elif(nodeType == 'XPONDER-INPUT'):
494 find = linkId in XPDR_IN
495 self.assertEqual(find, True)
496 XPDR_IN.remove(linkId)
497 elif(nodeType == 'XPONDER-OUTPUT'):
498 find = linkId in XPDR_OUT
499 self.assertEqual(find, True)
500 XPDR_OUT.remove(linkId)
502 self.assertFalse(True)
503 self.assertEqual(len(expressLink), 0)
504 self.assertEqual(len(addLink), 0)
505 self.assertEqual(len(dropLink), 0)
506 self.assertEqual(len(R2RLink), 0)
507 self.assertEqual(len(XPDR_IN), 0)
508 self.assertEqual(len(XPDR_OUT), 0)
510 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
511 url = "{}/config/ietf-network:networks/network/openroadm-topology"
512 response = test_utils.get_request(url)
513 self.assertEqual(response.status_code, requests.codes.ok)
514 res = response.json()
515 # Tests related to links
516 nbLink = len(res['network'][0]['ietf-network-topology:link'])
517 self.assertEqual(nbLink, 20)
518 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
519 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
520 for i in range(0, nbLink):
521 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
522 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
523 if(link_id in R2RLink):
525 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
526 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
527 length = res['network'][0]['ietf-network-topology:link'][i][
528 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
529 if((spanLoss != None) & (length != None)):
531 self.assertTrue(find)
532 R2RLink.remove(link_id)
533 self.assertEqual(len(R2RLink), 0)
535 def test_20_getNodes_OpenRoadmTopology(self):
536 url = "{}/config/ietf-network:networks/network/openroadm-topology"
537 response = test_utils.get_request(url)
538 res = response.json()
539 # Tests related to nodes
540 self.assertEqual(response.status_code, requests.codes.ok)
541 nbNode = len(res['network'][0]['node'])
542 self.assertEqual(nbNode, 8)
543 listNode = ['XPDR-A1-XPDR1',
544 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
545 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
546 # ************************Tests related to XPDRA nodes
547 for i in range(0, nbNode):
548 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
549 nodeId = res['network'][0]['node'][i]['node-id']
550 if(nodeId == 'XPDR-A1-XPDR1'):
551 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
552 res['network'][0]['node'][i]['supporting-node'])
553 self.assertEqual(nodeType, 'XPONDER')
554 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
555 self.assertTrue(nbTps >= 4)
558 for j in range(0, nbTps):
559 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
560 if (tpType == 'XPONDER-CLIENT'):
562 elif (tpType == 'XPONDER-NETWORK'):
564 self.assertTrue(client == 2)
565 self.assertTrue(network == 2)
566 listNode.remove(nodeId)
567 elif(nodeId == 'ROADM-A1-SRG1'):
568 # Test related to SRG1
569 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
570 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
571 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
572 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
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'], 'SRG')
577 listNode.remove(nodeId)
578 elif(nodeId == 'ROADM-A1-SRG3'):
579 # Test related to SRG1
580 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
581 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
582 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
583 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
584 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
585 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
586 res['network'][0]['node'][i]['supporting-node'])
587 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
588 listNode.remove(nodeId)
589 elif(nodeId == 'ROADM-A1-DEG1'):
590 # Test related to DEG1
591 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
592 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
593 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
594 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
595 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
596 res['network'][0]['node'][i]['supporting-node'])
597 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
598 listNode.remove(nodeId)
599 elif(nodeId == 'ROADM-A1-DEG2'):
600 # Test related to DEG2
601 self.assertIn({'tp-id': 'DEG2-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': 'DEG2-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-A1'},
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-SRG1'):
610 # Test related to SRG1
611 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
612 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
613 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
614 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
615 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
616 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
617 res['network'][0]['node'][i]['supporting-node'])
618 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
619 listNode.remove(nodeId)
620 elif(nodeId == 'ROADM-C1-DEG1'):
621 # Test related to DEG1
622 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
623 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
624 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
625 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
626 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
627 res['network'][0]['node'][i]['supporting-node'])
628 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
629 listNode.remove(nodeId)
630 elif(nodeId == 'ROADM-C1-DEG2'):
631 # Test related to DEG1
632 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
633 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
634 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
635 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
636 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
637 res['network'][0]['node'][i]['supporting-node'])
638 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
639 listNode.remove(nodeId)
641 self.assertFalse(True)
642 self.assertEqual(len(listNode), 0)
644 def test_21_connect_ROADMB(self):
645 response = test_utils.mount_device("ROADM-B1", 'roadmb')
646 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
648 def test_22_omsAttributes_ROADMA_ROADMB(self):
649 # Config ROADM-A1-ROADM-B1 oms-attributes
650 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
651 "link/ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
652 "OMS-attributes/span"
655 "auto-spanloss": "true",
656 "engineered-spanloss": 12.2,
657 "spanloss-current": 12,
658 "spanloss-base": 11.4,
659 "link-concatenation": [{
662 "SRLG-length": 100000,
664 response = test_utils.put_request(url, data)
665 self.assertEqual(response.status_code, requests.codes.created)
667 def test_23_omsAttributes_ROADMB_ROADMA(self):
668 # Config ROADM-B1-ROADM-A1 oms-attributes
669 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
670 "link/ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
671 "OMS-attributes/span"
674 "auto-spanloss": "true",
675 "engineered-spanloss": 12.2,
676 "spanloss-current": 12,
677 "spanloss-base": 11.4,
678 "link-concatenation": [{
681 "SRLG-length": 100000,
683 response = test_utils.put_request(url, data)
684 self.assertEqual(response.status_code, requests.codes.created)
686 def test_24_omsAttributes_ROADMB_ROADMC(self):
687 # Config ROADM-B1-ROADM-C1 oms-attributes
688 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
689 "link/ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
690 "OMS-attributes/span"
693 "auto-spanloss": "true",
694 "engineered-spanloss": 12.2,
695 "spanloss-current": 12,
696 "spanloss-base": 11.4,
697 "link-concatenation": [{
700 "SRLG-length": 100000,
702 response = test_utils.put_request(url, data)
703 self.assertEqual(response.status_code, requests.codes.created)
705 def test_25_omsAttributes_ROADMC_ROADMB(self):
706 # Config ROADM-C1-ROADM-B1 oms-attributes
707 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
708 "link/ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
709 "OMS-attributes/span"
712 "auto-spanloss": "true",
713 "engineered-spanloss": 12.2,
714 "link-concatenation": [{
717 "SRLG-length": 100000,
719 response = test_utils.put_request(url, data)
720 self.assertEqual(response.status_code, requests.codes.created)
722 def test_26_getClliNetwork(self):
723 url = "{}/config/ietf-network:networks/network/clli-network"
724 response = test_utils.get_request(url)
725 self.assertEqual(response.status_code, requests.codes.ok)
726 res = response.json()
727 nbNode = len(res['network'][0]['node'])
728 listNode = ['NodeA', 'NodeB', 'NodeC']
729 for i in range(0, nbNode):
730 nodeId = res['network'][0]['node'][i]['node-id']
731 find = nodeId in listNode
732 self.assertEqual(find, True)
733 if(nodeId == 'NodeA'):
734 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
735 elif(nodeId == 'NodeB'):
736 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
738 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
739 listNode.remove(nodeId)
740 self.assertEqual(len(listNode), 0)
742 def test_27_verifyDegree(self):
743 url = "{}/config/ietf-network:networks/network/openroadm-topology"
744 response = test_utils.get_request(url)
745 self.assertEqual(response.status_code, requests.codes.ok)
746 res = response.json()
747 # Tests related to links
748 nbLink = len(res['network'][0]['ietf-network-topology:link'])
749 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
750 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
751 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
752 for i in range(0, nbLink):
753 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
754 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
755 find = link_id in listR2RLink
756 self.assertEqual(find, True)
757 listR2RLink.remove(link_id)
758 self.assertEqual(len(listR2RLink), 0)
760 def test_28_verifyOppositeLinkTopology(self):
761 url = "{}/config/ietf-network:networks/network/openroadm-topology"
762 response = test_utils.get_request(url)
763 self.assertEqual(response.status_code, requests.codes.ok)
764 res = response.json()
765 # Tests related to links
766 nbLink = len(res['network'][0]['ietf-network-topology:link'])
767 self.assertEqual(nbLink, 26)
768 for i in range(0, nbLink):
769 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
770 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
771 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
772 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
773 oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
774 # Find the opposite link
775 url_oppLink = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
776 response_oppLink = test_utils.get_request(url_oppLink)
777 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
778 res_oppLink = response_oppLink.json()
779 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
780 ['org-openroadm-common-network:opposite-link'], link_id)
781 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
782 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
783 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
784 if link_type == 'ADD-LINK':
785 self.assertEqual(oppLink_type, 'DROP-LINK')
786 elif link_type == 'DROP-LINK':
787 self.assertEqual(oppLink_type, 'ADD-LINK')
788 elif link_type == 'EXPRESS-LINK':
789 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
790 elif link_type == 'ROADM-TO-ROADM':
791 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
792 elif link_type == 'XPONDER-INPUT':
793 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
794 elif link_type == 'XPONDER-OUTPUT':
795 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
797 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
798 url = "{}/config/ietf-network:networks/network/openroadm-topology"
799 response = test_utils.get_request(url)
800 self.assertEqual(response.status_code, requests.codes.ok)
801 res = response.json()
802 nbLink = len(res['network'][0]['ietf-network-topology:link'])
803 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
804 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
805 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
806 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
807 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
808 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
809 for i in range(0, nbLink):
810 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
811 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
812 if(link_id in R2RLink):
814 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
815 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
816 length = res['network'][0]['ietf-network-topology:link'][i][
817 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
818 if((spanLoss != None) & (length != None)):
820 self.assertTrue(find)
821 R2RLink.remove(link_id)
822 self.assertEqual(len(R2RLink), 0)
824 def test_30_disconnect_ROADMB(self):
825 # Delete in the topology-netconf
826 response = test_utils.unmount_device("ROADM-B1")
827 # Delete in the clli-network
828 url = "{}/config/ietf-network:networks/network/clli-network/node/NodeB"
830 response = test_utils.delete_request(url)
831 self.assertEqual(response.status_code, requests.codes.ok)
833 def test_31_disconnect_ROADMC(self):
834 # Delete in the topology-netconf
835 response = test_utils.unmount_device("ROADM-C1")
836 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
837 # Delete in the clli-network
838 url = "{}/config/ietf-network:networks/network/clli-network/node/NodeC"
840 response = test_utils.delete_request(url)
841 self.assertEqual(response.status_code, requests.codes.ok)
843 # def test_24_check_roadm2roadm_links_deletion(self):
844 # url = "{}/config/ietf-network:networks/network/openroadm-topology"
845 # response = test_utils.request(url)
846 # self.assertEqual(response.status_code, requests.codes.ok)
847 # res = response.json()
848 # #Write the response in the log
849 # with open('./transportpce_tests/log/response.log', 'a') as outfile1:
850 # outfile1.write(str(res))
851 # #Tests related to links
852 # nbLink=len(res['network'][0]['ietf-network-topology:link'])
853 # self.assertEqual(nbLink,8)
854 # expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
855 # addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
856 # dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
857 # XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
858 # XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
859 # for i in range(0,nbLink):
860 # nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
861 # linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
862 # if(nodeType=='EXPRESS-LINK'):
863 # find= linkId in expressLink
864 # self.assertEqual(find, True)
865 # expressLink.remove(linkId)
866 # elif(nodeType=='ADD-LINK'):
867 # find= linkId in addLink
868 # self.assertEqual(find, True)
869 # addLink.remove(linkId)
870 # elif(nodeType=='DROP-LINK'):
871 # find= linkId in dropLink
872 # self.assertEqual(find, True)
873 # dropLink.remove(linkId)
874 # elif(nodeType=='XPONDER-INPUT'):
875 # find= linkId in XPDR_IN
876 # self.assertEqual(find, True)
877 # XPDR_IN.remove(linkId)
878 # elif(nodeType=='XPONDER-OUTPUT'):
879 # find= linkId in XPDR_OUT
880 # self.assertEqual(find, True)
881 # XPDR_OUT.remove(linkId)
883 # self.assertFalse(True)
884 # self.assertEqual(len(expressLink),0)
885 # self.assertEqual(len(addLink),0)
886 # self.assertEqual(len(dropLink),0)
887 # self.assertEqual(len(XPDR_IN),0)
888 # self.assertEqual(len(XPDR_OUT),0)
890 # for i in range(0,nbLink):
891 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
892 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
893 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
894 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
895 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
896 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
897 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
899 def test_32_getNodes_OpenRoadmTopology(self):
900 url = "{}/config/ietf-network:networks/network/openroadm-topology"
901 response = test_utils.get_request(url)
902 res = response.json()
903 # Tests related to nodes
904 self.assertEqual(response.status_code, requests.codes.ok)
905 nbNode = len(res['network'][0]['node'])
906 self.assertEqual(nbNode, 5)
907 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
908 for i in range(0, nbNode):
909 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
910 nodeId = res['network'][0]['node'][i]['node-id']
911 # Tests related to XPDRA nodes
912 if(nodeId == 'XPDR-A1-XPDR1'):
913 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
914 for j in range(0, nbTp):
915 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
916 if (tpid == 'XPDR1-CLIENT1'):
917 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
918 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
919 if (tpid == 'XPDR1-NETWORK1'):
920 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
921 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
922 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
923 ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
924 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
925 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
926 res['network'][0]['node'][i]['supporting-node'])
927 listNode.remove(nodeId)
928 elif(nodeId == 'ROADM-A1-SRG1'):
929 # Test related to SRG1
930 self.assertEqual(nodeType, 'SRG')
931 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
932 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
933 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
934 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
935 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
936 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
937 res['network'][0]['node'][i]['supporting-node'])
938 listNode.remove(nodeId)
939 elif(nodeId == 'ROADM-A1-SRG3'):
940 # Test related to SRG1
941 self.assertEqual(nodeType, 'SRG')
942 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
943 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
944 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
945 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
946 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
947 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
948 res['network'][0]['node'][i]['supporting-node'])
949 listNode.remove(nodeId)
950 elif(nodeId == 'ROADM-A1-DEG1'):
951 # Test related to DEG1
952 self.assertEqual(nodeType, 'DEGREE')
953 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
954 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
955 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
956 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
957 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
958 res['network'][0]['node'][i]['supporting-node'])
959 listNode.remove(nodeId)
960 elif(nodeId == 'ROADM-A1-DEG2'):
961 # Test related to DEG2
962 self.assertEqual(nodeType, 'DEGREE')
963 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
964 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
965 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
966 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
967 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
968 res['network'][0]['node'][i]['supporting-node'])
969 listNode.remove(nodeId)
971 self.assertFalse(True)
972 self.assertEqual(len(listNode), 0)
973 # Test related to SRG1 of ROADMC
974 for i in range(0, nbNode):
975 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
976 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
977 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
979 def test_33_getOpenRoadmNetwork(self):
980 url = "{}/config/ietf-network:networks/network/openroadm-network"
981 response = test_utils.get_request(url)
982 self.assertEqual(response.status_code, requests.codes.ok)
983 res = response.json()
984 nbNode = len(res['network'][0]['node'])
985 self.assertEqual(nbNode, 2)
986 for i in range(0, nbNode-1):
987 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
988 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
990 def test_34_getClliNetwork(self):
991 url = "{}/config/ietf-network:networks/network/clli-network"
992 response = test_utils.get_request(url)
993 self.assertEqual(response.status_code, requests.codes.ok)
994 res = response.json()
995 nbNode = len(res['network'][0]['node'])
996 self.assertEqual(nbNode, 1)
997 for i in range(0, nbNode-1):
998 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
1000 def test_35_disconnect_XPDRA(self):
1001 response = test_utils.unmount_device("XPDR-A1")
1002 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1004 def test_36_getClliNetwork(self):
1005 url = "{}/config/ietf-network:networks/network/clli-network"
1006 response = test_utils.get_request(url)
1007 self.assertEqual(response.status_code, requests.codes.ok)
1008 res = response.json()
1009 nbNode = len(res['network'][0]['node'])
1010 self.assertEqual(nbNode, 1)
1011 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
1013 def test_37_getOpenRoadmNetwork(self):
1014 url = "{}/config/ietf-network:networks/network/openroadm-network"
1015 response = test_utils.get_request(url)
1016 self.assertEqual(response.status_code, requests.codes.ok)
1017 res = response.json()
1018 nbNode = len(res['network'][0]['node'])
1019 self.assertEqual(nbNode, 1)
1020 for i in range(0, nbNode):
1021 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
1023 def test_38_getNodes_OpenRoadmTopology(self):
1024 url = "{}/config/ietf-network:networks/network/openroadm-topology"
1025 response = test_utils.get_request(url)
1026 res = response.json()
1027 # Tests related to nodes
1028 self.assertEqual(response.status_code, requests.codes.ok)
1029 nbNode = len(res['network'][0]['node'])
1030 self.assertEqual(nbNode, 4)
1031 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
1032 for i in range(0, nbNode):
1033 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1034 res['network'][0]['node'][i]['supporting-node'])
1035 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1036 nodeId = res['network'][0]['node'][i]['node-id']
1037 if(nodeId == 'ROADM-A1-SRG1'):
1038 # Test related to SRG1
1039 self.assertEqual(nodeType, 'SRG')
1040 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1041 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1042 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1043 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1044 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1045 listNode.remove(nodeId)
1046 elif(nodeId == 'ROADM-A1-SRG3'):
1047 # Test related to SRG1
1048 self.assertEqual(nodeType, 'SRG')
1049 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1050 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1051 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1052 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1053 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1054 listNode.remove(nodeId)
1055 elif(nodeId == 'ROADM-A1-DEG1'):
1056 # Test related to DEG1
1057 self.assertEqual(nodeType, 'DEGREE')
1058 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1059 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1060 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1061 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1062 listNode.remove(nodeId)
1063 elif(nodeId == 'ROADM-A1-DEG2'):
1064 # Test related to DEG2
1065 self.assertEqual(nodeType, 'DEGREE')
1066 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1067 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1068 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1069 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1070 listNode.remove(nodeId)
1072 self.assertFalse(True)
1073 self.assertEqual(len(listNode), 0)
1075 def test_39_disconnect_ROADM_XPDRA_link(self):
1077 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1078 "link/XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX"
1081 response = test_utils.delete_request(url)
1082 self.assertEqual(response.status_code, requests.codes.ok)
1084 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1085 "link/ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1"
1088 response = test_utils.delete_request(url)
1089 self.assertEqual(response.status_code, requests.codes.ok)
1091 def test_40_getLinks_OpenRoadmTopology(self):
1092 url = "{}/config/ietf-network:networks/network/openroadm-topology"
1093 response = test_utils.get_request(url)
1094 self.assertEqual(response.status_code, requests.codes.ok)
1095 res = response.json()
1096 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1097 self.assertEqual(nbLink, 16)
1098 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1099 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1100 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1101 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1102 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1103 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1104 roadmtoroadmLink = 0
1105 for i in range(0, nbLink):
1106 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1107 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1108 find = link_id in expressLink
1109 self.assertEqual(find, True)
1110 expressLink.remove(link_id)
1111 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1112 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1113 find = link_id in addLink
1114 self.assertEqual(find, True)
1115 addLink.remove(link_id)
1116 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1117 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1118 find = link_id in dropLink
1119 self.assertEqual(find, True)
1120 dropLink.remove(link_id)
1122 roadmtoroadmLink += 1
1123 self.assertEqual(len(expressLink), 0)
1124 self.assertEqual(len(addLink), 0)
1125 self.assertEqual(len(dropLink), 0)
1126 self.assertEqual(roadmtoroadmLink, 6)
1127 for i in range(0, nbLink):
1128 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1129 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1130 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1131 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1133 def test_41_disconnect_ROADMA(self):
1134 response = test_utils.unmount_device("ROADM-A1")
1135 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1136 # Delete in the clli-network
1137 url = "{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1139 response = test_utils.delete_request(url)
1140 self.assertEqual(response.status_code, requests.codes.ok)
1142 def test_42_getClliNetwork(self):
1143 url = "{}/config/ietf-network:networks/network/clli-network"
1144 response = test_utils.get_request(url)
1145 self.assertEqual(response.status_code, requests.codes.ok)
1146 res = response.json()
1147 self.assertNotIn('node', res['network'][0])
1149 def test_43_getOpenRoadmNetwork(self):
1150 url = "{}/config/ietf-network:networks/network/openroadm-network"
1151 response = test_utils.get_request(url)
1152 self.assertEqual(response.status_code, requests.codes.ok)
1153 res = response.json()
1154 self.assertNotIn('node', res['network'][0])
1156 def test_44_check_roadm2roadm_link_persistence(self):
1157 url = "{}/config/ietf-network:networks/network/openroadm-topology"
1158 response = test_utils.get_request(url)
1159 self.assertEqual(response.status_code, requests.codes.ok)
1160 res = response.json()
1161 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1162 self.assertNotIn('node', res['network'][0])
1163 self.assertEqual(nbLink, 6)
1166 if __name__ == "__main__":
1167 unittest.main(verbosity=2)