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
40 from emuvim
.test
.api_base_openstack
import ApiBaseOpenStack
43 class testRestApi(ApiBaseOpenStack
):
45 Tests to check the REST API endpoints of the emulator.
50 self
.createNet(nswitches
=3, ndatacenter
=2, nhosts
=2, ndockers
=0, autolinkswitches
=True)
53 self
.net
.addLink(self
.dc
[0], self
.h
[0])
54 self
.net
.addLink(self
.h
[1], self
.dc
[1])
55 self
.net
.addLink(self
.dc
[0], self
.dc
[1])
60 # start Mininet network
63 def testNovaDummy(self
):
64 print('->>>>>>> test Nova Dummy Class->>>>>>>>>>>>>>>')
65 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
68 headers
= {'Content-type': 'application/json'}
69 test_heatapi_template_create_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "templates/test_heatapi_template_create_stack.yml")).read()
70 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
71 requests
.post(url
, data
=json
.dumps(yaml
.load(test_heatapi_template_create_stack
)),
74 print('->>>>>>> test Nova List Versions ->>>>>>>>>>>>>>>')
75 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
76 url
= "http://0.0.0.0:18774/"
77 listapiversionnovaresponse
= requests
.get(url
, headers
=headers
)
78 self
.assertEqual(listapiversionnovaresponse
.status_code
, 200)
79 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["id"], "v2.1")
80 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["status"], "CURRENT")
81 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["version"], "2.38")
82 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["min_version"], "2.1")
83 self
.assertEqual(json
.loads(listapiversionnovaresponse
.content
)["versions"][0]["updated"], "2013-07-23T11:33:21Z")
86 print('->>>>>>> test Nova Version Show ->>>>>>>>>>>>>>>')
87 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
88 url
= "http://0.0.0.0:18774/v2.1/id_bla"
89 listapiversion21novaresponse
= requests
.get(url
, headers
=headers
)
90 self
.assertEqual(listapiversion21novaresponse
.status_code
, 200)
91 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["id"], "v2.1")
92 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["status"], "CURRENT")
93 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["version"], "2.38")
94 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["min_version"], "2.1")
95 self
.assertEqual(json
.loads(listapiversion21novaresponse
.content
)["version"]["updated"], "2013-07-23T11:33:21Z")
98 print('->>>>>>> test Nova Version List Server APIs ->>>>>>>>>>>>>>>')
99 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
100 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers"
101 listserverapisnovaresponse
= requests
.get(url
, headers
=headers
)
102 self
.assertEqual(listserverapisnovaresponse
.status_code
, 200)
103 self
.assertNotEqual(json
.loads(listserverapisnovaresponse
.content
)["servers"][0]["name"], "")
106 print('->>>>>>> test Nova Delete Server APIs ->>>>>>>>>>>>>>>')
107 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
108 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json
.loads(listserverapisnovaresponse
.content
)["servers"][0]["id"])
109 deleteserverapisnovaresponse
= requests
.delete(url
, headers
=headers
)
110 self
.assertEqual(deleteserverapisnovaresponse
.status_code
, 204)
113 print('->>>>>>> test Nova Delete Non-Existing Server APIs ->>>>>>>>>>>>>>>')
114 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
115 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/non-existing-ix"
116 deleteserverapisnovaresponse
= requests
.delete(url
, headers
=headers
)
117 self
.assertEqual(deleteserverapisnovaresponse
.status_code
, 404)
121 print('->>>>>>> testNovaVersionListServerAPIs_withPortInformation ->>>>>>>>>>>>>>>')
122 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
123 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/andPorts"
124 listserverapisnovaresponse
= requests
.get(url
, headers
=headers
)
125 self
.assertEqual(listserverapisnovaresponse
.status_code
, 200)
126 self
.assertNotEqual(json
.loads(listserverapisnovaresponse
.content
)["servers"][0]["name"], "")
129 print('->>>>>>> test Nova List Flavors ->>>>>>>>>>>>>>>')
130 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
131 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors"
132 listflavorsresponse
= requests
.get(url
, headers
=headers
)
133 self
.assertEqual(listflavorsresponse
.status_code
, 200)
134 self
.assertIn(json
.loads(listflavorsresponse
.content
)["flavors"][0]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
135 self
.assertIn(json
.loads(listflavorsresponse
.content
)["flavors"][1]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
136 self
.assertIn(json
.loads(listflavorsresponse
.content
)["flavors"][2]["name"], ["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
139 print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
140 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
141 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors"
142 addflavorsresponse
= requests
.post(url
,
143 data
='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
145 self
.assertEqual(addflavorsresponse
.status_code
, 200)
146 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["id"])
147 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["links"][0]['href'])
150 print('->>>>>>> test Nova List Flavors Detail ->>>>>>>>>>>>>>>')
151 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
152 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
153 listflavorsdetailresponse
= requests
.get(url
, headers
=headers
)
154 self
.assertEqual(listflavorsdetailresponse
.status_code
, 200)
155 self
.assertIn(json
.loads(listflavorsdetailresponse
.content
)["flavors"][0]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
156 self
.assertIn(json
.loads(listflavorsdetailresponse
.content
)["flavors"][1]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
157 self
.assertIn(json
.loads(listflavorsdetailresponse
.content
)["flavors"][2]["name"],["m1.nano", "m1.tiny", "m1.micro", "m1.small"])
160 print('->>>>>>> testNovaAddFlavors ->>>>>>>>>>>>>>>')
161 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
162 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors/detail"
163 addflavorsresponse
= requests
.post(url
,
164 data
='{"flavor":{"name": "testFlavor", "vcpus": "test_vcpus", "ram": 1024, "disk": 10}}',
166 self
.assertEqual(addflavorsresponse
.status_code
, 200)
167 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["id"])
168 self
.assertIsNotNone(json
.loads(addflavorsresponse
.content
)["flavor"]["links"][0]['href'])
171 print('->>>>>>> test Nova List Flavor By Id ->>>>>>>>>>>>>>>')
173 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
174 url
= "http://0.0.0.0:18774/v2.1/id_bla/flavors/%s" % (json
.loads(listflavorsdetailresponse
.content
)["flavors"][0]["name"])
175 listflavorsbyidresponse
= requests
.get(url
, headers
=headers
)
176 self
.assertEqual(listflavorsbyidresponse
.status_code
, 200)
177 self
.assertEqual(json
.loads(listflavorsbyidresponse
.content
)["flavor"]["id"], json
.loads(listflavorsdetailresponse
.content
)["flavors"][0]["id"])
180 print('->>>>>>> test Nova List Images ->>>>>>>>>>>>>>>')
181 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
182 url
= "http://0.0.0.0:18774/v2.1/id_bla/images"
183 listimagesresponse
= requests
.get(url
, headers
=headers
)
184 self
.assertEqual(listimagesresponse
.status_code
, 200)
185 print(listimagesresponse
.content
)
186 # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
187 #self.assertIn(json.loads(listimagesresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
188 #self.assertIn(json.loads(listimagesresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
189 #self.assertIn(json.loads(listimagesresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
192 print('->>>>>>> test Nova List Images Details ->>>>>>>>>>>>>>>')
193 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
194 url
= "http://0.0.0.0:18774/v2.1/id_bla/images/detail"
195 listimagesdetailsresponse
= requests
.get(url
, headers
=headers
)
196 self
.assertEqual(listimagesdetailsresponse
.status_code
, 200)
197 # deactivated: highly depends on the environment in which the tests are executed. one cannot make such an assumption.
198 #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][0]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
199 #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][1]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
200 #self.assertIn(json.loads(listimagesdetailsresponse.content)["images"][2]["name"],["google/cadvisor:latest", "ubuntu:trusty", "prom/pushgateway:latest"])
201 self
.assertEqual(json
.loads(listimagesdetailsresponse
.content
)["images"][0]["metadata"]["architecture"],"x86_64")
204 print('->>>>>>> test Nova List Image By Id ->>>>>>>>>>>>>>>')
205 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
206 url
= "http://0.0.0.0:18774/v2.1/id_bla/images/%s" % (json
.loads(listimagesdetailsresponse
.content
)["images"][0]["id"])
207 listimagebyidresponse
= requests
.get(url
, headers
=headers
)
208 self
.assertEqual(listimagebyidresponse
.status_code
, 200)
209 self
.assertEqual(json
.loads(listimagebyidresponse
.content
)["image"]["id"],json
.loads(listimagesdetailsresponse
.content
)["images"][0]["id"])
212 print('->>>>>>> test Nova List Image By Non-Existend Id ->>>>>>>>>>>>>>>')
213 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
214 url
= "http://0.0.0.0:18774/v2.1/id_bla/images/non_existing_id"
215 listimagebynonexistingidresponse
= requests
.get(url
, headers
=headers
)
216 self
.assertEqual(listimagebynonexistingidresponse
.status_code
, 404)
220 for image
in json
.loads(listimagesresponse
.content
)["images"]:
221 if image
["name"] == "ubuntu:trusty":
222 ubuntu_image_id
= image
["id"]
224 print('->>>>>>> test Nova Create Server Instance ->>>>>>>>>>>>>>>')
225 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
226 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers"
227 data
= '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json
.loads(listflavorsresponse
.content
)["flavors"][0]["id"], ubuntu_image_id
)
228 createserverinstance
= requests
.post(url
, data
=data
, headers
=headers
)
229 self
.assertEqual(createserverinstance
.status_code
, 200)
230 self
.assertEqual(json
.loads(createserverinstance
.content
)["server"]["image"]["id"], ubuntu_image_id
)
233 print('->>>>>>> test Nova Create Server Instance With Already Existing Name ->>>>>>>>>>>>>>>')
234 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
235 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers"
236 data
= '{"server": {"name": "X", "flavorRef": "%s", "imageRef":"%s"}}' % (json
.loads(listflavorsresponse
.content
)["flavors"][0]["id"], ubuntu_image_id
)
237 createserverinstance
= requests
.post(url
, data
=data
, headers
=headers
)
238 self
.assertEqual(createserverinstance
.status_code
, 409)
241 print('->>>>>>> test Nova Version List Server APIs Detailed ->>>>>>>>>>>>>>>')
242 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
243 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/detail"
244 listserverapisdetailedresponse
= requests
.get(url
, headers
=headers
)
245 self
.assertEqual(listserverapisdetailedresponse
.status_code
, 200)
246 self
.assertEqual(json
.loads(listserverapisdetailedresponse
.content
)["servers"][0]["status"], "ACTIVE")
249 print('->>>>>>> test Nova Show Server Details ->>>>>>>>>>>>>>>')
250 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
251 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/%s" % (json
.loads(listserverapisdetailedresponse
.content
)["servers"][0]["id"])
252 listserverdetailsresponse
= requests
.get(url
, headers
=headers
)
253 self
.assertEqual(listserverdetailsresponse
.status_code
, 200)
254 self
.assertEqual(json
.loads(listserverdetailsresponse
.content
)["server"]["flavor"]["links"][0]["rel"], "bookmark")
257 print('->>>>>>> test Nova Show Non-Existing Server Details ->>>>>>>>>>>>>>>')
258 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
259 url
= "http://0.0.0.0:18774/v2.1/id_bla/servers/non_existing_server_id"
260 listnonexistingserverdetailsresponse
= requests
.get(url
, headers
=headers
)
261 self
.assertEqual(listnonexistingserverdetailsresponse
.status_code
, 404)
264 def testNeutronDummy(self
):
265 print('->>>>>>> test Neutron Dummy Class->>>>>>>>>>>>>>>')
266 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
269 headers
= {'Content-type': 'application/json'}
270 test_heatapi_template_create_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "templates/test_heatapi_template_create_stack.yml")).read()
271 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
272 requests
.post(url
, data
=json
.dumps(yaml
.load(test_heatapi_template_create_stack
)), headers
=headers
)
273 # test_heatapi_keystone_get_token = open("test_heatapi_keystone_get_token.json").read()
275 print('->>>>>>> test Neutron List Versions ->>>>>>>>>>>>>>>')
276 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
277 url
= "http://0.0.0.0:19696/"
278 listapiversionstackresponse
= requests
.get(url
, headers
=headers
)
279 self
.assertEqual(listapiversionstackresponse
.status_code
, 200)
280 self
.assertEqual(json
.loads(listapiversionstackresponse
.content
)["versions"][0]["id"], "v2.0")
283 print('->>>>>>> test Neutron Show API v2.0 ->>>>>>>>>>>>>>>')
284 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
285 url
= "http://0.0.0.0:19696/v2.0"
286 listapiversionv20response
= requests
.get(url
, headers
=headers
)
287 self
.assertEqual(listapiversionv20response
.status_code
, 200)
288 self
.assertEqual(json
.loads(listapiversionv20response
.content
)["resources"][0]["name"], "subnet")
289 self
.assertEqual(json
.loads(listapiversionv20response
.content
)["resources"][1]["name"], "network")
290 self
.assertEqual(json
.loads(listapiversionv20response
.content
)["resources"][2]["name"], "ports")
293 print('->>>>>>> test Neutron List Networks ->>>>>>>>>>>>>>>')
294 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
295 url
= "http://0.0.0.0:19696/v2.0/networks"
296 listnetworksesponse1
= requests
.get(url
, headers
=headers
)
297 self
.assertEqual(listnetworksesponse1
.status_code
, 200)
298 self
.assertEqual(json
.loads(listnetworksesponse1
.content
)["networks"][0]["status"], "ACTIVE")
299 listNetworksId
= json
.loads(listnetworksesponse1
.content
)["networks"][0]["id"]
300 listNetworksName
= json
.loads(listnetworksesponse1
.content
)["networks"][0]["name"]
301 listNetworksId2
= json
.loads(listnetworksesponse1
.content
)["networks"][1]["id"]
304 print('->>>>>>> test Neutron List Non-Existing Networks ->>>>>>>>>>>>>>>')
305 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
306 url
= "http://0.0.0.0:19696/v2.0/networks?name=non_existent_network_name"
307 listnetworksesponse2
= requests
.get(url
,headers
=headers
)
308 self
.assertEqual(listnetworksesponse2
.status_code
, 404)
311 print('->>>>>>> test Neutron List Networks By Name ->>>>>>>>>>>>>>>')
312 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
313 url
= "http://0.0.0.0:19696/v2.0/networks?name=" + listNetworksName
#tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
314 listnetworksesponse3
= requests
.get(url
, headers
=headers
)
315 self
.assertEqual(listnetworksesponse3
.status_code
, 200)
316 self
.assertEqual(json
.loads(listnetworksesponse3
.content
)["networks"][0]["name"], listNetworksName
)
319 print('->>>>>>> test Neutron List Networks By Id ->>>>>>>>>>>>>>>')
320 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
321 url
= "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId
# tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
322 listnetworksesponse4
= requests
.get(url
, headers
=headers
)
323 self
.assertEqual(listnetworksesponse4
.status_code
, 200)
324 self
.assertEqual(json
.loads(listnetworksesponse4
.content
)["networks"][0]["id"], listNetworksId
)
327 print('->>>>>>> test Neutron List Networks By Multiple Ids ->>>>>>>>>>>>>>>')
328 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
329 url
= "http://0.0.0.0:19696/v2.0/networks?id=" + listNetworksId
+ "&id="+ listNetworksId2
# tcpdump-vnf:input:net:9df6a98f-9e11-4cb7-b3c0-InAdUnitTest
330 listnetworksesponse5
= requests
.get(url
, headers
=headers
)
331 self
.assertEqual(listnetworksesponse5
.status_code
, 200)
332 self
.assertEqual(json
.loads(listnetworksesponse5
.content
)["networks"][0]["id"], listNetworksId
)
333 self
.assertEqual(json
.loads(listnetworksesponse5
.content
)["networks"][1]["id"], listNetworksId2
)
336 print('->>>>>>> test Neutron Show Network ->>>>>>>>>>>>>>>')
337 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
338 url
= "http://0.0.0.0:19696/v2.0/networks/"+listNetworksId
339 shownetworksesponse
= requests
.get(url
, headers
=headers
)
340 self
.assertEqual(shownetworksesponse
.status_code
, 200)
341 self
.assertEqual(json
.loads(shownetworksesponse
.content
)["network"]["status"], "ACTIVE")
344 print('->>>>>>> test Neutron Show Network Non-ExistendNetwork ->>>>>>>>>>>>>>>')
345 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
346 url
= "http://0.0.0.0:19696/v2.0/networks/non_existent_network_id"
347 shownetworksesponse2
= requests
.get(url
, headers
=headers
)
348 self
.assertEqual(shownetworksesponse2
.status_code
, 404)
351 print('->>>>>>> test Neutron Create Network ->>>>>>>>>>>>>>>')
352 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
353 url
= "http://0.0.0.0:19696/v2.0/networks"
354 createnetworkresponse
= requests
.post(url
, data
='{"network": {"name": "sample_network","admin_state_up": true}}', headers
=headers
)
355 self
.assertEqual(createnetworkresponse
.status_code
, 201)
356 self
.assertEqual(json
.loads(createnetworkresponse
.content
)["network"]["status"], "ACTIVE")
359 print('->>>>>>> test Neutron Create Network With Existing Name ->>>>>>>>>>>>>>>')
360 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
361 url
= "http://0.0.0.0:19696/v2.0/networks"
362 createnetworkresponsefailure
= requests
.post(url
,data
='{"network": {"name": "sample_network","admin_state_up": true}}',headers
=headers
)
363 self
.assertEqual(createnetworkresponsefailure
.status_code
, 400)
366 print('->>>>>>> test Neutron Update Network ->>>>>>>>>>>>>>>')
367 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
368 url
= "http://0.0.0.0:19696/v2.0/networks/%s" % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
369 updatenetworkresponse
= requests
.put(url
, data
='{"network": {"status": "ACTIVE", "admin_state_up":true, "tenant_id":"abcd123", "name": "sample_network_new_name", "shared":false}}' , headers
=headers
)
370 self
.assertEqual(updatenetworkresponse
.status_code
, 200)
371 self
.assertEqual(json
.loads(updatenetworkresponse
.content
)["network"]["name"], "sample_network_new_name")
372 self
.assertEqual(json
.loads(updatenetworkresponse
.content
)["network"]["tenant_id"], "abcd123")
375 print('->>>>>>> test Neutron Update Non-Existing Network ->>>>>>>>>>>>>>>')
376 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
377 url
= "http://0.0.0.0:19696/v2.0/networks/non-existing-name123"
378 updatenetworkresponse
= requests
.put(url
, data
='{"network": {"name": "sample_network_new_name"}}', headers
=headers
)
379 self
.assertEqual(updatenetworkresponse
.status_code
, 404)
382 print('->>>>>>> test Neutron List Subnets ->>>>>>>>>>>>>>>')
383 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
384 url
= "http://0.0.0.0:19696/v2.0/subnets"
385 listsubnetsresponse
= requests
.get(url
, headers
=headers
)
386 listSubnetName
= json
.loads(listsubnetsresponse
.content
)["subnets"][0]["name"]
387 listSubnetId
= json
.loads(listsubnetsresponse
.content
)["subnets"][0]["id"]
388 listSubnetId2
= json
.loads(listsubnetsresponse
.content
)["subnets"][1]["id"]
389 self
.assertEqual(listsubnetsresponse
.status_code
, 200)
390 self
.assertNotIn('None', listSubnetName
)
393 print('->>>>>>> test Neutron List Subnets By Name ->>>>>>>>>>>>>>>')
394 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
395 url
= "http://0.0.0.0:19696/v2.0/subnets?name="+listSubnetName
396 listsubnetByNameresponse
= requests
.get(url
, headers
=headers
)
397 self
.assertEqual(listsubnetByNameresponse
.status_code
, 200)
398 self
.assertNotIn('None', json
.loads(listsubnetByNameresponse
.content
)["subnets"][0]["name"])
401 print('->>>>>>> test Neutron List Subnets By Id ->>>>>>>>>>>>>>>')
402 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
403 url
= "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId
404 listsubnetsbyidresponse
= requests
.get(url
, headers
=headers
)
405 self
.assertEqual(listsubnetsbyidresponse
.status_code
, 200)
406 self
.assertNotIn("None", json
.loads(listsubnetsbyidresponse
.content
)["subnets"][0]["name"])
409 print('->>>>>>> test Neutron List Subnets By Multiple Id ->>>>>>>>>>>>>>>')
410 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
411 url
= "http://0.0.0.0:19696/v2.0/subnets?id=" + listSubnetId
+"&id="+listSubnetId2
412 listsubnetsbymultipleidsresponse
= requests
.get(url
, headers
=headers
)
413 self
.assertEqual(listsubnetsbymultipleidsresponse
.status_code
, 200)
414 self
.assertNotIn("None", json
.loads(listsubnetsbymultipleidsresponse
.content
)["subnets"][0]["name"])
419 print('->>>>>>> test Neutron Show Subnet->>>>>>>>>>>>>>>')
420 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
421 url
= "http://0.0.0.0:19696/v2.0/subnets/%s" % (json
.loads(listsubnetsresponse
.content
)["subnets"][0]["id"])
422 showsubnetsresponse
= requests
.get(url
, headers
=headers
)
423 self
.assertEqual(showsubnetsresponse
.status_code
, 200)
424 self
.assertNotIn("None", json
.loads(showsubnetsresponse
.content
)["subnet"]["name"])
427 print('->>>>>>> test Neutron Show Non-Existing Subnet->>>>>>>>>>>>>>>')
428 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
429 url
= "http://0.0.0.0:19696/v2.0/subnets/non-existing-id123"
430 showsubnetsresponse
= requests
.get(url
, headers
=headers
)
431 self
.assertEqual(showsubnetsresponse
.status_code
, 404)
435 print('->>>>>>> test Neutron Create Subnet ->>>>>>>>>>>>>>>')
436 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
437 url
= "http://0.0.0.0:19696/v2.0/subnets"
438 createsubnetdata
= '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
439 createsubnetresponse
= requests
.post(url
, data
=createsubnetdata
, headers
=headers
)
440 self
.assertEqual(createsubnetresponse
.status_code
, 201)
441 self
.assertEqual(json
.loads(createsubnetresponse
.content
)["subnet"]["name"], "new_subnet")
444 print('->>>>>>> test Neutron Create Second Subnet ->>>>>>>>>>>>>>>')
445 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
446 url
= "http://0.0.0.0:19696/v2.0/subnets"
447 createsubnetdata
= '{"subnet": {"name": "new_subnet", "network_id": "%s","ip_version": 4,"cidr": "10.0.0.1/24"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
448 createsubnetfailureresponse
= requests
.post(url
, data
=createsubnetdata
, headers
=headers
)
449 self
.assertEqual(createsubnetfailureresponse
.status_code
, 409)
452 print('->>>>>>> test Neutron Update Subnet ->>>>>>>>>>>>>>>')
453 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
454 url
= "http://0.0.0.0:19696/v2.0/subnets/%s" % (json
.loads(createsubnetresponse
.content
)["subnet"]["id"])
455 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} }'
456 updatesubnetresponse
= requests
.put(url
, data
=updatesubnetdata
, headers
=headers
)
457 self
.assertEqual(updatesubnetresponse
.status_code
, 200)
458 self
.assertEqual(json
.loads(updatesubnetresponse
.content
)["subnet"]["name"], "new_subnet_new_name")
461 print('->>>>>>> test Neutron Update Non-Existing Subnet ->>>>>>>>>>>>>>>')
462 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
463 url
= "http://0.0.0.0:19696/v2.0/subnets/non-existing-subnet-12345"
464 updatenonexistingsubnetdata
= '{"subnet": {"name": "new_subnet_new_name"} }'
465 updatenonexistingsubnetresponse
= requests
.put(url
, data
=updatenonexistingsubnetdata
, headers
=headers
)
466 self
.assertEqual(updatenonexistingsubnetresponse
.status_code
, 404)
469 print('->>>>>>> test Neutron List Ports ->>>>>>>>>>>>>>>')
470 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
471 url
= "http://0.0.0.0:19696/v2.0/ports"
472 listportsesponse
= requests
.get(url
, headers
=headers
)
473 self
.assertEqual(listportsesponse
.status_code
, 200)
474 self
.assertEqual(json
.loads(listportsesponse
.content
)["ports"][0]["status"], "ACTIVE")
475 listPortsName
= json
.loads(listportsesponse
.content
)["ports"][0]["name"]
476 listPortsId1
= json
.loads(listportsesponse
.content
)["ports"][0]["id"]
477 listPortsId2
= json
.loads(listportsesponse
.content
)["ports"][1]["id"]
480 print('->>>>>>> test Neutron List Ports By Name ->>>>>>>>>>>>>>>')
481 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
482 url
= "http://0.0.0.0:19696/v2.0/ports?name=" + listPortsName
483 listportsbynameesponse
= requests
.get(url
, headers
=headers
)
484 self
.assertEqual(listportsbynameesponse
.status_code
, 200)
485 self
.assertEqual(json
.loads(listportsbynameesponse
.content
)["ports"][0]["name"], listPortsName
)
488 print('->>>>>>> test Neutron List Ports By Id ->>>>>>>>>>>>>>>')
489 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
490 url
= "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1
491 listportsbyidesponse
= requests
.get(url
, headers
=headers
)
492 self
.assertEqual(listportsbyidesponse
.status_code
, 200)
493 self
.assertEqual(json
.loads(listportsbyidesponse
.content
)["ports"][0]["id"], listPortsId1
)
496 print('->>>>>>> test Neutron List Ports By Multiple Ids ->>>>>>>>>>>>>>>')
497 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
498 url
= "http://0.0.0.0:19696/v2.0/ports?id=" + listPortsId1
+"&id="+listPortsId2
499 listportsbymultipleidsesponse
= requests
.get(url
, headers
=headers
)
500 self
.assertEqual(listportsbymultipleidsesponse
.status_code
, 200)
501 self
.assertEqual(json
.loads(listportsbymultipleidsesponse
.content
)["ports"][0]["id"], listPortsId1
)
504 print('->>>>>>> test Neutron List Non-Existing Ports ->>>>>>>>>>>>>>>')
505 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
506 url
= "http://0.0.0.0:19696/v2.0/ports?id=non-existing-port-id"
507 listportsbynonexistingidsesponse
= requests
.get(url
, headers
=headers
)
508 self
.assertEqual(listportsbynonexistingidsesponse
.status_code
, 404)
511 print('->>>>>>> test Neutron Show Port ->>>>>>>>>>>>>>>')
512 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
513 url
= "http://0.0.0.0:19696/v2.0/ports/%s" % (json
.loads(listportsesponse
.content
)["ports"][0]["id"])
514 showportresponse
= requests
.get(url
, headers
=headers
)
515 self
.assertEqual(showportresponse
.status_code
, 200)
516 self
.assertEqual(json
.loads(showportresponse
.content
)["port"]["status"], "ACTIVE")
519 print('->>>>>>> test Neutron Show Non-Existing Port ->>>>>>>>>>>>>>>')
520 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
521 url
= "http://0.0.0.0:19696/v2.0/ports/non-existing-portid123"
522 shownonexistingportresponse
= requests
.get(url
, headers
=headers
)
523 self
.assertEqual(shownonexistingportresponse
.status_code
, 404)
526 print('->>>>>>> test Neutron Create Port In Non-Existing Network ->>>>>>>>>>>>>>>')
527 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
528 url
= "http://0.0.0.0:19696/v2.0/ports"
529 createnonexistingportdata
= '{"port": {"name": "new_port", "network_id": "non-existing-id"} }'
530 createnonexistingnetworkportresponse
= requests
.post(url
, data
=createnonexistingportdata
, headers
=headers
)
531 self
.assertEqual(createnonexistingnetworkportresponse
.status_code
, 404)
534 print('->>>>>>> test Neutron Create Port ->>>>>>>>>>>>>>>')
535 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
536 url
= "http://0.0.0.0:19696/v2.0/ports"
537 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"])
538 createportresponse
= requests
.post(url
, data
=createportdata
, headers
=headers
)
539 self
.assertEqual(createportresponse
.status_code
, 201)
540 print (createportresponse
.content
)
541 self
.assertEqual(json
.loads(createportresponse
.content
)["port"]["name"], "new_port")
544 print('->>>>>>> test Neutron Create Port With Existing Name ->>>>>>>>>>>>>>>')
545 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
546 url
= "http://0.0.0.0:19696/v2.0/ports"
547 createportwithexistingnamedata
= '{"port": {"name": "new_port", "network_id": "%s"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
548 createportwithexistingnameresponse
= requests
.post(url
, data
=createportwithexistingnamedata
, headers
=headers
)
549 self
.assertEqual(createportwithexistingnameresponse
.status_code
, 500)
552 print('->>>>>>> test Neutron Create Port Without Name ->>>>>>>>>>>>>>>')
553 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
554 url
= "http://0.0.0.0:19696/v2.0/ports"
555 createportdatawithoutname
= '{"port": {"network_id": "%s"} }' % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
556 createportwithoutnameresponse
= requests
.post(url
, data
=createportdatawithoutname
, headers
=headers
)
557 self
.assertEqual(createportwithoutnameresponse
.status_code
, 201)
558 self
.assertIn("port:cp", json
.loads(createportwithoutnameresponse
.content
)["port"]["name"])
561 print('->>>>>>> test Neutron Update Port ->>>>>>>>>>>>>>>')
562 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
563 print(json
.loads(createportresponse
.content
)["port"]["name"])
564 url
= "http://0.0.0.0:19696/v2.0/ports/%s" % (json
.loads(createportresponse
.content
)["port"]["name"])
565 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"} }'
566 updateportresponse
= requests
.put(url
, data
=updateportdata
, headers
=headers
)
567 self
.assertEqual(updateportresponse
.status_code
, 200)
568 self
.assertEqual(json
.loads(updateportresponse
.content
)["port"]["name"], "new_port_new_name")
571 print('->>>>>>> test Neutron Update Non-Existing Port ->>>>>>>>>>>>>>>')
572 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
573 url
= "http://0.0.0.0:19696/v2.0/ports/non-existing-port-ip"
574 updatenonexistingportdata
= '{"port": {"name": "new_port_new_name"} }'
575 updatenonexistingportresponse
= requests
.put(url
, data
=updatenonexistingportdata
, headers
=headers
)
576 self
.assertEqual(updatenonexistingportresponse
.status_code
, 404)
579 print('->>>>>>> test Neutron Delete Port ->>>>>>>>>>>>>>>')
580 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
581 righturl
= "http://0.0.0.0:19696/v2.0/ports/%s" % (json
.loads(createportresponse
.content
)["port"]["id"])
582 deleterightportresponse
= requests
.delete(righturl
, headers
=headers
)
583 self
.assertEqual(deleterightportresponse
.status_code
, 204)
587 print('->>>>>>> test Neutron Delete Non-Existing Port ->>>>>>>>>>>>>>>')
588 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
589 wrongurl
= "http://0.0.0.0:19696/v2.0/ports/unknownid"
590 deletewrongportresponse
= requests
.delete(wrongurl
, headers
=headers
)
591 self
.assertEqual(deletewrongportresponse
.status_code
, 404)
594 print('->>>>>>> test Neutron Delete Subnet ->>>>>>>>>>>>>>>')
595 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
596 wrongurl
= "http://0.0.0.0:19696/v2.0/subnets/unknownid"
597 righturl
= "http://0.0.0.0:19696/v2.0/subnets/%s" % (json
.loads(updatesubnetresponse
.content
)["subnet"]["id"])
598 deletewrongsubnetresponse
= requests
.delete(wrongurl
, headers
=headers
)
599 deleterightsubnetresponse
= requests
.delete(righturl
, headers
=headers
)
600 self
.assertEqual(deletewrongsubnetresponse
.status_code
, 404)
601 self
.assertEqual(deleterightsubnetresponse
.status_code
, 204)
604 print('->>>>>>> test Neutron Delete Network ->>>>>>>>>>>>>>>')
605 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
606 righturl
= "http://0.0.0.0:19696/v2.0/networks/%s" % (json
.loads(createnetworkresponse
.content
)["network"]["id"])
607 deleterightnetworkresponse
= requests
.delete(righturl
, headers
=headers
)
608 self
.assertEqual(deleterightnetworkresponse
.status_code
, 204)
611 print('->>>>>>> test Neutron Delete Non-Existing Network ->>>>>>>>>>>>>>>')
612 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
613 wrongurl
= "http://0.0.0.0:19696/v2.0/networks/unknownid"
614 deletewrongnetworkresponse
= requests
.delete(wrongurl
, headers
=headers
)
615 self
.assertEqual(deletewrongnetworkresponse
.status_code
, 404)
618 def testKeystomeDummy(self
):
619 print('->>>>>>> test Keystone Dummy Class->>>>>>>>>>>>>>>')
620 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
623 headers
= {'Content-type': 'application/json'}
624 test_heatapi_keystone_get_token
= open(os
.path
.join(os
.path
.dirname(__file__
), "templates/test_heatapi_keystone_get_token.yml")).read()
626 print('->>>>>>> test Keystone List Versions ->>>>>>>>>>>>>>>')
627 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
628 url
= "http://0.0.0.0:15000/"
629 listapiversionstackresponse
= requests
.get(url
, headers
=headers
)
630 self
.assertEqual(listapiversionstackresponse
.status_code
, 200)
631 self
.assertEqual(json
.loads(listapiversionstackresponse
.content
)["versions"]["values"][0]["id"], "v2.0")
634 print('->>>>>>> test Keystone Show ApiV2 ->>>>>>>>>>>>>>>')
635 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
636 url
= "http://0.0.0.0:15000/v2.0"
637 showapiversionstackresponse
= requests
.get(url
, headers
=headers
)
638 self
.assertEqual(showapiversionstackresponse
.status_code
, 200)
639 self
.assertEqual(json
.loads(showapiversionstackresponse
.content
)["version"]["id"], "v2.0")
642 print('->>>>>>> test Keystone Get Token ->>>>>>>>>>>>>>>')
643 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
644 url
= "http://0.0.0.0:15000/v2.0/tokens"
645 gettokenstackresponse
= requests
.post(url
, data
=json
.dumps(yaml
.load(test_heatapi_keystone_get_token
)), headers
=headers
)
646 self
.assertEqual(gettokenstackresponse
.status_code
, 200)
647 self
.assertEqual(json
.loads(gettokenstackresponse
.content
)["access"]["user"]["name"], "tenantName")
650 def testHeatDummy(self
):
651 print('->>>>>>> test Heat Dummy Class->>>>>>>>>>>>>>>')
652 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
655 headers
= {'Content-type': 'application/json'}
656 test_heatapi_template_create_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "templates/test_heatapi_template_create_stack.yml")).read()
657 test_heatapi_template_update_stack
= open(os
.path
.join(os
.path
.dirname(__file__
), "templates/test_heatapi_template_update_stack.yml")).read()
659 print('->>>>>>> test Heat List API Versions Stack ->>>>>>>>>>>>>>>')
660 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
661 url
= "http://0.0.0.0:18004/"
662 listapiversionstackresponse
= requests
.get(url
, headers
=headers
)
663 self
.assertEqual(listapiversionstackresponse
.status_code
, 200)
664 self
.assertEqual(json
.loads(listapiversionstackresponse
.content
)["versions"][0]["id"], "v1.0")
667 print('->>>>>>> test Create Stack ->>>>>>>>>>>>>>>')
668 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
669 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
670 createstackresponse
= requests
.post(url
, data
=json
.dumps(yaml
.load(test_heatapi_template_create_stack
)), headers
=headers
)
671 self
.assertEqual(createstackresponse
.status_code
, 201)
672 self
.assertNotEqual(json
.loads(createstackresponse
.content
)["stack"]["id"], "")
675 print('->>>>>>> test Create Stack With Existing Name ->>>>>>>>>>>>>>>')
676 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
677 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
678 createstackwithexistingnameresponse
= requests
.post(url
, data
='{"stack_name" : "s1"}', headers
=headers
)
679 self
.assertEqual(createstackwithexistingnameresponse
.status_code
, 409)
682 print('->>>>>>> test Create Stack With Unsupported Version ->>>>>>>>>>>>>>>')
683 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
684 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
685 createstackwitheunsupportedversionresponse
= requests
.post(url
, data
='{"stack_name" : "stackname123", "template" : {"heat_template_version": "2015-04-29"}}', headers
=headers
)
686 self
.assertEqual(createstackwitheunsupportedversionresponse
.status_code
, 400)
690 print('->>>>>>> test List Stack ->>>>>>>>>>>>>>>')
691 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
692 url
= "http://0.0.0.0:18004/v1/tenantabc123/stacks"
693 liststackresponse
= requests
.get(url
, headers
=headers
)
694 self
.assertEqual(liststackresponse
.status_code
, 200)
695 self
.assertEqual(json
.loads(liststackresponse
.content
)["stacks"][0]["stack_status"], "CREATE_COMPLETE")
699 print('->>>>>>> test Show Stack ->>>>>>>>>>>>>>>')
700 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
701 url
= "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s"% json
.loads(createstackresponse
.content
)['stack']['id']
702 liststackdetailsresponse
= requests
.get(url
, headers
=headers
)
703 self
.assertEqual(liststackdetailsresponse
.status_code
, 200)
704 self
.assertEqual(json
.loads(liststackdetailsresponse
.content
)["stack"]["stack_status"], "CREATE_COMPLETE")
707 print('->>>>>>> test Show Non-Exisitng Stack ->>>>>>>>>>>>>>>')
708 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
709 url
= "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/non_exisitng_id123"
710 listnonexistingstackdetailsresponse
= requests
.get(url
, headers
=headers
)
711 self
.assertEqual(listnonexistingstackdetailsresponse
.status_code
, 404)
714 print('->>>>>>> test Update Stack ->>>>>>>>>>>>>>>')
715 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
716 url
= "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/%s"% json
.loads(createstackresponse
.content
)['stack']['id']
717 updatestackresponse
= requests
.put(url
, data
=json
.dumps(yaml
.load(test_heatapi_template_update_stack
)),
719 self
.assertEqual(updatestackresponse
.status_code
, 202)
720 liststackdetailsresponse
= requests
.get(url
, headers
=headers
)
721 self
.assertEqual(json
.loads(liststackdetailsresponse
.content
)["stack"]["stack_status"], "UPDATE_COMPLETE")
724 print('->>>>>>> test Update Non-Existing Stack ->>>>>>>>>>>>>>>')
725 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
726 url
= "http://0.0.0.0:18004/v1/tenantabc123updateStack/stacks/non_existing_id_1234"
727 updatenonexistingstackresponse
= requests
.put(url
, data
={"non": "sense"}, headers
=headers
)
728 self
.assertEqual(updatenonexistingstackresponse
.status_code
, 404)
731 print('->>>>>>> test Delete Stack ->>>>>>>>>>>>>>>')
732 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
733 url
= "http://0.0.0.0:18004/v1/tenantabc123showStack/stacks/%s" % \
734 json
.loads(createstackresponse
.content
)['stack']['id']
735 deletestackdetailsresponse
= requests
.delete(url
, headers
=headers
)
736 self
.assertEqual(deletestackdetailsresponse
.status_code
, 204)
739 def testNeutronSFC(self
):
741 Tests the Neutron Service Function Chaining implementation. As Some functions build up on others, a
742 complete environment is created here:
744 Ports: p1, p2, p3, p4
745 Port Pairs: pp1(p1, p2), pp2(p3, p4)
746 Port Pair Groups: ppg1(pp1, pp2)
747 Flow Classifiers: fc1
748 Port Chain: pc1(ppg1, fc1)
751 headers
= {'Content-type': 'application/json'}
753 print('->>>>>>> Create ports p1 - p4 ->>>>>>>>>>>>>>>')
754 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
756 network_resp
= requests
.get("http://0.0.0.0:19696/v2.0/networks?name=default", headers
=headers
)
757 self
.assertEqual(network_resp
.status_code
, 200)
758 network_id
= json
.loads(network_resp
.content
)["networks"][0]["id"]
760 url
= "http://0.0.0.0:19696/v2.0/ports"
761 port_request
= '{"port": {"name": "%s", "network_id": "%s"}}'
762 p1_resp
= requests
.post(url
, data
=port_request
% ("p1", network_id
), headers
=headers
)
763 self
.assertEqual(p1_resp
.status_code
, 201)
764 p2_resp
= requests
.post(url
, data
=port_request
% ("p2", network_id
), headers
=headers
)
765 self
.assertEqual(p2_resp
.status_code
, 201)
766 p3_resp
= requests
.post(url
, data
=port_request
% ("p3", network_id
), headers
=headers
)
767 self
.assertEqual(p3_resp
.status_code
, 201)
768 p4_resp
= requests
.post(url
, data
=port_request
% ("p4", network_id
), headers
=headers
)
769 self
.assertEqual(p4_resp
.status_code
, 201)
771 p1_id
= json
.loads(p1_resp
.content
)["port"]["id"]
772 p2_id
= json
.loads(p2_resp
.content
)["port"]["id"]
773 p3_id
= json
.loads(p3_resp
.content
)["port"]["id"]
774 p4_id
= json
.loads(p4_resp
.content
)["port"]["id"]
776 print('->>>>>>> test Neutron SFC Port Pair Create ->>>>>>>>>>>>>>>')
777 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
778 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs"
779 pp1_resp
= requests
.post(url
, data
='{"port_pair": {"name": "pp1", "ingress": "%s", "egress": "%s"}}' % (p1_id
, p2_id
), headers
=headers
)
780 self
.assertEqual(pp1_resp
.status_code
, 201)
781 pp2_resp
= requests
.post(url
, data
='{"port_pair": {"name": "pp2", "ingress": "%s", "egress": "%s"}}' % (p3_id
, p4_id
), headers
=headers
)
782 self
.assertEqual(pp2_resp
.status_code
, 201)
783 pp3_resp
= requests
.post(url
, data
='{"port_pair": {"name": "pp3", "ingress": "%s", "egress": "%s"}}' % (p3_id
, p4_id
), headers
=headers
)
784 self
.assertEqual(pp3_resp
.status_code
, 201)
786 pp1_id
= json
.loads(pp1_resp
.content
)["port_pair"]["id"]
787 pp2_id
= json
.loads(pp2_resp
.content
)["port_pair"]["id"]
788 pp3_id
= json
.loads(pp3_resp
.content
)["port_pair"]["id"]
790 print('->>>>>>> test Neutron SFC Port Pair Update ->>>>>>>>>>>>>>>')
791 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
792 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp3_id
793 pp3_update_resp
= requests
.put(url
, data
='{"port_pair": {"description": "port_pair_update"}}', headers
=headers
)
794 self
.assertEqual(pp3_update_resp
.status_code
, 200)
795 self
.assertEqual(json
.loads(pp3_update_resp
.content
)["port_pair"]["description"], "port_pair_update")
797 print('->>>>>>> test Neutron SFC Port Pair Delete ->>>>>>>>>>>>>>>')
798 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
799 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp3_id
800 pp3_delete_resp
= requests
.delete(url
, headers
=headers
)
801 self
.assertEqual(pp3_delete_resp
.status_code
, 204)
803 print('->>>>>>> test Neutron SFC Port Pair List ->>>>>>>>>>>>>>>')
804 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
805 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs"
806 pp_list_resp
= requests
.get(url
, headers
=headers
)
807 self
.assertEqual(pp_list_resp
.status_code
, 200)
808 self
.assertEqual(len(json
.loads(pp_list_resp
.content
)["port_pairs"]), 2) # only pp1 and pp2 should be left
810 print('->>>>>>> test Neutron SFC Port Pair Show ->>>>>>>>>>>>>>>')
811 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
812 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pairs/%s" % pp2_id
813 pp2_show_resp
= requests
.get(url
, headers
=headers
)
814 self
.assertEqual(pp2_show_resp
.status_code
, 200)
815 self
.assertEqual(json
.loads(pp2_show_resp
.content
)["port_pair"]["name"], "pp2")
818 print('->>>>>>> test Neutron SFC Port Pair Group Create ->>>>>>>>>>>>>>>')
819 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
820 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups"
821 ppg1_resp
= requests
.post(url
, data
='{"port_pair_group": {"name": "ppg1", "port_pairs": ["%s"]}}' % (pp1_id
), headers
=headers
)
822 self
.assertEqual(ppg1_resp
.status_code
, 201)
823 ppg2_resp
= requests
.post(url
, data
='{"port_pair_group": {"name": "ppg2", "port_pairs": ["%s"]}}' % (pp2_id
), headers
=headers
)
824 self
.assertEqual(ppg2_resp
.status_code
, 201)
825 ppg3_resp
= requests
.post(url
, data
='{"port_pair_group": {"name": "ppg3", "port_pairs": ["%s"]}}' % (pp2_id
), headers
=headers
)
826 self
.assertEqual(ppg3_resp
.status_code
, 201)
828 ppg1_id
= json
.loads(ppg1_resp
.content
)["port_pair_group"]["id"]
829 ppg2_id
= json
.loads(ppg2_resp
.content
)["port_pair_group"]["id"]
830 ppg3_id
= json
.loads(ppg3_resp
.content
)["port_pair_group"]["id"]
832 print('->>>>>>> test Neutron SFC Port Pair Group Update ->>>>>>>>>>>>>>>')
833 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
834 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg3_id
835 ppg3_update_resp
= requests
.put(url
, data
='{"port_pair_group": {"description": "port_pair_group_update"}}', headers
=headers
)
836 self
.assertEqual(ppg3_update_resp
.status_code
, 200)
837 self
.assertEqual(json
.loads(ppg3_update_resp
.content
)["port_pair_group"]["description"], "port_pair_group_update")
839 print('->>>>>>> test Neutron SFC Port Pair Group Delete ->>>>>>>>>>>>>>>')
840 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
841 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg3_id
842 ppg3_delete_resp
= requests
.delete(url
, headers
=headers
)
843 self
.assertEqual(ppg3_delete_resp
.status_code
, 204)
845 print('->>>>>>> test Neutron SFC Port Pair Group List ->>>>>>>>>>>>>>>')
846 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
847 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups"
848 ppg_list_resp
= requests
.get(url
, headers
=headers
)
849 self
.assertEqual(ppg_list_resp
.status_code
, 200)
850 self
.assertEqual(len(json
.loads(ppg_list_resp
.content
)["port_pair_groups"]), 2) # only ppg1 and ppg2 should be left
852 print('->>>>>>> test Neutron SFC Port Pair Group Show ->>>>>>>>>>>>>>>')
853 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
854 url
= "http://0.0.0.0:19696/v2.0/sfc/port_pair_groups/%s" % ppg2_id
855 ppg2_show_resp
= requests
.get(url
, headers
=headers
)
856 self
.assertEqual(ppg2_show_resp
.status_code
, 200)
857 self
.assertEqual(json
.loads(ppg2_show_resp
.content
)["port_pair_group"]["name"], "ppg2")
859 print('->>>>>>> test Neutron SFC Flow Classifier Create ->>>>>>>>>>>>>>>')
860 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
861 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers"
862 fc1_resp
= requests
.post(url
, data
='{"flow_classifier": {"name": "fc1", "source_port_range_min": 22, "source_port_range_max": 4000}}', headers
=headers
)
863 self
.assertEqual(fc1_resp
.status_code
, 201)
864 fc2_resp
= requests
.post(url
, data
='{"flow_classifier": {"name": "fc2", "source_port_range_min": 22, "source_port_range_max": 4000}}', headers
=headers
)
865 self
.assertEqual(fc2_resp
.status_code
, 201)
867 fc1_id
= json
.loads(fc1_resp
.content
)["flow_classifier"]["id"]
868 fc2_id
= json
.loads(fc2_resp
.content
)["flow_classifier"]["id"]
870 print('->>>>>>> test Neutron SFC Flow Classifier Update ->>>>>>>>>>>>>>>')
871 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
872 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc2_id
873 fc2_update_resp
= requests
.put(url
, data
='{"flow_classifier": {"description": "flow_classifier_update"}}', headers
=headers
)
874 self
.assertEqual(fc2_update_resp
.status_code
, 200)
875 self
.assertEqual(json
.loads(fc2_update_resp
.content
)["flow_classifier"]["description"], "flow_classifier_update")
877 print('->>>>>>> test Neutron SFC Flow Classifier Delete ->>>>>>>>>>>>>>>')
878 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
879 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc2_id
880 fc2_delete_resp
= requests
.delete(url
, headers
=headers
)
881 self
.assertEqual(fc2_delete_resp
.status_code
, 204)
883 print('->>>>>>> test Neutron SFC Flow Classifier List ->>>>>>>>>>>>>>>')
884 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
885 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers"
886 fc_list_resp
= requests
.get(url
, headers
=headers
)
887 self
.assertEqual(fc_list_resp
.status_code
, 200)
888 self
.assertEqual(len(json
.loads(fc_list_resp
.content
)["flow_classifiers"]), 1) # only fc1
890 print('->>>>>>> test Neutron SFC Flow Classifier Show ->>>>>>>>>>>>>>>')
891 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
892 url
= "http://0.0.0.0:19696/v2.0/sfc/flow_classifiers/%s" % fc1_id
893 fc1_show_resp
= requests
.get(url
, headers
=headers
)
894 self
.assertEqual(fc1_show_resp
.status_code
, 200)
895 self
.assertEqual(json
.loads(fc1_show_resp
.content
)["flow_classifier"]["name"], "fc1")
898 print('->>>>>>> test Neutron SFC Port Chain Create ->>>>>>>>>>>>>>>')
899 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
900 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains"
901 pc1_resp
= requests
.post(url
, data
='{"port_chain": {"name": "pc1", "port_pair_groups": ["%s"], "flow_classifiers": ["%s"]}}' % (ppg1_id
, fc1_id
), headers
=headers
)
902 self
.assertEqual(pc1_resp
.status_code
, 201)
903 pc2_resp
= requests
.post(url
, data
='{"port_chain": {"name": "pc2", "port_pair_groups": ["%s"], "flow_classifiers": ["%s"]}}' % (ppg1_id
, fc1_id
), headers
=headers
)
904 self
.assertEqual(pc2_resp
.status_code
, 201)
906 pc1_id
= json
.loads(pc1_resp
.content
)["port_chain"]["id"]
907 pc2_id
= json
.loads(pc2_resp
.content
)["port_chain"]["id"]
909 print('->>>>>>> test Neutron SFC Port Chain Update ->>>>>>>>>>>>>>>')
910 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
911 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc2_id
912 pc2_update_resp
= requests
.put(url
, data
='{"port_chain": {"description": "port_chain_update"}}', headers
=headers
)
913 self
.assertEqual(pc2_update_resp
.status_code
, 200)
914 self
.assertEqual(json
.loads(pc2_update_resp
.content
)["port_chain"]["description"], "port_chain_update")
916 print('->>>>>>> test Neutron SFC Port Chain Delete ->>>>>>>>>>>>>>>')
917 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
918 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc2_id
919 pc2_delete_resp
= requests
.delete(url
, headers
=headers
)
920 self
.assertEqual(pc2_delete_resp
.status_code
, 204)
922 print('->>>>>>> test Neutron SFC Port Chain List ->>>>>>>>>>>>>>>')
923 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
924 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains"
925 pc_list_resp
= requests
.get(url
, headers
=headers
)
926 self
.assertEqual(pc_list_resp
.status_code
, 200)
927 self
.assertEqual(len(json
.loads(pc_list_resp
.content
)["port_chains"]), 1) # only pc1
929 print('->>>>>>> test Neutron SFC Port Chain Show ->>>>>>>>>>>>>>>')
930 print('->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
931 url
= "http://0.0.0.0:19696/v2.0/sfc/port_chains/%s" % pc1_id
932 pc1_show_resp
= requests
.get(url
, headers
=headers
)
933 self
.assertEqual(pc1_show_resp
.status_code
, 200)
934 self
.assertEqual(json
.loads(pc1_show_resp
.content
)["port_chain"]["name"], "pc1")
936 if __name__
== '__main__':