2 Copyright (c) 2015 SONATA-NFV
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
18 nor the names of its contributors may be used to endorse or promote
19 products derived from this software without specific prior written
22 This work has been performed in the framework of the SONATA project,
23 funded by the European Commission under Grant number 671517 through
24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
25 acknowledge the contributions of their colleagues of the SONATA
26 partner consortium (www.sonata-nfv.eu).
30 Test suite to automatically test emulator REST API endpoints.
36 import simplejson
as json
39 from emuvim
.test
.api_base_openstack
import ApiBaseOpenStack
42 class testRestApi(ApiBaseOpenStack
):
44 Tests to check the REST API endpoints of the emulator.
49 self
.createNet(nswitches
=3, ndatacenter
=2, nhosts
=2, ndockers
=0, autolinkswitches
=True)
52 self
.net
.addLink(self
.dc
[0], self
.h
[0])
53 self
.net
.addLink(self
.h
[1], self
.dc
[1])
54 self
.net
.addLink(self
.dc
[0], self
.dc
[1])
59 # start Mininet network
62 def testNovaDummy(self
):
63 print('->>>>>>> test Nova Dummy Class->>>>>>>>>>>>>>>')
64 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
67 headers
= {'Content-type': 'application/json'}
68 test_heatapi_template_create_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "test_heatapi_template_create_stack.json")).read()
69 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
70 requests
.post(url
, data
=json
.dumps(json
.loads(test_heatapi_template_create_stack
)),
73 print('->>>>>>> test Nova List Versions ->>>>>>>>>>>>>>>')
74 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
75 url
= "http://0.0.0.0:18774/"
76 listapiversionnovaresponse
= requests
.get(url
, headers
=headers
)
77 self
.assertEqual(listapiversionnovaresponse
.status_code
, 200)
78 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["id"], "v2.1")
79 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["status"], "CURRENT")
80 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["version"], "2.38")
81 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["min_version"], "2.1")
82 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["updated"], "2013-07-23T11:33:21Z")
85 print('->>>>>>> test Nova Version Show ->>>>>>>>>>>>>>>')
86 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
87 url
= "http://0.0.0.0:18774/v2.1/id_bla"
88 listapiversion21novaresponse
= requests
.get(url
, headers
=headers
)
89 self
.assertEqual(listapiversion21novaresponse
.status_code
, 200)
90 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["id"], "v2.1")
91 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["status"], "CURRENT")
92 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["version"], "2.38")
93 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["min_version"], "2.1")
94 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["updated"], "2013-07-23T11:33:21Z")
97 print('->>>>>>> test Nova Version List Server APIs ->>>>>>>>>>>>>>>')
98 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
99 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers"
100 listserverapisnovaresponse
= requests
.get(url
, headers
=headers
)
101 self
.assertEqual(listserverapisnovaresponse
.status_code
, 200)
102 self
.assertNotEqual(json
.loads(listserverapisnovaresponse
.content
)["servers"][0]["name"], "")
105 print('->>>>>>> test Nova Delete Server APIs ->>>>>>>>>>>>>>>')
106 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
107 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json
.loads(listserverapisnovaresponse
.content
)["servers"][0]["id"])
108 deleteserverapisnovaresponse
= requests
.delete(url
, headers
=headers
)
109 self
.assertEqual(deleteserverapisnovaresponse
.status_code
, 204)
112 print('->>>>>>> test Nova Delete Non-Existing Server APIs ->>>>>>>>>>>>>>>')
113 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
114 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/non-existing-ix"
115 deleteserverapisnovaresponse
= requests
.delete(url
, headers
=headers
)
116 self
.assertEqual(deleteserverapisnovaresponse
.status_code
, 404)
120 print('->>>>>>> testNovaVersionListServerAPIs_withPortInformation ->>>>>>>>>>>>>>>')
121 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
122 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/andPorts"
123 listserverapisnovaresponse
= requests
.get(url
, headers
=headers
)
124 self
.assertEqual(listserverapisnovaresponse
.status_code
, 200)
125 self
.assertNotEqual(json
.loads(listserverapisnovaresponse
.content
)["servers"][0]["name"], "")
128 print('->>>>>>> test Nova List Flavors ->>>>>>>>>>>>>>>')
129 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
130 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors"
131 listflavorsresponse
= requests
.get(url
, headers
=headers
)
132 self
.assertEqual(listflavorsresponse
.status_code
, 200)
133 self
.assertIn(json
.loads(listflavorsresponse
.content
)["flavors"][0]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
134 self
.assertIn(json
.loads(listflavorsresponse
.content
)["flavors"][1]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
135 self
.assertIn(json
.loads(listflavorsresponse
.content
)["flavors"][2]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
138 print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
139 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
140 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors"
141 addflavorsresponse
= requests
.post(url
,
142 data
='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
144 self
.assertEqual(addflavorsresponse
.status_code
, 200)
145 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["id"])
146 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["links"][0]['href'])
149 print('->>>>>>> test Nova List Flavors Detail ->>>>>>>>>>>>>>>')
150 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
151 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
152 listflavorsdetailresponse
= requests
.get(url
, headers
=headers
)
153 self
.assertEqual(listflavorsdetailresponse
.status_code
, 200)
154 self
.assertIn(json
.loads(listflavorsdetailresponse
.content
)["flavors"][0]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
155 self
.assertIn(json
.loads(listflavorsdetailresponse
.content
)["flavors"][1]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
156 self
.assertIn(json
.loads(listflavorsdetailresponse
.content
)["flavors"][2]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
159 print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
160 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
161 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
162 addflavorsresponse
= requests
.post(url
,
163 data
='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
165 self
.assertEqual(addflavorsresponse
.status_code
, 200)
166 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["id"])
167 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["links"][0]['href'])
170 print('->>>>>>> test Nova List Flavor By Id ->>>>>>>>>>>>>>>')
172 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
173 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors/%s" % (json
.loads(listflavorsdetailresponse
.content
)["flavors"][0]["name"])
174 listflavorsbyidresponse
= requests
.get(url
, headers
=headers
)
175 self
.assertEqual(listflavorsbyidresponse
.status_code
, 200)
176 self
.assertEqual(json
.loads(listflavorsbyidresponse
.content
)["flavor"]["id"], json
.loads(listflavorsdetailresponse
.content
)["flavors"][0]["id"])
179 print('->>>>>>> test Nova List Images ->>>>>>>>>>>>>>>')
180 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
181 url
= "http://0.0.0.0:18774/v2.1/id_bla/images"
182 listimagesresponse
= requests
.get(url
, headers
=headers
)
183 self
.assertEqual(listimagesresponse
.status_code
, 200)
184 print(listimagesresponse
.content
)
185 # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
186 #self.assertIn(json.loads(listimagesresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
187 #self.assertIn(json.loads(listimagesresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
188 #self.assertIn(json.loads(listimagesresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
191 print('->>>>>>> test Nova List Images Details ->>>>>>>>>>>>>>>')
192 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
193 url
= "http://0.0.0.0:18774/v2.1/id_bla/images/detail"
194 listimagesdetailsresponse
= requests
.get(url
, headers
=headers
)
195 self
.assertEqual(listimagesdetailsresponse
.status_code
, 200)
196 # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
197 #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
198 #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
199 #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
200 self
.assertEqual(json
.loads(listimagesdetailsresponse
.content
)["images"][0]["metadata"]["architecture"],"x86_64")
203 print('->>>>>>> test Nova List Image By Id ->>>>>>>>>>>>>>>')
204 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
205 url
= "http://0.0.0.0:18774/v2.1/id_bla/images/%s" % (json
.loads(listimagesdetailsresponse
.content
)["images"][0]["id"])
206 listimagebyidresponse
= requests
.get(url
, headers
=headers
)
207 self
.assertEqual(listimagebyidresponse
.status_code
, 200)
208 self
.assertEqual(json
.loads(listimagebyidresponse
.content
)["image"]["id"],json
.loads(listimagesdetailsresponse
.content
)["images"][0]["id"])
211 print('->>>>>>> test Nova List Image By Non-Existend Id ->>>>>>>>>>>>>>>')
212 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
213 url
= "http://0.0.0.0:18774/v2.1/id_bla/images/non_existing_id"
214 listimagebynonexistingidresponse
= requests
.get(url
, headers
=headers
)
215 self
.assertEqual(listimagebynonexistingidresponse
.status_code
, 404)
219 for image
in json
.loads(listimagesresponse
.content
)["images"]:
220 if image
["name"] == "ubuntu:trusty":
221 ubuntu_image_id
= image
["id"]
223 print('->>>>>>> test Nova Create Server Instance ->>>>>>>>>>>>>>>')
224 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
225 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers"
226 data
= '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json
.loads(listflavorsresponse
.content
)["flavors"][0]["id"], ubuntu_image_id
)
227 createserverinstance
= requests
.post(url
, data
=data
, headers
=headers
)
228 self
.assertEqual(createserverinstance
.status_code
, 200)
229 self
.assertEqual(json
.loads(createserverinstance
.content
)["server"]["image"]["id"], ubuntu_image_id
)
232 print('->>>>>>> test Nova Create Server Instance With Already Existing Name ->>>>>>>>>>>>>>>')
233 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
234 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers"
235 data
= '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json
.loads(listflavorsresponse
.content
)["flavors"][0]["id"], ubuntu_image_id
)
236 createserverinstance
= requests
.post(url
, data
=data
, headers
=headers
)
237 self
.assertEqual(createserverinstance
.status_code
, 409)
240 print('->>>>>>> test Nova Version List Server APIs Detailed ->>>>>>>>>>>>>>>')
241 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
242 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/detail"
243 listserverapisdetailedresponse
= requests
.get(url
, headers
=headers
)
244 self
.assertEqual(listserverapisdetailedresponse
.status_code
, 200)
245 self
.assertEqual(json
.loads(listserverapisdetailedresponse
.content
)["servers"][0]["status"], "ACTIVE")
248 print('->>>>>>> test Nova Show Server Details ->>>>>>>>>>>>>>>')
249 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
250 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json
.loads(listserverapisdetailedresponse
.content
)["servers"][0]["id"])
251 listserverdetailsresponse
= requests
.get(url
, headers
=headers
)
252 self
.assertEqual(listserverdetailsresponse
.status_code
, 200)
253 self
.assertEqual(json
.loads(listserverdetailsresponse
.content
)["server"]["flavor"]["links"][0]["rel"], "bookmark")
256 print('->>>>>>> test Nova Show Non-Existing Server Details ->>>>>>>>>>>>>>>')
257 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
258 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/non_existing_server_id"
259 listnonexistingserverdetailsresponse
= requests
.get(url
, headers
=headers
)
260 self
.assertEqual(listnonexistingserverdetailsresponse
.status_code
, 404)
263 def testNeutronDummy(self
):
264 print('->>>>>>> test Neutron Dummy Class->>>>>>>>>>>>>>>')
265 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
268 headers
= {'Content-type': 'application/json'}
269 test_heatapi_template_create_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "test_heatapi_template_create_stack.json")).read()
270 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
271 requests
.post(url
, data
=json
.dumps(json
.loads(test_heatapi_template_create_stack
)), headers
=headers
)
272 # test_heatapi_keystone_get_token = open("test_heatapi_keystone_get_token.json").read()
274 print('->>>>>>> test Neutron List Versions ->>>>>>>>>>>>>>>')
275 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
276 url
= "http://0.0.0.0:19696/"
277 listapiversionstackresponse
= requests
.get(url
, headers
=headers
)
278 self
.assertEqual(listapiversionstackresponse
.status_code
, 200)
279 self
.assertEqual(json
.loads(listapiversionstackresponse
.content
)["versions"][0]["id"], "v2.0")
282 print('->>>>>>> test Neutron Show API v2.0 ->>>>>>>>>>>>>>>')
283 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
284 url
= "http://0.0.0.0:19696/v2.0"
285 listapiversionv20response
= requests
.get(url
, headers
=headers
)
286 self
.assertEqual(listapiversionv20response
.status_code
, 200)
287 self
.assertEqual(json
.loads(listapiversionv20response
.content
)["resources"][0]["name"], "subnet")
288 self
.assertEqual(json
.loads(listapiversionv20response
.content
)["resources"][1]["name"], "network")
289 self
.assertEqual(json
.loads(listapiversionv20response
.content
)["resources"][2]["name"], "ports")
292 print('->>>>>>> test Neutron List Networks ->>>>>>>>>>>>>>>')
293 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
294 url
= "http://0.0.0.0:19696/v2.0/networks"
295 listnetworksesponse1
= requests
.get(url
, headers
=headers
)
296 self
.assertEqual(listnetworksesponse1
.status_code
, 200)
297 self
.assertEqual(json
.loads(listnetworksesponse1
.content
)["networks"][0]["status"], "ACTIVE")
298 listNetworksId
= json
.loads(listnetworksesponse1
.content
)["networks"][0]["id"]
299 listNetworksName
= json
.loads(listnetworksesponse1
.content
)["networks"][0]["name"]
300 listNetworksId2
= json
.loads(listnetworksesponse1
.content
)["networks"][1]["id"]
303 print('->>>>>>> test Neutron List Non-Existing Networks ->>>>>>>>>>>>>>>')
304 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
305 url
= "http://0.0.0.0:19696/v2.0/networks?name=non_existent_network_name"
306 listnetworksesponse2
= requests
.get(url
,headers
=headers
)
307 self
.assertEqual(listnetworksesponse2
.status_code
, 404)
310 print('->>>>>>> test Neutron List Networks By Name ->>>>>>>>>>>>>>>')
311 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
312 url
= "http://0.0.0.0:19696/v2.0/networks?name=" + listNetworksName
#tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
313 listnetworksesponse3
= requests
.get(url
, headers
=headers
)
314 self
.assertEqual(listnetworksesponse3
.status_code
, 200)
315 self
.assertEqual(json
.loads(listnetworksesponse3
.content
)["networks"][0]["name"], listNetworksName
)
318 print('->>>>>>> test Neutron List Networks By Id ->>>>>>>>>>>>>>>')
319 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
320 url
= "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId
# tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
321 listnetworksesponse4
= requests
.get(url
, headers
=headers
)
322 self
.assertEqual(listnetworksesponse4
.status_code
, 200)
323 self
.assertEqual(json
.loads(listnetworksesponse4
.content
)["networks"][0]["id"], listNetworksId
)
326 print('->>>>>>> test Neutron List Networks By Multiple Ids ->>>>>>>>>>>>>>>')
327 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
328 url
= "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId
+ "&id="+ listNetworksId2
# tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
329 listnetworksesponse5
= requests
.get(url
, headers
=headers
)
330 self
.assertEqual(listnetworksesponse5
.status_code
, 200)
331 self
.assertEqual(json
.loads(listnetworksesponse5
.content
)["networks"][0]["id"], listNetworksId
)
332 self
.assertEqual(json
.loads(listnetworksesponse5
.content
)["networks"][1]["id"], listNetworksId2
)
335 print('->>>>>>> test Neutron Show Network ->>>>>>>>>>>>>>>')
336 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
337 url
= "http://0.0.0.0:19696/v2.0/networks/"+listNetworksId
338 shownetworksesponse
= requests
.get(url
, headers
=headers
)
339 self
.assertEqual(shownetworksesponse
.status_code
, 200)
340 self
.assertEqual(json
.loads(shownetworksesponse
.content
)["network"]["status"], "ACTIVE")
343 print('->>>>>>> test Neutron Show Network Non-ExistendNetwork ->>>>>>>>>>>>>>>')
344 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
345 url
= "http://0.0.0.0:19696/v2.0/networks/non_existent_network_id"
346 shownetworksesponse2
= requests
.get(url
, headers
=headers
)
347 self
.assertEqual(shownetworksesponse2
.status_code
, 404)
350 print('->>>>>>> test Neutron Create Network ->>>>>>>>>>>>>>>')
351 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
352 url
= "http://0.0.0.0:19696/v2.0/networks"
353 createnetworkresponse
= requests
.post(url
, data
='{"network": {"name": "sample_network","admin_state_up": true}}', headers
=headers
)
354 self
.assertEqual(createnetworkresponse
.status_code
, 201)
355 self
.assertEqual(json
.loads(createnetworkresponse
.content
)["network"]["status"], "ACTIVE")
358 print('->>>>>>> test Neutron Create Network With Existing Name ->>>>>>>>>>>>>>>')
359 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
360 url
= "http://0.0.0.0:19696/v2.0/networks"
361 createnetworkresponsefailure
= requests
.post(url
,data
='{"network": {"name": "sample_network","admin_state_up": true}}',headers
=headers
)
362 self
.assertEqual(createnetworkresponsefailure
.status_code
, 400)
365 print('->>>>>>> test Neutron Update Network ->>>>>>>>>>>>>>>')
366 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
367 url
= "http://0.0.0.0:19696/v2.0/networks/%s" % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
368 updatenetworkresponse
= requests
.put(url
, data
='{"network": {"status": "ACTIVE", "admin_state_up":true, "tenant_id":"abcd123", "name": "sample_network_new_name", "shared":false}}' , headers
=headers
)
369 self
.assertEqual(updatenetworkresponse
.status_code
, 200)
370 self
.assertEqual(json
.loads(updatenetworkresponse
.content
)["network"]["name"], "sample_network_new_name")
371 self
.assertEqual(json
.loads(updatenetworkresponse
.content
)["network"]["tenant_id"], "abcd123")
374 print('->>>>>>> test Neutron Update Non-Existing Network ->>>>>>>>>>>>>>>')
375 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
376 url
= "http://0.0.0.0:19696/v2.0/networks/non-existing-name123"
377 updatenetworkresponse
= requests
.put(url
, data
='{"network": {"name": "sample_network_new_name"}}', headers
=headers
)
378 self
.assertEqual(updatenetworkresponse
.status_code
, 404)
381 print('->>>>>>> test Neutron List Subnets ->>>>>>>>>>>>>>>')
382 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
383 url
= "http://0.0.0.0:19696/v2.0/subnets"
384 listsubnetsresponse
= requests
.get(url
, headers
=headers
)
385 listSubnetName
= json
.loads(listsubnetsresponse
.content
)["subnets"][0]["name"]
386 listSubnetId
= json
.loads(listsubnetsresponse
.content
)["subnets"][0]["id"]
387 listSubnetId2
= json
.loads(listsubnetsresponse
.content
)["subnets"][1]["id"]
388 self
.assertEqual(listsubnetsresponse
.status_code
, 200)
389 self
.assertNotIn('None', listSubnetName
)
392 print('->>>>>>> test Neutron List Subnets By Name ->>>>>>>>>>>>>>>')
393 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
394 url
= "http://0.0.0.0:19696/v2.0/subnets?name="+listSubnetName
395 listsubnetByNameresponse
= requests
.get(url
, headers
=headers
)
396 self
.assertEqual(listsubnetByNameresponse
.status_code
, 200)
397 self
.assertNotIn('None', json
.loads(listsubnetByNameresponse
.content
)["subnets"][0]["name"])
400 print('->>>>>>> test Neutron List Subnets By Id ->>>>>>>>>>>>>>>')
401 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
402 url
= "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId
403 listsubnetsbyidresponse
= requests
.get(url
, headers
=headers
)
404 self
.assertEqual(listsubnetsbyidresponse
.status_code
, 200)
405 self
.assertNotIn("None", json
.loads(listsubnetsbyidresponse
.content
)["subnets"][0]["name"])
408 print('->>>>>>> test Neutron List Subnets By Multiple Id ->>>>>>>>>>>>>>>')
409 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
410 url
= "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId
+"&id="+listSubnetId2
411 listsubnetsbymultipleidsresponse
= requests
.get(url
, headers
=headers
)
412 self
.assertEqual(listsubnetsbymultipleidsresponse
.status_code
, 200)
413 self
.assertNotIn("None", json
.loads(listsubnetsbymultipleidsresponse
.content
)["subnets"][0]["name"])
418 print('->>>>>>> test Neutron Show Subnet->>>>>>>>>>>>>>>')
419 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
420 url
= "http://0.0.0.0:19696/v2.0/subnets/%s" % (json
.loads(listsubnetsresponse
.content
)["subnets"][0]["id"])
421 showsubnetsresponse
= requests
.get(url
, headers
=headers
)
422 self
.assertEqual(showsubnetsresponse
.status_code
, 200)
423 self
.assertNotIn("None", json
.loads(showsubnetsresponse
.content
)["subnet"]["name"])
426 print('->>>>>>> test Neutron Show Non-Existing Subnet->>>>>>>>>>>>>>>')
427 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
428 url
= "http://0.0.0.0:19696/v2.0/subnets/non-existing-id123"
429 showsubnetsresponse
= requests
.get(url
, headers
=headers
)
430 self
.assertEqual(showsubnetsresponse
.status_code
, 404)
434 print('->>>>>>> test Neutron Create Subnet ->>>>>>>>>>>>>>>')
435 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
436 url
= "http://0.0.0.0:19696/v2.0/subnets"
437 createsubnetdata
= '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
438 createsubnetresponse
= requests
.post(url
, data
=createsubnetdata
, headers
=headers
)
439 self
.assertEqual(createsubnetresponse
.status_code
, 201)
440 self
.assertEqual(json
.loads(createsubnetresponse
.content
)["subnet"]["name"], "new_subnet")
443 print('->>>>>>> test Neutron Create Second Subnet ->>>>>>>>>>>>>>>')
444 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
445 url
= "http://0.0.0.0:19696/v2.0/subnets"
446 createsubnetdata
= '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
447 createsubnetfailureresponse
= requests
.post(url
, data
=createsubnetdata
, headers
=headers
)
448 self
.assertEqual(createsubnetfailureresponse
.status_code
, 409)
451 print('->>>>>>> test Neutron Update Subnet ->>>>>>>>>>>>>>>')
452 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
453 url
= "http://0.0.0.0:19696/v2.0/subnets/%s" % (json
.loads(createsubnetresponse
.content
)["subnet"]["id"])
454 updatesubnetdata
= '{"subnet": {"name": "new_subnet_new_name", "network_id":"some_id", "tenant_id":"new_tenant_id", "allocation_pools":"change_me", "gateway_ip":"192.168.1.120", "ip_version":4, "cidr":"10.0.0.1/24", "id":"some_new_id", "enable_dhcp":true} }'
455 updatesubnetresponse
= requests
.put(url
, data
=updatesubnetdata
, headers
=headers
)
456 self
.assertEqual(updatesubnetresponse
.status_code
, 200)
457 self
.assertEqual(json
.loads(updatesubnetresponse
.content
)["subnet"]["name"], "new_subnet_new_name")
460 print('->>>>>>> test Neutron Update Non-Existing Subnet ->>>>>>>>>>>>>>>')
461 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
462 url
= "http://0.0.0.0:19696/v2.0/subnets/non-existing-subnet-12345"
463 updatenonexistingsubnetdata
= '{"subnet": {"name": "new_subnet_new_name"} }'
464 updatenonexistingsubnetresponse
= requests
.put(url
, data
=updatenonexistingsubnetdata
, headers
=headers
)
465 self
.assertEqual(updatenonexistingsubnetresponse
.status_code
, 404)
468 print('->>>>>>> test Neutron List Ports ->>>>>>>>>>>>>>>')
469 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
470 url
= "http://0.0.0.0:19696/v2.0/ports"
471 listportsesponse
= requests
.get(url
, headers
=headers
)
472 self
.assertEqual(listportsesponse
.status_code
, 200)
473 self
.assertEqual(json
.loads(listportsesponse
.content
)["ports"][0]["status"], "ACTIVE")
474 listPortsName
= json
.loads(listportsesponse
.content
)["ports"][0]["name"]
475 listPortsId1
= json
.loads(listportsesponse
.content
)["ports"][0]["id"]
476 listPortsId2
= json
.loads(listportsesponse
.content
)["ports"][1]["id"]
479 print('->>>>>>> test Neutron List Ports By Name ->>>>>>>>>>>>>>>')
480 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
481 url
= "http://0.0.0.0:19696/v2.0/ports?name=" + listPortsName
482 listportsbynameesponse
= requests
.get(url
, headers
=headers
)
483 self
.assertEqual(listportsbynameesponse
.status_code
, 200)
484 self
.assertEqual(json
.loads(listportsbynameesponse
.content
)["ports"][0]["name"], listPortsName
)
487 print('->>>>>>> test Neutron List Ports By Id ->>>>>>>>>>>>>>>')
488 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
489 url
= "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1
490 listportsbyidesponse
= requests
.get(url
, headers
=headers
)
491 self
.assertEqual(listportsbyidesponse
.status_code
, 200)
492 self
.assertEqual(json
.loads(listportsbyidesponse
.content
)["ports"][0]["id"], listPortsId1
)
495 print('->>>>>>> test Neutron List Ports By Multiple Ids ->>>>>>>>>>>>>>>')
496 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
497 url
= "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1
+"&id="+listPortsId2
498 listportsbymultipleidsesponse
= requests
.get(url
, headers
=headers
)
499 self
.assertEqual(listportsbymultipleidsesponse
.status_code
, 200)
500 self
.assertEqual(json
.loads(listportsbymultipleidsesponse
.content
)["ports"][0]["id"], listPortsId1
)
503 print('->>>>>>> test Neutron List Non-Existing Ports ->>>>>>>>>>>>>>>')
504 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
505 url
= "http://0.0.0.0:19696/v2.0/ports?id=non-existing-port-id"
506 listportsbynonexistingidsesponse
= requests
.get(url
, headers
=headers
)
507 self
.assertEqual(listportsbynonexistingidsesponse
.status_code
, 404)
510 print('->>>>>>> test Neutron Show Port ->>>>>>>>>>>>>>>')
511 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
512 url
= "http://0.0.0.0:19696/v2.0/ports/%s" % (json
.loads(listportsesponse
.content
)["ports"][0]["id"])
513 showportresponse
= requests
.get(url
, headers
=headers
)
514 self
.assertEqual(showportresponse
.status_code
, 200)
515 self
.assertEqual(json
.loads(showportresponse
.content
)["port"]["status"], "ACTIVE")
518 print('->>>>>>> test Neutron Show Non-Existing Port ->>>>>>>>>>>>>>>')
519 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
520 url
= "http://0.0.0.0:19696/v2.0/ports/non-existing-portid123"
521 shownonexistingportresponse
= requests
.get(url
, headers
=headers
)
522 self
.assertEqual(shownonexistingportresponse
.status_code
, 404)
525 print('->>>>>>> test Neutron Create Port In Non-Existing Network ->>>>>>>>>>>>>>>')
526 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
527 url
= "http://0.0.0.0:19696/v2.0/ports"
528 createnonexistingportdata
= '{"port": {"name": "new_port", "network_id": "non-existing-id"} }'
529 createnonexistingnetworkportresponse
= requests
.post(url
, data
=createnonexistingportdata
, headers
=headers
)
530 self
.assertEqual(createnonexistingnetworkportresponse
.status_code
, 404)
533 print('->>>>>>> test Neutron Create Port ->>>>>>>>>>>>>>>')
534 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
535 url
= "http://0.0.0.0:19696/v2.0/ports"
536 createportdata
= '{"port": {"name": "new_port", "network_id": "%s", "admin_state_up":true, "device_id":"device_id123", "device_owner":"device_owner123", "fixed_ips":"change_me","id":"new_id1234", "mac_address":"12:34:56:78:90", "status":"change_me", "tenant_id":"tenant_id123"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
537 createportresponse
= requests
.post(url
, data
=createportdata
, headers
=headers
)
538 self
.assertEqual(createportresponse
.status_code
, 201)
539 print (createportresponse
.content
)
540 self
.assertEqual(json
.loads(createportresponse
.content
)["port"]["name"], "new_port")
543 print('->>>>>>> test Neutron Create Port With Existing Name ->>>>>>>>>>>>>>>')
544 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
545 url
= "http://0.0.0.0:19696/v2.0/ports"
546 createportwithexistingnamedata
= '{"port": {"name": "new_port", "network_id": "%s"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
547 createportwithexistingnameresponse
= requests
.post(url
, data
=createportwithexistingnamedata
, headers
=headers
)
548 self
.assertEqual(createportwithexistingnameresponse
.status_code
, 500)
551 print('->>>>>>> test Neutron Create Port Without Name ->>>>>>>>>>>>>>>')
552 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
553 url
= "http://0.0.0.0:19696/v2.0/ports"
554 createportdatawithoutname
= '{"port": {"network_id": "%s"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
555 createportwithoutnameresponse
= requests
.post(url
, data
=createportdatawithoutname
, headers
=headers
)
556 self
.assertEqual(createportwithoutnameresponse
.status_code
, 201)
557 self
.assertIn("port:cp", json
.loads(createportwithoutnameresponse
.content
)["port"]["name"])
560 print('->>>>>>> test Neutron Update Port ->>>>>>>>>>>>>>>')
561 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
562 print(json
.loads(createportresponse
.content
)["port"]["name"])
563 url
= "http://0.0.0.0:19696/v2.0/ports/%s" % (json
.loads(createportresponse
.content
)["port"]["name"])
564 updateportdata
= '{"port": {"name": "new_port_new_name", "admin_state_up":true, "device_id":"device_id123", "device_owner":"device_owner123", "fixed_ips":"change_me","mac_address":"12:34:56:78:90", "status":"change_me", "tenant_id":"tenant_id123", "network_id":"network_id123"} }'
565 updateportresponse
= requests
.put(url
, data
=updateportdata
, headers
=headers
)
566 self
.assertEqual(updateportresponse
.status_code
, 200)
567 self
.assertEqual(json
.loads(updateportresponse
.content
)["port"]["name"], "new_port_new_name")
570 print('->>>>>>> test Neutron Update Non-Existing Port ->>>>>>>>>>>>>>>')
571 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
572 url
= "http://0.0.0.0:19696/v2.0/ports/non-existing-port-ip"
573 updatenonexistingportdata
= '{"port": {"name": "new_port_new_name"} }'
574 updatenonexistingportresponse
= requests
.put(url
, data
=updatenonexistingportdata
, headers
=headers
)
575 self
.assertEqual(updatenonexistingportresponse
.status_code
, 404)
578 print('->>>>>>> test Neutron Delete Port ->>>>>>>>>>>>>>>')
579 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
580 righturl
= "http://0.0.0.0:19696/v2.0/ports/%s" % (json
.loads(createportresponse
.content
)["port"]["id"])
581 deleterightportresponse
= requests
.delete(righturl
, headers
=headers
)
582 self
.assertEqual(deleterightportresponse
.status_code
, 204)
586 print('->>>>>>> test Neutron Delete Non-Existing Port ->>>>>>>>>>>>>>>')
587 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
588 wrongurl
= "http://0.0.0.0:19696/v2.0/ports/unknownid"
589 deletewrongportresponse
= requests
.delete(wrongurl
, headers
=headers
)
590 self
.assertEqual(deletewrongportresponse
.status_code
, 404)
593 print('->>>>>>> test Neutron Delete Subnet ->>>>>>>>>>>>>>>')
594 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
595 wrongurl
= "http://0.0.0.0:19696/v2.0/subnets/unknownid"
596 righturl
= "http://0.0.0.0:19696/v2.0/subnets/%s" % (json
.loads(updatesubnetresponse
.content
)["subnet"]["id"])
597 deletewrongsubnetresponse
= requests
.delete(wrongurl
, headers
=headers
)
598 deleterightsubnetresponse
= requests
.delete(righturl
, headers
=headers
)
599 self
.assertEqual(deletewrongsubnetresponse
.status_code
, 404)
600 self
.assertEqual(deleterightsubnetresponse
.status_code
, 204)
603 print('->>>>>>> test Neutron Delete Network ->>>>>>>>>>>>>>>')
604 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
605 righturl
= "http://0.0.0.0:19696/v2.0/networks/%s" % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
606 deleterightnetworkresponse
= requests
.delete(righturl
, headers
=headers
)
607 self
.assertEqual(deleterightnetworkresponse
.status_code
, 204)
610 print('->>>>>>> test Neutron Delete Non-Existing Network ->>>>>>>>>>>>>>>')
611 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
612 wrongurl
= "http://0.0.0.0:19696/v2.0/networks/unknownid"
613 deletewrongnetworkresponse
= requests
.delete(wrongurl
, headers
=headers
)
614 self
.assertEqual(deletewrongnetworkresponse
.status_code
, 404)
617 def testKeystomeDummy(self
):
618 print('->>>>>>> test Keystone Dummy Class->>>>>>>>>>>>>>>')
619 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
622 headers
= {'Content-type': 'application/json'}
623 test_heatapi_keystone_get_token
= open(os
.path
.join(os
.path
.dirname(__file__
), "test_heatapi_keystone_get_token.json")).read()
625 print('->>>>>>> test Keystone List Versions ->>>>>>>>>>>>>>>')
626 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
627 url
= "http://0.0.0.0:15000/"
628 listapiversionstackresponse
= requests
.get(url
, headers
=headers
)
629 self
.assertEqual(listapiversionstackresponse
.status_code
, 200)
630 self
.assertEqual(json
.loads(listapiversionstackresponse
.content
)["versions"]["values"][0]["id"], "v2.0")
633 print('->>>>>>> test Keystone Show ApiV2 ->>>>>>>>>>>>>>>')
634 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
635 url
= "http://0.0.0.0:15000/v2.0"
636 showapiversionstackresponse
= requests
.get(url
, headers
=headers
)
637 self
.assertEqual(showapiversionstackresponse
.status_code
, 200)
638 self
.assertEqual(json
.loads(showapiversionstackresponse
.content
)["version"]["id"], "v2.0")
641 print('->>>>>>> test Keystone Get Token ->>>>>>>>>>>>>>>')
642 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
643 url
= "http://0.0.0.0:15000/v2.0/tokens"
644 gettokenstackresponse
= requests
.post(url
, data
=json
.dumps(json
.loads(test_heatapi_keystone_get_token
)), headers
=headers
)
645 self
.assertEqual(gettokenstackresponse
.status_code
, 200)
646 self
.assertEqual(json
.loads(gettokenstackresponse
.content
)["access"]["user"]["name"], "tenantName")
649 def testHeatDummy(self
):
650 print('->>>>>>> test Heat Dummy Class->>>>>>>>>>>>>>>')
651 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
654 headers
= {'Content-type': 'application/json'}
655 test_heatapi_template_create_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "test_heatapi_template_create_stack.json")).read()
656 test_heatapi_template_update_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "test_heatapi_template_update_stack.json")).read()
658 print('->>>>>>> test Heat List API Versions Stack ->>>>>>>>>>>>>>>')
659 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
660 url
= "http://0.0.0.0:18004/"
661 listapiversionstackresponse
= requests
.get(url
, headers
=headers
)
662 self
.assertEqual(listapiversionstackresponse
.status_code
, 200)
663 self
.assertEqual(json
.loads(listapiversionstackresponse
.content
)["versions"][0]["id"], "v1.0")
666 print('->>>>>>> test Create Stack ->>>>>>>>>>>>>>>')
667 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
668 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
669 createstackresponse
= requests
.post(url
, data
=json
.dumps(json
.loads(test_heatapi_template_create_stack
)), headers
=headers
)
670 self
.assertEqual(createstackresponse
.status_code
, 201)
671 self
.assertNotEqual(json
.loads(createstackresponse
.content
)["stack"]["id"], "")
674 print('->>>>>>> test Create Stack With Existing Name ->>>>>>>>>>>>>>>')
675 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
676 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
677 createstackwithexistingnameresponse
= requests
.post(url
, data
='{"stack_name" : "s1"}', headers
=headers
)
678 self
.assertEqual(createstackwithexistingnameresponse
.status_code
, 409)
681 print('->>>>>>> test Create Stack With Unsupported Version ->>>>>>>>>>>>>>>')
682 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
683 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
684 createstackwitheunsupportedversionresponse
= requests
.post(url
, data
='{"stack_name" : "stackname123", "template" : {"heat_template_version": "2015-04-29"}}', headers
=headers
)
685 self
.assertEqual(createstackwitheunsupportedversionresponse
.status_code
, 400)
689 print('->>>>>>> test List Stack ->>>>>>>>>>>>>>>')
690 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
691 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
692 liststackresponse
= requests
.get(url
, headers
=headers
)
693 self
.assertEqual(liststackresponse
.status_code
, 200)
694 self
.assertEqual(json
.loads(liststackresponse
.content
)["stacks"][0]["stack_status"], "CREATE_COMPLETE")
698 print('->>>>>>> test Show Stack ->>>>>>>>>>>>>>>')
699 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
700 url
= "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s"% json
.loads(createstackresponse
.content
)['stack']['id']
701 liststackdetailsresponse
= requests
.get(url
, headers
=headers
)
702 self
.assertEqual(liststackdetailsresponse
.status_code
, 200)
703 self
.assertEqual(json
.loads(liststackdetailsresponse
.content
)["stack"]["stack_status"], "CREATE_COMPLETE")
706 print('->>>>>>> test Show Non-Exisitng Stack ->>>>>>>>>>>>>>>')
707 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
708 url
= "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/non_exisitng_id123"
709 listnonexistingstackdetailsresponse
= requests
.get(url
, headers
=headers
)
710 self
.assertEqual(listnonexistingstackdetailsresponse
.status_code
, 404)
713 print('->>>>>>> test Update Stack ->>>>>>>>>>>>>>>')
714 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
715 url
= "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/%s"% json
.loads(createstackresponse
.content
)['stack']['id']
716 updatestackresponse
= requests
.put(url
, data
=json
.dumps(json
.loads(test_heatapi_template_update_stack
)),
718 self
.assertEqual(updatestackresponse
.status_code
, 202)
719 liststackdetailsresponse
= requests
.get(url
, headers
=headers
)
720 self
.assertEqual(json
.loads(liststackdetailsresponse
.content
)["stack"]["stack_status"], "UPDATE_COMPLETE")
723 print('->>>>>>> test Update Non-Existing Stack ->>>>>>>>>>>>>>>')
724 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
725 url
= "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/non_existing_id_1234"
726 updatenonexistingstackresponse
= requests
.put(url
, data
={"non": "sense"}, headers
=headers
)
727 self
.assertEqual(updatenonexistingstackresponse
.status_code
, 404)
730 print('->>>>>>> test Delete Stack ->>>>>>>>>>>>>>>')
731 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
732 url
= "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s" % \
733 json
.loads(createstackresponse
.content
)['stack']['id']
734 deletestackdetailsresponse
= requests
.delete(url
, headers
=headers
)
735 self
.assertEqual(deletestackdetailsresponse
.status_code
, 204)
738 def testNeutronSFC(self
):
740 Tests the Neutron Service Function Chaining implementation. As Some functions build up on others, a
741 complete environment is created here:
743 Ports: p1, p2, p3, p4
744 Port Pairs: pp1(p1, p2), pp2(p3, p4)
745 Port Pair Groups: ppg1(pp1, pp2)
746 Flow Classifiers: fc1
747 Port Chain: pc1(ppg1, fc1)
750 headers
= {'Content-type': 'application/json'}
752 print('->>>>>>> Create ports p1 - p4 ->>>>>>>>>>>>>>>')
753 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
755 network_resp
= requests
.get("http://0.0.0.0:19696/v2.0/networks?name=default", headers
=headers
)
756 self
.assertEqual(network_resp
.status_code
, 200)
757 network_id
= json
.loads(network_resp
.content
)["networks"][0]["id"]
759 url
= "http://0.0.0.0:19696/v2.0/ports"
760 port_request
= '{"port": {"name": "%s", "network_id": "%s"}}'
761 p1_resp
= requests
.post(url
, data
=port_request
% ("p1", network_id
), headers
=headers
)
762 self
.assertEqual(p1_resp
.status_code
, 201)
763 p2_resp
= requests
.post(url
, data
=port_request
% ("p2", network_id
), headers
=headers
)
764 self
.assertEqual(p2_resp
.status_code
, 201)
765 p3_resp
= requests
.post(url
, data
=port_request
% ("p3", network_id
), headers
=headers
)
766 self
.assertEqual(p3_resp
.status_code
, 201)
767 p4_resp
= requests
.post(url
, data
=port_request
% ("p4", network_id
), headers
=headers
)
768 self
.assertEqual(p4_resp
.status_code
, 201)
770 p1_id
= json
.loads(p1_resp
.content
)["port"]["id"]
771 p2_id
= json
.loads(p2_resp
.content
)["port"]["id"]
772 p3_id
= json
.loads(p3_resp
.content
)["port"]["id"]
773 p4_id
= json
.loads(p4_resp
.content
)["port"]["id"]
775 print('->>>>>>> test Neutron SFC Port Pair Create ->>>>>>>>>>>>>>>')
776 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
777 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs"
778 pp1_resp
= requests
.post(url
, data
='{"port_pair": {"name": "pp1", "ingress": "%s", "egress": "%s"}}' % (p1_id
, p2_id
), headers
=headers
)
779 self
.assertEqual(pp1_resp
.status_code
, 201)
780 pp2_resp
= requests
.post(url
, data
='{"port_pair": {"name": "pp2", "ingress": "%s", "egress": "%s"}}' % (p3_id
, p4_id
), headers
=headers
)
781 self
.assertEqual(pp2_resp
.status_code
, 201)
782 pp3_resp
= requests
.post(url
, data
='{"port_pair": {"name": "pp3", "ingress": "%s", "egress": "%s"}}' % (p3_id
, p4_id
), headers
=headers
)
783 self
.assertEqual(pp3_resp
.status_code
, 201)
785 pp1_id
= json
.loads(pp1_resp
.content
)["port_pair"]["id"]
786 pp2_id
= json
.loads(pp2_resp
.content
)["port_pair"]["id"]
787 pp3_id
= json
.loads(pp3_resp
.content
)["port_pair"]["id"]
789 print('->>>>>>> test Neutron SFC Port Pair Update ->>>>>>>>>>>>>>>')
790 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
791 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp3_id
792 pp3_update_resp
= requests
.put(url
, data
='{"port_pair": {"description": "port_pair_update"}}', headers
=headers
)
793 self
.assertEqual(pp3_update_resp
.status_code
, 200)
794 self
.assertEqual(json
.loads(pp3_update_resp
.content
)["port_pair"]["description"], "port_pair_update")
796 print('->>>>>>> test Neutron SFC Port Pair Delete ->>>>>>>>>>>>>>>')
797 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
798 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp3_id
799 pp3_delete_resp
= requests
.delete(url
, headers
=headers
)
800 self
.assertEqual(pp3_delete_resp
.status_code
, 204)
802 print('->>>>>>> test Neutron SFC Port Pair List ->>>>>>>>>>>>>>>')
803 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
804 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs"
805 pp_list_resp
= requests
.get(url
, headers
=headers
)
806 self
.assertEqual(pp_list_resp
.status_code
, 200)
807 self
.assertEqual(len(json
.loads(pp_list_resp
.content
)["port_pairs"]), 2) # only pp1 and pp2 should be left
809 print('->>>>>>> test Neutron SFC Port Pair Show ->>>>>>>>>>>>>>>')
810 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
811 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp2_id
812 pp2_show_resp
= requests
.get(url
, headers
=headers
)
813 self
.assertEqual(pp2_show_resp
.status_code
, 200)
814 self
.assertEqual(json
.loads(pp2_show_resp
.content
)["port_pair"]["name"], "pp2")
817 print('->>>>>>> test Neutron SFC Port Pair Group Create ->>>>>>>>>>>>>>>')
818 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
819 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups"
820 ppg1_resp
= requests
.post(url
, data
='{"port_pair_group": {"name": "ppg1", "port_pairs": ["%s"]}}' % (pp1_id
), headers
=headers
)
821 self
.assertEqual(ppg1_resp
.status_code
, 201)
822 ppg2_resp
= requests
.post(url
, data
='{"port_pair_group": {"name": "ppg2", "port_pairs": ["%s"]}}' % (pp2_id
), headers
=headers
)
823 self
.assertEqual(ppg2_resp
.status_code
, 201)
824 ppg3_resp
= requests
.post(url
, data
='{"port_pair_group": {"name": "ppg3", "port_pairs": ["%s"]}}' % (pp2_id
), headers
=headers
)
825 self
.assertEqual(ppg3_resp
.status_code
, 201)
827 ppg1_id
= json
.loads(ppg1_resp
.content
)["port_pair_group"]["id"]
828 ppg2_id
= json
.loads(ppg2_resp
.content
)["port_pair_group"]["id"]
829 ppg3_id
= json
.loads(ppg3_resp
.content
)["port_pair_group"]["id"]
831 print('->>>>>>> test Neutron SFC Port Pair Group Update ->>>>>>>>>>>>>>>')
832 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
833 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg3_id
834 ppg3_update_resp
= requests
.put(url
, data
='{"port_pair_group": {"description": "port_pair_group_update"}}', headers
=headers
)
835 self
.assertEqual(ppg3_update_resp
.status_code
, 200)
836 self
.assertEqual(json
.loads(ppg3_update_resp
.content
)["port_pair_group"]["description"], "port_pair_group_update")
838 print('->>>>>>> test Neutron SFC Port Pair Group Delete ->>>>>>>>>>>>>>>')
839 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
840 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg3_id
841 ppg3_delete_resp
= requests
.delete(url
, headers
=headers
)
842 self
.assertEqual(ppg3_delete_resp
.status_code
, 204)
844 print('->>>>>>> test Neutron SFC Port Pair Group List ->>>>>>>>>>>>>>>')
845 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
846 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups"
847 ppg_list_resp
= requests
.get(url
, headers
=headers
)
848 self
.assertEqual(ppg_list_resp
.status_code
, 200)
849 self
.assertEqual(len(json
.loads(ppg_list_resp
.content
)["port_pair_groups"]), 2) # only ppg1 and ppg2 should be left
851 print('->>>>>>> test Neutron SFC Port Pair Group Show ->>>>>>>>>>>>>>>')
852 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
853 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg2_id
854 ppg2_show_resp
= requests
.get(url
, headers
=headers
)
855 self
.assertEqual(ppg2_show_resp
.status_code
, 200)
856 self
.assertEqual(json
.loads(ppg2_show_resp
.content
)["port_pair_group"]["name"], "ppg2")
858 print('->>>>>>> test Neutron SFC Flow Classifier Create ->>>>>>>>>>>>>>>')
859 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
860 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers"
861 fc1_resp
= requests
.post(url
, data
='{"flow_classifier": {"name": "fc1", "source_port_range_min": 22, "source_port_range_max": 4000}}', headers
=headers
)
862 self
.assertEqual(fc1_resp
.status_code
, 201)
863 fc2_resp
= requests
.post(url
, data
='{"flow_classifier": {"name": "fc2", "source_port_range_min": 22, "source_port_range_max": 4000}}', headers
=headers
)
864 self
.assertEqual(fc2_resp
.status_code
, 201)
866 fc1_id
= json
.loads(fc1_resp
.content
)["flow_classifier"]["id"]
867 fc2_id
= json
.loads(fc2_resp
.content
)["flow_classifier"]["id"]
869 print('->>>>>>> test Neutron SFC Flow Classifier Update ->>>>>>>>>>>>>>>')
870 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
871 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc2_id
872 fc2_update_resp
= requests
.put(url
, data
='{"flow_classifier": {"description": "flow_classifier_update"}}', headers
=headers
)
873 self
.assertEqual(fc2_update_resp
.status_code
, 200)
874 self
.assertEqual(json
.loads(fc2_update_resp
.content
)["flow_classifier"]["description"], "flow_classifier_update")
876 print('->>>>>>> test Neutron SFC Flow Classifier Delete ->>>>>>>>>>>>>>>')
877 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
878 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc2_id
879 fc2_delete_resp
= requests
.delete(url
, headers
=headers
)
880 self
.assertEqual(fc2_delete_resp
.status_code
, 204)
882 print('->>>>>>> test Neutron SFC Flow Classifier List ->>>>>>>>>>>>>>>')
883 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
884 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers"
885 fc_list_resp
= requests
.get(url
, headers
=headers
)
886 self
.assertEqual(fc_list_resp
.status_code
, 200)
887 self
.assertEqual(len(json
.loads(fc_list_resp
.content
)["flow_classifiers"]), 1) # only fc1
889 print('->>>>>>> test Neutron SFC Flow Classifier Show ->>>>>>>>>>>>>>>')
890 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
891 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc1_id
892 fc1_show_resp
= requests
.get(url
, headers
=headers
)
893 self
.assertEqual(fc1_show_resp
.status_code
, 200)
894 self
.assertEqual(json
.loads(fc1_show_resp
.content
)["flow_classifier"]["name"], "fc1")
897 print('->>>>>>> test Neutron SFC Port Chain Create ->>>>>>>>>>>>>>>')
898 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
899 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains"
900 pc1_resp
= requests
.post(url
, data
='{"port_chain": {"name": "pc1", "port_pair_groups": ["%s"], "flow_classifiers": ["%s"]}}' % (ppg1_id
, fc1_id
), headers
=headers
)
901 self
.assertEqual(pc1_resp
.status_code
, 201)
902 pc2_resp
= requests
.post(url
, data
='{"port_chain": {"name": "pc2", "port_pair_groups": ["%s"], "flow_classifiers": ["%s"]}}' % (ppg1_id
, fc1_id
), headers
=headers
)
903 self
.assertEqual(pc2_resp
.status_code
, 201)
905 pc1_id
= json
.loads(pc1_resp
.content
)["port_chain"]["id"]
906 pc2_id
= json
.loads(pc2_resp
.content
)["port_chain"]["id"]
908 print('->>>>>>> test Neutron SFC Port Chain Update ->>>>>>>>>>>>>>>')
909 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
910 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc2_id
911 pc2_update_resp
= requests
.put(url
, data
='{"port_chain": {"description": "port_chain_update"}}', headers
=headers
)
912 self
.assertEqual(pc2_update_resp
.status_code
, 200)
913 self
.assertEqual(json
.loads(pc2_update_resp
.content
)["port_chain"]["description"], "port_chain_update")
915 print('->>>>>>> test Neutron SFC Port Chain Delete ->>>>>>>>>>>>>>>')
916 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
917 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc2_id
918 pc2_delete_resp
= requests
.delete(url
, headers
=headers
)
919 self
.assertEqual(pc2_delete_resp
.status_code
, 204)
921 print('->>>>>>> test Neutron SFC Port Chain List ->>>>>>>>>>>>>>>')
922 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
923 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains"
924 pc_list_resp
= requests
.get(url
, headers
=headers
)
925 self
.assertEqual(pc_list_resp
.status_code
, 200)
926 self
.assertEqual(len(json
.loads(pc_list_resp
.content
)["port_chains"]), 1) # only pc1
928 print('->>>>>>> test Neutron SFC Port Chain Show ->>>>>>>>>>>>>>>')
929 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
930 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc1_id
931 pc1_show_resp
= requests
.get(url
, headers
=headers
)
932 self
.assertEqual(pc1_show_resp
.status_code
, 200)
933 self
.assertEqual(json
.loads(pc1_show_resp
.content
)["port_chain"]["name"], "pc1")
935 if __name__
== '__main__':