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 ##############################################################################
24 class TransportPCETopologyTesting(unittest.TestCase):
26 honeynode_process1 = None
27 honeynode_process2 = None
28 honeynode_process3 = None
29 honeynode_process4 = None
31 restconf_baseurl = "http://localhost:8181/restconf"
33 #START_IGNORE_XTESTING
37 print ("starting honeynode1...")
38 cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
41 print ("starting honeynode2...")
42 cls.honeynode_process2 = test_utils.start_roadma_honeynode()
45 print ("starting honeynode3...")
46 cls.honeynode_process3 = test_utils.start_roadmb_honeynode()
49 print ("starting honeynode4...")
50 cls.honeynode_process4 = test_utils.start_roadmc_honeynode()
52 print ("all honeynodes started")
54 print ("starting opendaylight...")
55 cls.odl_process = test_utils.start_tpce()
57 print ("opendaylight started")
60 def tearDownClass(cls):
61 for child in psutil.Process(cls.odl_process.pid).children():
62 child.send_signal(signal.SIGINT)
64 cls.odl_process.send_signal(signal.SIGINT)
65 cls.odl_process.wait()
66 for child in psutil.Process(cls.honeynode_process1.pid).children():
67 child.send_signal(signal.SIGINT)
69 cls.honeynode_process1.send_signal(signal.SIGINT)
70 cls.honeynode_process1.wait()
71 for child in psutil.Process(cls.honeynode_process2.pid).children():
72 child.send_signal(signal.SIGINT)
74 cls.honeynode_process2.send_signal(signal.SIGINT)
75 cls.honeynode_process2.wait()
77 for child in psutil.Process(cls.honeynode_process3.pid).children():
78 child.send_signal(signal.SIGINT)
80 cls.honeynode_process3.send_signal(signal.SIGINT)
81 cls.honeynode_process3.wait()
83 for child in psutil.Process(cls.honeynode_process4.pid).children():
84 child.send_signal(signal.SIGINT)
86 cls.honeynode_process4.send_signal(signal.SIGINT)
87 cls.honeynode_process4.wait()
94 def test_01_connect_ROADMA(self):
96 url = ("{}/config/network-topology:"
97 "network-topology/topology/topology-netconf/node/ROADMA01"
98 .format(self.restconf_baseurl))
100 "node-id": "ROADMA01",
101 "netconf-node-topology:username": "admin",
102 "netconf-node-topology:password": "admin",
103 "netconf-node-topology:host": "127.0.0.1",
104 "netconf-node-topology:port": "17831",
105 "netconf-node-topology:tcp-only": "false",
106 "netconf-node-topology:pass-through": {}}]}
107 headers = {'content-type': 'application/json'}
108 response = requests.request(
109 "PUT", url, data=json.dumps(data), headers=headers,
110 auth=('admin', 'admin'))
111 self.assertEqual(response.status_code, requests.codes.created)
114 def test_02_getClliNetwork(self):
115 url = ("{}/config/ietf-network:networks/network/clli-network"
116 .format(self.restconf_baseurl))
117 headers = {'content-type': 'application/json'}
118 response = requests.request(
119 "GET", url, headers=headers, auth=('admin', 'admin'))
120 self.assertEqual(response.status_code, requests.codes.ok)
121 res = response.json()
122 self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
123 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
125 def test_03_getOpenRoadmNetwork(self):
126 url = ("{}/config/ietf-network:networks/network/openroadm-network"
127 .format(self.restconf_baseurl))
128 headers = {'content-type': 'application/json'}
129 response = requests.request(
130 "GET", url, headers=headers, auth=('admin', 'admin'))
131 self.assertEqual(response.status_code, requests.codes.ok)
132 res = response.json()
133 self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA01')
134 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
135 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
136 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'],'ROADM')
137 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'2')
139 def test_04_getLinks_OpenroadmTopology(self):
140 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
141 .format(self.restconf_baseurl))
142 headers = {'content-type': 'application/json'}
143 response = requests.request(
144 "GET", url, headers=headers, auth=('admin', 'admin'))
145 self.assertEqual(response.status_code, requests.codes.ok)
146 res = response.json()
147 #Tests related to links
148 nbLink=len(res['network'][0]['ietf-network-topology:link'])
149 self.assertEqual(nbLink,10)
150 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
151 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
152 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
153 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
154 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
155 for i in range(0,nbLink):
156 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
157 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
158 find= linkId in expressLink
159 self.assertEqual(find, True)
160 expressLink.remove(linkId)
161 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
162 find= linkId in addLink
163 self.assertEqual(find, True)
164 addLink.remove(linkId)
165 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
166 find= linkId in dropLink
167 self.assertEqual(find, True)
168 dropLink.remove(linkId)
170 self.assertFalse(True)
171 self.assertEqual(len(expressLink),0)
172 self.assertEqual(len(addLink),0)
173 self.assertEqual(len(dropLink),0)
175 def test_05_getNodes_OpenRoadmTopology(self):
176 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
177 .format(self.restconf_baseurl))
178 headers = {'content-type': 'application/json'}
179 response = requests.request(
180 "GET", url, headers=headers, auth=('admin', 'admin'))
181 res = response.json()
182 #Tests related to nodes
183 self.assertEqual(response.status_code, requests.codes.ok)
184 nbNode=len(res['network'][0]['node'])
185 self.assertEqual(nbNode,4)
186 listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
187 for i in range(0,nbNode):
188 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
189 res['network'][0]['node'][i]['supporting-node'])
190 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
191 nodeId=res['network'][0]['node'][i]['node-id']
192 if(nodeId=='ROADMA01-SRG1'):
193 #Test related to SRG1
194 self.assertEqual(nodeType,'SRG')
195 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
196 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
197 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
198 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
199 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
200 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
201 res['network'][0]['node'][i]['supporting-node'])
202 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
203 res['network'][0]['node'][i]['supporting-node'])
204 listNode.remove(nodeId)
205 elif(nodeId=='ROADMA01-SRG3'):
206 #Test related to SRG1
207 self.assertEqual(nodeType,'SRG')
208 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
209 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
210 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
211 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
212 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
213 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
214 res['network'][0]['node'][i]['supporting-node'])
215 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
216 res['network'][0]['node'][i]['supporting-node'])
217 listNode.remove(nodeId)
218 elif(nodeId=='ROADMA01-DEG1'):
219 #Test related to DEG1
220 self.assertEqual(nodeType,'DEGREE')
221 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
222 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
223 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
224 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
225 listNode.remove(nodeId)
226 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
227 res['network'][0]['node'][i]['supporting-node'])
228 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
229 res['network'][0]['node'][i]['supporting-node'])
230 elif(nodeId=='ROADMA01-DEG2'):
231 #Test related to DEG2
232 self.assertEqual(nodeType,'DEGREE')
233 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
234 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
235 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
236 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
237 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
238 res['network'][0]['node'][i]['supporting-node'])
239 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
240 res['network'][0]['node'][i]['supporting-node'])
241 listNode.remove(nodeId)
243 self.assertFalse(True)
244 self.assertEqual(len(listNode),0)
246 def test_06_connect_XPDRA(self):
247 url = ("{}/config/network-topology:"
248 "network-topology/topology/topology-netconf/node/XPDRA01"
249 .format(self.restconf_baseurl))
251 "node-id": "XPDRA01",
252 "netconf-node-topology:username": "admin",
253 "netconf-node-topology:password": "admin",
254 "netconf-node-topology:host": "127.0.0.1",
255 "netconf-node-topology:port": "17830",
256 "netconf-node-topology:tcp-only": "false",
257 "netconf-node-topology:pass-through": {}}]}
258 headers = {'content-type': 'application/json'}
259 response = requests.request(
260 "PUT", url, data=json.dumps(data), headers=headers,
261 auth=('admin', 'admin'))
262 self.assertEqual(response.status_code, requests.codes.created)
265 def test_07_getClliNetwork(self):
266 url = ("{}/config/ietf-network:networks/network/clli-network"
267 .format(self.restconf_baseurl))
268 headers = {'content-type': 'application/json'}
269 response = requests.request(
270 "GET", url, headers=headers, auth=('admin', 'admin'))
271 self.assertEqual(response.status_code, requests.codes.ok)
272 res = response.json()
273 self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
274 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
276 def test_08_getOpenRoadmNetwork(self):
277 url = ("{}/config/ietf-network:networks/network/openroadm-network"
278 .format(self.restconf_baseurl))
279 headers = {'content-type': 'application/json'}
280 response = requests.request(
281 "GET", url, headers=headers, auth=('admin', 'admin'))
282 self.assertEqual(response.status_code, requests.codes.ok)
283 res = response.json()
284 nbNode=len(res['network'][0]['node'])
285 self.assertEqual(nbNode,2)
286 for i in range(0,nbNode):
287 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
288 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
289 nodeId=res['network'][0]['node'][i]['node-id']
290 if(nodeId=='XPDRA01'):
291 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
292 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
293 elif(nodeId=='ROADMA01'):
294 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
295 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
297 self.assertFalse(True)
299 def test_09_getNodes_OpenRoadmTopology(self):
300 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
301 .format(self.restconf_baseurl))
302 headers = {'content-type': 'application/json'}
303 response = requests.request(
304 "GET", url, headers=headers, auth=('admin', 'admin'))
305 res = response.json()
306 #Tests related to nodes
307 self.assertEqual(response.status_code, requests.codes.ok)
308 nbNode=len(res['network'][0]['node'])
309 self.assertEqual(nbNode,5)
310 listNode=['XPDRA01-XPDR1','ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
311 for i in range(0,nbNode):
312 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
313 nodeId=res['network'][0]['node'][i]['node-id']
314 #Tests related to XPDRA nodes
315 if(nodeId=='XPDRA01-XPDR1'):
316 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
317 res['network'][0]['node'][i]['supporting-node'])
318 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
319 res['network'][0]['node'][i]['supporting-node'])
320 self.assertEqual(nodeType,'XPONDER')
321 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
324 for j in range(0,nbTps):
325 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
326 tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
327 if (tpType=='XPONDER-CLIENT'):
329 elif (tpType=='XPONDER-NETWORK'):
331 if (tpId == 'XPDR1-NETWORK2'):
332 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT3')
333 if (tpId == 'XPDR1-CLIENT3'):
334 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
335 self.assertTrue(client == 4)
336 self.assertTrue(network == 2)
337 listNode.remove(nodeId)
338 elif(nodeId=='ROADMA01-SRG1'):
339 #Test related to SRG1
340 self.assertEqual(nodeType,'SRG')
341 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
342 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
343 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
344 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
345 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
346 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
347 res['network'][0]['node'][i]['supporting-node'])
348 listNode.remove(nodeId)
349 elif(nodeId=='ROADMA01-SRG3'):
350 #Test related to SRG1
351 self.assertEqual(nodeType,'SRG')
352 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
353 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
354 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
355 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
356 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
357 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
358 res['network'][0]['node'][i]['supporting-node'])
359 listNode.remove(nodeId)
360 elif(nodeId=='ROADMA01-DEG1'):
361 #Test related to DEG1
362 self.assertEqual(nodeType,'DEGREE')
363 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
364 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
365 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
366 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
367 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
368 res['network'][0]['node'][i]['supporting-node'])
369 listNode.remove(nodeId)
370 elif(nodeId=='ROADMA01-DEG2'):
371 #Test related to DEG2
372 self.assertEqual(nodeType,'DEGREE')
373 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
374 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
375 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
376 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
377 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
378 res['network'][0]['node'][i]['supporting-node'])
379 listNode.remove(nodeId)
381 self.assertFalse(True)
382 self.assertEqual(len(listNode),0)
384 #Connect the tail XPDRA to ROADMA and vice versa
385 def test_10_connect_tail_xpdr_rdm(self):
386 #Connect the tail: XPDRA to ROADMA
387 url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
388 .format(self.restconf_baseurl))
389 data = {"networkutils:input": {
390 "networkutils:links-input": {
391 "networkutils:xpdr-node": "XPDRA01",
392 "networkutils:xpdr-num": "1",
393 "networkutils:network-num": "1",
394 "networkutils:rdm-node": "ROADMA01",
395 "networkutils:srg-num": "1",
396 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
400 headers = {'content-type': 'application/json'}
401 response = requests.request(
402 "POST", url, data=json.dumps(data), headers=headers,
403 auth=('admin', 'admin'))
404 self.assertEqual(response.status_code, requests.codes.ok)
406 def test_11_connect_tail_rdm_xpdr(self):
407 #Connect the tail: ROADMA to XPDRA
408 url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
409 .format(self.restconf_baseurl))
410 data = {"networkutils:input": {
411 "networkutils:links-input": {
412 "networkutils:xpdr-node": "XPDRA01",
413 "networkutils:xpdr-num": "1",
414 "networkutils:network-num": "1",
415 "networkutils:rdm-node": "ROADMA01",
416 "networkutils:srg-num": "1",
417 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
421 headers = {'content-type': 'application/json'}
422 response = requests.request(
423 "POST", url, data=json.dumps(data), headers=headers,
424 auth=('admin', 'admin'))
425 self.assertEqual(response.status_code, requests.codes.ok)
427 def test_12_getLinks_OpenRoadmTopology(self):
428 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
429 .format(self.restconf_baseurl))
430 headers = {'content-type': 'application/json'}
431 response = requests.request(
432 "GET", url, headers=headers, auth=('admin', 'admin'))
433 self.assertEqual(response.status_code, requests.codes.ok)
434 res = response.json()
435 #Tests related to links
436 nbLink=len(res['network'][0]['ietf-network-topology:link'])
437 self.assertEqual(nbLink,12)
438 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
439 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
440 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
441 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
442 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
443 XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
444 XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
445 for i in range(0,nbLink):
446 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
447 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
448 if(nodeType=='EXPRESS-LINK'):
449 find= linkId in expressLink
450 self.assertEqual(find, True)
451 expressLink.remove(linkId)
452 elif(nodeType=='ADD-LINK'):
453 find= linkId in addLink
454 self.assertEqual(find, True)
455 addLink.remove(linkId)
456 elif(nodeType=='DROP-LINK'):
457 find= linkId in dropLink
458 self.assertEqual(find, True)
459 dropLink.remove(linkId)
460 elif(nodeType=='XPONDER-INPUT'):
461 find= linkId in XPDR_IN
462 self.assertEqual(find, True)
463 XPDR_IN.remove(linkId)
464 elif(nodeType=='XPONDER-OUTPUT'):
465 find= linkId in XPDR_OUT
466 self.assertEqual(find, True)
467 XPDR_OUT.remove(linkId)
469 self.assertFalse(True)
470 self.assertEqual(len(expressLink),0)
471 self.assertEqual(len(addLink),0)
472 self.assertEqual(len(dropLink),0)
473 self.assertEqual(len(XPDR_IN),0)
474 self.assertEqual(len(XPDR_OUT),0)
476 def test_13_connect_ROADMC(self):
478 url = ("{}/config/network-topology:"
479 "network-topology/topology/topology-netconf/node/ROADMC01"
480 .format(self.restconf_baseurl))
482 "node-id": "ROADMC01",
483 "netconf-node-topology:username": "admin",
484 "netconf-node-topology:password": "admin",
485 "netconf-node-topology:host": "127.0.0.1",
486 "netconf-node-topology:port": "17833",
487 "netconf-node-topology:tcp-only": "false",
488 "netconf-node-topology:pass-through": {}}]}
489 headers = {'content-type': 'application/json'}
490 response = requests.request(
491 "PUT", url, data=json.dumps(data), headers=headers,
492 auth=('admin', 'admin'))
493 self.assertEqual(response.status_code, requests.codes.created)
496 def test_14_omsAttributes_ROADMA_ROADMC(self):
497 # Config ROADMA01-ROADMC01 oms-attributes
498 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
499 "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
500 "OMS-attributes/span"
501 .format(self.restconf_baseurl))
503 "auto-spanloss": "true",
504 "engineered-spanloss": 12.2,
505 "link-concatenation": [{
508 "SRLG-length": 100000,
510 headers = {'content-type': 'application/json'}
511 response = requests.request(
512 "PUT", url, data=json.dumps(data), headers=headers,
513 auth=('admin', 'admin'))
514 self.assertEqual(response.status_code, requests.codes.created)
516 def test_15_omsAttributes_ROADMC_ROADMA(self):
517 # Config ROADMC01-ROADMA oms-attributes
518 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
519 "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
520 "OMS-attributes/span"
521 .format(self.restconf_baseurl))
523 "auto-spanloss": "true",
524 "engineered-spanloss": 12.2,
525 "link-concatenation": [{
528 "SRLG-length": 100000,
530 headers = {'content-type': 'application/json'}
531 response = requests.request(
532 "PUT", url, data=json.dumps(data), headers=headers,
533 auth=('admin', 'admin'))
534 self.assertEqual(response.status_code, requests.codes.created)
536 def test_16_getClliNetwork(self):
537 url = ("{}/config/ietf-network:networks/network/clli-network"
538 .format(self.restconf_baseurl))
539 headers = {'content-type': 'application/json'}
540 response = requests.request(
541 "GET", url, headers=headers, auth=('admin', 'admin'))
542 self.assertEqual(response.status_code, requests.codes.ok)
543 res = response.json()
544 nbNode=len(res['network'][0]['node'])
545 listNode=['NodeA','NodeC']
546 for i in range(0,nbNode):
547 nodeId = res['network'][0]['node'][i]['node-id']
548 find= nodeId in listNode
549 self.assertEqual(find, True)
551 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
553 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
554 listNode.remove(nodeId)
556 self.assertEqual(len(listNode),0)
558 def test_17_getOpenRoadmNetwork(self):
559 url = ("{}/config/ietf-network:networks/network/openroadm-network"
560 .format(self.restconf_baseurl))
561 headers = {'content-type': 'application/json'}
562 response = requests.request(
563 "GET", url, headers=headers, auth=('admin', 'admin'))
564 self.assertEqual(response.status_code, requests.codes.ok)
565 res = response.json()
566 nbNode=len(res['network'][0]['node'])
567 self.assertEqual(nbNode,3)
568 listNode=['XPDRA01','ROADMA01','ROADMC01']
569 for i in range(0,nbNode):
570 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
571 nodeId=res['network'][0]['node'][i]['node-id']
572 if(nodeId=='XPDRA01'):
573 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
574 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
575 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
576 listNode.remove(nodeId)
577 elif(nodeId=='ROADMA01'):
578 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
579 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
580 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
581 listNode.remove(nodeId)
582 elif(nodeId=='ROADMC01'):
583 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
584 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
585 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
586 listNode.remove(nodeId)
588 self.assertFalse(True)
589 self.assertEqual(len(listNode),0)
591 def test_18_getROADMLinkOpenRoadmTopology(self):
592 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
593 .format(self.restconf_baseurl))
594 headers = {'content-type': 'application/json'}
595 response = requests.request(
596 "GET", url, headers=headers, auth=('admin', 'admin'))
597 self.assertEqual(response.status_code, requests.codes.ok)
598 res = response.json()
599 #Tests related to links
600 nbLink=len(res['network'][0]['ietf-network-topology:link'])
601 self.assertEqual(nbLink,20)
602 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
603 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX','ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
604 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
605 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
606 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX','ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
607 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
608 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
609 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX','ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
610 R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
611 XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
612 XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
613 for i in range(0,nbLink):
614 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
615 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
616 if(nodeType=='EXPRESS-LINK'):
617 find= linkId in expressLink
618 self.assertEqual(find, True)
619 expressLink.remove(linkId)
620 elif(nodeType=='ADD-LINK'):
621 find= linkId in addLink
622 self.assertEqual(find, True)
623 addLink.remove(linkId)
624 elif(nodeType=='DROP-LINK'):
625 find= linkId in dropLink
626 self.assertEqual(find, True)
627 dropLink.remove(linkId)
628 elif(nodeType=='ROADM-TO-ROADM'):
629 find= linkId in R2RLink
630 self.assertEqual(find, True)
631 R2RLink.remove(linkId)
632 elif(nodeType=='XPONDER-INPUT'):
633 find= linkId in XPDR_IN
634 self.assertEqual(find, True)
635 XPDR_IN.remove(linkId)
636 elif(nodeType=='XPONDER-OUTPUT'):
637 find= linkId in XPDR_OUT
638 self.assertEqual(find, True)
639 XPDR_OUT.remove(linkId)
641 self.assertFalse(True)
642 self.assertEqual(len(expressLink),0)
643 self.assertEqual(len(addLink),0)
644 self.assertEqual(len(dropLink),0)
645 self.assertEqual(len(R2RLink),0)
646 self.assertEqual(len(XPDR_IN),0)
647 self.assertEqual(len(XPDR_OUT),0)
649 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
650 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
651 .format(self.restconf_baseurl))
652 headers = {'content-type': 'application/json'}
653 response = requests.request(
654 "GET", url, headers=headers, auth=('admin', 'admin'))
655 self.assertEqual(response.status_code, requests.codes.ok)
656 res = response.json()
657 #Tests related to links
658 nbLink=len(res['network'][0]['ietf-network-topology:link'])
659 self.assertEqual(nbLink,20)
660 R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
661 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
662 for i in range(0,nbLink):
663 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
664 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
665 if(link_id in R2RLink):
667 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
668 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
669 length = res['network'][0]['ietf-network-topology:link'][i][
670 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
671 if((spanLoss!=None)&(length!=None)):
673 self.assertTrue(find)
674 R2RLink.remove(link_id)
675 self.assertEqual(len(R2RLink),0)
677 def test_20_getNodes_OpenRoadmTopology(self):
678 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
679 .format(self.restconf_baseurl))
680 headers = {'content-type': 'application/json'}
681 response = requests.request(
682 "GET", url, headers=headers, auth=('admin', 'admin'))
683 res = response.json()
684 #Tests related to nodes
685 self.assertEqual(response.status_code, requests.codes.ok)
686 nbNode=len(res['network'][0]['node'])
687 self.assertEqual(nbNode,8)
688 listNode=['XPDRA01-XPDR1',
689 'ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2',
690 'ROADMC01-SRG1','ROADMC01-DEG1','ROADMC01-DEG2']
691 #************************Tests related to XPDRA nodes
692 for i in range(0,nbNode):
693 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
694 nodeId=res['network'][0]['node'][i]['node-id']
695 if(nodeId=='XPDRA01-XPDR1'):
696 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
697 res['network'][0]['node'][i]['supporting-node'])
698 self.assertEqual(nodeType,'XPONDER')
699 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
700 self.assertTrue(nbTps == 6)
703 for j in range(0,nbTps):
704 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
705 if (tpType=='XPONDER-CLIENT'):
707 elif (tpType=='XPONDER-NETWORK'):
709 self.assertTrue(client == 4)
710 self.assertTrue(network == 2)
711 listNode.remove(nodeId)
712 elif(nodeId=='ROADMA01-SRG1'):
713 #Test related to SRG1
714 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
715 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
716 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
717 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
718 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
719 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
720 res['network'][0]['node'][i]['supporting-node'])
721 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
722 listNode.remove(nodeId)
723 elif(nodeId=='ROADMA01-SRG3'):
724 #Test related to SRG1
725 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
726 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
727 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
728 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
729 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
730 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
731 res['network'][0]['node'][i]['supporting-node'])
732 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
733 listNode.remove(nodeId)
734 elif(nodeId=='ROADMA01-DEG1'):
735 #Test related to DEG1
736 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
737 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
738 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
739 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
740 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
741 res['network'][0]['node'][i]['supporting-node'])
742 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
743 listNode.remove(nodeId)
744 elif(nodeId=='ROADMA01-DEG2'):
745 #Test related to DEG2
746 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
747 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
748 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
749 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
750 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
751 res['network'][0]['node'][i]['supporting-node'])
752 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
753 listNode.remove(nodeId)
754 elif(nodeId=='ROADMC01-SRG1'):
755 #Test related to SRG1
756 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
757 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
758 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
759 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
760 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
761 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
762 res['network'][0]['node'][i]['supporting-node'])
763 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
764 listNode.remove(nodeId)
765 elif(nodeId=='ROADMC01-DEG1'):
766 #Test related to DEG1
767 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
768 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
769 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
770 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
771 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
772 res['network'][0]['node'][i]['supporting-node'])
773 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
774 listNode.remove(nodeId)
775 elif(nodeId=='ROADMC01-DEG2'):
776 #Test related to DEG2
777 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
778 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
779 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
780 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
781 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
782 res['network'][0]['node'][i]['supporting-node'])
783 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
784 listNode.remove(nodeId)
786 self.assertFalse(True)
787 self.assertEqual(len(listNode),0)
789 def test_21_connect_ROADMB(self):
790 url = ("{}/config/network-topology:"
791 "network-topology/topology/topology-netconf/node/ROADMB01"
792 .format(self.restconf_baseurl))
794 "node-id": "ROADMB01",
795 "netconf-node-topology:username": "admin",
796 "netconf-node-topology:password": "admin",
797 "netconf-node-topology:host": "127.0.0.1",
798 "netconf-node-topology:port": "17832",
799 "netconf-node-topology:tcp-only": "false",
800 "netconf-node-topology:pass-through": {}}]}
801 headers = {'content-type': 'application/json'}
802 response = requests.request(
803 "PUT", url, data=json.dumps(data), headers=headers,
804 auth=('admin', 'admin'))
805 self.assertEqual(response.status_code, requests.codes.created)
808 def test_22_omsAttributes_ROADMA_ROADMB(self):
809 # Config ROADMA01-ROADMB01 oms-attributes
810 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
811 "link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
812 "OMS-attributes/span"
813 .format(self.restconf_baseurl))
815 "auto-spanloss": "true",
816 "engineered-spanloss": 12.2,
817 "link-concatenation": [{
820 "SRLG-length": 100000,
822 headers = {'content-type': 'application/json'}
823 response = requests.request(
824 "PUT", url, data=json.dumps(data), headers=headers,
825 auth=('admin', 'admin'))
826 self.assertEqual(response.status_code, requests.codes.created)
828 def test_23_omsAttributes_ROADMB_ROADMA(self):
829 # Config ROADMB01-ROADMA01 oms-attributes
830 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
831 "link/ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
832 "OMS-attributes/span"
833 .format(self.restconf_baseurl))
835 "auto-spanloss": "true",
836 "engineered-spanloss": 12.2,
837 "link-concatenation": [{
840 "SRLG-length": 100000,
842 headers = {'content-type': 'application/json'}
843 response = requests.request(
844 "PUT", url, data=json.dumps(data), headers=headers,
845 auth=('admin', 'admin'))
846 self.assertEqual(response.status_code, requests.codes.created)
848 def test_24_omsAttributes_ROADMB_ROADMC(self):
849 # Config ROADMB01-ROADMC01 oms-attributes
850 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
851 "link/ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
852 "OMS-attributes/span"
853 .format(self.restconf_baseurl))
855 "auto-spanloss": "true",
856 "engineered-spanloss": 12.2,
857 "link-concatenation": [{
860 "SRLG-length": 100000,
862 headers = {'content-type': 'application/json'}
863 response = requests.request(
864 "PUT", url, data=json.dumps(data), headers=headers,
865 auth=('admin', 'admin'))
866 self.assertEqual(response.status_code, requests.codes.created)
868 def test_25_omsAttributes_ROADMC_ROADMB(self):
869 # Config ROADMC01-ROADMB01 oms-attributes
870 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
871 "link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
872 "OMS-attributes/span"
873 .format(self.restconf_baseurl))
875 "auto-spanloss": "true",
876 "engineered-spanloss": 12.2,
877 "link-concatenation": [{
880 "SRLG-length": 100000,
882 headers = {'content-type': 'application/json'}
883 response = requests.request(
884 "PUT", url, data=json.dumps(data), headers=headers,
885 auth=('admin', 'admin'))
886 self.assertEqual(response.status_code, requests.codes.created)
888 def test_26_getClliNetwork(self):
889 url = ("{}/config/ietf-network:networks/network/clli-network"
890 .format(self.restconf_baseurl))
891 headers = {'content-type': 'application/json'}
892 response = requests.request(
893 "GET", url, headers=headers, auth=('admin', 'admin'))
894 self.assertEqual(response.status_code, requests.codes.ok)
895 res = response.json()
896 nbNode=len(res['network'][0]['node'])
897 listNode=['NodeA','NodeB','NodeC']
898 for i in range(0,nbNode):
899 nodeId = res['network'][0]['node'][i]['node-id']
900 find= nodeId in listNode
901 self.assertEqual(find, True)
903 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
904 elif(nodeId=='NodeB'):
905 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
907 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
908 listNode.remove(nodeId)
909 self.assertEqual(len(listNode),0)
911 def test_27_verifyDegree(self):
912 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
913 .format(self.restconf_baseurl))
914 headers = {'content-type': 'application/json'}
915 response = requests.request(
916 "GET", url, headers=headers, auth=('admin', 'admin'))
917 self.assertEqual(response.status_code, requests.codes.ok)
918 res = response.json()
919 #Tests related to links
920 nbLink=len(res['network'][0]['ietf-network-topology:link'])
921 listR2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
922 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX','ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
923 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX','ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
924 for i in range(0,nbLink):
925 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
926 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
927 find= link_id in listR2RLink
928 self.assertEqual(find, True)
929 listR2RLink.remove(link_id)
930 self.assertEqual(len(listR2RLink),0)
932 def test_28_verifyOppositeLinkTopology(self):
933 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
934 .format(self.restconf_baseurl))
935 headers = {'content-type': 'application/json'}
936 response = requests.request(
937 "GET", url, headers=headers, auth=('admin', 'admin'))
938 self.assertEqual(response.status_code, requests.codes.ok)
939 res = response.json()
940 #Tests related to links
941 nbLink=len(res['network'][0]['ietf-network-topology:link'])
942 self.assertEqual(nbLink,34)
943 for i in range(0,nbLink):
944 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
945 link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
946 link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
947 link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
948 oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
949 #Find the opposite link
950 url_oppLink="{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
951 url = (url_oppLink.format(self.restconf_baseurl))
952 headers = {'content-type': 'application/json'}
953 response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
954 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
955 res_oppLink = response_oppLink.json()
956 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
957 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
958 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
959 oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
960 if link_type=='ADD-LINK':
961 self.assertEqual(oppLink_type, 'DROP-LINK')
962 elif link_type=='DROP-LINK':
963 self.assertEqual(oppLink_type, 'ADD-LINK')
964 elif link_type=='EXPRESS-LINK':
965 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
966 elif link_type=='ROADM-TO-ROADM':
967 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
968 elif link_type=='XPONDER-INPUT':
969 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
970 elif link_type=='XPONDER-OUTPUT':
971 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
973 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
974 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
975 .format(self.restconf_baseurl))
976 headers = {'content-type': 'application/json'}
977 response = requests.request(
978 "GET", url, headers=headers, auth=('admin', 'admin'))
979 self.assertEqual(response.status_code, requests.codes.ok)
980 res = response.json()
981 nbLink=len(res['network'][0]['ietf-network-topology:link'])
982 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
983 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
984 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
985 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
986 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
987 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
988 for i in range(0,nbLink):
989 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
990 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
991 if(link_id in R2RLink):
993 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
994 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
995 length = res['network'][0]['ietf-network-topology:link'][i][
996 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
997 if((spanLoss!=None)&(length!=None)):
999 self.assertTrue(find)
1000 R2RLink.remove(link_id)
1001 self.assertEqual(len(R2RLink),0)
1003 def test_30_disconnect_ROADMB(self):
1004 #Delete in the topology-netconf
1005 url = ("{}/config/network-topology:"
1006 "network-topology/topology/topology-netconf/node/ROADMB01"
1007 .format(self.restconf_baseurl))
1009 headers = {'content-type': 'application/json'}
1010 response = requests.request(
1011 "DELETE", url, data=json.dumps(data), headers=headers,
1012 auth=('admin', 'admin'))
1013 self.assertEqual(response.status_code, requests.codes.ok)
1014 #Delete in the clli-network
1015 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
1016 .format(self.restconf_baseurl))
1018 headers = {'content-type': 'application/json'}
1019 response = requests.request(
1020 "DELETE", url, data=json.dumps(data), headers=headers,
1021 auth=('admin', 'admin'))
1022 self.assertEqual(response.status_code, requests.codes.ok)
1024 def test_31_disconnect_ROADMC(self):
1025 #Delete in the topology-netconf
1026 url = ("{}/config/network-topology:"
1027 "network-topology/topology/topology-netconf/node/ROADMC01"
1028 .format(self.restconf_baseurl))
1030 headers = {'content-type': 'application/json'}
1031 response = requests.request(
1032 "DELETE", url, data=json.dumps(data), headers=headers,
1033 auth=('admin', 'admin'))
1034 self.assertEqual(response.status_code, requests.codes.ok)
1035 #Delete in the clli-network
1036 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
1037 .format(self.restconf_baseurl))
1039 headers = {'content-type': 'application/json'}
1040 response = requests.request(
1041 "DELETE", url, data=json.dumps(data), headers=headers,
1042 auth=('admin', 'admin'))
1043 self.assertEqual(response.status_code, requests.codes.ok)
1045 def test_32_getNodes_OpenRoadmTopology(self):
1046 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1047 .format(self.restconf_baseurl))
1048 headers = {'content-type': 'application/json'}
1049 response = requests.request(
1050 "GET", url, headers=headers, auth=('admin', 'admin'))
1051 res = response.json()
1052 #Tests related to nodes
1053 self.assertEqual(response.status_code, requests.codes.ok)
1054 nbNode=len(res['network'][0]['node'])
1055 self.assertEqual(nbNode,5)
1056 listNode=['XPDRA01-XPDR1','ROADMA01-SRG1', 'ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
1057 for i in range(0,nbNode):
1058 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1059 nodeId=res['network'][0]['node'][i]['node-id']
1060 #Tests related to XPDRA nodes
1061 if(nodeId=='XPDRA01-XPDR1'):
1062 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1063 for j in range(0, nbTp):
1064 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
1065 if (tpid == 'XPDR1-CLIENT1'):
1066 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1067 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
1068 if (tpid == 'XPDR1-NETWORK1'):
1069 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1070 ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
1071 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1072 ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
1073 'ROADMA01-SRG1--SRG1-PP1-TXRX')
1074 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
1075 res['network'][0]['node'][i]['supporting-node'])
1076 listNode.remove(nodeId)
1077 elif(nodeId=='ROADMA01-SRG1'):
1078 #Test related to SRG1
1079 self.assertEqual(nodeType,'SRG')
1080 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1081 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1082 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1083 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1084 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1085 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1086 res['network'][0]['node'][i]['supporting-node'])
1087 listNode.remove(nodeId)
1088 elif(nodeId=='ROADMA01-SRG3'):
1089 #Test related to SRG1
1090 self.assertEqual(nodeType,'SRG')
1091 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1092 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1093 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1094 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1095 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1096 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1097 res['network'][0]['node'][i]['supporting-node'])
1098 listNode.remove(nodeId)
1099 elif(nodeId=='ROADMA01-DEG1'):
1100 #Test related to DEG1
1101 self.assertEqual(nodeType,'DEGREE')
1102 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1103 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1104 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1105 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1106 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1107 res['network'][0]['node'][i]['supporting-node'])
1108 listNode.remove(nodeId)
1109 elif(nodeId=='ROADMA01-DEG2'):
1110 #Test related to DEG2
1111 self.assertEqual(nodeType,'DEGREE')
1112 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1113 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1114 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1115 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1116 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1117 res['network'][0]['node'][i]['supporting-node'])
1118 listNode.remove(nodeId)
1120 self.assertFalse(True)
1121 self.assertEqual(len(listNode),0)
1122 #Test related to SRG1 of ROADMC
1123 for i in range(0,nbNode):
1124 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-SRG1')
1125 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG1')
1126 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG2')
1128 def test_33_getOpenRoadmNetwork(self):
1129 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1130 .format(self.restconf_baseurl))
1131 headers = {'content-type': 'application/json'}
1132 response = requests.request(
1133 "GET", url, headers=headers, auth=('admin', 'admin'))
1134 self.assertEqual(response.status_code, requests.codes.ok)
1135 res = response.json()
1136 nbNode=len(res['network'][0]['node'])
1137 self.assertEqual(nbNode,2)
1138 for i in range(0,nbNode-1):
1139 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01')
1140 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB01')
1142 def test_34_getClliNetwork(self):
1143 url = ("{}/config/ietf-network:networks/network/clli-network"
1144 .format(self.restconf_baseurl))
1145 headers = {'content-type': 'application/json'}
1146 response = requests.request(
1147 "GET", url, headers=headers, auth=('admin', 'admin'))
1148 self.assertEqual(response.status_code, requests.codes.ok)
1149 res = response.json()
1150 nbNode=len(res['network'][0]['node'])
1151 self.assertEqual(nbNode,1)
1152 for i in range(0,nbNode-1):
1153 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
1155 def test_35_disconnect_XPDRA(self):
1156 url = ("{}/config/network-topology:"
1157 "network-topology/topology/topology-netconf/node/XPDRA01"
1158 .format(self.restconf_baseurl))
1160 headers = {'content-type': 'application/json'}
1161 response = requests.request(
1162 "DELETE", url, data=json.dumps(data), headers=headers,
1163 auth=('admin', 'admin'))
1164 self.assertEqual(response.status_code, requests.codes.ok)
1166 def test_36_getClliNetwork(self):
1167 url = ("{}/config/ietf-network:networks/network/clli-network"
1168 .format(self.restconf_baseurl))
1169 headers = {'content-type': 'application/json'}
1170 response = requests.request(
1171 "GET", url, headers=headers, auth=('admin', 'admin'))
1172 self.assertEqual(response.status_code, requests.codes.ok)
1173 res = response.json()
1174 nbNode=len(res['network'][0]['node'])
1175 self.assertEqual(nbNode,1)
1176 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
1178 def test_37_getOpenRoadmNetwork(self):
1179 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1180 .format(self.restconf_baseurl))
1181 headers = {'content-type': 'application/json'}
1182 response = requests.request(
1183 "GET", url, headers=headers, auth=('admin', 'admin'))
1184 self.assertEqual(response.status_code, requests.codes.ok)
1185 res = response.json()
1186 nbNode=len(res['network'][0]['node'])
1187 self.assertEqual(nbNode,1)
1188 for i in range(0,nbNode):
1189 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA01')
1191 def test_38_getNodes_OpenRoadmTopology(self):
1192 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1193 .format(self.restconf_baseurl))
1194 headers = {'content-type': 'application/json'}
1195 response = requests.request(
1196 "GET", url, headers=headers, auth=('admin', 'admin'))
1197 res = response.json()
1198 #Tests related to nodes
1199 self.assertEqual(response.status_code, requests.codes.ok)
1200 nbNode=len(res['network'][0]['node'])
1201 self.assertEqual(nbNode,4)
1202 listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
1203 for i in range(0,nbNode):
1204 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1205 res['network'][0]['node'][i]['supporting-node'])
1206 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1207 nodeId=res['network'][0]['node'][i]['node-id']
1208 if(nodeId=='ROADMA01-SRG1'):
1209 #Test related to SRG1
1210 self.assertEqual(nodeType,'SRG')
1211 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1212 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1213 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1214 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1215 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1216 listNode.remove(nodeId)
1217 elif(nodeId=='ROADMA01-SRG3'):
1218 #Test related to SRG1
1219 self.assertEqual(nodeType,'SRG')
1220 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1221 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1222 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1223 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1224 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1225 listNode.remove(nodeId)
1226 elif(nodeId=='ROADMA01-DEG1'):
1227 #Test related to DEG1
1228 self.assertEqual(nodeType,'DEGREE')
1229 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1230 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1231 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1232 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1233 listNode.remove(nodeId)
1234 elif(nodeId=='ROADMA01-DEG2'):
1235 #Test related to DEG2
1236 self.assertEqual(nodeType,'DEGREE')
1237 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1238 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1239 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1240 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1241 listNode.remove(nodeId)
1243 self.assertFalse(True)
1244 self.assertEqual(len(listNode),0)
1246 def test_39_disconnect_ROADM_XPDRA_link(self):
1248 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1249 "link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
1250 .format(self.restconf_baseurl))
1252 headers = {'content-type': 'application/json'}
1253 response = requests.request(
1254 "DELETE", url, data=json.dumps(data), headers=headers,
1255 auth=('admin', 'admin'))
1256 self.assertEqual(response.status_code, requests.codes.ok)
1258 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1259 "link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
1260 .format(self.restconf_baseurl))
1262 headers = {'content-type': 'application/json'}
1263 response = requests.request(
1264 "DELETE", url, data=json.dumps(data), headers=headers,
1265 auth=('admin', 'admin'))
1266 self.assertEqual(response.status_code, requests.codes.ok)
1268 def test_40_getLinks_OpenRoadmTopology(self):
1269 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1270 .format(self.restconf_baseurl))
1271 headers = {'content-type': 'application/json'}
1272 response = requests.request(
1273 "GET", url, headers=headers, auth=('admin', 'admin'))
1274 self.assertEqual(response.status_code, requests.codes.ok)
1275 res = response.json()
1276 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1277 self.assertEqual(nbLink,16)
1278 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
1279 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
1280 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
1281 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
1282 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
1283 roadmtoroadmLink = 0
1284 for i in range(0,nbLink):
1285 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
1286 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1287 find= link_id in expressLink
1288 self.assertEqual(find, True)
1289 expressLink.remove(link_id)
1290 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
1291 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1292 find= link_id in addLink
1293 self.assertEqual(find, True)
1294 addLink.remove(link_id)
1295 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
1296 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1297 find= link_id in dropLink
1298 self.assertEqual(find, True)
1299 dropLink.remove(link_id)
1301 roadmtoroadmLink += 1
1302 self.assertEqual(len(expressLink),0)
1303 self.assertEqual(len(addLink),0)
1304 self.assertEqual(len(dropLink),0)
1305 self.assertEqual(roadmtoroadmLink, 6)
1306 for i in range(0,nbLink):
1307 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
1308 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
1310 def test_41_disconnect_ROADMA(self):
1311 url = ("{}/config/network-topology:"
1312 "network-topology/topology/topology-netconf/node/ROADMA01"
1313 .format(self.restconf_baseurl))
1315 headers = {'content-type': 'application/json'}
1316 response = requests.request(
1317 "DELETE", url, data=json.dumps(data), headers=headers,
1318 auth=('admin', 'admin'))
1319 self.assertEqual(response.status_code, requests.codes.ok)
1320 #Delete in the clli-network
1321 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1322 .format(self.restconf_baseurl))
1324 headers = {'content-type': 'application/json'}
1325 response = requests.request(
1326 "DELETE", url, data=json.dumps(data), headers=headers,
1327 auth=('admin', 'admin'))
1328 self.assertEqual(response.status_code, requests.codes.ok)
1330 def test_42_getClliNetwork(self):
1331 url = ("{}/config/ietf-network:networks/network/clli-network"
1332 .format(self.restconf_baseurl))
1333 headers = {'content-type': 'application/json'}
1334 response = requests.request(
1335 "GET", url, headers=headers, auth=('admin', 'admin'))
1336 self.assertEqual(response.status_code, requests.codes.ok)
1337 res = response.json()
1338 self.assertNotIn('node', res['network'][0])
1340 def test_43_getOpenRoadmNetwork(self):
1341 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1342 .format(self.restconf_baseurl))
1343 headers = {'content-type': 'application/json'}
1344 response = requests.request(
1345 "GET", url, headers=headers, auth=('admin', 'admin'))
1346 self.assertEqual(response.status_code, requests.codes.ok)
1347 res = response.json()
1348 self.assertNotIn('node', res['network'][0])
1350 def test_44_check_roadm2roadm_link_persistence(self):
1351 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1352 .format(self.restconf_baseurl))
1353 headers = {'content-type': 'application/json'}
1354 response = requests.request(
1355 "GET", url, headers=headers, auth=('admin', 'admin'))
1356 self.assertEqual(response.status_code, requests.codes.ok)
1357 res = response.json()
1358 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1359 self.assertNotIn('node', res['network'][0])
1360 self.assertEqual(nbLink, 6)
1362 if __name__ == "__main__":
1363 unittest.main(verbosity=2)