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 .format(test_utils.RESTCONF_BASE_URL))
45 response = requests.request(
46 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
47 self.assertEqual(response.status_code, requests.codes.ok)
50 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
51 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
53 def test_03_getOpenRoadmNetwork(self):
54 url = ("{}/config/ietf-network:networks/network/openroadm-network"
55 .format(test_utils.RESTCONF_BASE_URL))
56 response = requests.request(
57 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
58 self.assertEqual(response.status_code, requests.codes.ok)
60 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
61 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
62 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
63 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
64 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
66 def test_04_getLinks_OpenroadmTopology(self):
67 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
68 .format(test_utils.RESTCONF_BASE_URL))
69 response = requests.request(
70 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
71 self.assertEqual(response.status_code, requests.codes.ok)
73 # Tests related to links
74 nbLink = len(res['network'][0]['ietf-network-topology:link'])
75 self.assertEqual(nbLink, 10)
76 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
77 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
78 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
79 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
80 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
81 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
82 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
83 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
84 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
85 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
86 for i in range(0, nbLink):
87 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
88 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
89 find = linkId in expressLink
90 self.assertEqual(find, True)
91 expressLink.remove(linkId)
92 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
93 find = linkId in addLink
94 self.assertEqual(find, True)
95 addLink.remove(linkId)
96 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
97 find = linkId in dropLink
98 self.assertEqual(find, True)
99 dropLink.remove(linkId)
101 self.assertFalse(True)
102 self.assertEqual(len(expressLink), 0)
103 self.assertEqual(len(addLink), 0)
104 self.assertEqual(len(dropLink), 0)
106 def test_05_getNodes_OpenRoadmTopology(self):
107 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
108 .format(test_utils.RESTCONF_BASE_URL))
109 response = requests.request(
110 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
111 res = response.json()
112 # Tests related to nodes
113 self.assertEqual(response.status_code, requests.codes.ok)
114 nbNode = len(res['network'][0]['node'])
115 self.assertEqual(nbNode, 4)
116 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
117 for i in range(0, nbNode):
118 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
119 res['network'][0]['node'][i]['supporting-node'])
120 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
121 nodeId = res['network'][0]['node'][i]['node-id']
122 if(nodeId == 'ROADM-A1-SRG1'):
123 # Test related to SRG1
124 self.assertEqual(nodeType, 'SRG')
125 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
126 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
127 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
128 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
129 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
130 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
131 res['network'][0]['node'][i]['supporting-node'])
132 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
133 res['network'][0]['node'][i]['supporting-node'])
134 listNode.remove(nodeId)
135 elif(nodeId == 'ROADM-A1-SRG3'):
136 # Test related to SRG1
137 self.assertEqual(nodeType, 'SRG')
138 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
139 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
140 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
141 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
142 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
143 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
144 res['network'][0]['node'][i]['supporting-node'])
145 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
146 res['network'][0]['node'][i]['supporting-node'])
147 listNode.remove(nodeId)
148 elif(nodeId == 'ROADM-A1-DEG1'):
149 # Test related to DEG1
150 self.assertEqual(nodeType, 'DEGREE')
151 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
152 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
153 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
154 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
155 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
156 res['network'][0]['node'][i]['supporting-node'])
157 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
158 res['network'][0]['node'][i]['supporting-node'])
159 listNode.remove(nodeId)
160 elif(nodeId == 'ROADM-A1-DEG2'):
161 # Test related to DEG2
162 self.assertEqual(nodeType, 'DEGREE')
163 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
164 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
165 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
166 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
167 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
168 res['network'][0]['node'][i]['supporting-node'])
169 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
170 res['network'][0]['node'][i]['supporting-node'])
171 listNode.remove(nodeId)
173 self.assertFalse(True)
174 self.assertEqual(len(listNode), 0)
176 def test_06_connect_XPDRA(self):
177 response = test_utils.mount_device("XPDR-A1", 'xpdra')
178 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
180 def test_07_getClliNetwork(self):
181 url = ("{}/config/ietf-network:networks/network/clli-network"
182 .format(test_utils.RESTCONF_BASE_URL))
183 response = requests.request(
184 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
185 self.assertEqual(response.status_code, requests.codes.ok)
186 res = response.json()
187 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
188 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
190 def test_08_getOpenRoadmNetwork(self):
191 url = ("{}/config/ietf-network:networks/network/openroadm-network"
192 .format(test_utils.RESTCONF_BASE_URL))
193 response = requests.request(
194 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
195 self.assertEqual(response.status_code, requests.codes.ok)
196 res = response.json()
197 nbNode = len(res['network'][0]['node'])
198 self.assertEqual(nbNode, 2)
199 for i in range(0, nbNode):
200 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
201 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
202 nodeId = res['network'][0]['node'][i]['node-id']
203 if(nodeId == 'XPDR-A1'):
204 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
205 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
206 elif(nodeId == 'ROADM-A1'):
207 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
208 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
210 self.assertFalse(True)
212 def test_09_getNodes_OpenRoadmTopology(self):
213 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
214 .format(test_utils.RESTCONF_BASE_URL))
215 response = requests.request(
216 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
217 res = response.json()
218 # Tests related to nodes
219 self.assertEqual(response.status_code, requests.codes.ok)
220 nbNode = len(res['network'][0]['node'])
221 self.assertEqual(nbNode, 5)
222 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
223 for i in range(0, nbNode):
224 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
225 nodeId = res['network'][0]['node'][i]['node-id']
226 # Tests related to XPDRA nodes
227 if(nodeId == 'XPDR-A1-XPDR1'):
228 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
229 res['network'][0]['node'][i]['supporting-node'])
230 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
231 res['network'][0]['node'][i]['supporting-node'])
232 self.assertEqual(nodeType, 'XPONDER')
233 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
236 for j in range(0, nbTps):
237 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
238 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
239 if (tpType == 'XPONDER-CLIENT'):
241 elif (tpType == 'XPONDER-NETWORK'):
243 if (tpId == 'XPDR1-NETWORK2'):
244 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
245 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
246 if (tpId == 'XPDR1-CLIENT2'):
247 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
248 ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
250 self.assertTrue(client == 2)
251 self.assertTrue(network == 2)
252 listNode.remove(nodeId)
253 elif(nodeId == 'ROADM-A1-SRG1'):
254 # Test related to SRG1
255 self.assertEqual(nodeType, 'SRG')
256 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
257 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
258 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
259 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
260 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
261 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
262 res['network'][0]['node'][i]['supporting-node'])
263 listNode.remove(nodeId)
264 elif(nodeId == 'ROADM-A1-SRG3'):
265 # Test related to SRG1
266 self.assertEqual(nodeType, 'SRG')
267 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
268 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
269 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
270 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
271 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
272 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
273 res['network'][0]['node'][i]['supporting-node'])
274 listNode.remove(nodeId)
275 elif(nodeId == 'ROADM-A1-DEG1'):
276 # Test related to DEG1
277 self.assertEqual(nodeType, 'DEGREE')
278 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
279 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
280 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
281 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
282 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
283 res['network'][0]['node'][i]['supporting-node'])
284 listNode.remove(nodeId)
285 elif(nodeId == 'ROADM-A1-DEG2'):
286 # Test related to DEG2
287 self.assertEqual(nodeType, 'DEGREE')
288 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
289 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
290 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
291 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
292 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
293 res['network'][0]['node'][i]['supporting-node'])
294 listNode.remove(nodeId)
296 self.assertFalse(True)
297 self.assertEqual(len(listNode), 0)
299 # Connect the tail XPDRA to ROADMA and vice versa
300 def test_10_connect_tail_xpdr_rdm(self):
301 # Connect the tail: XPDRA to ROADMA
302 url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
303 .format(test_utils.RESTCONF_BASE_URL))
304 data = {"networkutils:input": {
305 "networkutils:links-input": {
306 "networkutils:xpdr-node": "XPDR-A1",
307 "networkutils:xpdr-num": "1",
308 "networkutils:network-num": "1",
309 "networkutils:rdm-node": "ROADM-A1",
310 "networkutils:srg-num": "1",
311 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
315 response = requests.request(
316 "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
317 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
318 self.assertEqual(response.status_code, requests.codes.ok)
320 def test_11_connect_tail_rdm_xpdr(self):
321 # Connect the tail: ROADMA to XPDRA
322 url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
323 .format(test_utils.RESTCONF_BASE_URL))
324 data = {"networkutils:input": {
325 "networkutils:links-input": {
326 "networkutils:xpdr-node": "XPDR-A1",
327 "networkutils:xpdr-num": "1",
328 "networkutils:network-num": "1",
329 "networkutils:rdm-node": "ROADM-A1",
330 "networkutils:srg-num": "1",
331 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
335 response = requests.request(
336 "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
337 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
338 self.assertEqual(response.status_code, requests.codes.ok)
340 def test_12_getLinks_OpenRoadmTopology(self):
341 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
342 .format(test_utils.RESTCONF_BASE_URL))
343 response = requests.request(
344 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
345 self.assertEqual(response.status_code, requests.codes.ok)
346 res = response.json()
347 # Tests related to links
348 nbLink = len(res['network'][0]['ietf-network-topology:link'])
349 self.assertEqual(nbLink, 12)
350 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
351 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
352 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
353 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
354 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
355 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
356 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
357 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
358 for i in range(0, nbLink):
359 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
360 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
361 if(nodeType == 'EXPRESS-LINK'):
362 find = linkId in expressLink
363 self.assertEqual(find, True)
364 expressLink.remove(linkId)
365 elif(nodeType == 'ADD-LINK'):
366 find = linkId in addLink
367 self.assertEqual(find, True)
368 addLink.remove(linkId)
369 elif(nodeType == 'DROP-LINK'):
370 find = linkId in dropLink
371 self.assertEqual(find, True)
372 dropLink.remove(linkId)
373 elif(nodeType == 'XPONDER-INPUT'):
374 find = linkId in XPDR_IN
375 self.assertEqual(find, True)
376 XPDR_IN.remove(linkId)
377 elif(nodeType == 'XPONDER-OUTPUT'):
378 find = linkId in XPDR_OUT
379 self.assertEqual(find, True)
380 XPDR_OUT.remove(linkId)
382 self.assertFalse(True)
383 self.assertEqual(len(expressLink), 0)
384 self.assertEqual(len(addLink), 0)
385 self.assertEqual(len(dropLink), 0)
386 self.assertEqual(len(XPDR_IN), 0)
387 self.assertEqual(len(XPDR_OUT), 0)
389 def test_13_connect_ROADMC(self):
390 response = test_utils.mount_device("ROADM-C1", 'roadmc')
391 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
393 def test_14_omsAttributes_ROADMA_ROADMC(self):
394 # Config ROADMA-ROADMC oms-attributes
395 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
396 "link/ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
397 "OMS-attributes/span"
398 .format(test_utils.RESTCONF_BASE_URL))
400 "auto-spanloss": "true",
401 "engineered-spanloss": 12.2,
402 "link-concatenation": [{
405 "SRLG-length": 100000,
407 response = requests.request(
408 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
409 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
410 self.assertEqual(response.status_code, requests.codes.created)
412 def test_15_omsAttributes_ROADMC_ROADMA(self):
413 # Config ROADM-C1-ROADM-A1 oms-attributes
414 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
415 "link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
416 "OMS-attributes/span"
417 .format(test_utils.RESTCONF_BASE_URL))
419 "auto-spanloss": "true",
420 "engineered-spanloss": 12.2,
421 "link-concatenation": [{
424 "SRLG-length": 100000,
427 response = requests.request(
428 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
429 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
430 self.assertEqual(response.status_code, requests.codes.created)
432 def test_16_getClliNetwork(self):
433 url = ("{}/config/ietf-network:networks/network/clli-network"
434 .format(test_utils.RESTCONF_BASE_URL))
435 response = requests.request(
436 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
437 self.assertEqual(response.status_code, requests.codes.ok)
438 res = response.json()
439 nbNode = len(res['network'][0]['node'])
440 listNode = ['NodeA', 'NodeC']
441 for i in range(0, nbNode):
442 nodeId = res['network'][0]['node'][i]['node-id']
443 find = nodeId in listNode
444 self.assertEqual(find, True)
445 if(nodeId == 'NodeA'):
446 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
448 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
449 listNode.remove(nodeId)
450 self.assertEqual(len(listNode), 0)
452 def test_17_getOpenRoadmNetwork(self):
453 url = ("{}/config/ietf-network:networks/network/openroadm-network"
454 .format(test_utils.RESTCONF_BASE_URL))
455 response = requests.request(
456 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
457 self.assertEqual(response.status_code, requests.codes.ok)
458 res = response.json()
459 nbNode = len(res['network'][0]['node'])
460 self.assertEqual(nbNode, 3)
461 listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
462 for i in range(0, nbNode):
463 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
464 nodeId = res['network'][0]['node'][i]['node-id']
465 if(nodeId == 'XPDR-A1'):
466 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
467 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
468 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
469 listNode.remove(nodeId)
470 elif(nodeId == 'ROADM-A1'):
471 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
472 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
473 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
474 listNode.remove(nodeId)
475 elif(nodeId == 'ROADM-C1'):
476 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
477 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
478 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
479 listNode.remove(nodeId)
481 self.assertFalse(True)
482 self.assertEqual(len(listNode), 0)
484 def test_18_getROADMLinkOpenRoadmTopology(self):
485 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
486 .format(test_utils.RESTCONF_BASE_URL))
487 response = requests.request(
488 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
489 self.assertEqual(response.status_code, requests.codes.ok)
490 res = response.json()
491 # Tests related to links
492 nbLink = len(res['network'][0]['ietf-network-topology:link'])
493 self.assertEqual(nbLink, 20)
494 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
495 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
496 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
497 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
498 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
499 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
500 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
501 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
502 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
503 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
504 XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
505 XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-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 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
509 if(nodeType == 'EXPRESS-LINK'):
510 find = linkId in expressLink
511 self.assertEqual(find, True)
512 expressLink.remove(linkId)
513 elif(nodeType == 'ADD-LINK'):
514 find = linkId in addLink
515 self.assertEqual(find, True)
516 addLink.remove(linkId)
517 elif(nodeType == 'DROP-LINK'):
518 find = linkId in dropLink
519 self.assertEqual(find, True)
520 dropLink.remove(linkId)
521 elif(nodeType == 'ROADM-TO-ROADM'):
522 find = linkId in R2RLink
523 self.assertEqual(find, True)
524 R2RLink.remove(linkId)
525 elif(nodeType == 'XPONDER-INPUT'):
526 find = linkId in XPDR_IN
527 self.assertEqual(find, True)
528 XPDR_IN.remove(linkId)
529 elif(nodeType == 'XPONDER-OUTPUT'):
530 find = linkId in XPDR_OUT
531 self.assertEqual(find, True)
532 XPDR_OUT.remove(linkId)
534 self.assertFalse(True)
535 self.assertEqual(len(expressLink), 0)
536 self.assertEqual(len(addLink), 0)
537 self.assertEqual(len(dropLink), 0)
538 self.assertEqual(len(R2RLink), 0)
539 self.assertEqual(len(XPDR_IN), 0)
540 self.assertEqual(len(XPDR_OUT), 0)
542 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
543 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
544 .format(test_utils.RESTCONF_BASE_URL))
545 response = requests.request(
546 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
547 self.assertEqual(response.status_code, requests.codes.ok)
548 res = response.json()
549 # Tests related to links
550 nbLink = len(res['network'][0]['ietf-network-topology:link'])
551 self.assertEqual(nbLink, 20)
552 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
553 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
554 for i in range(0, nbLink):
555 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
556 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
557 if(link_id in R2RLink):
559 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
560 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
561 length = res['network'][0]['ietf-network-topology:link'][i][
562 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
563 if((spanLoss != None) & (length != None)):
565 self.assertTrue(find)
566 R2RLink.remove(link_id)
567 self.assertEqual(len(R2RLink), 0)
569 def test_20_getNodes_OpenRoadmTopology(self):
570 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
571 .format(test_utils.RESTCONF_BASE_URL))
572 response = requests.request(
573 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
574 res = response.json()
575 # Tests related to nodes
576 self.assertEqual(response.status_code, requests.codes.ok)
577 nbNode = len(res['network'][0]['node'])
578 self.assertEqual(nbNode, 8)
579 listNode = ['XPDR-A1-XPDR1',
580 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
581 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
582 # ************************Tests related to XPDRA nodes
583 for i in range(0, nbNode):
584 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
585 nodeId = res['network'][0]['node'][i]['node-id']
586 if(nodeId == 'XPDR-A1-XPDR1'):
587 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
588 res['network'][0]['node'][i]['supporting-node'])
589 self.assertEqual(nodeType, 'XPONDER')
590 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
591 self.assertTrue(nbTps >= 4)
594 for j in range(0, nbTps):
595 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
596 if (tpType == 'XPONDER-CLIENT'):
598 elif (tpType == 'XPONDER-NETWORK'):
600 self.assertTrue(client == 2)
601 self.assertTrue(network == 2)
602 listNode.remove(nodeId)
603 elif(nodeId == 'ROADM-A1-SRG1'):
604 # Test related to SRG1
605 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
606 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
607 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
608 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
609 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
610 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
611 res['network'][0]['node'][i]['supporting-node'])
612 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
613 listNode.remove(nodeId)
614 elif(nodeId == 'ROADM-A1-SRG3'):
615 # Test related to SRG1
616 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
617 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
618 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
619 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
620 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
621 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
622 res['network'][0]['node'][i]['supporting-node'])
623 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
624 listNode.remove(nodeId)
625 elif(nodeId == 'ROADM-A1-DEG1'):
626 # Test related to DEG1
627 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
628 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
629 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
630 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
631 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
632 res['network'][0]['node'][i]['supporting-node'])
633 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
634 listNode.remove(nodeId)
635 elif(nodeId == 'ROADM-A1-DEG2'):
636 # Test related to DEG2
637 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
638 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
639 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
640 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
641 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
642 res['network'][0]['node'][i]['supporting-node'])
643 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
644 listNode.remove(nodeId)
645 elif(nodeId == 'ROADM-C1-SRG1'):
646 # Test related to SRG1
647 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
648 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
649 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
650 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
651 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
652 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
653 res['network'][0]['node'][i]['supporting-node'])
654 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
655 listNode.remove(nodeId)
656 elif(nodeId == 'ROADM-C1-DEG1'):
657 # Test related to DEG1
658 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
659 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
660 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
661 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
662 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
663 res['network'][0]['node'][i]['supporting-node'])
664 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
665 listNode.remove(nodeId)
666 elif(nodeId == 'ROADM-C1-DEG2'):
667 # Test related to DEG1
668 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
669 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
670 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
671 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
672 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
673 res['network'][0]['node'][i]['supporting-node'])
674 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
675 listNode.remove(nodeId)
677 self.assertFalse(True)
678 self.assertEqual(len(listNode), 0)
680 def test_21_connect_ROADMB(self):
681 response = test_utils.mount_device("ROADM-B1", 'roadmb')
682 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
684 def test_22_omsAttributes_ROADMA_ROADMB(self):
685 # Config ROADM-A1-ROADM-B1 oms-attributes
686 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
687 "link/ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
688 "OMS-attributes/span"
689 .format(test_utils.RESTCONF_BASE_URL))
691 "auto-spanloss": "true",
692 "engineered-spanloss": 12.2,
693 "spanloss-current": 12,
694 "spanloss-base": 11.4,
695 "link-concatenation": [{
698 "SRLG-length": 100000,
700 response = requests.request(
701 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
702 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
703 self.assertEqual(response.status_code, requests.codes.created)
705 def test_23_omsAttributes_ROADMB_ROADMA(self):
706 # Config ROADM-B1-ROADM-A1 oms-attributes
707 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
708 "link/ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
709 "OMS-attributes/span"
710 .format(test_utils.RESTCONF_BASE_URL))
712 "auto-spanloss": "true",
713 "engineered-spanloss": 12.2,
714 "spanloss-current": 12,
715 "spanloss-base": 11.4,
716 "link-concatenation": [{
719 "SRLG-length": 100000,
721 response = requests.request(
722 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
723 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
724 self.assertEqual(response.status_code, requests.codes.created)
726 def test_24_omsAttributes_ROADMB_ROADMC(self):
727 # Config ROADM-B1-ROADM-C1 oms-attributes
728 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
729 "link/ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
730 "OMS-attributes/span"
731 .format(test_utils.RESTCONF_BASE_URL))
733 "auto-spanloss": "true",
734 "engineered-spanloss": 12.2,
735 "spanloss-current": 12,
736 "spanloss-base": 11.4,
737 "link-concatenation": [{
740 "SRLG-length": 100000,
742 response = requests.request(
743 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
744 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
745 self.assertEqual(response.status_code, requests.codes.created)
747 def test_25_omsAttributes_ROADMC_ROADMB(self):
748 # Config ROADM-C1-ROADM-B1 oms-attributes
749 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
750 "link/ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
751 "OMS-attributes/span"
752 .format(test_utils.RESTCONF_BASE_URL))
754 "auto-spanloss": "true",
755 "engineered-spanloss": 12.2,
756 "link-concatenation": [{
759 "SRLG-length": 100000,
761 response = requests.request(
762 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
763 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
764 self.assertEqual(response.status_code, requests.codes.created)
766 def test_26_getClliNetwork(self):
767 url = ("{}/config/ietf-network:networks/network/clli-network"
768 .format(test_utils.RESTCONF_BASE_URL))
769 response = requests.request(
770 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
771 self.assertEqual(response.status_code, requests.codes.ok)
772 res = response.json()
773 nbNode = len(res['network'][0]['node'])
774 listNode = ['NodeA', 'NodeB', 'NodeC']
775 for i in range(0, nbNode):
776 nodeId = res['network'][0]['node'][i]['node-id']
777 find = nodeId in listNode
778 self.assertEqual(find, True)
779 if(nodeId == 'NodeA'):
780 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
781 elif(nodeId == 'NodeB'):
782 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
784 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
785 listNode.remove(nodeId)
786 self.assertEqual(len(listNode), 0)
788 def test_27_verifyDegree(self):
789 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
790 .format(test_utils.RESTCONF_BASE_URL))
791 response = requests.request(
792 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
793 self.assertEqual(response.status_code, requests.codes.ok)
794 res = response.json()
795 # Tests related to links
796 nbLink = len(res['network'][0]['ietf-network-topology:link'])
797 listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
798 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
799 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
800 for i in range(0, nbLink):
801 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
802 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
803 find = link_id in listR2RLink
804 self.assertEqual(find, True)
805 listR2RLink.remove(link_id)
806 self.assertEqual(len(listR2RLink), 0)
808 def test_28_verifyOppositeLinkTopology(self):
809 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
810 .format(test_utils.RESTCONF_BASE_URL))
811 response = requests.request(
812 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
813 self.assertEqual(response.status_code, requests.codes.ok)
814 res = response.json()
815 # Tests related to links
816 nbLink = len(res['network'][0]['ietf-network-topology:link'])
817 self.assertEqual(nbLink, 26)
818 for i in range(0, nbLink):
819 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
820 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
821 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
822 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
823 oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
824 # Find the opposite link
825 url_oppLink = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
826 url = (url_oppLink.format(test_utils.RESTCONF_BASE_URL))
827 response_oppLink = requests.request(
828 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
829 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
830 res_oppLink = response_oppLink.json()
831 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
832 ['org-openroadm-common-network:opposite-link'], link_id)
833 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
834 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
835 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
836 if link_type == 'ADD-LINK':
837 self.assertEqual(oppLink_type, 'DROP-LINK')
838 elif link_type == 'DROP-LINK':
839 self.assertEqual(oppLink_type, 'ADD-LINK')
840 elif link_type == 'EXPRESS-LINK':
841 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
842 elif link_type == 'ROADM-TO-ROADM':
843 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
844 elif link_type == 'XPONDER-INPUT':
845 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
846 elif link_type == 'XPONDER-OUTPUT':
847 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
849 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
850 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
851 .format(test_utils.RESTCONF_BASE_URL))
852 response = requests.request(
853 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
854 self.assertEqual(response.status_code, requests.codes.ok)
855 res = response.json()
856 nbLink = len(res['network'][0]['ietf-network-topology:link'])
857 R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
858 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
859 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
860 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
861 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
862 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
863 for i in range(0, nbLink):
864 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
865 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
866 if(link_id in R2RLink):
868 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
869 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
870 length = res['network'][0]['ietf-network-topology:link'][i][
871 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
872 if((spanLoss != None) & (length != None)):
874 self.assertTrue(find)
875 R2RLink.remove(link_id)
876 self.assertEqual(len(R2RLink), 0)
878 def test_30_disconnect_ROADMB(self):
879 # Delete in the topology-netconf
880 response = test_utils.unmount_device("ROADM-B1")
881 # Delete in the clli-network
882 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
883 .format(test_utils.RESTCONF_BASE_URL))
885 response = requests.request(
886 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
887 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
888 self.assertEqual(response.status_code, requests.codes.ok)
890 def test_31_disconnect_ROADMC(self):
891 # Delete in the topology-netconf
892 response = test_utils.unmount_device("ROADM-C1")
893 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
894 # Delete in the clli-network
895 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
896 .format(test_utils.RESTCONF_BASE_URL))
898 response = requests.request(
899 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
900 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
901 self.assertEqual(response.status_code, requests.codes.ok)
903 # def test_24_check_roadm2roadm_links_deletion(self):
904 # url = ("{}/config/ietf-network:networks/network/openroadm-topology"
905 # .format(test_utils.RESTCONF_BASE_URL))
906 # response = requests.request(
907 # "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
908 # self.assertEqual(response.status_code, requests.codes.ok)
909 # res = response.json()
910 # #Write the response in the log
911 # with open('./transportpce_tests/log/response.log', 'a') as outfile1:
912 # outfile1.write(str(res))
913 # #Tests related to links
914 # nbLink=len(res['network'][0]['ietf-network-topology:link'])
915 # self.assertEqual(nbLink,8)
916 # expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
917 # addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
918 # dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
919 # XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
920 # XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
921 # for i in range(0,nbLink):
922 # nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
923 # linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
924 # if(nodeType=='EXPRESS-LINK'):
925 # find= linkId in expressLink
926 # self.assertEqual(find, True)
927 # expressLink.remove(linkId)
928 # elif(nodeType=='ADD-LINK'):
929 # find= linkId in addLink
930 # self.assertEqual(find, True)
931 # addLink.remove(linkId)
932 # elif(nodeType=='DROP-LINK'):
933 # find= linkId in dropLink
934 # self.assertEqual(find, True)
935 # dropLink.remove(linkId)
936 # elif(nodeType=='XPONDER-INPUT'):
937 # find= linkId in XPDR_IN
938 # self.assertEqual(find, True)
939 # XPDR_IN.remove(linkId)
940 # elif(nodeType=='XPONDER-OUTPUT'):
941 # find= linkId in XPDR_OUT
942 # self.assertEqual(find, True)
943 # XPDR_OUT.remove(linkId)
945 # self.assertFalse(True)
946 # self.assertEqual(len(expressLink),0)
947 # self.assertEqual(len(addLink),0)
948 # self.assertEqual(len(dropLink),0)
949 # self.assertEqual(len(XPDR_IN),0)
950 # self.assertEqual(len(XPDR_OUT),0)
952 # for i in range(0,nbLink):
953 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
954 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
955 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
956 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
957 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
958 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
959 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
961 def test_32_getNodes_OpenRoadmTopology(self):
962 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
963 .format(test_utils.RESTCONF_BASE_URL))
964 response = requests.request(
965 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
966 res = response.json()
967 # Tests related to nodes
968 self.assertEqual(response.status_code, requests.codes.ok)
969 nbNode = len(res['network'][0]['node'])
970 self.assertEqual(nbNode, 5)
971 listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
972 for i in range(0, nbNode):
973 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
974 nodeId = res['network'][0]['node'][i]['node-id']
975 # Tests related to XPDRA nodes
976 if(nodeId == 'XPDR-A1-XPDR1'):
977 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
978 for j in range(0, nbTp):
979 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
980 if (tpid == 'XPDR1-CLIENT1'):
981 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
982 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
983 if (tpid == 'XPDR1-NETWORK1'):
984 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
985 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
986 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
987 ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
988 'ROADM-A1-SRG1--SRG1-PP1-TXRX')
989 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
990 res['network'][0]['node'][i]['supporting-node'])
991 listNode.remove(nodeId)
992 elif(nodeId == 'ROADM-A1-SRG1'):
993 # Test related to SRG1
994 self.assertEqual(nodeType, 'SRG')
995 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
996 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
997 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
998 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
999 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1000 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1001 res['network'][0]['node'][i]['supporting-node'])
1002 listNode.remove(nodeId)
1003 elif(nodeId == 'ROADM-A1-SRG3'):
1004 # Test related to SRG1
1005 self.assertEqual(nodeType, 'SRG')
1006 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1007 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1008 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1009 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1010 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1011 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1012 res['network'][0]['node'][i]['supporting-node'])
1013 listNode.remove(nodeId)
1014 elif(nodeId == 'ROADM-A1-DEG1'):
1015 # Test related to DEG1
1016 self.assertEqual(nodeType, 'DEGREE')
1017 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1018 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1019 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1020 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1021 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1022 res['network'][0]['node'][i]['supporting-node'])
1023 listNode.remove(nodeId)
1024 elif(nodeId == 'ROADM-A1-DEG2'):
1025 # Test related to DEG2
1026 self.assertEqual(nodeType, 'DEGREE')
1027 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1028 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1029 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1030 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1031 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1032 res['network'][0]['node'][i]['supporting-node'])
1033 listNode.remove(nodeId)
1035 self.assertFalse(True)
1036 self.assertEqual(len(listNode), 0)
1037 # Test related to SRG1 of ROADMC
1038 for i in range(0, nbNode):
1039 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
1040 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
1041 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
1043 def test_33_getOpenRoadmNetwork(self):
1044 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1045 .format(test_utils.RESTCONF_BASE_URL))
1046 response = requests.request(
1047 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1048 self.assertEqual(response.status_code, requests.codes.ok)
1049 res = response.json()
1050 nbNode = len(res['network'][0]['node'])
1051 self.assertEqual(nbNode, 2)
1052 for i in range(0, nbNode-1):
1053 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
1054 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
1056 def test_34_getClliNetwork(self):
1057 url = ("{}/config/ietf-network:networks/network/clli-network"
1058 .format(test_utils.RESTCONF_BASE_URL))
1059 response = requests.request(
1060 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1061 self.assertEqual(response.status_code, requests.codes.ok)
1062 res = response.json()
1063 nbNode = len(res['network'][0]['node'])
1064 self.assertEqual(nbNode, 1)
1065 for i in range(0, nbNode-1):
1066 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
1068 def test_35_disconnect_XPDRA(self):
1069 response = test_utils.unmount_device("XPDR-A1")
1070 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1072 def test_36_getClliNetwork(self):
1073 url = ("{}/config/ietf-network:networks/network/clli-network"
1074 .format(test_utils.RESTCONF_BASE_URL))
1075 response = requests.request(
1076 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1077 self.assertEqual(response.status_code, requests.codes.ok)
1078 res = response.json()
1079 nbNode = len(res['network'][0]['node'])
1080 self.assertEqual(nbNode, 1)
1081 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
1083 def test_37_getOpenRoadmNetwork(self):
1084 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1085 .format(test_utils.RESTCONF_BASE_URL))
1086 response = requests.request(
1087 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1088 self.assertEqual(response.status_code, requests.codes.ok)
1089 res = response.json()
1090 nbNode = len(res['network'][0]['node'])
1091 self.assertEqual(nbNode, 1)
1092 for i in range(0, nbNode):
1093 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
1095 def test_38_getNodes_OpenRoadmTopology(self):
1096 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1097 .format(test_utils.RESTCONF_BASE_URL))
1098 response = requests.request(
1099 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1100 res = response.json()
1101 # Tests related to nodes
1102 self.assertEqual(response.status_code, requests.codes.ok)
1103 nbNode = len(res['network'][0]['node'])
1104 self.assertEqual(nbNode, 4)
1105 listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
1106 for i in range(0, nbNode):
1107 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1108 res['network'][0]['node'][i]['supporting-node'])
1109 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1110 nodeId = res['network'][0]['node'][i]['node-id']
1111 if(nodeId == 'ROADM-A1-SRG1'):
1112 # Test related to SRG1
1113 self.assertEqual(nodeType, 'SRG')
1114 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1115 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1116 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1117 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1118 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1119 listNode.remove(nodeId)
1120 elif(nodeId == 'ROADM-A1-SRG3'):
1121 # Test related to SRG1
1122 self.assertEqual(nodeType, 'SRG')
1123 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
1124 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1125 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1126 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1127 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1128 listNode.remove(nodeId)
1129 elif(nodeId == 'ROADM-A1-DEG1'):
1130 # Test related to DEG1
1131 self.assertEqual(nodeType, 'DEGREE')
1132 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1133 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1134 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1135 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1136 listNode.remove(nodeId)
1137 elif(nodeId == 'ROADM-A1-DEG2'):
1138 # Test related to DEG2
1139 self.assertEqual(nodeType, 'DEGREE')
1140 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1141 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1142 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1143 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1144 listNode.remove(nodeId)
1146 self.assertFalse(True)
1147 self.assertEqual(len(listNode), 0)
1149 def test_39_disconnect_ROADM_XPDRA_link(self):
1151 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1152 "link/XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX"
1153 .format(test_utils.RESTCONF_BASE_URL))
1155 response = requests.request(
1156 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
1157 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1158 self.assertEqual(response.status_code, requests.codes.ok)
1160 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1161 "link/ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1"
1162 .format(test_utils.RESTCONF_BASE_URL))
1164 response = requests.request(
1165 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
1166 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1167 self.assertEqual(response.status_code, requests.codes.ok)
1169 def test_40_getLinks_OpenRoadmTopology(self):
1170 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1171 .format(test_utils.RESTCONF_BASE_URL))
1172 response = requests.request(
1173 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1174 self.assertEqual(response.status_code, requests.codes.ok)
1175 res = response.json()
1176 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1177 self.assertEqual(nbLink, 16)
1178 expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1179 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1180 addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1181 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1182 dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1183 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1184 roadmtoroadmLink = 0
1185 for i in range(0, nbLink):
1186 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1187 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1188 find = link_id in expressLink
1189 self.assertEqual(find, True)
1190 expressLink.remove(link_id)
1191 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1192 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1193 find = link_id in addLink
1194 self.assertEqual(find, True)
1195 addLink.remove(link_id)
1196 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1197 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1198 find = link_id in dropLink
1199 self.assertEqual(find, True)
1200 dropLink.remove(link_id)
1202 roadmtoroadmLink += 1
1203 self.assertEqual(len(expressLink), 0)
1204 self.assertEqual(len(addLink), 0)
1205 self.assertEqual(len(dropLink), 0)
1206 self.assertEqual(roadmtoroadmLink, 6)
1207 for i in range(0, nbLink):
1208 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1209 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1210 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1211 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1213 def test_41_disconnect_ROADMA(self):
1214 response = test_utils.unmount_device("ROADM-A1")
1215 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1216 # Delete in the clli-network
1217 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1218 .format(test_utils.RESTCONF_BASE_URL))
1220 response = requests.request(
1221 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
1222 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1223 self.assertEqual(response.status_code, requests.codes.ok)
1225 def test_42_getClliNetwork(self):
1226 url = ("{}/config/ietf-network:networks/network/clli-network"
1227 .format(test_utils.RESTCONF_BASE_URL))
1228 response = requests.request(
1229 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1230 self.assertEqual(response.status_code, requests.codes.ok)
1231 res = response.json()
1232 self.assertNotIn('node', res['network'][0])
1234 def test_43_getOpenRoadmNetwork(self):
1235 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1236 .format(test_utils.RESTCONF_BASE_URL))
1237 response = requests.request(
1238 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1239 self.assertEqual(response.status_code, requests.codes.ok)
1240 res = response.json()
1241 self.assertNotIn('node', res['network'][0])
1243 def test_44_check_roadm2roadm_link_persistence(self):
1244 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1245 .format(test_utils.RESTCONF_BASE_URL))
1246 response = requests.request(
1247 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1248 self.assertEqual(response.status_code, requests.codes.ok)
1249 res = response.json()
1250 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1251 self.assertNotIn('node', res['network'][0])
1252 self.assertEqual(nbLink, 6)
1255 if __name__ == "__main__":
1256 unittest.main(verbosity=2)