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 listNode.remove(nodeId)
201 elif(nodeId=='ROADMA01-SRG3'):
202 #Test related to SRG1
203 self.assertEqual(nodeType,'SRG')
204 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
205 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
206 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
207 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
208 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
209 listNode.remove(nodeId)
210 elif(nodeId=='ROADMA01-DEG1'):
211 #Test related to DEG1
212 self.assertEqual(nodeType,'DEGREE')
213 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
214 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
215 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
216 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
217 listNode.remove(nodeId)
218 elif(nodeId=='ROADMA01-DEG2'):
219 #Test related to DEG2
220 self.assertEqual(nodeType,'DEGREE')
221 self.assertIn({'tp-id': 'DEG2-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': 'DEG2-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)
227 self.assertFalse(True)
228 self.assertEqual(len(listNode),0)
230 def test_06_connect_XPDRA(self):
231 url = ("{}/config/network-topology:"
232 "network-topology/topology/topology-netconf/node/XPDRA01"
233 .format(self.restconf_baseurl))
235 "node-id": "XPDRA01",
236 "netconf-node-topology:username": "admin",
237 "netconf-node-topology:password": "admin",
238 "netconf-node-topology:host": "127.0.0.1",
239 "netconf-node-topology:port": "17830",
240 "netconf-node-topology:tcp-only": "false",
241 "netconf-node-topology:pass-through": {}}]}
242 headers = {'content-type': 'application/json'}
243 response = requests.request(
244 "PUT", url, data=json.dumps(data), headers=headers,
245 auth=('admin', 'admin'))
246 self.assertEqual(response.status_code, requests.codes.created)
249 def test_07_getClliNetwork(self):
250 url = ("{}/config/ietf-network:networks/network/clli-network"
251 .format(self.restconf_baseurl))
252 headers = {'content-type': 'application/json'}
253 response = requests.request(
254 "GET", url, headers=headers, auth=('admin', 'admin'))
255 self.assertEqual(response.status_code, requests.codes.ok)
256 res = response.json()
257 self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
258 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
260 def test_08_getOpenRoadmNetwork(self):
261 url = ("{}/config/ietf-network:networks/network/openroadm-network"
262 .format(self.restconf_baseurl))
263 headers = {'content-type': 'application/json'}
264 response = requests.request(
265 "GET", url, headers=headers, auth=('admin', 'admin'))
266 self.assertEqual(response.status_code, requests.codes.ok)
267 res = response.json()
268 nbNode=len(res['network'][0]['node'])
269 self.assertEqual(nbNode,2)
270 for i in range(0,nbNode):
271 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
272 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
273 nodeId=res['network'][0]['node'][i]['node-id']
274 if(nodeId=='XPDRA01'):
275 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
276 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
277 elif(nodeId=='ROADMA01'):
278 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
279 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
281 self.assertFalse(True)
283 def test_09_getNodes_OpenRoadmTopology(self):
284 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
285 .format(self.restconf_baseurl))
286 headers = {'content-type': 'application/json'}
287 response = requests.request(
288 "GET", url, headers=headers, auth=('admin', 'admin'))
289 res = response.json()
290 #Tests related to nodes
291 self.assertEqual(response.status_code, requests.codes.ok)
292 nbNode=len(res['network'][0]['node'])
293 self.assertEqual(nbNode,5)
294 listNode=['XPDRA01-XPDR1','ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
295 for i in range(0,nbNode):
296 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
297 nodeId=res['network'][0]['node'][i]['node-id']
298 #Tests related to XPDRA nodes
299 if(nodeId=='XPDRA01-XPDR1'):
300 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
301 res['network'][0]['node'][i]['supporting-node'])
302 self.assertEqual(nodeType,'XPONDER')
303 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
306 for j in range(0,nbTps):
307 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
308 tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
309 if (tpType=='XPONDER-CLIENT'):
311 elif (tpType=='XPONDER-NETWORK'):
313 if (tpId == 'XPDR1-NETWORK2'):
314 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT3')
315 if (tpId == 'XPDR1-CLIENT3'):
316 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
317 self.assertTrue(client == 4)
318 self.assertTrue(network == 2)
319 listNode.remove(nodeId)
320 elif(nodeId=='ROADMA01-SRG1'):
321 #Test related to SRG1
322 self.assertEqual(nodeType,'SRG')
323 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
324 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
325 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
326 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
327 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
328 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
329 res['network'][0]['node'][i]['supporting-node'])
330 listNode.remove(nodeId)
331 elif(nodeId=='ROADMA01-SRG3'):
332 #Test related to SRG1
333 self.assertEqual(nodeType,'SRG')
334 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
335 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
336 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
337 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
338 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
339 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
340 res['network'][0]['node'][i]['supporting-node'])
341 listNode.remove(nodeId)
342 elif(nodeId=='ROADMA01-DEG1'):
343 #Test related to DEG1
344 self.assertEqual(nodeType,'DEGREE')
345 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
346 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
347 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
348 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
349 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
350 res['network'][0]['node'][i]['supporting-node'])
351 listNode.remove(nodeId)
352 elif(nodeId=='ROADMA01-DEG2'):
353 #Test related to DEG2
354 self.assertEqual(nodeType,'DEGREE')
355 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
356 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
357 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
358 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
359 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
360 res['network'][0]['node'][i]['supporting-node'])
361 listNode.remove(nodeId)
363 self.assertFalse(True)
364 self.assertEqual(len(listNode),0)
366 #Connect the tail XPDRA to ROADMA and vice versa
367 def test_10_connect_tail_xpdr_rdm(self):
368 #Connect the tail: XPDRA to ROADMA
369 url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
370 .format(self.restconf_baseurl))
371 data = {"networkutils:input": {
372 "networkutils:links-input": {
373 "networkutils:xpdr-node": "XPDRA01",
374 "networkutils:xpdr-num": "1",
375 "networkutils:network-num": "1",
376 "networkutils:rdm-node": "ROADMA01",
377 "networkutils:srg-num": "1",
378 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
382 headers = {'content-type': 'application/json'}
383 response = requests.request(
384 "POST", url, data=json.dumps(data), headers=headers,
385 auth=('admin', 'admin'))
386 self.assertEqual(response.status_code, requests.codes.ok)
389 def test_11_connect_tail_rdm_xpdr(self):
390 #Connect the tail: ROADMA to XPDRA
391 url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
392 .format(self.restconf_baseurl))
393 data = {"networkutils:input": {
394 "networkutils:links-input": {
395 "networkutils:xpdr-node": "XPDRA01",
396 "networkutils:xpdr-num": "1",
397 "networkutils:network-num": "1",
398 "networkutils:rdm-node": "ROADMA01",
399 "networkutils:srg-num": "1",
400 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
404 headers = {'content-type': 'application/json'}
405 response = requests.request(
406 "POST", url, data=json.dumps(data), headers=headers,
407 auth=('admin', 'admin'))
408 self.assertEqual(response.status_code, requests.codes.ok)
411 def test_12_getLinks_OpenRoadmTopology(self):
412 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
413 .format(self.restconf_baseurl))
414 headers = {'content-type': 'application/json'}
415 response = requests.request(
416 "GET", url, headers=headers, auth=('admin', 'admin'))
417 self.assertEqual(response.status_code, requests.codes.ok)
418 res = response.json()
419 #Tests related to links
420 nbLink=len(res['network'][0]['ietf-network-topology:link'])
421 self.assertEqual(nbLink,12)
422 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
423 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
424 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
425 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
426 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
427 XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
428 XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
429 for i in range(0,nbLink):
430 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
431 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
432 if(nodeType=='EXPRESS-LINK'):
433 find= linkId in expressLink
434 self.assertEqual(find, True)
435 expressLink.remove(linkId)
436 elif(nodeType=='ADD-LINK'):
437 find= linkId in addLink
438 self.assertEqual(find, True)
439 addLink.remove(linkId)
440 elif(nodeType=='DROP-LINK'):
441 find= linkId in dropLink
442 self.assertEqual(find, True)
443 dropLink.remove(linkId)
444 elif(nodeType=='XPONDER-INPUT'):
445 find= linkId in XPDR_IN
446 self.assertEqual(find, True)
447 XPDR_IN.remove(linkId)
448 elif(nodeType=='XPONDER-OUTPUT'):
449 find= linkId in XPDR_OUT
450 self.assertEqual(find, True)
451 XPDR_OUT.remove(linkId)
453 self.assertFalse(True)
454 self.assertEqual(len(expressLink),0)
455 self.assertEqual(len(addLink),0)
456 self.assertEqual(len(dropLink),0)
457 self.assertEqual(len(XPDR_IN),0)
458 self.assertEqual(len(XPDR_OUT),0)
460 def test_13_connect_ROADMC(self):
462 url = ("{}/config/network-topology:"
463 "network-topology/topology/topology-netconf/node/ROADMC01"
464 .format(self.restconf_baseurl))
466 "node-id": "ROADMC01",
467 "netconf-node-topology:username": "admin",
468 "netconf-node-topology:password": "admin",
469 "netconf-node-topology:host": "127.0.0.1",
470 "netconf-node-topology:port": "17833",
471 "netconf-node-topology:tcp-only": "false",
472 "netconf-node-topology:pass-through": {}}]}
473 headers = {'content-type': 'application/json'}
474 response = requests.request(
475 "PUT", url, data=json.dumps(data), headers=headers,
476 auth=('admin', 'admin'))
477 self.assertEqual(response.status_code, requests.codes.created)
480 def test_14_omsAttributes_ROADMA_ROADMC(self):
481 # Config ROADMA-ROADMC oms-attributes
482 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
483 "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
484 "OMS-attributes/span"
485 .format(self.restconf_baseurl))
488 "auto-spanloss": "true",
489 "engineered-spanloss": 12.2,
490 "link-concatenation": [{
493 "SRLG-length": 100000,
495 headers = {'content-type': 'application/json'}
496 response = requests.request(
497 "PUT", url, data=json.dumps(data), headers=headers,
498 auth=('admin', 'admin'))
499 self.assertEqual(response.status_code, requests.codes.created)
501 def test_15_omsAttributes_ROADMC_ROADMA(self):
502 # Config ROADMC01-ROADMA oms-attributes
503 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
504 "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
505 "OMS-attributes/span"
506 .format(self.restconf_baseurl))
509 "auto-spanloss": "true",
510 "engineered-spanloss": 12.2,
511 "link-concatenation": [{
514 "SRLG-length": 100000,
516 headers = {'content-type': 'application/json'}
517 response = requests.request(
518 "PUT", url, data=json.dumps(data), headers=headers,
519 auth=('admin', 'admin'))
520 self.assertEqual(response.status_code, requests.codes.created)
522 def test_16_getClliNetwork(self):
523 url = ("{}/config/ietf-network:networks/network/clli-network"
524 .format(self.restconf_baseurl))
525 headers = {'content-type': 'application/json'}
526 response = requests.request(
527 "GET", url, headers=headers, auth=('admin', 'admin'))
528 self.assertEqual(response.status_code, requests.codes.ok)
529 res = response.json()
530 nbNode=len(res['network'][0]['node'])
531 listNode=['NodeA','NodeC']
532 for i in range(0,nbNode):
533 nodeId = res['network'][0]['node'][i]['node-id']
534 find= nodeId in listNode
535 self.assertEqual(find, True)
537 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
539 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
540 listNode.remove(nodeId)
542 self.assertEqual(len(listNode),0)
544 def test_17_getOpenRoadmNetwork(self):
545 url = ("{}/config/ietf-network:networks/network/openroadm-network"
546 .format(self.restconf_baseurl))
547 headers = {'content-type': 'application/json'}
548 response = requests.request(
549 "GET", url, headers=headers, auth=('admin', 'admin'))
550 self.assertEqual(response.status_code, requests.codes.ok)
551 res = response.json()
552 nbNode=len(res['network'][0]['node'])
553 self.assertEqual(nbNode,3)
554 listNode=['XPDRA01','ROADMA01','ROADMC01']
555 for i in range(0,nbNode):
556 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
557 nodeId=res['network'][0]['node'][i]['node-id']
558 if(nodeId=='XPDRA01'):
559 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
560 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
561 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
562 listNode.remove(nodeId)
563 elif(nodeId=='ROADMA01'):
564 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
565 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
566 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
567 listNode.remove(nodeId)
568 elif(nodeId=='ROADMC01'):
569 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
570 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
571 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
572 listNode.remove(nodeId)
574 self.assertFalse(True)
575 self.assertEqual(len(listNode),0)
577 def test_18_getROADMLinkOpenRoadmTopology(self):
578 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
579 .format(self.restconf_baseurl))
580 headers = {'content-type': 'application/json'}
581 response = requests.request(
582 "GET", url, headers=headers, auth=('admin', 'admin'))
583 self.assertEqual(response.status_code, requests.codes.ok)
584 res = response.json()
585 #Tests related to links
586 nbLink=len(res['network'][0]['ietf-network-topology:link'])
587 self.assertEqual(nbLink,20)
588 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
589 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX','ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
590 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
591 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
592 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX','ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
593 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
594 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
595 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX','ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
596 R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
597 XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
598 XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
599 for i in range(0,nbLink):
600 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
601 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
602 if(nodeType=='EXPRESS-LINK'):
603 find= linkId in expressLink
604 self.assertEqual(find, True)
605 expressLink.remove(linkId)
606 elif(nodeType=='ADD-LINK'):
607 find= linkId in addLink
608 self.assertEqual(find, True)
609 addLink.remove(linkId)
610 elif(nodeType=='DROP-LINK'):
611 find= linkId in dropLink
612 self.assertEqual(find, True)
613 dropLink.remove(linkId)
614 elif(nodeType=='ROADM-TO-ROADM'):
615 find= linkId in R2RLink
616 self.assertEqual(find, True)
617 R2RLink.remove(linkId)
618 elif(nodeType=='XPONDER-INPUT'):
619 find= linkId in XPDR_IN
620 self.assertEqual(find, True)
621 XPDR_IN.remove(linkId)
622 elif(nodeType=='XPONDER-OUTPUT'):
623 find= linkId in XPDR_OUT
624 self.assertEqual(find, True)
625 XPDR_OUT.remove(linkId)
627 self.assertFalse(True)
628 self.assertEqual(len(expressLink),0)
629 self.assertEqual(len(addLink),0)
630 self.assertEqual(len(dropLink),0)
631 self.assertEqual(len(R2RLink),0)
632 self.assertEqual(len(XPDR_IN),0)
633 self.assertEqual(len(XPDR_OUT),0)
635 def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
636 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
637 .format(self.restconf_baseurl))
638 headers = {'content-type': 'application/json'}
639 response = requests.request(
640 "GET", url, headers=headers, auth=('admin', 'admin'))
641 self.assertEqual(response.status_code, requests.codes.ok)
642 res = response.json()
643 #Tests related to links
644 nbLink=len(res['network'][0]['ietf-network-topology:link'])
645 self.assertEqual(nbLink,20)
646 R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
647 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
648 for i in range(0,nbLink):
649 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
650 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
651 if(link_id in R2RLink):
653 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
654 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
655 length = res['network'][0]['ietf-network-topology:link'][i][
656 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
657 if((spanLoss!=None)&(length!=None)):
659 self.assertTrue(find)
660 R2RLink.remove(link_id)
661 self.assertEqual(len(R2RLink),0)
663 def test_20_getNodes_OpenRoadmTopology(self):
664 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
665 .format(self.restconf_baseurl))
666 headers = {'content-type': 'application/json'}
667 response = requests.request(
668 "GET", url, headers=headers, auth=('admin', 'admin'))
669 res = response.json()
670 #Tests related to nodes
671 self.assertEqual(response.status_code, requests.codes.ok)
672 nbNode=len(res['network'][0]['node'])
673 self.assertEqual(nbNode,8)
674 listNode=['XPDRA01-XPDR1',
675 'ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2',
676 'ROADMC01-SRG1','ROADMC01-DEG1','ROADMC01-DEG2']
677 #************************Tests related to XPDRA nodes
678 for i in range(0,nbNode):
679 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
680 nodeId=res['network'][0]['node'][i]['node-id']
681 if(nodeId=='XPDRA01-XPDR1'):
682 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
683 res['network'][0]['node'][i]['supporting-node'])
684 self.assertEqual(nodeType,'XPONDER')
685 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
686 self.assertTrue(nbTps == 6)
689 for j in range(0,nbTps):
690 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
691 if (tpType=='XPONDER-CLIENT'):
693 elif (tpType=='XPONDER-NETWORK'):
695 self.assertTrue(client == 4)
696 self.assertTrue(network == 2)
697 listNode.remove(nodeId)
698 elif(nodeId=='ROADMA01-SRG1'):
699 #Test related to SRG1
700 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
701 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
702 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
703 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
704 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
705 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
706 res['network'][0]['node'][i]['supporting-node'])
707 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
708 listNode.remove(nodeId)
709 elif(nodeId=='ROADMA01-SRG3'):
710 #Test related to SRG1
711 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
712 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
713 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
714 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
715 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
716 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
717 res['network'][0]['node'][i]['supporting-node'])
718 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
719 listNode.remove(nodeId)
720 elif(nodeId=='ROADMA01-DEG1'):
721 #Test related to DEG1
722 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
723 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
724 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
725 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
726 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
727 res['network'][0]['node'][i]['supporting-node'])
728 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
729 listNode.remove(nodeId)
730 elif(nodeId=='ROADMA01-DEG2'):
731 #Test related to DEG2
732 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
733 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
734 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
735 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
736 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
737 res['network'][0]['node'][i]['supporting-node'])
738 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
739 listNode.remove(nodeId)
740 elif(nodeId=='ROADMC01-SRG1'):
741 #Test related to SRG1
742 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
743 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
744 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
745 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
746 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
747 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
748 res['network'][0]['node'][i]['supporting-node'])
749 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
750 listNode.remove(nodeId)
751 elif(nodeId=='ROADMC01-DEG1'):
752 #Test related to DEG1
753 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
754 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
755 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
756 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
757 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
758 res['network'][0]['node'][i]['supporting-node'])
759 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
760 listNode.remove(nodeId)
761 elif(nodeId=='ROADMC01-DEG2'):
762 #Test related to DEG2
763 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
764 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
765 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
766 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
767 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
768 res['network'][0]['node'][i]['supporting-node'])
769 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
770 listNode.remove(nodeId)
772 self.assertFalse(True)
773 self.assertEqual(len(listNode),0)
775 def test_21_connect_ROADMB(self):
776 url = ("{}/config/network-topology:"
777 "network-topology/topology/topology-netconf/node/ROADMB"
778 .format(self.restconf_baseurl))
781 "netconf-node-topology:username": "admin",
782 "netconf-node-topology:password": "admin",
783 "netconf-node-topology:host": "127.0.0.1",
784 "netconf-node-topology:port": "17832",
785 "netconf-node-topology:tcp-only": "false",
786 "netconf-node-topology:pass-through": {}}]}
787 headers = {'content-type': 'application/json'}
788 response = requests.request(
789 "PUT", url, data=json.dumps(data), headers=headers,
790 auth=('admin', 'admin'))
791 self.assertEqual(response.status_code, requests.codes.created)
794 def test_22_omsAttributes_ROADMA_ROADMB(self):
795 # Config ROADMA-ROADMB oms-attributes
796 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
797 "link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
798 "OMS-attributes/span"
799 .format(self.restconf_baseurl))
802 "auto-spanloss": "true",
803 "engineered-spanloss": 12.2,
804 "link-concatenation": [{
807 "SRLG-length": 100000,
809 headers = {'content-type': 'application/json'}
810 response = requests.request(
811 "PUT", url, data=json.dumps(data), headers=headers,
812 auth=('admin', 'admin'))
813 self.assertEqual(response.status_code, requests.codes.created)
815 def test_23_omsAttributes_ROADMB_ROADMA(self):
816 # Config ROADMB-ROADMA oms-attributes
817 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
818 "link/ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
819 "OMS-attributes/span"
820 .format(self.restconf_baseurl))
823 "auto-spanloss": "true",
824 "engineered-spanloss": 12.2,
825 "link-concatenation": [{
828 "SRLG-length": 100000,
830 headers = {'content-type': 'application/json'}
831 response = requests.request(
832 "PUT", url, data=json.dumps(data), headers=headers,
833 auth=('admin', 'admin'))
834 self.assertEqual(response.status_code, requests.codes.created)
836 def test_24_omsAttributes_ROADMB_ROADMC(self):
837 # Config ROADMB-ROADMC oms-attributes
838 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
839 "link/ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
840 "OMS-attributes/span"
841 .format(self.restconf_baseurl))
844 "auto-spanloss": "true",
845 "engineered-spanloss": 12.2,
846 "link-concatenation": [{
849 "SRLG-length": 100000,
851 headers = {'content-type': 'application/json'}
852 response = requests.request(
853 "PUT", url, data=json.dumps(data), headers=headers,
854 auth=('admin', 'admin'))
855 self.assertEqual(response.status_code, requests.codes.created)
857 def test_25_omsAttributes_ROADMC_ROADMB(self):
858 # Config ROADMC01-ROADMB oms-attributes
859 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
860 "link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
861 "OMS-attributes/span"
862 .format(self.restconf_baseurl))
865 "auto-spanloss": "true",
866 "engineered-spanloss": 12.2,
867 "link-concatenation": [{
870 "SRLG-length": 100000,
872 headers = {'content-type': 'application/json'}
873 response = requests.request(
874 "PUT", url, data=json.dumps(data), headers=headers,
875 auth=('admin', 'admin'))
876 self.assertEqual(response.status_code, requests.codes.created)
878 def test_26_getClliNetwork(self):
879 url = ("{}/config/ietf-network:networks/network/clli-network"
880 .format(self.restconf_baseurl))
881 headers = {'content-type': 'application/json'}
882 response = requests.request(
883 "GET", url, headers=headers, auth=('admin', 'admin'))
884 self.assertEqual(response.status_code, requests.codes.ok)
885 res = response.json()
886 nbNode=len(res['network'][0]['node'])
887 listNode=['NodeA','NodeB','NodeC']
888 for i in range(0,nbNode):
889 nodeId = res['network'][0]['node'][i]['node-id']
890 find= nodeId in listNode
891 self.assertEqual(find, True)
893 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
894 elif(nodeId=='NodeB'):
895 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
897 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
898 listNode.remove(nodeId)
900 self.assertEqual(len(listNode),0)
902 def test_27_verifyDegree(self):
903 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
904 .format(self.restconf_baseurl))
905 headers = {'content-type': 'application/json'}
906 response = requests.request(
907 "GET", url, headers=headers, auth=('admin', 'admin'))
908 self.assertEqual(response.status_code, requests.codes.ok)
909 res = response.json()
910 #Tests related to links
911 nbLink=len(res['network'][0]['ietf-network-topology:link'])
912 listR2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
913 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
914 'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
915 for i in range(0,nbLink):
916 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
917 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
918 find= link_id in listR2RLink
919 self.assertEqual(find, True)
920 listR2RLink.remove(link_id)
921 self.assertEqual(len(listR2RLink),0)
923 def test_28_verifyOppositeLinkTopology(self):
924 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
925 .format(self.restconf_baseurl))
926 headers = {'content-type': 'application/json'}
927 response = requests.request(
928 "GET", url, headers=headers, auth=('admin', 'admin'))
929 self.assertEqual(response.status_code, requests.codes.ok)
930 res = response.json()
931 #Tests related to links
932 nbLink=len(res['network'][0]['ietf-network-topology:link'])
933 self.assertEqual(nbLink,34)
934 for i in range(0,nbLink):
935 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
936 link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
937 link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
938 link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
939 oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
940 #Find the opposite link
941 url_oppLink="{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
942 url = (url_oppLink.format(self.restconf_baseurl))
943 headers = {'content-type': 'application/json'}
944 response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
945 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
946 res_oppLink = response_oppLink.json()
947 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
948 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
949 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
950 oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
951 if link_type=='ADD-LINK':
952 self.assertEqual(oppLink_type, 'DROP-LINK')
953 elif link_type=='DROP-LINK':
954 self.assertEqual(oppLink_type, 'ADD-LINK')
955 elif link_type=='EXPRESS-LINK':
956 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
957 elif link_type=='ROADM-TO-ROADM':
958 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
959 elif link_type=='XPONDER-INPUT':
960 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
961 elif link_type=='XPONDER-OUTPUT':
962 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
965 def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
966 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
967 .format(self.restconf_baseurl))
968 headers = {'content-type': 'application/json'}
969 response = requests.request(
970 "GET", url, headers=headers, auth=('admin', 'admin'))
971 self.assertEqual(response.status_code, requests.codes.ok)
972 res = response.json()
973 nbLink=len(res['network'][0]['ietf-network-topology:link'])
974 R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
975 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
976 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX',
977 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
978 'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
979 'ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
980 for i in range(0,nbLink):
981 nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
982 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
983 if(link_id in R2RLink):
985 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
986 'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
987 length = res['network'][0]['ietf-network-topology:link'][i][
988 'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
989 if((spanLoss!=None)&(length!=None)):
991 self.assertTrue(find)
992 R2RLink.remove(link_id)
993 self.assertEqual(len(R2RLink),0)
995 def test_30_disconnect_ROADMB(self):
996 #Delete in the topology-netconf
997 url = ("{}/config/network-topology:"
998 "network-topology/topology/topology-netconf/node/ROADMB"
999 .format(self.restconf_baseurl))
1001 headers = {'content-type': 'application/json'}
1002 response = requests.request(
1003 "DELETE", url, data=json.dumps(data), headers=headers,
1004 auth=('admin', 'admin'))
1005 self.assertEqual(response.status_code, requests.codes.ok)
1006 #Delete in the clli-network
1007 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
1008 .format(self.restconf_baseurl))
1010 headers = {'content-type': 'application/json'}
1011 response = requests.request(
1012 "DELETE", url, data=json.dumps(data), headers=headers,
1013 auth=('admin', 'admin'))
1014 self.assertEqual(response.status_code, requests.codes.ok)
1016 def test_31_disconnect_ROADMC(self):
1017 #Delete in the topology-netconf
1018 url = ("{}/config/network-topology:"
1019 "network-topology/topology/topology-netconf/node/ROADMC01"
1020 .format(self.restconf_baseurl))
1022 headers = {'content-type': 'application/json'}
1023 response = requests.request(
1024 "DELETE", url, data=json.dumps(data), headers=headers,
1025 auth=('admin', 'admin'))
1026 self.assertEqual(response.status_code, requests.codes.ok)
1027 #Delete in the clli-network
1028 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
1029 .format(self.restconf_baseurl))
1031 headers = {'content-type': 'application/json'}
1032 response = requests.request(
1033 "DELETE", url, data=json.dumps(data), headers=headers,
1034 auth=('admin', 'admin'))
1035 self.assertEqual(response.status_code, requests.codes.ok)
1037 def test_32_getNodes_OpenRoadmTopology(self):
1038 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1039 .format(self.restconf_baseurl))
1040 headers = {'content-type': 'application/json'}
1041 response = requests.request(
1042 "GET", url, headers=headers, auth=('admin', 'admin'))
1043 res = response.json()
1044 #Tests related to nodes
1045 self.assertEqual(response.status_code, requests.codes.ok)
1046 nbNode=len(res['network'][0]['node'])
1047 self.assertEqual(nbNode,5)
1048 listNode=['XPDRA01-XPDR1','ROADMA01-SRG1', 'ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
1049 for i in range(0,nbNode):
1050 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1051 nodeId=res['network'][0]['node'][i]['node-id']
1052 #Tests related to XPDRA nodes
1053 if(nodeId=='XPDRA01-XPDR1'):
1054 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1055 for j in range(0, nbTp):
1056 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
1057 if (tpid == 'XPDR1-CLIENT1'):
1058 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1059 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
1060 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
1061 ['org-openroadm-network-topology:xpdr-client-attributes']['tail-equipment-id'],
1063 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
1064 res['network'][0]['node'][i]['supporting-node'])
1065 listNode.remove(nodeId)
1066 elif(nodeId=='ROADMA01-SRG1'):
1067 #Test related to SRG1
1068 self.assertEqual(nodeType,'SRG')
1069 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1070 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1071 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1072 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1073 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1074 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1075 res['network'][0]['node'][i]['supporting-node'])
1076 listNode.remove(nodeId)
1077 elif(nodeId=='ROADMA01-SRG3'):
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': 'SRG3-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': 'SRG3-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-DEG1'):
1089 #Test related to DEG1
1090 self.assertEqual(nodeType,'DEGREE')
1091 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1092 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1093 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1094 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1095 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1096 res['network'][0]['node'][i]['supporting-node'])
1097 listNode.remove(nodeId)
1098 elif(nodeId=='ROADMA01-DEG2'):
1099 #Test related to DEG2
1100 self.assertEqual(nodeType,'DEGREE')
1101 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1102 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1103 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1104 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1105 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1106 res['network'][0]['node'][i]['supporting-node'])
1107 listNode.remove(nodeId)
1109 self.assertFalse(True)
1110 self.assertEqual(len(listNode),0)
1111 #Test related to SRG1 of ROADMC
1112 for i in range(0,nbNode):
1113 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-SRG1')
1114 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG1')
1115 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG2')
1117 def test_33_getOpenRoadmNetwork(self):
1118 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1119 .format(self.restconf_baseurl))
1120 headers = {'content-type': 'application/json'}
1121 response = requests.request(
1122 "GET", url, headers=headers, auth=('admin', 'admin'))
1123 self.assertEqual(response.status_code, requests.codes.ok)
1124 res = response.json()
1125 nbNode=len(res['network'][0]['node'])
1126 self.assertEqual(nbNode,2)
1127 for i in range(0,nbNode-1):
1128 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01')
1129 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB')
1131 def test_34_getClliNetwork(self):
1132 url = ("{}/config/ietf-network:networks/network/clli-network"
1133 .format(self.restconf_baseurl))
1134 headers = {'content-type': 'application/json'}
1135 response = requests.request(
1136 "GET", url, headers=headers, auth=('admin', 'admin'))
1137 self.assertEqual(response.status_code, requests.codes.ok)
1138 res = response.json()
1139 nbNode=len(res['network'][0]['node'])
1140 self.assertEqual(nbNode,1)
1141 for i in range(0,nbNode-1):
1142 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
1144 def test_35_disconnect_XPDRA(self):
1145 url = ("{}/config/network-topology:"
1146 "network-topology/topology/topology-netconf/node/XPDRA01"
1147 .format(self.restconf_baseurl))
1149 headers = {'content-type': 'application/json'}
1150 response = requests.request(
1151 "DELETE", url, data=json.dumps(data), headers=headers,
1152 auth=('admin', 'admin'))
1153 self.assertEqual(response.status_code, requests.codes.ok)
1155 def test_36_getClliNetwork(self):
1156 url = ("{}/config/ietf-network:networks/network/clli-network"
1157 .format(self.restconf_baseurl))
1158 headers = {'content-type': 'application/json'}
1159 response = requests.request(
1160 "GET", url, headers=headers, auth=('admin', 'admin'))
1161 self.assertEqual(response.status_code, requests.codes.ok)
1162 res = response.json()
1163 nbNode=len(res['network'][0]['node'])
1164 self.assertEqual(nbNode,1)
1165 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
1167 def test_37_getOpenRoadmNetwork(self):
1168 url = ("{}/config/ietf-network:networks/network/openroadm-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):
1178 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA01')
1180 def test_38_getNodes_OpenRoadmTopology(self):
1181 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1182 .format(self.restconf_baseurl))
1183 headers = {'content-type': 'application/json'}
1184 response = requests.request(
1185 "GET", url, headers=headers, auth=('admin', 'admin'))
1186 res = response.json()
1187 #Tests related to nodes
1188 self.assertEqual(response.status_code, requests.codes.ok)
1189 nbNode=len(res['network'][0]['node'])
1190 self.assertEqual(nbNode,4)
1191 listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
1192 for i in range(0,nbNode):
1193 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
1194 res['network'][0]['node'][i]['supporting-node'])
1195 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1196 nodeId=res['network'][0]['node'][i]['node-id']
1197 if(nodeId=='ROADMA01-SRG1'):
1198 #Test related to SRG1
1199 self.assertEqual(nodeType,'SRG')
1200 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1201 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1202 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1203 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1204 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1205 listNode.remove(nodeId)
1206 elif(nodeId=='ROADMA01-SRG3'):
1207 #Test related to SRG1
1208 self.assertEqual(nodeType,'SRG')
1209 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
1210 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1211 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1212 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1213 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1214 listNode.remove(nodeId)
1215 elif(nodeId=='ROADMA01-DEG1'):
1216 #Test related to DEG1
1217 self.assertEqual(nodeType,'DEGREE')
1218 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1219 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1220 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1221 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1222 listNode.remove(nodeId)
1223 elif(nodeId=='ROADMA01-DEG2'):
1224 #Test related to DEG2
1225 self.assertEqual(nodeType,'DEGREE')
1226 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1227 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1228 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1229 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1230 listNode.remove(nodeId)
1232 self.assertFalse(True)
1233 self.assertEqual(len(listNode),0)
1235 def test_39_disconnect_ROADM_XPDRA_link(self):
1237 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1238 "link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
1239 .format(self.restconf_baseurl))
1241 headers = {'content-type': 'application/json'}
1242 response = requests.request(
1243 "DELETE", url, data=json.dumps(data), headers=headers,
1244 auth=('admin', 'admin'))
1245 self.assertEqual(response.status_code, requests.codes.ok)
1247 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1248 "link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
1249 .format(self.restconf_baseurl))
1251 headers = {'content-type': 'application/json'}
1252 response = requests.request(
1253 "DELETE", url, data=json.dumps(data), headers=headers,
1254 auth=('admin', 'admin'))
1255 self.assertEqual(response.status_code, requests.codes.ok)
1257 def test_40_getLinks_OpenRoadmTopology(self):
1258 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1259 .format(self.restconf_baseurl))
1260 headers = {'content-type': 'application/json'}
1261 response = requests.request(
1262 "GET", url, headers=headers, auth=('admin', 'admin'))
1263 self.assertEqual(response.status_code, requests.codes.ok)
1264 res = response.json()
1265 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1266 self.assertEqual(nbLink,16)
1267 expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
1268 addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
1269 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
1270 dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
1271 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
1272 roadmtoroadmLink = 0
1273 for i in range(0,nbLink):
1274 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
1275 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1276 find= link_id in expressLink
1277 self.assertEqual(find, True)
1278 expressLink.remove(link_id)
1279 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
1280 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1281 find= link_id in addLink
1282 self.assertEqual(find, True)
1283 addLink.remove(link_id)
1284 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
1285 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1286 find= link_id in dropLink
1287 self.assertEqual(find, True)
1288 dropLink.remove(link_id)
1290 roadmtoroadmLink += 1
1291 self.assertEqual(len(expressLink),0)
1292 self.assertEqual(len(addLink),0)
1293 self.assertEqual(len(dropLink),0)
1294 self.assertEqual(roadmtoroadmLink, 6)
1295 for i in range(0,nbLink):
1296 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
1297 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
1299 def test_41_disconnect_ROADMA(self):
1300 url = ("{}/config/network-topology:"
1301 "network-topology/topology/topology-netconf/node/ROADMA01"
1302 .format(self.restconf_baseurl))
1304 headers = {'content-type': 'application/json'}
1305 response = requests.request(
1306 "DELETE", url, data=json.dumps(data), headers=headers,
1307 auth=('admin', 'admin'))
1308 self.assertEqual(response.status_code, requests.codes.ok)
1309 #Delete in the clli-network
1310 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1311 .format(self.restconf_baseurl))
1313 headers = {'content-type': 'application/json'}
1314 response = requests.request(
1315 "DELETE", url, data=json.dumps(data), headers=headers,
1316 auth=('admin', 'admin'))
1317 self.assertEqual(response.status_code, requests.codes.ok)
1319 def test_42_getClliNetwork(self):
1320 url = ("{}/config/ietf-network:networks/network/clli-network"
1321 .format(self.restconf_baseurl))
1322 headers = {'content-type': 'application/json'}
1323 response = requests.request(
1324 "GET", url, headers=headers, auth=('admin', 'admin'))
1325 self.assertEqual(response.status_code, requests.codes.ok)
1326 res = response.json()
1327 self.assertNotIn('node', res['network'][0])
1329 def test_43_getOpenRoadmNetwork(self):
1330 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1331 .format(self.restconf_baseurl))
1332 headers = {'content-type': 'application/json'}
1333 response = requests.request(
1334 "GET", url, headers=headers, auth=('admin', 'admin'))
1335 self.assertEqual(response.status_code, requests.codes.ok)
1336 res = response.json()
1337 self.assertNotIn('node', res['network'][0])
1339 def test_44_check_roadm2roadm_link_persistence(self):
1340 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1341 .format(self.restconf_baseurl))
1342 headers = {'content-type': 'application/json'}
1343 response = requests.request(
1344 "GET", url, headers=headers, auth=('admin', 'admin'))
1345 self.assertEqual(response.status_code, requests.codes.ok)
1346 res = response.json()
1347 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1348 self.assertNotIn('node', res['network'][0])
1349 self.assertEqual(nbLink, 6)
1351 if __name__ == "__main__":
1352 unittest.main(verbosity=2)