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 TransportPCEtesting(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()
76 for child in psutil.Process(cls.honeynode_process3.pid).children():
77 child.send_signal(signal.SIGINT)
79 cls.honeynode_process3.send_signal(signal.SIGINT)
80 cls.honeynode_process3.wait()
81 for child in psutil.Process(cls.honeynode_process4.pid).children():
82 child.send_signal(signal.SIGINT)
84 cls.honeynode_process4.send_signal(signal.SIGINT)
85 cls.honeynode_process4.wait()
93 def test_01_connect_ROADM_A1(self):
95 url = ("{}/config/network-topology:"
96 "network-topology/topology/topology-netconf/node/ROADM-A1"
97 .format(self.restconf_baseurl))
99 "node-id": "ROADM-A1",
100 "netconf-node-topology:username": "admin",
101 "netconf-node-topology:password": "admin",
102 "netconf-node-topology:host": "127.0.0.1",
103 "netconf-node-topology:port": "17841",
104 "netconf-node-topology:tcp-only": "false",
105 "netconf-node-topology:pass-through": {}}]}
106 headers = {'content-type': 'application/json'}
107 response = requests.request(
108 "PUT", url, data=json.dumps(data), headers=headers,
109 auth=('admin', 'admin'))
110 self.assertEqual(response.status_code, requests.codes.created)
113 def test_02_getClliNetwork(self):
114 url = ("{}/config/ietf-network:networks/network/clli-network"
115 .format(self.restconf_baseurl))
116 headers = {'content-type': 'application/json'}
117 response = requests.request(
118 "GET", url, headers=headers, auth=('admin', 'admin'))
119 self.assertEqual(response.status_code, requests.codes.ok)
120 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'],'ROADM-A1')
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'],'model2')
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=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
151 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
152 addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
153 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
154 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
155 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
156 dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
157 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
158 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
159 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
160 for i in range(0,nbLink):
161 linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
162 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
163 find= linkId in expressLink
164 self.assertEqual(find, True)
165 expressLink.remove(linkId)
166 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
167 find= linkId in addLink
168 self.assertEqual(find, True)
169 addLink.remove(linkId)
170 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
171 find= linkId in dropLink
172 self.assertEqual(find, True)
173 dropLink.remove(linkId)
175 self.assertFalse(True)
176 self.assertEqual(len(expressLink),0)
177 self.assertEqual(len(addLink),0)
178 self.assertEqual(len(dropLink),0)
180 def test_05_getNodes_OpenRoadmTopology(self):
181 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
182 .format(self.restconf_baseurl))
183 headers = {'content-type': 'application/json'}
184 response = requests.request(
185 "GET", url, headers=headers, auth=('admin', 'admin'))
186 res = response.json()
187 #Tests related to nodes
188 self.assertEqual(response.status_code, requests.codes.ok)
189 nbNode=len(res['network'][0]['node'])
190 self.assertEqual(nbNode,4)
191 listNode=['ROADM-A1-SRG1', 'ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
192 for i in range(0,nbNode):
193 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
194 res['network'][0]['node'][i]['supporting-node'])
195 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
196 nodeId=res['network'][0]['node'][i]['node-id']
197 if(nodeId=='ROADM-A1-SRG1'):
198 #Test related to SRG1
199 self.assertEqual(nodeType,'SRG')
200 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
201 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
202 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
203 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
204 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
205 listNode.remove(nodeId)
206 elif(nodeId=='ROADM-A1-SRG3'):
207 #Test related to SRG1
208 self.assertEqual(nodeType,'SRG')
209 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
210 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
211 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
212 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
213 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
214 listNode.remove(nodeId)
215 elif(nodeId=='ROADM-A1-DEG1'):
216 #Test related to DEG1
217 self.assertEqual(nodeType,'DEGREE')
218 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
219 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
220 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
221 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
222 listNode.remove(nodeId)
223 elif(nodeId=='ROADM-A1-DEG2'):
224 #Test related to DEG2
225 self.assertEqual(nodeType,'DEGREE')
226 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
227 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
228 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
229 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
230 listNode.remove(nodeId)
232 self.assertFalse(True)
233 self.assertEqual(len(listNode),0)
235 def test_06_connect_XPDRA(self):
236 url = ("{}/config/network-topology:"
237 "network-topology/topology/topology-netconf/node/XPDR-A1"
238 .format(self.restconf_baseurl))
240 "node-id": "XPDR-A1",
241 "netconf-node-topology:username": "admin",
242 "netconf-node-topology:password": "admin",
243 "netconf-node-topology:host": "127.0.0.1",
244 "netconf-node-topology:port": "17840",
245 "netconf-node-topology:tcp-only": "false",
246 "netconf-node-topology:pass-through": {}}]}
247 headers = {'content-type': 'application/json'}
248 response = requests.request(
249 "PUT", url, data=json.dumps(data), headers=headers,
250 auth=('admin', 'admin'))
251 self.assertEqual(response.status_code, requests.codes.created)
254 def test_07_getClliNetwork(self):
255 url = ("{}/config/ietf-network:networks/network/clli-network"
256 .format(self.restconf_baseurl))
257 headers = {'content-type': 'application/json'}
258 response = requests.request(
259 "GET", url, headers=headers, auth=('admin', 'admin'))
260 self.assertEqual(response.status_code, requests.codes.ok)
261 res = response.json()
262 self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
263 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
265 def test_08_getOpenRoadmNetwork(self):
266 url = ("{}/config/ietf-network:networks/network/openroadm-network"
267 .format(self.restconf_baseurl))
268 headers = {'content-type': 'application/json'}
269 response = requests.request(
270 "GET", url, headers=headers, auth=('admin', 'admin'))
271 self.assertEqual(response.status_code, requests.codes.ok)
272 res = response.json()
273 nbNode=len(res['network'][0]['node'])
274 self.assertEqual(nbNode,2)
275 for i in range(0,nbNode):
276 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
277 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
278 nodeId=res['network'][0]['node'][i]['node-id']
279 if(nodeId=='XPDR-A1'):
280 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
281 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
282 elif(nodeId=='ROADM-A1'):
283 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
284 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
286 self.assertFalse(True)
288 def test_09_getNodes_OpenRoadmTopology(self):
289 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
290 .format(self.restconf_baseurl))
291 headers = {'content-type': 'application/json'}
292 response = requests.request(
293 "GET", url, headers=headers, auth=('admin', 'admin'))
294 res = response.json()
295 #Tests related to nodes
296 self.assertEqual(response.status_code, requests.codes.ok)
297 nbNode=len(res['network'][0]['node'])
298 self.assertEqual(nbNode,5)
299 listNode=['XPDR-A1-XPDR1','ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
300 for i in range(0,nbNode):
301 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
302 nodeId=res['network'][0]['node'][i]['node-id']
303 #Tests related to XPDRA nodes
304 if(nodeId=='XPDR-A1-XPDR1'):
305 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
306 res['network'][0]['node'][i]['supporting-node'])
307 self.assertEqual(nodeType,'XPONDER')
308 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
311 for j in range(0,nbTps):
312 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
313 tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
314 if (tpType=='XPONDER-CLIENT'):
316 elif (tpType=='XPONDER-NETWORK'):
318 if (tpId == 'XPDR1-NETWORK2'):
319 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
320 ['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT2')
321 if (tpId == 'XPDR1-CLIENT2'):
322 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
323 ['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
325 self.assertTrue(client == 2)
326 self.assertTrue(network == 2)
327 listNode.remove(nodeId)
328 elif(nodeId=='ROADM-A1-SRG1'):
329 #Test related to SRG1
330 self.assertEqual(nodeType,'SRG')
331 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
332 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
333 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
334 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
335 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
336 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
337 res['network'][0]['node'][i]['supporting-node'])
338 listNode.remove(nodeId)
339 elif(nodeId=='ROADM-A1-SRG3'):
340 #Test related to SRG1
341 self.assertEqual(nodeType,'SRG')
342 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
343 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
344 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
345 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
346 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
347 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
348 res['network'][0]['node'][i]['supporting-node'])
349 listNode.remove(nodeId)
350 elif(nodeId=='ROADM-A1-DEG1'):
351 #Test related to DEG1
352 self.assertEqual(nodeType,'DEGREE')
353 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
354 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
355 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
356 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
357 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
358 res['network'][0]['node'][i]['supporting-node'])
359 listNode.remove(nodeId)
360 elif(nodeId=='ROADM-A1-DEG2'):
361 #Test related to DEG2
362 self.assertEqual(nodeType,'DEGREE')
363 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
364 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
365 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
366 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
367 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
368 res['network'][0]['node'][i]['supporting-node'])
369 listNode.remove(nodeId)
371 self.assertFalse(True)
372 self.assertEqual(len(listNode),0)
374 #Connect the tail XPDRA to ROADMA and vice versa
375 def test_10_connect_tail_xpdr_rdm(self):
376 #Connect the tail: XPDRA to ROADMA
377 url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
378 .format(self.restconf_baseurl))
379 data = {"networkutils:input": {
380 "networkutils:links-input": {
381 "networkutils:xpdr-node": "XPDR-A1",
382 "networkutils:xpdr-num": "1",
383 "networkutils:network-num": "1",
384 "networkutils:rdm-node": "ROADM-A1",
385 "networkutils:srg-num": "1",
386 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
390 headers = {'content-type': 'application/json'}
391 response = requests.request(
392 "POST", url, data=json.dumps(data), headers=headers,
393 auth=('admin', 'admin'))
394 self.assertEqual(response.status_code, requests.codes.ok)
397 def test_11_connect_tail_rdm_xpdr(self):
398 #Connect the tail: ROADMA to XPDRA
399 url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
400 .format(self.restconf_baseurl))
401 data = {"networkutils:input": {
402 "networkutils:links-input": {
403 "networkutils:xpdr-node": "XPDR-A1",
404 "networkutils:xpdr-num": "1",
405 "networkutils:network-num": "1",
406 "networkutils:rdm-node": "ROADM-A1",
407 "networkutils:srg-num": "1",
408 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
412 headers = {'content-type': 'application/json'}
413 response = requests.request(
414 "POST", url, data=json.dumps(data), headers=headers,
415 auth=('admin', 'admin'))
416 self.assertEqual(response.status_code, requests.codes.ok)
419 def test_12_getLinks_OpenRoadmTopology(self):
420 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
421 .format(self.restconf_baseurl))
422 headers = {'content-type': 'application/json'}
423 response = requests.request(
424 "GET", url, headers=headers, auth=('admin', 'admin'))
425 self.assertEqual(response.status_code, requests.codes.ok)
426 res = response.json()
427 #Tests related to links
428 nbLink=len(res['network'][0]['ietf-network-topology:link'])
429 self.assertEqual(nbLink,12)
430 expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX','ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
431 addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
432 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
433 dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
434 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
435 XPDR_IN=['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
436 XPDR_OUT=['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
437 for i in range(0,nbLink):
438 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
439 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
440 if(nodeType=='EXPRESS-LINK'):
441 find= linkId in expressLink
442 self.assertEqual(find, True)
443 expressLink.remove(linkId)
444 elif(nodeType=='ADD-LINK'):
445 find= linkId in addLink
446 self.assertEqual(find, True)
447 addLink.remove(linkId)
448 elif(nodeType=='DROP-LINK'):
449 find= linkId in dropLink
450 self.assertEqual(find, True)
451 dropLink.remove(linkId)
452 elif(nodeType=='XPONDER-INPUT'):
453 find= linkId in XPDR_IN
454 self.assertEqual(find, True)
455 XPDR_IN.remove(linkId)
456 elif(nodeType=='XPONDER-OUTPUT'):
457 find= linkId in XPDR_OUT
458 self.assertEqual(find, True)
459 XPDR_OUT.remove(linkId)
461 self.assertFalse(True)
462 self.assertEqual(len(expressLink),0)
463 self.assertEqual(len(addLink),0)
464 self.assertEqual(len(dropLink),0)
465 self.assertEqual(len(XPDR_IN),0)
466 self.assertEqual(len(XPDR_OUT),0)
468 def test_13_connect_ROADMC(self):
470 url = ("{}/config/network-topology:"
471 "network-topology/topology/topology-netconf/node/ROADM-C1"
472 .format(self.restconf_baseurl))
474 "node-id": "ROADM-C1",
475 "netconf-node-topology:username": "admin",
476 "netconf-node-topology:password": "admin",
477 "netconf-node-topology:host": "127.0.0.1",
478 "netconf-node-topology:port": "17843",
479 "netconf-node-topology:tcp-only": "false",
480 "netconf-node-topology:pass-through": {}}]}
481 headers = {'content-type': 'application/json'}
482 response = requests.request(
483 "PUT", url, data=json.dumps(data), headers=headers,
484 auth=('admin', 'admin'))
485 self.assertEqual(response.status_code, requests.codes.created)
488 def test_14_getClliNetwork(self):
489 url = ("{}/config/ietf-network:networks/network/clli-network"
490 .format(self.restconf_baseurl))
491 headers = {'content-type': 'application/json'}
492 response = requests.request(
493 "GET", url, headers=headers, auth=('admin', 'admin'))
494 self.assertEqual(response.status_code, requests.codes.ok)
495 res = response.json()
496 nbNode=len(res['network'][0]['node'])
497 listNode=['NodeA','NodeC']
498 for i in range(0,nbNode):
499 nodeId = res['network'][0]['node'][i]['node-id']
500 find= nodeId in listNode
501 self.assertEqual(find, True)
503 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
505 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
506 listNode.remove(nodeId)
508 self.assertEqual(len(listNode),0)
510 def test_15_getOpenRoadmNetwork(self):
511 url = ("{}/config/ietf-network:networks/network/openroadm-network"
512 .format(self.restconf_baseurl))
513 headers = {'content-type': 'application/json'}
514 response = requests.request(
515 "GET", url, headers=headers, auth=('admin', 'admin'))
516 self.assertEqual(response.status_code, requests.codes.ok)
517 res = response.json()
518 nbNode=len(res['network'][0]['node'])
519 self.assertEqual(nbNode,3)
520 listNode=['XPDR-A1','ROADM-A1','ROADM-C1']
521 for i in range(0,nbNode):
522 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
523 nodeId=res['network'][0]['node'][i]['node-id']
524 if(nodeId=='XPDR-A1'):
525 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
526 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
527 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
528 listNode.remove(nodeId)
529 elif(nodeId=='ROADM-A1'):
530 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
531 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
532 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
533 listNode.remove(nodeId)
534 elif(nodeId=='ROADM-C1'):
535 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
536 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
537 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
538 listNode.remove(nodeId)
540 self.assertFalse(True)
541 self.assertEqual(len(listNode),0)
543 def test_16_getROADMLinkOpenRoadmTopology(self):
544 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
545 .format(self.restconf_baseurl))
546 headers = {'content-type': 'application/json'}
547 response = requests.request(
548 "GET", url, headers=headers, auth=('admin', 'admin'))
549 self.assertEqual(response.status_code, requests.codes.ok)
550 res = response.json()
551 #Tests related to links
552 nbLink=len(res['network'][0]['ietf-network-topology:link'])
553 self.assertEqual(nbLink,20)
554 expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX','ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
555 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX','ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
556 addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
557 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
558 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX','ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
559 dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
560 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
561 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX','ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
562 R2RLink=['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
563 XPDR_IN=['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
564 XPDR_OUT=['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
565 for i in range(0,nbLink):
566 nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
567 linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
568 if(nodeType=='EXPRESS-LINK'):
569 find= linkId in expressLink
570 self.assertEqual(find, True)
571 expressLink.remove(linkId)
572 elif(nodeType=='ADD-LINK'):
573 find= linkId in addLink
574 self.assertEqual(find, True)
575 addLink.remove(linkId)
576 elif(nodeType=='DROP-LINK'):
577 find= linkId in dropLink
578 self.assertEqual(find, True)
579 dropLink.remove(linkId)
580 elif(nodeType=='ROADM-TO-ROADM'):
581 find= linkId in R2RLink
582 self.assertEqual(find, True)
583 R2RLink.remove(linkId)
584 elif(nodeType=='XPONDER-INPUT'):
585 find= linkId in XPDR_IN
586 self.assertEqual(find, True)
587 XPDR_IN.remove(linkId)
588 elif(nodeType=='XPONDER-OUTPUT'):
589 find= linkId in XPDR_OUT
590 self.assertEqual(find, True)
591 XPDR_OUT.remove(linkId)
593 self.assertFalse(True)
594 self.assertEqual(len(expressLink),0)
595 self.assertEqual(len(addLink),0)
596 self.assertEqual(len(dropLink),0)
597 self.assertEqual(len(R2RLink),0)
598 self.assertEqual(len(XPDR_IN),0)
599 self.assertEqual(len(XPDR_OUT),0)
601 def test_17_getNodes_OpenRoadmTopology(self):
602 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
603 .format(self.restconf_baseurl))
604 headers = {'content-type': 'application/json'}
605 response = requests.request(
606 "GET", url, headers=headers, auth=('admin', 'admin'))
607 res = response.json()
608 #Tests related to nodes
609 self.assertEqual(response.status_code, requests.codes.ok)
610 nbNode=len(res['network'][0]['node'])
611 self.assertEqual(nbNode,8)
612 listNode=['XPDR-A1-XPDR1',
613 'ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2',
614 'ROADM-C1-SRG1','ROADM-C1-DEG1', 'ROADM-C1-DEG2']
615 #************************Tests related to XPDRA nodes
616 for i in range(0,nbNode):
617 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
618 nodeId=res['network'][0]['node'][i]['node-id']
619 if(nodeId=='XPDR-A1-XPDR1'):
620 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
621 res['network'][0]['node'][i]['supporting-node'])
622 self.assertEqual(nodeType,'XPONDER')
623 nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
624 self.assertTrue(nbTps >= 4)
627 for j in range(0,nbTps):
628 tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
629 if (tpType=='XPONDER-CLIENT'):
631 elif (tpType=='XPONDER-NETWORK'):
633 self.assertTrue(client == 2)
634 self.assertTrue(network == 2)
635 listNode.remove(nodeId)
636 elif(nodeId=='ROADM-A1-SRG1'):
637 #Test related to SRG1
638 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
639 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
640 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
641 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
642 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
643 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
644 res['network'][0]['node'][i]['supporting-node'])
645 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
646 listNode.remove(nodeId)
647 elif(nodeId=='ROADM-A1-SRG3'):
648 #Test related to SRG1
649 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
650 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
651 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
652 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
653 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
654 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
655 res['network'][0]['node'][i]['supporting-node'])
656 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
657 listNode.remove(nodeId)
658 elif(nodeId=='ROADM-A1-DEG1'):
659 #Test related to DEG1
660 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
661 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
662 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
663 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
664 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
665 res['network'][0]['node'][i]['supporting-node'])
666 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
667 listNode.remove(nodeId)
668 elif(nodeId=='ROADM-A1-DEG2'):
669 #Test related to DEG2
670 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
671 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
672 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
673 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
674 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
675 res['network'][0]['node'][i]['supporting-node'])
676 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
677 listNode.remove(nodeId)
678 elif(nodeId=='ROADM-C1-SRG1'):
679 #Test related to SRG1
680 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
681 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
682 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
683 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
684 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
685 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
686 res['network'][0]['node'][i]['supporting-node'])
687 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
688 listNode.remove(nodeId)
689 elif(nodeId=='ROADM-C1-DEG1'):
690 #Test related to DEG1
691 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
692 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
693 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
694 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
695 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
696 res['network'][0]['node'][i]['supporting-node'])
697 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
698 listNode.remove(nodeId)
699 elif(nodeId=='ROADM-C1-DEG2'):
700 #Test related to DEG1
701 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
702 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
703 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
704 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
705 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
706 res['network'][0]['node'][i]['supporting-node'])
707 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
708 listNode.remove(nodeId)
710 self.assertFalse(True)
711 self.assertEqual(len(listNode),0)
713 def test_18_connect_ROADMB(self):
714 url = ("{}/config/network-topology:"
715 "network-topology/topology/topology-netconf/node/ROADM-B1"
716 .format(self.restconf_baseurl))
718 "node-id": "ROADM-B1",
719 "netconf-node-topology:username": "admin",
720 "netconf-node-topology:password": "admin",
721 "netconf-node-topology:host": "127.0.0.1",
722 "netconf-node-topology:port": "17842",
723 "netconf-node-topology:tcp-only": "false",
724 "netconf-node-topology:pass-through": {}}]}
725 headers = {'content-type': 'application/json'}
726 response = requests.request(
727 "PUT", url, data=json.dumps(data), headers=headers,
728 auth=('admin', 'admin'))
729 self.assertEqual(response.status_code, requests.codes.created)
732 def test_19_getClliNetwork(self):
733 url = ("{}/config/ietf-network:networks/network/clli-network"
734 .format(self.restconf_baseurl))
735 headers = {'content-type': 'application/json'}
736 response = requests.request(
737 "GET", url, headers=headers, auth=('admin', 'admin'))
738 self.assertEqual(response.status_code, requests.codes.ok)
739 res = response.json()
740 nbNode=len(res['network'][0]['node'])
741 listNode=['NodeA','NodeB','NodeC']
742 for i in range(0,nbNode):
743 nodeId = res['network'][0]['node'][i]['node-id']
744 find= nodeId in listNode
745 self.assertEqual(find, True)
747 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
748 elif(nodeId=='NodeB'):
749 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
751 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
752 listNode.remove(nodeId)
754 self.assertEqual(len(listNode),0)
756 def test_20_verifyDegree(self):
757 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
758 .format(self.restconf_baseurl))
759 headers = {'content-type': 'application/json'}
760 response = requests.request(
761 "GET", url, headers=headers, auth=('admin', 'admin'))
762 self.assertEqual(response.status_code, requests.codes.ok)
763 res = response.json()
764 #Tests related to links
765 nbLink=len(res['network'][0]['ietf-network-topology:link'])
766 listR2RLink=['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
767 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
768 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX','ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
769 for i in range(0,nbLink):
770 if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
771 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
772 find= link_id in listR2RLink
773 self.assertEqual(find, True)
774 listR2RLink.remove(link_id)
775 self.assertEqual(len(listR2RLink),0)
777 def test_21_verifyOppositeLinkTopology(self):
778 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
779 .format(self.restconf_baseurl))
780 headers = {'content-type': 'application/json'}
781 response = requests.request(
782 "GET", url, headers=headers, auth=('admin', 'admin'))
783 self.assertEqual(response.status_code, requests.codes.ok)
784 res = response.json()
785 #Tests related to links
786 nbLink=len(res['network'][0]['ietf-network-topology:link'])
787 self.assertEqual(nbLink,26)
788 for i in range(0,nbLink):
789 link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
790 link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
791 link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
792 link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
793 oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
794 #Find the opposite link
795 url_oppLink="{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
796 url = (url_oppLink.format(self.restconf_baseurl))
797 headers = {'content-type': 'application/json'}
798 response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
799 self.assertEqual(response_oppLink.status_code, requests.codes.ok)
800 res_oppLink = response_oppLink.json()
801 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
802 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
803 self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
804 oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
805 if link_type=='ADD-LINK':
806 self.assertEqual(oppLink_type, 'DROP-LINK')
807 elif link_type=='DROP-LINK':
808 self.assertEqual(oppLink_type, 'ADD-LINK')
809 elif link_type=='EXPRESS-LINK':
810 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
811 elif link_type=='ROADM-TO-ROADM':
812 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
813 elif link_type=='XPONDER-INPUT':
814 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
815 elif link_type=='XPONDER-OUTPUT':
816 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
819 def test_22_disconnect_ROADMB(self):
820 #Delete in the topology-netconf
821 url = ("{}/config/network-topology:"
822 "network-topology/topology/topology-netconf/node/ROADM-B1"
823 .format(self.restconf_baseurl))
825 headers = {'content-type': 'application/json'}
826 response = requests.request(
827 "DELETE", url, data=json.dumps(data), headers=headers,
828 auth=('admin', 'admin'))
829 self.assertEqual(response.status_code, requests.codes.ok)
830 #Delete in the clli-network
831 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
832 .format(self.restconf_baseurl))
834 headers = {'content-type': 'application/json'}
835 response = requests.request(
836 "DELETE", url, data=json.dumps(data), headers=headers,
837 auth=('admin', 'admin'))
838 self.assertEqual(response.status_code, requests.codes.ok)
840 def test_23_disconnect_ROADMC(self):
841 #Delete in the topology-netconf
842 url = ("{}/config/network-topology:"
843 "network-topology/topology/topology-netconf/node/ROADM-C1"
844 .format(self.restconf_baseurl))
846 headers = {'content-type': 'application/json'}
847 response = requests.request(
848 "DELETE", url, data=json.dumps(data), headers=headers,
849 auth=('admin', 'admin'))
850 self.assertEqual(response.status_code, requests.codes.ok)
851 #Delete in the clli-network
852 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
853 .format(self.restconf_baseurl))
855 headers = {'content-type': 'application/json'}
856 response = requests.request(
857 "DELETE", url, data=json.dumps(data), headers=headers,
858 auth=('admin', 'admin'))
859 self.assertEqual(response.status_code, requests.codes.ok)
861 # def test_24_check_roadm2roadm_links_deletion(self):
862 # url = ("{}/config/ietf-network:networks/network/openroadm-topology"
863 # .format(self.restconf_baseurl))
864 # headers = {'content-type': 'application/json'}
865 # response = requests.request(
866 # "GET", url, headers=headers, auth=('admin', 'admin'))
867 # self.assertEqual(response.status_code, requests.codes.ok)
868 # res = response.json()
869 # #Write the response in the log
870 # with open('./transportpce_tests/log/response.log', 'a') as outfile1:
871 # outfile1.write(str(res))
872 # #Tests related to links
873 # nbLink=len(res['network'][0]['ietf-network-topology:link'])
874 # self.assertEqual(nbLink,8)
875 # expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
876 # addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
877 # dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
878 # XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
879 # XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
880 # for i in range(0,nbLink):
881 # nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
882 # linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
883 # if(nodeType=='EXPRESS-LINK'):
884 # find= linkId in expressLink
885 # self.assertEqual(find, True)
886 # expressLink.remove(linkId)
887 # elif(nodeType=='ADD-LINK'):
888 # find= linkId in addLink
889 # self.assertEqual(find, True)
890 # addLink.remove(linkId)
891 # elif(nodeType=='DROP-LINK'):
892 # find= linkId in dropLink
893 # self.assertEqual(find, True)
894 # dropLink.remove(linkId)
895 # elif(nodeType=='XPONDER-INPUT'):
896 # find= linkId in XPDR_IN
897 # self.assertEqual(find, True)
898 # XPDR_IN.remove(linkId)
899 # elif(nodeType=='XPONDER-OUTPUT'):
900 # find= linkId in XPDR_OUT
901 # self.assertEqual(find, True)
902 # XPDR_OUT.remove(linkId)
904 # self.assertFalse(True)
905 # self.assertEqual(len(expressLink),0)
906 # self.assertEqual(len(addLink),0)
907 # self.assertEqual(len(dropLink),0)
908 # self.assertEqual(len(XPDR_IN),0)
909 # self.assertEqual(len(XPDR_OUT),0)
911 # for i in range(0,nbLink):
912 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
913 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
914 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
915 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
916 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
917 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
918 # self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
920 def test_25_getNodes_OpenRoadmTopology(self):
921 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
922 .format(self.restconf_baseurl))
923 headers = {'content-type': 'application/json'}
924 response = requests.request(
925 "GET", url, headers=headers, auth=('admin', 'admin'))
926 res = response.json()
927 #Tests related to nodes
928 self.assertEqual(response.status_code, requests.codes.ok)
929 nbNode=len(res['network'][0]['node'])
930 self.assertEqual(nbNode,5)
931 listNode=['XPDR-A1-XPDR1','ROADM-A1-SRG1', 'ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
932 for i in range(0,nbNode):
933 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
934 nodeId=res['network'][0]['node'][i]['node-id']
935 #Tests related to XPDRA nodes
936 if(nodeId=='XPDR-A1-XPDR1'):
937 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
938 for j in range(0, nbTp):
939 tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
940 if (tpid == 'XPDR1-CLIENT1'):
941 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
942 ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
943 self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
944 ['org-openroadm-network-topology:xpdr-client-attributes']['tail-equipment-id'],
946 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
947 res['network'][0]['node'][i]['supporting-node'])
948 listNode.remove(nodeId)
949 elif(nodeId=='ROADM-A1-SRG1'):
950 #Test related to SRG1
951 self.assertEqual(nodeType,'SRG')
952 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
953 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
954 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
955 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
956 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
957 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
958 res['network'][0]['node'][i]['supporting-node'])
959 listNode.remove(nodeId)
960 elif(nodeId=='ROADM-A1-SRG3'):
961 #Test related to SRG1
962 self.assertEqual(nodeType,'SRG')
963 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
964 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
965 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
966 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
967 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
968 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
969 res['network'][0]['node'][i]['supporting-node'])
970 listNode.remove(nodeId)
971 elif(nodeId=='ROADM-A1-DEG1'):
972 #Test related to DEG1
973 self.assertEqual(nodeType,'DEGREE')
974 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
975 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
976 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
977 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
978 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
979 res['network'][0]['node'][i]['supporting-node'])
980 listNode.remove(nodeId)
981 elif(nodeId=='ROADM-A1-DEG2'):
982 #Test related to DEG2
983 self.assertEqual(nodeType,'DEGREE')
984 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
985 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
986 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
987 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
988 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
989 res['network'][0]['node'][i]['supporting-node'])
990 listNode.remove(nodeId)
992 self.assertFalse(True)
993 self.assertEqual(len(listNode),0)
994 #Test related to SRG1 of ROADMC
995 for i in range(0,nbNode):
996 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-SRG1')
997 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-DEG1')
998 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-DEG2')
1000 def test_26_getOpenRoadmNetwork(self):
1001 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1002 .format(self.restconf_baseurl))
1003 headers = {'content-type': 'application/json'}
1004 response = requests.request(
1005 "GET", url, headers=headers, auth=('admin', 'admin'))
1006 self.assertEqual(response.status_code, requests.codes.ok)
1007 res = response.json()
1008 nbNode=len(res['network'][0]['node'])
1009 self.assertEqual(nbNode,2)
1010 for i in range(0,nbNode-1):
1011 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1')
1012 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-B1')
1014 def test_27_getClliNetwork(self):
1015 url = ("{}/config/ietf-network:networks/network/clli-network"
1016 .format(self.restconf_baseurl))
1017 headers = {'content-type': 'application/json'}
1018 response = requests.request(
1019 "GET", url, headers=headers, auth=('admin', 'admin'))
1020 self.assertEqual(response.status_code, requests.codes.ok)
1021 res = response.json()
1022 nbNode=len(res['network'][0]['node'])
1023 self.assertEqual(nbNode,1)
1024 for i in range(0,nbNode-1):
1025 self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
1027 def test_28_disconnect_XPDRA(self):
1028 url = ("{}/config/network-topology:"
1029 "network-topology/topology/topology-netconf/node/XPDR-A1"
1030 .format(self.restconf_baseurl))
1032 headers = {'content-type': 'application/json'}
1033 response = requests.request(
1034 "DELETE", url, data=json.dumps(data), headers=headers,
1035 auth=('admin', 'admin'))
1036 self.assertEqual(response.status_code, requests.codes.ok)
1038 def test_29_getClliNetwork(self):
1039 url = ("{}/config/ietf-network:networks/network/clli-network"
1040 .format(self.restconf_baseurl))
1041 headers = {'content-type': 'application/json'}
1042 response = requests.request(
1043 "GET", url, headers=headers, auth=('admin', 'admin'))
1044 self.assertEqual(response.status_code, requests.codes.ok)
1045 res = response.json()
1046 nbNode=len(res['network'][0]['node'])
1047 self.assertEqual(nbNode,1)
1048 self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
1050 def test_30_getOpenRoadmNetwork(self):
1051 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1052 .format(self.restconf_baseurl))
1053 headers = {'content-type': 'application/json'}
1054 response = requests.request(
1055 "GET", url, headers=headers, auth=('admin', 'admin'))
1056 self.assertEqual(response.status_code, requests.codes.ok)
1057 res = response.json()
1058 nbNode=len(res['network'][0]['node'])
1059 self.assertEqual(nbNode,1)
1060 for i in range(0,nbNode):
1061 self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDR-A1')
1063 def test_31_getNodes_OpenRoadmTopology(self):
1064 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1065 .format(self.restconf_baseurl))
1066 headers = {'content-type': 'application/json'}
1067 response = requests.request(
1068 "GET", url, headers=headers, auth=('admin', 'admin'))
1069 res = response.json()
1070 #Tests related to nodes
1071 self.assertEqual(response.status_code, requests.codes.ok)
1072 nbNode=len(res['network'][0]['node'])
1073 self.assertEqual(nbNode,4)
1074 listNode=['ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
1075 for i in range(0,nbNode):
1076 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
1077 res['network'][0]['node'][i]['supporting-node'])
1078 nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
1079 nodeId=res['network'][0]['node'][i]['node-id']
1080 if(nodeId=='ROADM-A1-SRG1'):
1081 #Test related to SRG1
1082 self.assertEqual(nodeType,'SRG')
1083 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
1084 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1085 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1086 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1087 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1088 listNode.remove(nodeId)
1089 elif(nodeId=='ROADM-A1-SRG3'):
1090 #Test related to SRG1
1091 self.assertEqual(nodeType,'SRG')
1092 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
1093 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
1094 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1095 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1096 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1097 listNode.remove(nodeId)
1098 elif(nodeId=='ROADM-A1-DEG1'):
1099 #Test related to DEG1
1100 self.assertEqual(nodeType,'DEGREE')
1101 self.assertIn({'tp-id': 'DEG1-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': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1104 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1105 listNode.remove(nodeId)
1106 elif(nodeId=='ROADM-A1-DEG2'):
1107 #Test related to DEG2
1108 self.assertEqual(nodeType,'DEGREE')
1109 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1110 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1111 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1112 res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1113 listNode.remove(nodeId)
1115 self.assertFalse(True)
1116 self.assertEqual(len(listNode),0)
1118 def test_32_disconnect_ROADM_XPDRA_link(self):
1120 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1121 "link/XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX"
1122 .format(self.restconf_baseurl))
1124 headers = {'content-type': 'application/json'}
1125 response = requests.request(
1126 "DELETE", url, data=json.dumps(data), headers=headers,
1127 auth=('admin', 'admin'))
1128 self.assertEqual(response.status_code, requests.codes.ok)
1130 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
1131 "link/ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1"
1132 .format(self.restconf_baseurl))
1134 headers = {'content-type': 'application/json'}
1135 response = requests.request(
1136 "DELETE", url, data=json.dumps(data), headers=headers,
1137 auth=('admin', 'admin'))
1138 self.assertEqual(response.status_code, requests.codes.ok)
1140 def test_33_getLinks_OpenRoadmTopology(self):
1141 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1142 .format(self.restconf_baseurl))
1143 headers = {'content-type': 'application/json'}
1144 response = requests.request(
1145 "GET", url, headers=headers, auth=('admin', 'admin'))
1146 self.assertEqual(response.status_code, requests.codes.ok)
1147 res = response.json()
1148 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1149 self.assertEqual(nbLink, 16)
1150 expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX','ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1151 addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1152 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1153 dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1154 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1155 roadmtoroadmLink = 0
1156 for i in range(0,nbLink):
1157 if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
1158 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1159 find= link_id in expressLink
1160 self.assertEqual(find, True)
1161 expressLink.remove(link_id)
1162 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
1163 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1164 find= link_id in addLink
1165 self.assertEqual(find, True)
1166 addLink.remove(link_id)
1167 elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
1168 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1169 find= link_id in dropLink
1170 self.assertEqual(find, True)
1171 dropLink.remove(link_id)
1173 roadmtoroadmLink += 1
1174 self.assertEqual(len(expressLink),0)
1175 self.assertEqual(len(addLink),0)
1176 self.assertEqual(len(dropLink),0)
1177 self.assertEqual(roadmtoroadmLink, 6)
1178 for i in range(0,nbLink):
1179 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
1180 self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
1182 def test_34_disconnect_ROADMA(self):
1183 url = ("{}/config/network-topology:"
1184 "network-topology/topology/topology-netconf/node/ROADM-A1"
1185 .format(self.restconf_baseurl))
1187 headers = {'content-type': 'application/json'}
1188 response = requests.request(
1189 "DELETE", url, data=json.dumps(data), headers=headers,
1190 auth=('admin', 'admin'))
1191 self.assertEqual(response.status_code, requests.codes.ok)
1192 #Delete in the clli-network
1193 url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
1194 .format(self.restconf_baseurl))
1196 headers = {'content-type': 'application/json'}
1197 response = requests.request(
1198 "DELETE", url, data=json.dumps(data), headers=headers,
1199 auth=('admin', 'admin'))
1200 self.assertEqual(response.status_code, requests.codes.ok)
1202 def test_35_getClliNetwork(self):
1203 url = ("{}/config/ietf-network:networks/network/clli-network"
1204 .format(self.restconf_baseurl))
1205 headers = {'content-type': 'application/json'}
1206 response = requests.request(
1207 "GET", url, headers=headers, auth=('admin', 'admin'))
1208 self.assertEqual(response.status_code, requests.codes.ok)
1209 res = response.json()
1210 self.assertNotIn('node', res['network'][0])
1212 def test_36_getOpenRoadmNetwork(self):
1213 url = ("{}/config/ietf-network:networks/network/openroadm-network"
1214 .format(self.restconf_baseurl))
1215 headers = {'content-type': 'application/json'}
1216 response = requests.request(
1217 "GET", url, headers=headers, auth=('admin', 'admin'))
1218 self.assertEqual(response.status_code, requests.codes.ok)
1219 res = response.json()
1220 self.assertNotIn('node', res['network'][0])
1222 def test_37_check_roadm2roadm_link_persistence(self):
1223 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
1224 .format(self.restconf_baseurl))
1225 headers = {'content-type': 'application/json'}
1226 response = requests.request(
1227 "GET", url, headers=headers, auth=('admin', 'admin'))
1228 self.assertEqual(response.status_code, requests.codes.ok)
1229 res = response.json()
1230 nbLink=len(res['network'][0]['ietf-network-topology:link'])
1231 self.assertNotIn('node', res['network'][0])
1232 self.assertEqual(nbLink, 6)
1234 if __name__ == "__main__":
1235 unittest.main(verbosity=2)