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 ##############################################################################
23 class TransportPCETopologyTesting(unittest.TestCase):
25 honeynode_process1 = None
26 honeynode_process2 = None
27 honeynode_process3 = None
28 honeynode_process4 = None
30 restconf_baseurl = "http://localhost:8181/restconf"
32 #START_IGNORE_XTESTING
35 def __start_honeynode1(cls):
36 executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
37 "/honeynode-distribution-1.18.01/honeycomb-tpce")
38 if os.path.isfile(executable):
39 with open('honeynode1.log', 'w') as outfile:
40 cls.honeynode_process1 = subprocess.Popen(
41 [executable, "17830", "sample_configs/openroadm/2.1/oper-XPDRA.xml"],
45 def __start_honeynode2(cls):
46 executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
47 "/honeynode-distribution-1.18.01/honeycomb-tpce")
48 if os.path.isfile(executable):
49 with open('honeynode2.log', 'w') as outfile:
50 cls.honeynode_process2 = subprocess.Popen(
51 [executable, "17831", "sample_configs/openroadm/2.1/oper-ROADMA.xml"],
55 def __start_honeynode3(cls):
56 executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
57 "/honeynode-distribution-1.18.01/honeycomb-tpce")
58 if os.path.isfile(executable):
59 with open('honeynode3.log', 'w') as outfile:
60 cls.honeynode_process3 = subprocess.Popen(
61 [executable, "17832", "sample_configs/openroadm/2.1/oper-ROADMB.xml"],
65 def __start_honeynode4(cls):
66 executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
67 "/honeynode-distribution-1.18.01/honeycomb-tpce")
68 if os.path.isfile(executable):
69 with open('honeynode4.log', 'w') as outfile:
70 cls.honeynode_process4 = subprocess.Popen(
71 [executable, "17833", "sample_configs/openroadm/2.1/oper-ROADMC.xml"],
76 executable = "../karaf/target/assembly/bin/karaf"
77 with open('odl.log', 'w') as outfile:
78 cls.odl_process = subprocess.Popen(
79 ["bash", executable, "server"], stdout=outfile,
80 stdin=open(os.devnull))
84 cls.__start_honeynode1()
86 cls.__start_honeynode2()
88 cls.__start_honeynode3()
90 cls.__start_honeynode4()
96 def tearDownClass(cls):
97 for child in psutil.Process(cls.odl_process.pid).children():
98 child.send_signal(signal.SIGINT)
100 cls.odl_process.send_signal(signal.SIGINT)
101 cls.odl_process.wait()
102 for child in psutil.Process(cls.honeynode_process1.pid).children():
103 child.send_signal(signal.SIGINT)
105 cls.honeynode_process1.send_signal(signal.SIGINT)
106 cls.honeynode_process1.wait()
107 for child in psutil.Process(cls.honeynode_process2.pid).children():
108 child.send_signal(signal.SIGINT)
110 cls.honeynode_process2.send_signal(signal.SIGINT)
111 cls.honeynode_process2.wait()
113 for child in psutil.Process(cls.honeynode_process3.pid).children():
114 child.send_signal(signal.SIGINT)
116 cls.honeynode_process3.send_signal(signal.SIGINT)
117 cls.honeynode_process3.wait()
119 for child in psutil.Process(cls.honeynode_process4.pid).children():
120 child.send_signal(signal.SIGINT)
122 cls.honeynode_process4.send_signal(signal.SIGINT)
123 cls.honeynode_process4.wait()
130 def test_01_connect_ROADMA(self):
132 url = ("{}/config/network-topology:"
133 "network-topology/topology/topology-netconf/node/ROADMA"
134 .format(self.restconf_baseurl))
137 "netconf-node-topology:username": "admin",
138 "netconf-node-topology:password": "admin",
139 "netconf-node-topology:host": "127.0.0.1",
140 "netconf-node-topology:port": "17831",
141 "netconf-node-topology:tcp-only": "false",
142 "netconf-node-topology:pass-through": {}}]}
143 headers = {'content-type': 'application/json'}
144 response = requests.request(
145 "PUT", url, data=json.dumps(data), headers=headers,
146 auth=('admin', 'admin'))
147 self.assertEqual(response.status_code, requests.codes.created)
150 def test_02_getClliNetwork(self):
151 url = ("{}/config/ietf-network:networks/network/clli-network"
152 .format(self.restconf_baseurl))
153 headers = {'content-type': 'application/json'}
154 response = requests.request(
155 "GET", url, headers=headers, auth=('admin', 'admin'))
156 self.assertEqual(response.status_code, requests.codes.ok)
157 res = response.json()
158 self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
159 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
161 def test_03_getOpenRoadmNetwork(self):
162 url = ("{}/config/ietf-network:networks/network/openroadm-network"
163 .format(self.restconf_baseurl))
164 headers = {'content-type': 'application/json'}
165 response = requests.request(
166 "GET", url, headers=headers, auth=('admin', 'admin'))
167 self.assertEqual(response.status_code, requests.codes.ok)
168 res = response.json()
169 self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA')
170 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
171 self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
172 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:node-type'],'ROADM')
173 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'2')
175 def test_04_getLinks_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 self.assertEqual(response.status_code, requests.codes.ok)
182 res = response.json()
183 #Tests related to links
184 nbLink=len(res['network'][0]['ietf-network-topology:link'])
185 self.assertEqual(nbLink,10)
186 expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
187 addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
188 'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
189 dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
190 'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX']
191 for i in range(0,nbLink):
192 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
193 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='EXPRESS-LINK'):
194 find= linkId in expressLink
195 self.assertEqual(find, True)
196 expressLink.remove(linkId)
197 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='ADD-LINK'):
198 find= linkId in addLink
199 self.assertEqual(find, True)
200 addLink.remove(linkId)
201 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='DROP-LINK'):
202 find= linkId in dropLink
203 self.assertEqual(find, True)
204 dropLink.remove(linkId)
206 self.assertFalse(True)
207 self.assertEqual(len(expressLink),0)
208 self.assertEqual(len(addLink),0)
209 self.assertEqual(len(dropLink),0)
211 def test_05_getNodes_OpenRoadmTopology(self):
212 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
213 .format(self.restconf_baseurl))
214 headers = {'content-type': 'application/json'}
215 response = requests.request(
216 "GET", url, headers=headers, auth=('admin', 'admin'))
217 res = response.json()
218 #Tests related to nodes
219 self.assertEqual(response.status_code, requests.codes.ok)
220 nbNode=len(res['network'][0]['node'])
221 self.assertEqual(nbNode,4)
222 listNode=['ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
223 for i in range(0,nbNode):
224 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
225 res['network'][0]['node'][i]['supporting-node'])
226 nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
227 nodeId=res['network'][0]['node'][i]['node-id']
228 if(nodeId=='ROADMA-SRG1'):
229 #Test related to SRG1
230 self.assertEqual(nodeType,'SRG')
231 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
232 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
233 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
234 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
235 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
236 listNode.remove(nodeId)
237 elif(nodeId=='ROADMA-SRG3'):
238 #Test related to SRG1
239 self.assertEqual(nodeType,'SRG')
240 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
241 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
242 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
243 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
244 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
245 listNode.remove(nodeId)
246 elif(nodeId=='ROADMA-DEG1'):
247 #Test related to DEG1
248 self.assertEqual(nodeType,'DEGREE')
249 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
250 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
251 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
252 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
253 listNode.remove(nodeId)
254 elif(nodeId=='ROADMA-DEG2'):
255 #Test related to DEG2
256 self.assertEqual(nodeType,'DEGREE')
257 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
258 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
259 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
260 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
261 listNode.remove(nodeId)
263 self.assertFalse(True)
264 self.assertEqual(len(listNode),0)
266 def test_06_connect_XPDRA(self):
267 url = ("{}/config/network-topology:"
268 "network-topology/topology/topology-netconf/node/XPDRA"
269 .format(self.restconf_baseurl))
272 "netconf-node-topology:username": "admin",
273 "netconf-node-topology:password": "admin",
274 "netconf-node-topology:host": "127.0.0.1",
275 "netconf-node-topology:port": "17830",
276 "netconf-node-topology:tcp-only": "false",
277 "netconf-node-topology:pass-through": {}}]}
278 headers = {'content-type': 'application/json'}
279 response = requests.request(
280 "PUT", url, data=json.dumps(data), headers=headers,
281 auth=('admin', 'admin'))
282 self.assertEqual(response.status_code, requests.codes.created)
285 def test_07_getClliNetwork(self):
286 url = ("{}/config/ietf-network:networks/network/clli-network"
287 .format(self.restconf_baseurl))
288 headers = {'content-type': 'application/json'}
289 response = requests.request(
290 "GET", url, headers=headers, auth=('admin', 'admin'))
291 self.assertEqual(response.status_code, requests.codes.ok)
292 res = response.json()
293 self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
294 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
296 def test_08_getOpenRoadmNetwork(self):
297 url = ("{}/config/ietf-network:networks/network/openroadm-network"
298 .format(self.restconf_baseurl))
299 headers = {'content-type': 'application/json'}
300 response = requests.request(
301 "GET", url, headers=headers, auth=('admin', 'admin'))
302 self.assertEqual(response.status_code, requests.codes.ok)
303 res = response.json()
304 nbNode=len(res['network'][0]['node'])
305 self.assertEqual(nbNode,2)
306 for i in range(0,nbNode):
307 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
308 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
309 nodeId=res['network'][0]['node'][i]['node-id']
311 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'XPONDER')
312 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
313 elif(nodeId=='ROADMA'):
314 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
315 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
317 self.assertFalse(True)
319 def test_09_getNodes_OpenRoadmTopology(self):
320 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
321 .format(self.restconf_baseurl))
322 headers = {'content-type': 'application/json'}
323 response = requests.request(
324 "GET", url, headers=headers, auth=('admin', 'admin'))
325 res = response.json()
326 #Tests related to nodes
327 self.assertEqual(response.status_code, requests.codes.ok)
328 nbNode=len(res['network'][0]['node'])
329 self.assertEqual(nbNode,5)
330 listNode=['XPDRA-XPDR1','ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
331 for i in range(0,nbNode):
332 nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
333 nodeId=res['network'][0]['node'][i]['node-id']
334 #Tests related to XPDRA nodes
335 if(nodeId=='XPDRA-XPDR1'):
336 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
337 res['network'][0]['node'][i]['supporting-node'])
338 self.assertEqual(nodeType,'XPONDER')
339 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
342 for j in range(0,nbTps):
343 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-network-topology:tp-type']
344 tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
345 if (tpType=='XPONDER-CLIENT'):
347 elif (tpType=='XPONDER-NETWORK'):
349 if (tpId == 'XPDR1-NETWORK2'):
350 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT3')
351 if (tpId == 'XPDR1-CLIENT3'):
352 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
353 self.assertTrue(client == 4)
354 self.assertTrue(network == 2)
355 listNode.remove(nodeId)
356 elif(nodeId=='ROADMA-SRG1'):
357 #Test related to SRG1
358 self.assertEqual(nodeType,'SRG')
359 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
360 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
361 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
362 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
363 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
364 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
365 res['network'][0]['node'][i]['supporting-node'])
366 listNode.remove(nodeId)
367 elif(nodeId=='ROADMA-SRG3'):
368 #Test related to SRG1
369 self.assertEqual(nodeType,'SRG')
370 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
371 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
372 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
373 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
374 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
375 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
376 res['network'][0]['node'][i]['supporting-node'])
377 listNode.remove(nodeId)
378 elif(nodeId=='ROADMA-DEG1'):
379 #Test related to DEG1
380 self.assertEqual(nodeType,'DEGREE')
381 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
382 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
383 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
384 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
385 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
386 res['network'][0]['node'][i]['supporting-node'])
387 listNode.remove(nodeId)
388 elif(nodeId=='ROADMA-DEG2'):
389 #Test related to DEG2
390 self.assertEqual(nodeType,'DEGREE')
391 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
392 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
393 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
394 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
395 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
396 res['network'][0]['node'][i]['supporting-node'])
397 listNode.remove(nodeId)
399 self.assertFalse(True)
400 self.assertEqual(len(listNode),0)
402 #Connect the tail XPDRA to ROADMA and vice versa
403 def test_10_connect_tail_xpdr_rdm(self):
404 #Connect the tail: XPDRA to ROADMA
405 url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
406 .format(self.restconf_baseurl))
407 data = {"networkutils:input": {
408 "networkutils:links-input": {
409 "networkutils:xpdr-node": "XPDRA",
410 "networkutils:xpdr-num": "1",
411 "networkutils:network-num": "1",
412 "networkutils:rdm-node": "ROADMA",
413 "networkutils:srg-num": "1",
414 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
418 headers = {'content-type': 'application/json'}
419 response = requests.request(
420 "POST", url, data=json.dumps(data), headers=headers,
421 auth=('admin', 'admin'))
422 self.assertEqual(response.status_code, requests.codes.ok)
425 def test_11_connect_tail_rdm_xpdr(self):
426 #Connect the tail: ROADMA to XPDRA
427 url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
428 .format(self.restconf_baseurl))
429 data = {"networkutils:input": {
430 "networkutils:links-input": {
431 "networkutils:xpdr-node": "XPDRA",
432 "networkutils:xpdr-num": "1",
433 "networkutils:network-num": "1",
434 "networkutils:rdm-node": "ROADMA",
435 "networkutils:srg-num": "1",
436 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
440 headers = {'content-type': 'application/json'}
441 response = requests.request(
442 "POST", url, data=json.dumps(data), headers=headers,
443 auth=('admin', 'admin'))
444 self.assertEqual(response.status_code, requests.codes.ok)
447 def test_12_getLinks_OpenRoadmTopology(self):
448 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
449 .format(self.restconf_baseurl))
450 headers = {'content-type': 'application/json'}
451 response = requests.request(
452 "GET", url, headers=headers, auth=('admin', 'admin'))
453 self.assertEqual(response.status_code, requests.codes.ok)
454 res = response.json()
455 #Tests related to links
456 nbLink=len(res['network'][0]['ietf-network-topology:link'])
457 self.assertEqual(nbLink,12)
458 expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
459 addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
460 'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
461 dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
462 'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX']
463 XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
464 XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
465 for i in range(0,nbLink):
466 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
467 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
468 if(nodeType=='EXPRESS-LINK'):
469 find= linkId in expressLink
470 self.assertEqual(find, True)
471 expressLink.remove(linkId)
472 elif(nodeType=='ADD-LINK'):
473 find= linkId in addLink
474 self.assertEqual(find, True)
475 addLink.remove(linkId)
476 elif(nodeType=='DROP-LINK'):
477 find= linkId in dropLink
478 self.assertEqual(find, True)
479 dropLink.remove(linkId)
480 elif(nodeType=='XPONDER-INPUT'):
481 find= linkId in XPDR_IN
482 self.assertEqual(find, True)
483 XPDR_IN.remove(linkId)
484 elif(nodeType=='XPONDER-OUTPUT'):
485 find= linkId in XPDR_OUT
486 self.assertEqual(find, True)
487 XPDR_OUT.remove(linkId)
489 self.assertFalse(True)
490 self.assertEqual(len(expressLink),0)
491 self.assertEqual(len(addLink),0)
492 self.assertEqual(len(dropLink),0)
493 self.assertEqual(len(XPDR_IN),0)
494 self.assertEqual(len(XPDR_OUT),0)
496 def test_13_connect_ROADMC(self):
498 url = ("{}/config/network-topology:"
499 "network-topology/topology/topology-netconf/node/ROADMC"
500 .format(self.restconf_baseurl))
503 "netconf-node-topology:username": "admin",
504 "netconf-node-topology:password": "admin",
505 "netconf-node-topology:host": "127.0.0.1",
506 "netconf-node-topology:port": "17833",
507 "netconf-node-topology:tcp-only": "false",
508 "netconf-node-topology:pass-through": {}}]}
509 headers = {'content-type': 'application/json'}
510 response = requests.request(
511 "PUT", url, data=json.dumps(data), headers=headers,
512 auth=('admin', 'admin'))
513 self.assertEqual(response.status_code, requests.codes.created)
516 def test_14_omsAttributes_ROADMA_ROADMC(self):
517 # Config ROADMA-ROADMC oms-attributes
518 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
519 "link/ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
520 "OMS-attributes/span"
521 .format(self.restconf_baseurl))
524 "auto-spanloss": "true",
525 "engineered-spanloss": 12.2,
526 "link-concatenation": [{
529 "SRLG-length": 100000,
531 headers = {'content-type': 'application/json'}
532 response = requests.request(
533 "PUT", url, data=json.dumps(data), headers=headers,
534 auth=('admin', 'admin'))
535 self.assertEqual(response.status_code, requests.codes.created)
537 def test_15_omsAttributes_ROADMC_ROADMA(self):
538 # Config ROADMC-ROADMA oms-attributes
539 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
540 "link/ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
541 "OMS-attributes/span"
542 .format(self.restconf_baseurl))
545 "auto-spanloss": "true",
546 "engineered-spanloss": 12.2,
547 "link-concatenation": [{
550 "SRLG-length": 100000,
552 headers = {'content-type': 'application/json'}
553 response = requests.request(
554 "PUT", url, data=json.dumps(data), headers=headers,
555 auth=('admin', 'admin'))
556 self.assertEqual(response.status_code, requests.codes.created)
558 def test_16_getClliNetwork(self):
559 url = ("{}/config/ietf-network:networks/network/clli-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 listNode=['NodeA','NodeC']
568 for i in range(0,nbNode):
569 nodeId = res['network'][0]['node'][i]['node-id']
570 find= nodeId in listNode
571 self.assertEqual(find, True)
573 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
575 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
576 listNode.remove(nodeId)
578 self.assertEqual(len(listNode),0)
580 def test_17_getOpenRoadmNetwork(self):
581 url = ("{}/config/ietf-network:networks/network/openroadm-network"
582 .format(self.restconf_baseurl))
583 headers = {'content-type': 'application/json'}
584 response = requests.request(
585 "GET", url, headers=headers, auth=('admin', 'admin'))
586 self.assertEqual(response.status_code, requests.codes.ok)
587 res = response.json()
588 nbNode=len(res['network'][0]['node'])
589 self.assertEqual(nbNode,3)
590 listNode=['XPDRA','ROADMA','ROADMC']
591 for i in range(0,nbNode):
592 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
593 nodeId=res['network'][0]['node'][i]['node-id']
595 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
596 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'XPONDER')
597 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
598 listNode.remove(nodeId)
599 elif(nodeId=='ROADMA'):
600 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
601 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
602 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
603 listNode.remove(nodeId)
604 elif(nodeId=='ROADMC'):
605 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
606 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
607 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
608 listNode.remove(nodeId)
610 self.assertFalse(True)
611 self.assertEqual(len(listNode),0)
613 def test_18_getROADMLinkOpenRoadmTopology(self):
614 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
615 .format(self.restconf_baseurl))
616 headers = {'content-type': 'application/json'}
617 response = requests.request(
618 "GET", url, headers=headers, auth=('admin', 'admin'))
619 self.assertEqual(response.status_code, requests.codes.ok)
620 res = response.json()
621 #Tests related to links
622 nbLink=len(res['network'][0]['ietf-network-topology:link'])
623 self.assertEqual(nbLink,20)
624 expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX',
625 'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX','ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX']
626 addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
627 'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
628 'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX','ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX']
629 dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
630 'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX',
631 'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX','ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX']
632 R2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX']
633 XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
634 XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
635 for i in range(0,nbLink):
636 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
637 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
638 if(nodeType=='EXPRESS-LINK'):
639 find= linkId in expressLink
640 self.assertEqual(find, True)
641 expressLink.remove(linkId)
642 elif(nodeType=='ADD-LINK'):
643 find= linkId in addLink
644 self.assertEqual(find, True)
645 addLink.remove(linkId)
646 elif(nodeType=='DROP-LINK'):
647 find= linkId in dropLink
648 self.assertEqual(find, True)
649 dropLink.remove(linkId)
650 elif(nodeType=='ROADM-TO-ROADM'):
651 find= linkId in R2RLink
652 self.assertEqual(find, True)
653 R2RLink.remove(linkId)
654 elif(nodeType=='XPONDER-INPUT'):
655 find= linkId in XPDR_IN
656 self.assertEqual(find, True)
657 XPDR_IN.remove(linkId)
658 elif(nodeType=='XPONDER-OUTPUT'):
659 find= linkId in XPDR_OUT
660 self.assertEqual(find, True)
661 XPDR_OUT.remove(linkId)
663 self.assertFalse(True)
664 self.assertEqual(len(expressLink),0)
665 self.assertEqual(len(addLink),0)
666 self.assertEqual(len(dropLink),0)
667 self.assertEqual(len(R2RLink),0)
668 self.assertEqual(len(XPDR_IN),0)
669 self.assertEqual(len(XPDR_OUT),0)
671 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
672 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
673 .format(self.restconf_baseurl))
674 headers = {'content-type': 'application/json'}
675 response = requests.request(
676 "GET", url, headers=headers, auth=('admin', 'admin'))
677 self.assertEqual(response.status_code, requests.codes.ok)
678 res = response.json()
679 #Tests related to links
680 nbLink=len(res['network'][0]['ietf-network-topology:link'])
681 self.assertEqual(nbLink,20)
682 R2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX',
683 'ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX']
684 for i in range(0,nbLink):
685 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
686 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
687 if(link_id in R2RLink):
689 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
690 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
691 length = res['network'][0]['ietf-network-topology:link'][i][
692 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
693 if((spanLoss!=None)&(length!=None)):
695 self.assertTrue(find)
696 R2RLink.remove(link_id)
697 self.assertEqual(len(R2RLink),0)
699 def test_20_getNodes_OpenRoadmTopology(self):
700 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
701 .format(self.restconf_baseurl))
702 headers = {'content-type': 'application/json'}
703 response = requests.request(
704 "GET", url, headers=headers, auth=('admin', 'admin'))
705 res = response.json()
706 #Tests related to nodes
707 self.assertEqual(response.status_code, requests.codes.ok)
708 nbNode=len(res['network'][0]['node'])
709 self.assertEqual(nbNode,8)
710 listNode=['XPDRA-XPDR1',
711 'ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2',
712 'ROADMC-SRG1','ROADMC-DEG1','ROADMC-DEG2']
713 #************************Tests related to XPDRA nodes
714 for i in range(0,nbNode):
715 nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
716 nodeId=res['network'][0]['node'][i]['node-id']
717 if(nodeId=='XPDRA-XPDR1'):
718 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
719 res['network'][0]['node'][i]['supporting-node'])
720 self.assertEqual(nodeType,'XPONDER')
721 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
722 self.assertTrue(nbTps == 6)
725 for j in range(0,nbTps):
726 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-network-topology:tp-type']
727 if (tpType=='XPONDER-CLIENT'):
729 elif (tpType=='XPONDER-NETWORK'):
731 self.assertTrue(client == 4)
732 self.assertTrue(network == 2)
733 listNode.remove(nodeId)
734 elif(nodeId=='ROADMA-SRG1'):
735 #Test related to SRG1
736 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
737 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
738 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
739 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
740 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
741 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
742 res['network'][0]['node'][i]['supporting-node'])
743 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
744 listNode.remove(nodeId)
745 elif(nodeId=='ROADMA-SRG3'):
746 #Test related to SRG1
747 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
748 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
749 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
750 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
751 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
752 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
753 res['network'][0]['node'][i]['supporting-node'])
754 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
755 listNode.remove(nodeId)
756 elif(nodeId=='ROADMA-DEG1'):
757 #Test related to DEG1
758 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
759 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
760 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
761 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
762 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
763 res['network'][0]['node'][i]['supporting-node'])
764 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
765 listNode.remove(nodeId)
766 elif(nodeId=='ROADMA-DEG2'):
767 #Test related to DEG2
768 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
769 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
770 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
771 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
772 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
773 res['network'][0]['node'][i]['supporting-node'])
774 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
775 listNode.remove(nodeId)
776 elif(nodeId=='ROADMC-SRG1'):
777 #Test related to SRG1
778 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
779 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
780 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
781 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
782 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
783 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
784 res['network'][0]['node'][i]['supporting-node'])
785 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
786 listNode.remove(nodeId)
787 elif(nodeId=='ROADMC-DEG1'):
788 #Test related to DEG1
789 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
790 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
791 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
792 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
793 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
794 res['network'][0]['node'][i]['supporting-node'])
795 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
796 listNode.remove(nodeId)
797 elif(nodeId=='ROADMC-DEG2'):
798 #Test related to DEG2
799 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
800 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
801 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
802 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
803 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
804 res['network'][0]['node'][i]['supporting-node'])
805 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
806 listNode.remove(nodeId)
808 self.assertFalse(True)
809 self.assertEqual(len(listNode),0)
811 def test_21_connect_ROADMB(self):
812 url = ("{}/config/network-topology:"
813 "network-topology/topology/topology-netconf/node/ROADMB"
814 .format(self.restconf_baseurl))
817 "netconf-node-topology:username": "admin",
818 "netconf-node-topology:password": "admin",
819 "netconf-node-topology:host": "127.0.0.1",
820 "netconf-node-topology:port": "17832",
821 "netconf-node-topology:tcp-only": "false",
822 "netconf-node-topology:pass-through": {}}]}
823 headers = {'content-type': 'application/json'}
824 response = requests.request(
825 "PUT", url, data=json.dumps(data), headers=headers,
826 auth=('admin', 'admin'))
827 self.assertEqual(response.status_code, requests.codes.created)
830 def test_22_omsAttributes_ROADMA_ROADMB(self):
831 # Config ROADMA-ROADMB oms-attributes
832 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
833 "link/ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
834 "OMS-attributes/span"
835 .format(self.restconf_baseurl))
838 "auto-spanloss": "true",
839 "engineered-spanloss": 12.2,
840 "link-concatenation": [{
843 "SRLG-length": 100000,
845 headers = {'content-type': 'application/json'}
846 response = requests.request(
847 "PUT", url, data=json.dumps(data), headers=headers,
848 auth=('admin', 'admin'))
849 self.assertEqual(response.status_code, requests.codes.created)
851 def test_23_omsAttributes_ROADMB_ROADMA(self):
852 # Config ROADMB-ROADMA oms-attributes
853 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
854 "link/ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
855 "OMS-attributes/span"
856 .format(self.restconf_baseurl))
859 "auto-spanloss": "true",
860 "engineered-spanloss": 12.2,
861 "link-concatenation": [{
864 "SRLG-length": 100000,
866 headers = {'content-type': 'application/json'}
867 response = requests.request(
868 "PUT", url, data=json.dumps(data), headers=headers,
869 auth=('admin', 'admin'))
870 self.assertEqual(response.status_code, requests.codes.created)
872 def test_24_omsAttributes_ROADMB_ROADMC(self):
873 # Config ROADMB-ROADMC oms-attributes
874 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
875 "link/ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
876 "OMS-attributes/span"
877 .format(self.restconf_baseurl))
880 "auto-spanloss": "true",
881 "engineered-spanloss": 12.2,
882 "link-concatenation": [{
885 "SRLG-length": 100000,
887 headers = {'content-type': 'application/json'}
888 response = requests.request(
889 "PUT", url, data=json.dumps(data), headers=headers,
890 auth=('admin', 'admin'))
891 self.assertEqual(response.status_code, requests.codes.created)
893 def test_25_omsAttributes_ROADMC_ROADMB(self):
894 # Config ROADMC-ROADMB oms-attributes
895 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
896 "link/ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
897 "OMS-attributes/span"
898 .format(self.restconf_baseurl))
901 "auto-spanloss": "true",
902 "engineered-spanloss": 12.2,
903 "link-concatenation": [{
906 "SRLG-length": 100000,
908 headers = {'content-type': 'application/json'}
909 response = requests.request(
910 "PUT", url, data=json.dumps(data), headers=headers,
911 auth=('admin', 'admin'))
912 self.assertEqual(response.status_code, requests.codes.created)
914 def test_26_getClliNetwork(self):
915 url = ("{}/config/ietf-network:networks/network/clli-network"
916 .format(self.restconf_baseurl))
917 headers = {'content-type': 'application/json'}
918 response = requests.request(
919 "GET", url, headers=headers, auth=('admin', 'admin'))
920 self.assertEqual(response.status_code, requests.codes.ok)
921 res = response.json()
922 nbNode=len(res['network'][0]['node'])
923 listNode=['NodeA','NodeB','NodeC']
924 for i in range(0,nbNode):
925 nodeId = res['network'][0]['node'][i]['node-id']
926 find= nodeId in listNode
927 self.assertEqual(find, True)
929 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
930 elif(nodeId=='NodeB'):
931 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
933 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
934 listNode.remove(nodeId)
936 self.assertEqual(len(listNode),0)
938 def test_27_verifyDegree(self):
939 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
940 .format(self.restconf_baseurl))
941 headers = {'content-type': 'application/json'}
942 response = requests.request(
943 "GET", url, headers=headers, auth=('admin', 'admin'))
944 self.assertEqual(response.status_code, requests.codes.ok)
945 res = response.json()
946 #Tests related to links
947 nbLink=len(res['network'][0]['ietf-network-topology:link'])
948 listR2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX',
949 'ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
950 'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX']
951 for i in range(0,nbLink):
952 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'] == 'ROADM-TO-ROADM':
953 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
954 find= link_id in listR2RLink
955 self.assertEqual(find, True)
956 listR2RLink.remove(link_id)
957 self.assertEqual(len(listR2RLink),0)
959 def test_28_verifyOppositeLinkTopology(self):
960 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
961 .format(self.restconf_baseurl))
962 headers = {'content-type': 'application/json'}
963 response = requests.request(
964 "GET", url, headers=headers, auth=('admin', 'admin'))
965 self.assertEqual(response.status_code, requests.codes.ok)
966 res = response.json()
967 #Tests related to links
968 nbLink=len(res['network'][0]['ietf-network-topology:link'])
969 self.assertEqual(nbLink,34)
970 for i in range(0,nbLink):
971 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
972 link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
973 link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
974 link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
975 oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
976 #Find the opposite link
977 url_oppLink="{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
978 url = (url_oppLink.format(self.restconf_baseurl))
979 headers = {'content-type': 'application/json'}
980 response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
981 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
982 res_oppLink = response_oppLink.json()
983 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
984 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
985 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
986 oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type']
987 if link_type=='ADD-LINK':
988 self.assertEqual(oppLink_type, 'DROP-LINK')
989 elif link_type=='DROP-LINK':
990 self.assertEqual(oppLink_type, 'ADD-LINK')
991 elif link_type=='EXPRESS-LINK':
992 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
993 elif link_type=='ROADM-TO-ROADM':
994 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
995 elif link_type=='XPONDER-INPUT':
996 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
997 elif link_type=='XPONDER-OUTPUT':
998 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
1001 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
1002 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1003 .format(self.restconf_baseurl))
1004 headers = {'content-type': 'application/json'}
1005 response = requests.request(
1006 "GET", url, headers=headers, auth=('admin', 'admin'))
1007 self.assertEqual(response.status_code, requests.codes.ok)
1008 res = response.json()
1009 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1010 R2RLink = ['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX',
1011 'ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX',
1012 'ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX',
1013 'ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
1014 'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX',
1015 'ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX']
1016 for i in range(0,nbLink):
1017 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
1018 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
1019 if(link_id in R2RLink):
1021 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
1022 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
1023 length = res['network'][0]['ietf-network-topology:link'][i][
1024 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
1025 if((spanLoss!=None)&(length!=None)):
1027 self.assertTrue(find)
1028 R2RLink.remove(link_id)
1029 self.assertEqual(len(R2RLink),0)
1031 def test_30_disconnect_ROADMB(self):
1032 #Delete in the topology-netconf
1033 url = ("{}/config/network-topology:"
1034 "network-topology/topology/topology-netconf/node/ROADMB"
1035 .format(self.restconf_baseurl))
1037 headers = {'content-type': 'application/json'}
1038 response = requests.request(
1039 "DELETE", url, data=json.dumps(data), headers=headers,
1040 auth=('admin', 'admin'))
1041 self.assertEqual(response.status_code, requests.codes.ok)
1042 #Delete in the clli-network
1043 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
1044 .format(self.restconf_baseurl))
1046 headers = {'content-type': 'application/json'}
1047 response = requests.request(
1048 "DELETE", url, data=json.dumps(data), headers=headers,
1049 auth=('admin', 'admin'))
1050 self.assertEqual(response.status_code, requests.codes.ok)
1052 def test_31_disconnect_ROADMC(self):
1053 #Delete in the topology-netconf
1054 url = ("{}/config/network-topology:"
1055 "network-topology/topology/topology-netconf/node/ROADMC"
1056 .format(self.restconf_baseurl))
1058 headers = {'content-type': 'application/json'}
1059 response = requests.request(
1060 "DELETE", url, data=json.dumps(data), headers=headers,
1061 auth=('admin', 'admin'))
1062 self.assertEqual(response.status_code, requests.codes.ok)
1063 #Delete in the clli-network
1064 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
1065 .format(self.restconf_baseurl))
1067 headers = {'content-type': 'application/json'}
1068 response = requests.request(
1069 "DELETE", url, data=json.dumps(data), headers=headers,
1070 auth=('admin', 'admin'))
1071 self.assertEqual(response.status_code, requests.codes.ok)
1073 def test_32_getNodes_OpenRoadmTopology(self):
1074 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1075 .format(self.restconf_baseurl))
1076 headers = {'content-type': 'application/json'}
1077 response = requests.request(
1078 "GET", url, headers=headers, auth=('admin', 'admin'))
1079 res = response.json()
1080 #Tests related to nodes
1081 self.assertEqual(response.status_code, requests.codes.ok)
1082 nbNode=len(res['network'][0]['node'])
1083 self.assertEqual(nbNode,5)
1084 listNode=['XPDRA-XPDR1','ROADMA-SRG1', 'ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
1085 for i in range(0,nbNode):
1086 nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
1087 nodeId=res['network'][0]['node'][i]['node-id']
1088 #Tests related to XPDRA nodes
1089 if(nodeId=='XPDRA-XPDR1'):
1090 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1091 for j in range(0, nbTp):
1092 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
1093 if (tpid == 'XPDR1-CLIENT1'):
1094 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1095 ['org-openroadm-network-topology:tp-type'], 'XPONDER-CLIENT')
1096 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1097 ['org-openroadm-network-topology:xpdr-client-attributes']['tail-equipment-id'],
1099 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
1100 res['network'][0]['node'][i]['supporting-node'])
1101 listNode.remove(nodeId)
1102 elif(nodeId=='ROADMA-SRG1'):
1103 #Test related to SRG1
1104 self.assertEqual(nodeType,'SRG')
1105 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1106 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1107 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1108 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1109 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1110 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1111 res['network'][0]['node'][i]['supporting-node'])
1112 listNode.remove(nodeId)
1113 elif(nodeId=='ROADMA-SRG3'):
1114 #Test related to SRG1
1115 self.assertEqual(nodeType,'SRG')
1116 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1117 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1118 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1119 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1120 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1121 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1122 res['network'][0]['node'][i]['supporting-node'])
1123 listNode.remove(nodeId)
1124 elif(nodeId=='ROADMA-DEG1'):
1125 #Test related to DEG1
1126 self.assertEqual(nodeType,'DEGREE')
1127 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1128 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1129 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1130 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1131 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1132 res['network'][0]['node'][i]['supporting-node'])
1133 listNode.remove(nodeId)
1134 elif(nodeId=='ROADMA-DEG2'):
1135 #Test related to DEG2
1136 self.assertEqual(nodeType,'DEGREE')
1137 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1138 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1139 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1140 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1141 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1142 res['network'][0]['node'][i]['supporting-node'])
1143 listNode.remove(nodeId)
1145 self.assertFalse(True)
1146 self.assertEqual(len(listNode),0)
1147 #Test related to SRG1 of ROADMC
1148 for i in range(0,nbNode):
1149 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-SRG1')
1150 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG1')
1151 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG2')
1153 def test_33_getOpenRoadmNetwork(self):
1154 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1155 .format(self.restconf_baseurl))
1156 headers = {'content-type': 'application/json'}
1157 response = requests.request(
1158 "GET", url, headers=headers, auth=('admin', 'admin'))
1159 self.assertEqual(response.status_code, requests.codes.ok)
1160 res = response.json()
1161 nbNode=len(res['network'][0]['node'])
1162 self.assertEqual(nbNode,2)
1163 for i in range(0,nbNode-1):
1164 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC')
1165 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB')
1167 def test_34_getClliNetwork(self):
1168 url = ("{}/config/ietf-network:networks/network/clli-network"
1169 .format(self.restconf_baseurl))
1170 headers = {'content-type': 'application/json'}
1171 response = requests.request(
1172 "GET", url, headers=headers, auth=('admin', 'admin'))
1173 self.assertEqual(response.status_code, requests.codes.ok)
1174 res = response.json()
1175 nbNode=len(res['network'][0]['node'])
1176 self.assertEqual(nbNode,1)
1177 for i in range(0,nbNode-1):
1178 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
1180 def test_35_disconnect_XPDRA(self):
1181 url = ("{}/config/network-topology:"
1182 "network-topology/topology/topology-netconf/node/XPDRA"
1183 .format(self.restconf_baseurl))
1185 headers = {'content-type': 'application/json'}
1186 response = requests.request(
1187 "DELETE", url, data=json.dumps(data), headers=headers,
1188 auth=('admin', 'admin'))
1189 self.assertEqual(response.status_code, requests.codes.ok)
1191 def test_36_getClliNetwork(self):
1192 url = ("{}/config/ietf-network:networks/network/clli-network"
1193 .format(self.restconf_baseurl))
1194 headers = {'content-type': 'application/json'}
1195 response = requests.request(
1196 "GET", url, headers=headers, auth=('admin', 'admin'))
1197 self.assertEqual(response.status_code, requests.codes.ok)
1198 res = response.json()
1199 nbNode=len(res['network'][0]['node'])
1200 self.assertEqual(nbNode,1)
1201 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
1203 def test_37_getOpenRoadmNetwork(self):
1204 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1205 .format(self.restconf_baseurl))
1206 headers = {'content-type': 'application/json'}
1207 response = requests.request(
1208 "GET", url, headers=headers, auth=('admin', 'admin'))
1209 self.assertEqual(response.status_code, requests.codes.ok)
1210 res = response.json()
1211 nbNode=len(res['network'][0]['node'])
1212 self.assertEqual(nbNode,1)
1213 for i in range(0,nbNode):
1214 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA')
1216 def test_38_getNodes_OpenRoadmTopology(self):
1217 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1218 .format(self.restconf_baseurl))
1219 headers = {'content-type': 'application/json'}
1220 response = requests.request(
1221 "GET", url, headers=headers, auth=('admin', 'admin'))
1222 res = response.json()
1223 #Tests related to nodes
1224 self.assertEqual(response.status_code, requests.codes.ok)
1225 nbNode=len(res['network'][0]['node'])
1226 self.assertEqual(nbNode,4)
1227 listNode=['ROADMA-SRG1','ROADMA-SRG3','ROADMA-DEG1','ROADMA-DEG2']
1228 for i in range(0,nbNode):
1229 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
1230 res['network'][0]['node'][i]['supporting-node'])
1231 nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
1232 nodeId=res['network'][0]['node'][i]['node-id']
1233 if(nodeId=='ROADMA-SRG1'):
1234 #Test related to SRG1
1235 self.assertEqual(nodeType,'SRG')
1236 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1237 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1238 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1239 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1240 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1241 listNode.remove(nodeId)
1242 elif(nodeId=='ROADMA-SRG3'):
1243 #Test related to SRG1
1244 self.assertEqual(nodeType,'SRG')
1245 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1246 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
1247 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1248 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
1249 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1250 listNode.remove(nodeId)
1251 elif(nodeId=='ROADMA-DEG1'):
1252 #Test related to DEG1
1253 self.assertEqual(nodeType,'DEGREE')
1254 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1255 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1256 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1257 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1258 listNode.remove(nodeId)
1259 elif(nodeId=='ROADMA-DEG2'):
1260 #Test related to DEG2
1261 self.assertEqual(nodeType,'DEGREE')
1262 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
1263 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1264 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
1265 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1266 listNode.remove(nodeId)
1268 self.assertFalse(True)
1269 self.assertEqual(len(listNode),0)
1271 def test_39_disconnect_ROADM_XPDRA_link(self):
1273 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1274 "link/XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX"
1275 .format(self.restconf_baseurl))
1277 headers = {'content-type': 'application/json'}
1278 response = requests.request(
1279 "DELETE", url, data=json.dumps(data), headers=headers,
1280 auth=('admin', 'admin'))
1281 self.assertEqual(response.status_code, requests.codes.ok)
1283 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1284 "link/ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1"
1285 .format(self.restconf_baseurl))
1287 headers = {'content-type': 'application/json'}
1288 response = requests.request(
1289 "DELETE", url, data=json.dumps(data), headers=headers,
1290 auth=('admin', 'admin'))
1291 self.assertEqual(response.status_code, requests.codes.ok)
1293 def test_40_getLinks_OpenRoadmTopology(self):
1294 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1295 .format(self.restconf_baseurl))
1296 headers = {'content-type': 'application/json'}
1297 response = requests.request(
1298 "GET", url, headers=headers, auth=('admin', 'admin'))
1299 self.assertEqual(response.status_code, requests.codes.ok)
1300 res = response.json()
1301 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1302 self.assertEqual(nbLink,16)
1303 expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
1304 addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
1305 'ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG3-SRG3-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
1306 dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
1307 'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG3-SRG3-CP-TXRX']
1308 roadmtoroadmLink = 0
1309 for i in range(0,nbLink):
1310 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='EXPRESS-LINK'):
1311 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1312 find= link_id in expressLink
1313 self.assertEqual(find, True)
1314 expressLink.remove(link_id)
1315 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='ADD-LINK'):
1316 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1317 find= link_id in addLink
1318 self.assertEqual(find, True)
1319 addLink.remove(link_id)
1320 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='DROP-LINK'):
1321 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1322 find= link_id in dropLink
1323 self.assertEqual(find, True)
1324 dropLink.remove(link_id)
1326 roadmtoroadmLink += 1
1327 self.assertEqual(len(expressLink),0)
1328 self.assertEqual(len(addLink),0)
1329 self.assertEqual(len(dropLink),0)
1330 self.assertEqual(roadmtoroadmLink, 6)
1331 for i in range(0,nbLink):
1332 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
1333 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
1335 def test_41_disconnect_ROADMA(self):
1336 url = ("{}/config/network-topology:"
1337 "network-topology/topology/topology-netconf/node/ROADMA"
1338 .format(self.restconf_baseurl))
1340 headers = {'content-type': 'application/json'}
1341 response = requests.request(
1342 "DELETE", url, data=json.dumps(data), headers=headers,
1343 auth=('admin', 'admin'))
1344 self.assertEqual(response.status_code, requests.codes.ok)
1345 #Delete in the clli-network
1346 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1347 .format(self.restconf_baseurl))
1349 headers = {'content-type': 'application/json'}
1350 response = requests.request(
1351 "DELETE", url, data=json.dumps(data), headers=headers,
1352 auth=('admin', 'admin'))
1353 self.assertEqual(response.status_code, requests.codes.ok)
1355 def test_42_getClliNetwork(self):
1356 url = ("{}/config/ietf-network:networks/network/clli-network"
1357 .format(self.restconf_baseurl))
1358 headers = {'content-type': 'application/json'}
1359 response = requests.request(
1360 "GET", url, headers=headers, auth=('admin', 'admin'))
1361 self.assertEqual(response.status_code, requests.codes.ok)
1362 res = response.json()
1363 self.assertNotIn('node', res['network'][0])
1365 def test_43_getOpenRoadmNetwork(self):
1366 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1367 .format(self.restconf_baseurl))
1368 headers = {'content-type': 'application/json'}
1369 response = requests.request(
1370 "GET", url, headers=headers, auth=('admin', 'admin'))
1371 self.assertEqual(response.status_code, requests.codes.ok)
1372 res = response.json()
1373 self.assertNotIn('node', res['network'][0])
1375 def test_44_check_roadm2roadm_link_persistence(self):
1376 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1377 .format(self.restconf_baseurl))
1378 headers = {'content-type': 'application/json'}
1379 response = requests.request(
1380 "GET", url, headers=headers, auth=('admin', 'admin'))
1381 self.assertEqual(response.status_code, requests.codes.ok)
1382 res = response.json()
1383 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1384 self.assertNotIn('node', res['network'][0])
1385 self.assertEqual(nbLink, 6)
1387 if __name__ == "__main__":
1388 unittest.main(verbosity=2)