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 ##############################################################################
19 from common import test_utils
22 class TransportGNPYtesting(unittest.TestCase):
25 def __init_logfile(cls):
26 if os.path.isfile("./transportpce_tests/gnpy.log"):
27 os.remove("transportpce_tests/gnpy.log")
30 restconf_baseurl = "http://localhost:8181/restconf"
34 cls.processes = test_utils.start_tpce()
37 def tearDownClass(cls):
38 for process in cls.processes:
39 test_utils.shutdown_process(process)
40 print("all processes killed")
45 # Mount the different topologies
46 def test_01_connect_clliNetwork(self):
47 url = ("{}/config/ietf-network:networks/network/clli-network"
48 .format(self.restconf_baseurl))
49 topo_cllinet_file = "sample_configs/gnpy/clliNetwork.json"
50 if os.path.isfile(topo_cllinet_file):
51 with open(topo_cllinet_file, 'r') as clli_net:
52 body = clli_net.read()
53 headers = {'content-type': 'application/json'}
54 response = requests.request(
55 "PUT", url, data=body, headers=headers,
56 auth=('admin', 'admin'))
57 self.assertEqual(response.status_code, requests.codes.ok)
60 def test_02_connect_openroadmNetwork(self):
61 url = ("{}/config/ietf-network:networks/network/openroadm-network"
62 .format(self.restconf_baseurl))
63 topo_ordnet_file = "sample_configs/gnpy/openroadmNetwork.json"
64 if os.path.isfile(topo_ordnet_file):
65 with open(topo_ordnet_file, 'r') as ord_net:
67 headers = {'content-type': 'application/json'}
68 response = requests.request(
69 "PUT", url, data=body, headers=headers,
70 auth=('admin', 'admin'))
71 self.assertEqual(response.status_code, requests.codes.ok)
74 def test_03_connect_openroadmTopology(self):
75 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
76 .format(self.restconf_baseurl))
77 topo_ordtopo_file = "sample_configs/gnpy/openroadmTopology.json"
78 if os.path.isfile(topo_ordtopo_file):
79 with open(topo_ordtopo_file, 'r') as ord_topo:
80 body = ord_topo.read()
81 headers = {'content-type': 'application/json'}
82 response = requests.request(
83 "PUT", url, data=body, headers=headers,
84 auth=('admin', 'admin'))
85 self.assertEqual(response.status_code, requests.codes.ok)
88 # Path computed by PCE is feasible according to Gnpy
89 def test_04_path_computation_FeasibleWithPCE(self):
90 url = ("{}/operations/transportpce-pce:path-computation-request"
91 .format(self.restconf_baseurl))
94 "service-name": "service-1",
95 "resource-reserve": "true",
96 "pce-metric": "hop-count",
97 "service-handler-header": {
98 "request-id": "request-1"
101 "node-id": "XPONDER-1",
102 "service-rate": "100",
103 "service-format": "Ethernet",
107 "node-id": "XPONDER-5",
108 "service-rate": "100",
109 "service-format": "Ethernet",
114 headers = {'content-type': 'application/json',
115 "Accept": "application/json"}
116 response = requests.request(
117 "POST", url, data=json.dumps(body), headers=headers,
118 auth=('admin', 'admin'))
119 self.assertEqual(response.status_code, requests.codes.ok)
120 res = response.json()
121 self.assertEqual(res['output']['configuration-response-common'][
122 'response-code'], '200')
123 self.assertEqual(res['output']['configuration-response-common'][
125 'Path is calculated by PCE')
126 self.assertEqual(res['output']['gnpy-response'][0]['path-dir'],
128 self.assertEqual(res['output']['gnpy-response'][0]['feasibility'], True)
129 self.assertEqual(res['output']['gnpy-response'][1]['path-dir'],
131 self.assertEqual(res['output']['gnpy-response'][1]['feasibility'], True)
134 # Path computed by PCE is not feasible by GNPy and GNPy cannot find
135 # another one (low SNR)
136 def test_05_path_computation_FoundByPCE_NotFeasibleByGnpy(self):
137 url = ("{}/operations/transportpce-pce:path-computation-request"
138 .format(self.restconf_baseurl))
141 "service-name": "service-2",
142 "resource-reserve": "true",
143 "pce-metric": "hop-count",
144 "service-handler-header": {
145 "request-id": "request-2"
148 "node-id": "XPONDER-1",
149 "service-rate": "100",
150 "service-format": "Ethernet",
154 "node-id": "XPONDER-5",
155 "service-rate": "100",
156 "service-format": "Ethernet",
159 "hard-constraints": {
165 "node-id": "OpenROADM-2"
171 "node-id": "OpenROADM-3"
177 "node-id": "OpenROADM-4"
185 headers = {'content-type': 'application/json',
186 "Accept": "application/json"}
187 response = requests.request(
188 "POST", url, data=json.dumps(body), headers=headers,
189 auth=('admin', 'admin'))
190 self.assertEqual(response.status_code, requests.codes.ok)
191 res = response.json()
192 self.assertEqual(res['output']['configuration-response-common'][
193 'response-code'], '500')
194 self.assertEqual(res['output']['configuration-response-common'][
196 'No path available by PCE and GNPy ')
197 self.assertEqual(res['output']['gnpy-response'][0]['path-dir'],
199 self.assertEqual(res['output']['gnpy-response'][0]['feasibility'],
201 self.assertEqual(res['output']['gnpy-response'][1]['path-dir'],
203 self.assertEqual(res['output']['gnpy-response'][1]['feasibility'],
207 # #PCE cannot find a path while GNPy finds a feasible one
208 def test_06_path_computation_NotFoundByPCE_FoundByGNPy(self):
209 url = ("{}/operations/transportpce-pce:path-computation-request"
210 .format(self.restconf_baseurl))
213 "service-name": "service-3",
214 "resource-reserve": "true",
215 "pce-metric": "hop-count",
216 "service-handler-header": {
217 "request-id": "request-3"
220 "node-id": "XPONDER-1",
221 "service-rate": "100",
222 "service-format": "Ethernet",
226 "node-id": "XPONDER-4",
227 "service-rate": "100",
228 "service-format": "Ethernet",
231 "hard-constraints": {
237 "node-id": "OpenROADM-2"
243 "node-id": "OpenROADM-3"
251 headers = {'content-type': 'application/json',
252 "Accept": "application/json"}
253 response = requests.request(
254 "POST", url, data=json.dumps(body), headers=headers,
255 auth=('admin', 'admin'))
256 self.assertEqual(response.status_code, requests.codes.ok)
257 res = response.json()
258 self.assertEqual(res['output']['configuration-response-common'][
259 'response-code'], '200')
260 self.assertEqual(res['output']['configuration-response-common'][
262 'Path is calculated by GNPy')
263 self.assertEqual(res['output']['gnpy-response'][0]['path-dir'],
265 self.assertEqual(res['output']['gnpy-response'][0]['feasibility'], True)
266 self.assertEqual(res['output']['gnpy-response'][1]['path-dir'],
268 self.assertEqual(res['output']['gnpy-response'][1]['feasibility'], True)
271 # Not found path by PCE and GNPy cannot find another one
272 def test_07_path_computation_FoundByPCE_NotFeasibleByGnpy(self):
273 url = ("{}/operations/transportpce-pce:path-computation-request"
274 .format(self.restconf_baseurl))
277 "service-name": "service-4",
278 "resource-reserve": "true",
279 "pce-metric": "hop-count",
280 "service-handler-header": {
281 "request-id": "request-4"
284 "node-id": "XPONDER-1",
285 "service-rate": "100",
286 "service-format": "Ethernet",
290 "node-id": "XPONDER-4",
291 "service-rate": "100",
292 "service-format": "Ethernet",
295 "hard-constraints": {
301 "node-id": "OpenROADM-2"
307 "node-id": "OpenROADM-3"
313 "node-id": "OpenROADM-4"
319 "node-id": "OpenROADM-3"
327 headers = {'content-type': 'application/json',
328 "Accept": "application/json"}
329 response = requests.request(
330 "POST", url, data=json.dumps(body), headers=headers,
331 auth=('admin', 'admin'))
332 self.assertEqual(response.status_code, requests.codes.ok)
333 res = response.json()
334 self.assertEqual(res['output']['configuration-response-common'][
335 'response-code'], '500')
336 self.assertEqual(res['output']['configuration-response-common'][
338 'No path available by PCE and GNPy ')
341 # Disconnect the different topologies
342 def test_08_disconnect_openroadmTopology(self):
343 url = ("{}/config/ietf-network:networks/network/openroadm-topology"
344 .format(self.restconf_baseurl))
346 headers = {'content-type': 'application/json'}
347 response = requests.request(
348 "DELETE", url, data=json.dumps(data), headers=headers,
349 auth=('admin', 'admin'))
350 self.assertEqual(response.status_code, requests.codes.ok)
353 def test_09_disconnect_openroadmNetwork(self):
354 url = ("{}/config/ietf-network:networks/network/openroadm-network"
355 .format(self.restconf_baseurl))
357 headers = {'content-type': 'application/json'}
358 response = requests.request(
359 "DELETE", url, data=json.dumps(data), headers=headers,
360 auth=('admin', 'admin'))
361 self.assertEqual(response.status_code, requests.codes.ok)
364 def test_10_disconnect_clliNetwork(self):
365 url = ("{}/config/ietf-network:networks/network/clli-network"
366 .format(self.restconf_baseurl))
368 headers = {'content-type': 'application/json'}
369 response = requests.request(
370 "DELETE", url, data=json.dumps(data), headers=headers,
371 auth=('admin', 'admin'))
372 self.assertEqual(response.status_code, requests.codes.ok)
376 if __name__ == "__main__":
377 # logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
378 unittest.main(verbosity=2)