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 ##############################################################################
16 from common import test_utils
19 class TransportPCETopologyTesting(unittest.TestCase):
25 cls.processes = test_utils.start_tpce()
26 cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
29 def tearDownClass(cls):
30 for process in cls.processes:
31 test_utils.shutdown_process(process)
32 print("all processes killed")
37 def test_01_connect_ROADMA(self):
38 response = test_utils.mount_device("ROADMA01", 'roadma')
39 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
41 def test_02_getClliNetwork(self):
42 url = ("{}/config/ietf-network:networks/network/clli-network"
43 .format(test_utils.RESTCONF_BASE_URL))
44 response = requests.request(
45 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
46 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 .format(test_utils.RESTCONF_BASE_URL))
54 response = requests.request(
55 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
56 self.assertEqual(response.status_code, requests.codes.ok)
58 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADMA01')
59 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
60 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
61 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
62 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], '2')
64 def test_04_getLinks_OpenroadmTopology(self):
65 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
66 .format(test_utils.RESTCONF_BASE_URL))
67 response = requests.request(
68 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
69 self.assertEqual(response.status_code, requests.codes.ok)
71 # Tests related to links
72 nbLink = len(res['network'][0]['ietf-network-topology:link'])
73 self.assertEqual(nbLink, 10)
74 expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
75 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
76 addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
77 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
78 dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
79 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-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 .format(test_utils.RESTCONF_BASE_URL))
103 response = requests.request("GET", url, headers=test_utils.TYPE_APPLICATION_JSON,
104 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
105 res = response.json()
106 # Tests related to nodes
107 self.assertEqual(response.status_code, requests.codes.ok)
108 nbNode = len(res['network'][0]['node'])
109 self.assertEqual(nbNode, 4)
110 listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
111 for i in range(0, nbNode):
112 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
113 res['network'][0]['node'][i]['supporting-node'])
114 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
115 nodeId = res['network'][0]['node'][i]['node-id']
116 if nodeId == 'ROADMA01-SRG1':
117 # Test related to SRG1
118 self.assertEqual(nodeType, 'SRG')
119 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
120 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
121 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
122 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
123 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
124 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
125 res['network'][0]['node'][i]['supporting-node'])
126 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
127 res['network'][0]['node'][i]['supporting-node'])
128 listNode.remove(nodeId)
129 elif nodeId == 'ROADMA01-SRG3':
130 # Test related to SRG1
131 self.assertEqual(nodeType, 'SRG')
132 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
133 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
134 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
135 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
136 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
137 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
138 res['network'][0]['node'][i]['supporting-node'])
139 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
140 res['network'][0]['node'][i]['supporting-node'])
141 listNode.remove(nodeId)
142 elif nodeId == 'ROADMA01-DEG1':
143 # Test related to DEG1
144 self.assertEqual(nodeType, 'DEGREE')
145 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
146 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
147 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
148 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
149 listNode.remove(nodeId)
150 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
151 res['network'][0]['node'][i]['supporting-node'])
152 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
153 res['network'][0]['node'][i]['supporting-node'])
154 elif nodeId == 'ROADMA01-DEG2':
155 # Test related to DEG2
156 self.assertEqual(nodeType, 'DEGREE')
157 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
158 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
159 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
160 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
161 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
162 res['network'][0]['node'][i]['supporting-node'])
163 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
164 res['network'][0]['node'][i]['supporting-node'])
165 listNode.remove(nodeId)
167 self.assertFalse(True)
168 self.assertEqual(len(listNode), 0)
170 def test_06_connect_XPDRA(self):
171 response = test_utils.mount_device("XPDRA01", 'xpdra')
172 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
174 def test_07_getClliNetwork(self):
175 url = ("{}/config/ietf-network:networks/network/clli-network"
176 .format(test_utils.RESTCONF_BASE_URL))
177 response = requests.request("GET", url, headers=test_utils.TYPE_APPLICATION_JSON,
178 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
179 self.assertEqual(response.status_code, requests.codes.ok)
180 res = response.json()
181 self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
182 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
184 def test_08_getOpenRoadmNetwork(self):
185 url = ("{}/config/ietf-network:networks/network/openroadm-network"
186 .format(test_utils.RESTCONF_BASE_URL))
187 response = requests.request(
188 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
189 self.assertEqual(response.status_code, requests.codes.ok)
190 res = response.json()
191 nbNode = len(res['network'][0]['node'])
192 self.assertEqual(nbNode, 2)
193 for i in range(0, nbNode):
194 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
195 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
196 nodeId = res['network'][0]['node'][i]['node-id']
197 if(nodeId == 'XPDRA01'):
198 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
199 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '1')
200 elif(nodeId == 'ROADMA01'):
201 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
202 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
204 self.assertFalse(True)
206 def test_09_getNodes_OpenRoadmTopology(self):
207 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
208 .format(test_utils.RESTCONF_BASE_URL))
209 response = requests.request(
210 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
211 res = response.json()
212 # Tests related to nodes
213 self.assertEqual(response.status_code, requests.codes.ok)
214 nbNode = len(res['network'][0]['node'])
215 self.assertEqual(nbNode, 5)
216 listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
217 for i in range(0, nbNode):
218 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
219 nodeId = res['network'][0]['node'][i]['node-id']
220 # Tests related to XPDRA nodes
221 if(nodeId == 'XPDRA01-XPDR1'):
222 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
223 res['network'][0]['node'][i]['supporting-node'])
224 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
225 res['network'][0]['node'][i]['supporting-node'])
226 self.assertEqual(nodeType, 'XPONDER')
227 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
230 for j in range(0, nbTps):
231 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
232 tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
233 if (tpType == 'XPONDER-CLIENT'):
235 elif (tpType == 'XPONDER-NETWORK'):
237 if (tpId == 'XPDR1-NETWORK2'):
238 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
239 [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT3')
240 if (tpId == 'XPDR1-CLIENT3'):
241 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
242 [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
243 self.assertTrue(client == 4)
244 self.assertTrue(network == 2)
245 listNode.remove(nodeId)
246 elif(nodeId == 'ROADMA01-SRG1'):
247 # Test related to SRG1
248 self.assertEqual(nodeType, 'SRG')
249 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
250 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
251 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
252 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
253 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
254 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
255 res['network'][0]['node'][i]['supporting-node'])
256 listNode.remove(nodeId)
257 elif(nodeId == 'ROADMA01-SRG3'):
258 # Test related to SRG1
259 self.assertEqual(nodeType, 'SRG')
260 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
261 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
262 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
263 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
264 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
265 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
266 res['network'][0]['node'][i]['supporting-node'])
267 listNode.remove(nodeId)
268 elif(nodeId == 'ROADMA01-DEG1'):
269 # Test related to DEG1
270 self.assertEqual(nodeType, 'DEGREE')
271 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
272 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
273 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
274 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
275 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
276 res['network'][0]['node'][i]['supporting-node'])
277 listNode.remove(nodeId)
278 elif(nodeId == 'ROADMA01-DEG2'):
279 # Test related to DEG2
280 self.assertEqual(nodeType, 'DEGREE')
281 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
282 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
283 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
284 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
285 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
286 res['network'][0]['node'][i]['supporting-node'])
287 listNode.remove(nodeId)
289 self.assertFalse(True)
290 self.assertEqual(len(listNode), 0)
292 # Connect the tail XPDRA to ROADMA and vice versa
293 def test_10_connect_tail_xpdr_rdm(self):
294 # Connect the tail: XPDRA to ROADMA
295 url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
296 .format(test_utils.RESTCONF_BASE_URL))
297 data = {"networkutils:input": {
298 "networkutils:links-input": {
299 "networkutils:xpdr-node": "XPDRA01",
300 "networkutils:xpdr-num": "1",
301 "networkutils:network-num": "1",
302 "networkutils:rdm-node": "ROADMA01",
303 "networkutils:srg-num": "1",
304 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
308 response = requests.request(
309 "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
310 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
311 self.assertEqual(response.status_code, requests.codes.ok)
313 def test_11_connect_tail_rdm_xpdr(self):
314 # Connect the tail: ROADMA to XPDRA
315 url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
316 .format(test_utils.RESTCONF_BASE_URL))
317 data = {"networkutils:input": {
318 "networkutils:links-input": {
319 "networkutils:xpdr-node": "XPDRA01",
320 "networkutils:xpdr-num": "1",
321 "networkutils:network-num": "1",
322 "networkutils:rdm-node": "ROADMA01",
323 "networkutils:srg-num": "1",
324 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
328 response = requests.request(
329 "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
330 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
331 self.assertEqual(response.status_code, requests.codes.ok)
333 def test_12_getLinks_OpenRoadmTopology(self):
334 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
335 .format(test_utils.RESTCONF_BASE_URL))
336 response = requests.request(
337 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
338 self.assertEqual(response.status_code, requests.codes.ok)
339 res = response.json()
340 # Tests related to links
341 nbLink = len(res['network'][0]['ietf-network-topology:link'])
342 self.assertEqual(nbLink, 12)
343 expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
344 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
345 addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
346 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
347 dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
348 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
349 XPDR_IN = ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
350 XPDR_OUT = ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
351 for i in range(0, nbLink):
352 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
353 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
354 if(nodeType == 'EXPRESS-LINK'):
355 find = linkId in expressLink
356 self.assertEqual(find, True)
357 expressLink.remove(linkId)
358 elif(nodeType == 'ADD-LINK'):
359 find = linkId in addLink
360 self.assertEqual(find, True)
361 addLink.remove(linkId)
362 elif(nodeType == 'DROP-LINK'):
363 find = linkId in dropLink
364 self.assertEqual(find, True)
365 dropLink.remove(linkId)
366 elif(nodeType == 'XPONDER-INPUT'):
367 find = linkId in XPDR_IN
368 self.assertEqual(find, True)
369 XPDR_IN.remove(linkId)
370 elif(nodeType == 'XPONDER-OUTPUT'):
371 find = linkId in XPDR_OUT
372 self.assertEqual(find, True)
373 XPDR_OUT.remove(linkId)
375 self.assertFalse(True)
376 self.assertEqual(len(expressLink), 0)
377 self.assertEqual(len(addLink), 0)
378 self.assertEqual(len(dropLink), 0)
379 self.assertEqual(len(XPDR_IN), 0)
380 self.assertEqual(len(XPDR_OUT), 0)
382 def test_13_connect_ROADMC(self):
383 response = test_utils.mount_device("ROADMC01", 'roadmc')
384 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
386 def test_14_omsAttributes_ROADMA_ROADMC(self):
387 # Config ROADMA01-ROADMC01 oms-attributes
388 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
389 "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
390 "OMS-attributes/span"
391 .format(test_utils.RESTCONF_BASE_URL))
393 "auto-spanloss": "true",
394 "engineered-spanloss": 12.2,
395 "link-concatenation": [{
398 "SRLG-length": 100000,
400 response = requests.request(
401 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
402 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
403 self.assertEqual(response.status_code, requests.codes.created)
405 def test_15_omsAttributes_ROADMC_ROADMA(self):
406 # Config ROADMC01-ROADMA oms-attributes
407 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
408 "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
409 "OMS-attributes/span"
410 .format(test_utils.RESTCONF_BASE_URL))
412 "auto-spanloss": "true",
413 "engineered-spanloss": 12.2,
414 "link-concatenation": [{
417 "SRLG-length": 100000,
419 response = requests.request(
420 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
421 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
422 self.assertEqual(response.status_code, requests.codes.created)
424 def test_16_getClliNetwork(self):
425 url = ("{}/config/ietf-network:networks/network/clli-network"
426 .format(test_utils.RESTCONF_BASE_URL))
427 response = requests.request(
428 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
429 self.assertEqual(response.status_code, requests.codes.ok)
430 res = response.json()
431 nbNode = len(res['network'][0]['node'])
432 listNode = ['NodeA', 'NodeC']
433 for i in range(0, nbNode):
434 nodeId = res['network'][0]['node'][i]['node-id']
435 find = nodeId in listNode
436 self.assertEqual(find, True)
437 if(nodeId == 'NodeA'):
438 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
440 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
441 listNode.remove(nodeId)
443 self.assertEqual(len(listNode), 0)
445 def test_17_getOpenRoadmNetwork(self):
446 url = ("{}/config/ietf-network:networks/network/openroadm-network"
447 .format(test_utils.RESTCONF_BASE_URL))
448 response = requests.request(
449 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
450 self.assertEqual(response.status_code, requests.codes.ok)
451 res = response.json()
452 nbNode = len(res['network'][0]['node'])
453 self.assertEqual(nbNode, 3)
454 listNode = ['XPDRA01', 'ROADMA01', 'ROADMC01']
455 for i in range(0, nbNode):
456 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
457 nodeId = res['network'][0]['node'][i]['node-id']
458 if(nodeId == 'XPDRA01'):
459 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
460 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
461 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '1')
462 listNode.remove(nodeId)
463 elif(nodeId == 'ROADMA01'):
464 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
465 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
466 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
467 listNode.remove(nodeId)
468 elif(nodeId == 'ROADMC01'):
469 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
470 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
471 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
472 listNode.remove(nodeId)
474 self.assertFalse(True)
475 self.assertEqual(len(listNode), 0)
477 def test_18_getROADMLinkOpenRoadmTopology(self):
478 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
479 .format(test_utils.RESTCONF_BASE_URL))
480 response = requests.request(
481 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
482 self.assertEqual(response.status_code, requests.codes.ok)
483 res = response.json()
484 # Tests related to links
485 nbLink = len(res['network'][0]['ietf-network-topology:link'])
486 self.assertEqual(nbLink, 20)
487 expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX', 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
488 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX', 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
489 addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
490 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
491 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX', 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
492 dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
493 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
494 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX', 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
495 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
496 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
497 XPDR_IN = ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
498 XPDR_OUT = ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
499 for i in range(0, nbLink):
500 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
501 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
502 if(nodeType == 'EXPRESS-LINK'):
503 find = linkId in expressLink
504 self.assertEqual(find, True)
505 expressLink.remove(linkId)
506 elif(nodeType == 'ADD-LINK'):
507 find = linkId in addLink
508 self.assertEqual(find, True)
509 addLink.remove(linkId)
510 elif(nodeType == 'DROP-LINK'):
511 find = linkId in dropLink
512 self.assertEqual(find, True)
513 dropLink.remove(linkId)
514 elif(nodeType == 'ROADM-TO-ROADM'):
515 find = linkId in R2RLink
516 self.assertEqual(find, True)
517 R2RLink.remove(linkId)
518 elif(nodeType == 'XPONDER-INPUT'):
519 find = linkId in XPDR_IN
520 self.assertEqual(find, True)
521 XPDR_IN.remove(linkId)
522 elif(nodeType == 'XPONDER-OUTPUT'):
523 find = linkId in XPDR_OUT
524 self.assertEqual(find, True)
525 XPDR_OUT.remove(linkId)
527 self.assertFalse(True)
528 self.assertEqual(len(expressLink), 0)
529 self.assertEqual(len(addLink), 0)
530 self.assertEqual(len(dropLink), 0)
531 self.assertEqual(len(R2RLink), 0)
532 self.assertEqual(len(XPDR_IN), 0)
533 self.assertEqual(len(XPDR_OUT), 0)
535 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
536 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
537 .format(test_utils.RESTCONF_BASE_URL))
538 response = requests.request(
539 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
540 self.assertEqual(response.status_code, requests.codes.ok)
541 res = response.json()
542 # Tests related to links
543 nbLink = len(res['network'][0]['ietf-network-topology:link'])
544 self.assertEqual(nbLink, 20)
545 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
546 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
547 for i in range(0, nbLink):
548 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
549 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
550 if(link_id in R2RLink):
552 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
553 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
554 length = res['network'][0]['ietf-network-topology:link'][i][
555 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
556 if((spanLoss != None) & (length != None)):
558 self.assertTrue(find)
559 R2RLink.remove(link_id)
560 self.assertEqual(len(R2RLink), 0)
562 def test_20_getNodes_OpenRoadmTopology(self):
563 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
564 .format(test_utils.RESTCONF_BASE_URL))
565 response = requests.request(
566 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
567 res = response.json()
568 # Tests related to nodes
569 self.assertEqual(response.status_code, requests.codes.ok)
570 nbNode = len(res['network'][0]['node'])
571 self.assertEqual(nbNode, 8)
572 listNode = ['XPDRA01-XPDR1',
573 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2',
574 'ROADMC01-SRG1', 'ROADMC01-DEG1', 'ROADMC01-DEG2']
575 # ************************Tests related to XPDRA nodes
576 for i in range(0, nbNode):
577 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
578 nodeId = res['network'][0]['node'][i]['node-id']
579 if(nodeId == 'XPDRA01-XPDR1'):
580 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
581 res['network'][0]['node'][i]['supporting-node'])
582 self.assertEqual(nodeType, 'XPONDER')
583 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
584 self.assertTrue(nbTps == 6)
587 for j in range(0, nbTps):
588 tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
589 if (tpType == 'XPONDER-CLIENT'):
591 elif (tpType == 'XPONDER-NETWORK'):
593 self.assertTrue(client == 4)
594 self.assertTrue(network == 2)
595 listNode.remove(nodeId)
596 elif(nodeId == 'ROADMA01-SRG1'):
597 # Test related to SRG1
598 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
599 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
600 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
601 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
602 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
603 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
604 res['network'][0]['node'][i]['supporting-node'])
605 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
606 listNode.remove(nodeId)
607 elif(nodeId == 'ROADMA01-SRG3'):
608 # Test related to SRG1
609 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
610 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
611 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
612 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
613 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
614 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
615 res['network'][0]['node'][i]['supporting-node'])
616 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
617 listNode.remove(nodeId)
618 elif(nodeId == 'ROADMA01-DEG1'):
619 # Test related to DEG1
620 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
621 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
622 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
623 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
624 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
625 res['network'][0]['node'][i]['supporting-node'])
626 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
627 listNode.remove(nodeId)
628 elif(nodeId == 'ROADMA01-DEG2'):
629 # Test related to DEG2
630 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
631 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
632 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
633 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
634 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
635 res['network'][0]['node'][i]['supporting-node'])
636 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
637 listNode.remove(nodeId)
638 elif(nodeId == 'ROADMC01-SRG1'):
639 # Test related to SRG1
640 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
641 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
642 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
643 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
644 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
645 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
646 res['network'][0]['node'][i]['supporting-node'])
647 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
648 listNode.remove(nodeId)
649 elif(nodeId == 'ROADMC01-DEG1'):
650 # Test related to DEG1
651 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
652 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
653 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
654 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
655 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
656 res['network'][0]['node'][i]['supporting-node'])
657 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
658 listNode.remove(nodeId)
659 elif(nodeId == 'ROADMC01-DEG2'):
660 # Test related to DEG2
661 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
662 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
663 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
664 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
665 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
666 res['network'][0]['node'][i]['supporting-node'])
667 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
668 listNode.remove(nodeId)
670 self.assertFalse(True)
671 self.assertEqual(len(listNode), 0)
673 def test_21_connect_ROADMB(self):
674 response = test_utils.mount_device("ROADMB01", 'roadmb')
675 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
677 def test_22_omsAttributes_ROADMA_ROADMB(self):
678 # Config ROADMA01-ROADMB01 oms-attributes
679 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
680 "link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
681 "OMS-attributes/span"
682 .format(test_utils.RESTCONF_BASE_URL))
684 "auto-spanloss": "true",
685 "engineered-spanloss": 12.2,
686 "link-concatenation": [{
689 "SRLG-length": 100000,
691 response = requests.request(
692 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
693 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
694 self.assertEqual(response.status_code, requests.codes.created)
696 def test_23_omsAttributes_ROADMB_ROADMA(self):
697 # Config ROADMB01-ROADMA01 oms-attributes
698 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
699 "link/ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
700 "OMS-attributes/span"
701 .format(test_utils.RESTCONF_BASE_URL))
703 "auto-spanloss": "true",
704 "engineered-spanloss": 12.2,
705 "link-concatenation": [{
708 "SRLG-length": 100000,
710 response = requests.request(
711 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
712 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
713 self.assertEqual(response.status_code, requests.codes.created)
715 def test_24_omsAttributes_ROADMB_ROADMC(self):
716 # Config ROADMB01-ROADMC01 oms-attributes
717 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
718 "link/ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
719 "OMS-attributes/span"
720 .format(test_utils.RESTCONF_BASE_URL))
722 "auto-spanloss": "true",
723 "engineered-spanloss": 12.2,
724 "link-concatenation": [{
727 "SRLG-length": 100000,
729 response = requests.request(
730 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
731 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
732 self.assertEqual(response.status_code, requests.codes.created)
734 def test_25_omsAttributes_ROADMC_ROADMB(self):
735 # Config ROADMC01-ROADMB01 oms-attributes
736 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
737 "link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
738 "OMS-attributes/span"
739 .format(test_utils.RESTCONF_BASE_URL))
741 "auto-spanloss": "true",
742 "engineered-spanloss": 12.2,
743 "link-concatenation": [{
746 "SRLG-length": 100000,
748 response = requests.request(
749 "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
750 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
751 self.assertEqual(response.status_code, requests.codes.created)
753 def test_26_getClliNetwork(self):
754 url = ("{}/config/ietf-network:networks/network/clli-network"
755 .format(test_utils.RESTCONF_BASE_URL))
756 response = requests.request(
757 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
758 self.assertEqual(response.status_code, requests.codes.ok)
759 res = response.json()
760 nbNode = len(res['network'][0]['node'])
761 listNode = ['NodeA', 'NodeB', 'NodeC']
762 for i in range(0, nbNode):
763 nodeId = res['network'][0]['node'][i]['node-id']
764 find = nodeId in listNode
765 self.assertEqual(find, True)
766 if(nodeId == 'NodeA'):
767 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
768 elif(nodeId == 'NodeB'):
769 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
771 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
772 listNode.remove(nodeId)
773 self.assertEqual(len(listNode), 0)
775 def test_27_verifyDegree(self):
776 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
777 .format(test_utils.RESTCONF_BASE_URL))
778 response = requests.request(
779 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
780 self.assertEqual(response.status_code, requests.codes.ok)
781 res = response.json()
782 # Tests related to links
783 nbLink = len(res['network'][0]['ietf-network-topology:link'])
784 listR2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX', 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
785 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX', 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
786 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX', 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
787 for i in range(0, nbLink):
788 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
789 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
790 find = link_id in listR2RLink
791 self.assertEqual(find, True)
792 listR2RLink.remove(link_id)
793 self.assertEqual(len(listR2RLink), 0)
795 def test_28_verifyOppositeLinkTopology(self):
796 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
797 .format(test_utils.RESTCONF_BASE_URL))
798 response = requests.request(
799 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
800 self.assertEqual(response.status_code, requests.codes.ok)
801 res = response.json()
802 # Tests related to links
803 nbLink = len(res['network'][0]['ietf-network-topology:link'])
804 self.assertEqual(nbLink, 34)
805 for i in range(0, nbLink):
806 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
807 link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
808 link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
809 link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
810 oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
811 # Find the opposite link
812 url_oppLink = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
813 url = (url_oppLink.format(test_utils.RESTCONF_BASE_URL))
814 response_oppLink = requests.request(
815 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
816 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
817 res_oppLink = response_oppLink.json()
818 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
819 ['org-openroadm-common-network:opposite-link'], link_id)
820 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
821 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
822 oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
823 if link_type == 'ADD-LINK':
824 self.assertEqual(oppLink_type, 'DROP-LINK')
825 elif link_type == 'DROP-LINK':
826 self.assertEqual(oppLink_type, 'ADD-LINK')
827 elif link_type == 'EXPRESS-LINK':
828 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
829 elif link_type == 'ROADM-TO-ROADM':
830 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
831 elif link_type == 'XPONDER-INPUT':
832 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
833 elif link_type == 'XPONDER-OUTPUT':
834 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
836 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
837 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
838 .format(test_utils.RESTCONF_BASE_URL))
839 response = requests.request(
840 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
841 self.assertEqual(response.status_code, requests.codes.ok)
842 res = response.json()
843 nbLink = len(res['network'][0]['ietf-network-topology:link'])
844 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
845 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
846 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
847 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
848 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
849 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
850 for i in range(0, nbLink):
851 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
852 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
853 if(link_id in R2RLink):
855 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
856 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
857 length = res['network'][0]['ietf-network-topology:link'][i][
858 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
859 if((spanLoss != None) & (length != None)):
861 self.assertTrue(find)
862 R2RLink.remove(link_id)
863 self.assertEqual(len(R2RLink), 0)
865 def test_30_disconnect_ROADMB(self):
866 # Delete in the topology-netconf
867 response = test_utils.unmount_device("ROADMB01")
868 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
869 # Delete in the clli-network
870 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
871 .format(test_utils.RESTCONF_BASE_URL))
873 response = requests.request(
874 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
875 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
876 self.assertEqual(response.status_code, requests.codes.ok)
878 def test_31_disconnect_ROADMC(self):
879 response = test_utils.unmount_device("ROADMC01")
880 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
881 # Delete in the clli-network
882 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
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_32_getNodes_OpenRoadmTopology(self):
891 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
892 .format(test_utils.RESTCONF_BASE_URL))
893 response = requests.request(
894 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
895 res = response.json()
896 # Tests related to nodes
897 self.assertEqual(response.status_code, requests.codes.ok)
898 nbNode = len(res['network'][0]['node'])
899 self.assertEqual(nbNode, 5)
900 listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
901 for i in range(0, nbNode):
902 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
903 nodeId = res['network'][0]['node'][i]['node-id']
904 # Tests related to XPDRA nodes
905 if(nodeId == 'XPDRA01-XPDR1'):
906 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
907 for j in range(0, nbTp):
908 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
909 if (tpid == 'XPDR1-CLIENT1'):
910 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
911 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
912 if (tpid == 'XPDR1-NETWORK1'):
913 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
914 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
915 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
916 ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
917 'ROADMA01-SRG1--SRG1-PP1-TXRX')
918 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
919 res['network'][0]['node'][i]['supporting-node'])
920 listNode.remove(nodeId)
921 elif(nodeId == 'ROADMA01-SRG1'):
922 # Test related to SRG1
923 self.assertEqual(nodeType, 'SRG')
924 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
925 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
926 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
927 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
928 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
929 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
930 res['network'][0]['node'][i]['supporting-node'])
931 listNode.remove(nodeId)
932 elif(nodeId == 'ROADMA01-SRG3'):
933 # Test related to SRG1
934 self.assertEqual(nodeType, 'SRG')
935 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
936 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
937 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
938 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
939 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
940 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
941 res['network'][0]['node'][i]['supporting-node'])
942 listNode.remove(nodeId)
943 elif(nodeId == 'ROADMA01-DEG1'):
944 # Test related to DEG1
945 self.assertEqual(nodeType, 'DEGREE')
946 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
947 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
948 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
949 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
950 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
951 res['network'][0]['node'][i]['supporting-node'])
952 listNode.remove(nodeId)
953 elif(nodeId == 'ROADMA01-DEG2'):
954 # Test related to DEG2
955 self.assertEqual(nodeType, 'DEGREE')
956 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
957 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
958 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
959 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
960 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
961 res['network'][0]['node'][i]['supporting-node'])
962 listNode.remove(nodeId)
964 self.assertFalse(True)
965 self.assertEqual(len(listNode), 0)
966 # Test related to SRG1 of ROADMC
967 for i in range(0, nbNode):
968 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-SRG1')
969 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-DEG1')
970 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-DEG2')
972 def test_33_getOpenRoadmNetwork(self):
973 url = ("{}/config/ietf-network:networks/network/openroadm-network"
974 .format(test_utils.RESTCONF_BASE_URL))
975 response = requests.request(
976 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
977 self.assertEqual(response.status_code, requests.codes.ok)
978 res = response.json()
979 nbNode = len(res['network'][0]['node'])
980 self.assertEqual(nbNode, 2)
981 for i in range(0, nbNode-1):
982 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01')
983 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMB01')
985 def test_34_getClliNetwork(self):
986 url = ("{}/config/ietf-network:networks/network/clli-network"
987 .format(test_utils.RESTCONF_BASE_URL))
988 response = requests.request(
989 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
990 self.assertEqual(response.status_code, requests.codes.ok)
991 res = response.json()
992 nbNode = len(res['network'][0]['node'])
993 self.assertEqual(nbNode, 1)
994 for i in range(0, nbNode-1):
995 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
997 def test_35_disconnect_XPDRA(self):
998 response = test_utils.unmount_device("XPDRA01")
999 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1001 def test_36_getClliNetwork(self):
1002 url = ("{}/config/ietf-network:networks/network/clli-network"
1003 .format(test_utils.RESTCONF_BASE_URL))
1004 response = requests.request(
1005 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1006 self.assertEqual(response.status_code, requests.codes.ok)
1007 res = response.json()
1008 nbNode = len(res['network'][0]['node'])
1009 self.assertEqual(nbNode, 1)
1010 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
1012 def test_37_getOpenRoadmNetwork(self):
1013 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1014 .format(test_utils.RESTCONF_BASE_URL))
1015 response = requests.request(
1016 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1017 self.assertEqual(response.status_code, requests.codes.ok)
1018 res = response.json()
1019 nbNode = len(res['network'][0]['node'])
1020 self.assertEqual(nbNode, 1)
1021 for i in range(0, nbNode):
1022 self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDRA01')
1024 def test_38_getNodes_OpenRoadmTopology(self):
1025 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1026 .format(test_utils.RESTCONF_BASE_URL))
1027 response = requests.request(
1028 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1029 res = response.json()
1030 # Tests related to nodes
1031 self.assertEqual(response.status_code, requests.codes.ok)
1032 nbNode = len(res['network'][0]['node'])
1033 self.assertEqual(nbNode, 4)
1034 listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
1035 for i in range(0, nbNode):
1036 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1037 res['network'][0]['node'][i]['supporting-node'])
1038 nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1039 nodeId = res['network'][0]['node'][i]['node-id']
1040 if(nodeId == 'ROADMA01-SRG1'):
1041 # Test related to SRG1
1042 self.assertEqual(nodeType, 'SRG')
1043 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
1044 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1045 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1046 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1047 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1048 listNode.remove(nodeId)
1049 elif(nodeId == 'ROADMA01-SRG3'):
1050 # Test related to SRG1
1051 self.assertEqual(nodeType, 'SRG')
1052 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
1053 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1054 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1055 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1056 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1057 listNode.remove(nodeId)
1058 elif(nodeId == 'ROADMA01-DEG1'):
1059 # Test related to DEG1
1060 self.assertEqual(nodeType, 'DEGREE')
1061 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1062 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1063 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1064 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1065 listNode.remove(nodeId)
1066 elif(nodeId == 'ROADMA01-DEG2'):
1067 # Test related to DEG2
1068 self.assertEqual(nodeType, 'DEGREE')
1069 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1070 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1071 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1072 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1073 listNode.remove(nodeId)
1075 self.assertFalse(True)
1076 self.assertEqual(len(listNode), 0)
1078 def test_39_disconnect_ROADM_XPDRA_link(self):
1080 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1081 "link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
1082 .format(test_utils.RESTCONF_BASE_URL))
1084 response = requests.request(
1085 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
1086 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1087 self.assertEqual(response.status_code, requests.codes.ok)
1089 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1090 "link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
1091 .format(test_utils.RESTCONF_BASE_URL))
1093 response = requests.request(
1094 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
1095 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1096 self.assertEqual(response.status_code, requests.codes.ok)
1098 def test_40_getLinks_OpenRoadmTopology(self):
1099 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1100 .format(test_utils.RESTCONF_BASE_URL))
1101 response = requests.request(
1102 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1103 self.assertEqual(response.status_code, requests.codes.ok)
1104 res = response.json()
1105 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1106 self.assertEqual(nbLink, 16)
1107 expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
1108 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
1109 addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
1110 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
1111 dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
1112 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
1113 roadmtoroadmLink = 0
1114 for i in range(0, nbLink):
1115 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1116 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1117 find = link_id in expressLink
1118 self.assertEqual(find, True)
1119 expressLink.remove(link_id)
1120 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1121 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1122 find = link_id in addLink
1123 self.assertEqual(find, True)
1124 addLink.remove(link_id)
1125 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1126 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1127 find = link_id in dropLink
1128 self.assertEqual(find, True)
1129 dropLink.remove(link_id)
1131 roadmtoroadmLink += 1
1132 self.assertEqual(len(expressLink), 0)
1133 self.assertEqual(len(addLink), 0)
1134 self.assertEqual(len(dropLink), 0)
1135 self.assertEqual(roadmtoroadmLink, 6)
1136 for i in range(0, nbLink):
1137 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1138 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1139 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1140 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1142 def test_41_disconnect_ROADMA(self):
1143 response = test_utils.unmount_device("ROADMA01")
1144 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1145 # Delete in the clli-network
1146 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1147 .format(test_utils.RESTCONF_BASE_URL))
1149 response = requests.request(
1150 "DELETE", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
1151 auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1152 self.assertEqual(response.status_code, requests.codes.ok)
1154 def test_42_getClliNetwork(self):
1155 url = ("{}/config/ietf-network:networks/network/clli-network"
1156 .format(test_utils.RESTCONF_BASE_URL))
1157 response = requests.request(
1158 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1159 self.assertEqual(response.status_code, requests.codes.ok)
1160 res = response.json()
1161 self.assertNotIn('node', res['network'][0])
1163 def test_43_getOpenRoadmNetwork(self):
1164 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1165 .format(test_utils.RESTCONF_BASE_URL))
1166 response = requests.request(
1167 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1168 self.assertEqual(response.status_code, requests.codes.ok)
1169 res = response.json()
1170 self.assertNotIn('node', res['network'][0])
1172 def test_44_check_roadm2roadm_link_persistence(self):
1173 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1174 .format(test_utils.RESTCONF_BASE_URL))
1175 response = requests.request(
1176 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
1177 self.assertEqual(response.status_code, requests.codes.ok)
1178 res = response.json()
1179 nbLink = len(res['network'][0]['ietf-network-topology:link'])
1180 self.assertNotIn('node', res['network'][0])
1181 self.assertEqual(nbLink, 6)
1184 if __name__ == "__main__":
1185 unittest.main(verbosity=2)