root / snf-cyclades-app / synnefo / neutron / tests / api.py @ efabd2d4
History | View | Annotate | Download (27.1 kB)
1 |
from snf_django.utils.testing import BaseAPITest |
---|---|
2 |
from django.utils import simplejson as json |
3 |
from synnefo.cyclades_settings import cyclades_services |
4 |
from synnefo.lib.services import get_service_path |
5 |
from synnefo.lib import join_urls |
6 |
from ipaddr import IPv4Network |
7 |
import json |
8 |
import synnefo.neutron.models_factory as mf |
9 |
import synnefo.db.models_factory as dbmf |
10 |
|
11 |
|
12 |
NEUTRON_URL = get_service_path(cyclades_services, "neutron", "v2.0") |
13 |
NETWORKS_URL = join_urls(NEUTRON_URL, "networks/")
|
14 |
SUBNETS_URL = join_urls(NEUTRON_URL, "subnets/")
|
15 |
ROUTERS_URL = join_urls(NEUTRON_URL, "routers/")
|
16 |
|
17 |
|
18 |
class NetworkTest(BaseAPITest): |
19 |
|
20 |
def test_list_networks(self): |
21 |
response = self.get(NETWORKS_URL)
|
22 |
self.assertSuccess(response)
|
23 |
networks = json.loads(response.content) |
24 |
self.assertEqual(networks, {"networks": []}) |
25 |
|
26 |
def test_create_network(self): |
27 |
request = { |
28 |
"network": {
|
29 |
"name": "sample_network" |
30 |
} |
31 |
} |
32 |
response = self.post(NETWORKS_URL, params=json.dumps(request))
|
33 |
code = response.status_code |
34 |
self.assertEqual(code, 201) |
35 |
|
36 |
def test_create_network_no_name(self): |
37 |
response = self.post(NETWORKS_URL, params="") |
38 |
code = response.status_code |
39 |
self.assertEqual(code, 201) |
40 |
|
41 |
def test_get_unfound_network(self): |
42 |
url = join_urls(NETWORKS_URL, "123")
|
43 |
response = self.get(url)
|
44 |
self.assertItemNotFound(response)
|
45 |
|
46 |
def test_get_network(self): |
47 |
test_net = mf.NetworkFactory.create() |
48 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
49 |
response = self.get(url, user=test_net.userid)
|
50 |
# validate response
|
51 |
res = json.loads(response.content) |
52 |
net = res['network']
|
53 |
keys = net.keys() |
54 |
must_send = set(["status", "subnets", "name", "admin_state_up", |
55 |
"tenant_id", "id"]) |
56 |
self.assertEqual(set(keys).issuperset(must_send), True) |
57 |
self.assertEqual(response.status_code, 200) |
58 |
|
59 |
def test_get_deleted_network(self): |
60 |
test_net = mf.NetworkFactory.create() |
61 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
62 |
self.delete(url, user=test_net.userid)
|
63 |
response = self.get(url, user=test_net.userid)
|
64 |
self.assertEqual(response.status_code, 400) |
65 |
|
66 |
def test_delete_unfound_network(self): |
67 |
url = join_urls(NETWORKS_URL, "123")
|
68 |
response = self.delete(url)
|
69 |
self.assertItemNotFound(response)
|
70 |
|
71 |
def test_delete_network(self): |
72 |
test_net = mf.NetworkFactory.create() |
73 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
74 |
response = self.delete(url, user=test_net.userid)
|
75 |
self.assertEqual(response.status_code, 204) |
76 |
|
77 |
def test_delete_network_in_use(self): |
78 |
test_net = mf.NetworkFactory.create() |
79 |
test_iface = mf.NetworkInterfaceFactory.create(network=test_net) |
80 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
81 |
response = self.delete(url, user=test_net.userid)
|
82 |
self.assertEqual(response.status_code, 409) |
83 |
|
84 |
def test_put_unfound_network(self): |
85 |
url = join_urls(NETWORKS_URL, "123")
|
86 |
response = self.delete(url)
|
87 |
self.assertItemNotFound(response)
|
88 |
|
89 |
def test_put_network(self): |
90 |
test_net = mf.NetworkFactory.create() |
91 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
92 |
request = { |
93 |
"network": {
|
94 |
"name": "new_name"} |
95 |
} |
96 |
response = self.put(url, params=json.dumps(request),
|
97 |
user=test_net.userid) |
98 |
self.assertEqual(response.status_code, 200) |
99 |
|
100 |
def test_put_network_wrong_data(self): |
101 |
test_net = mf.NetworkFactory.create() |
102 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
103 |
request = { |
104 |
"network": {
|
105 |
"wrong_field": "new_name"} |
106 |
} |
107 |
response = self.put(url, params=json.dumps(request),
|
108 |
user=test_net.userid) |
109 |
self.assertEqual(response.status_code, 400) |
110 |
|
111 |
def test_put_no_data(self): |
112 |
test_net = mf.NetworkFactory.create() |
113 |
url = join_urls(NETWORKS_URL, str(test_net.id))
|
114 |
response = self.put(url, params="", user=test_net.userid) |
115 |
self.assertEqual(response.status_code, 400) |
116 |
|
117 |
|
118 |
class RouterTest(BaseAPITest): |
119 |
def test_list_empty_routers(self): |
120 |
response = self.get(ROUTERS_URL)
|
121 |
self.assertSuccess(response)
|
122 |
routers = json.loads(response.content) |
123 |
self.assertEqual(routers, {"routers": []}) |
124 |
|
125 |
def test_create_router(self): |
126 |
pass
|
127 |
|
128 |
def test_get_router(self): |
129 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
130 |
net = mf.NetworkFactory.create(public=True)
|
131 |
nic = mf.NetworkInterfaceFactory.create(network=net, machine=router) |
132 |
response = self.get(ROUTERS_URL, user=router.userid)
|
133 |
self.assertSuccess(response)
|
134 |
|
135 |
def test_delete_router(self): |
136 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
137 |
url = join_urls(ROUTERS_URL, str(router.id))
|
138 |
response = self.delete(url, user=router.userid)
|
139 |
self.assertEqual(response.status_code, 204) |
140 |
|
141 |
def test_delete_router_with_private_net(self): |
142 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
143 |
net = mf.NetworkFactory.create(public=False)
|
144 |
nic = mf.NetworkInterfaceFactory.create(network=net, machine=router) |
145 |
url = join_urls(ROUTERS_URL, str(router.id))
|
146 |
response = self.delete(url, user=router.userid)
|
147 |
self.assertEqual(response.status_code, 409) |
148 |
|
149 |
def test_update_router(self): |
150 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
151 |
net1 = mf.NetworkFactory.create(public=True)
|
152 |
net2 = mf.NetworkFactory.create(public=True)
|
153 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router) |
154 |
request = { |
155 |
"router": {
|
156 |
"name": "new_name", |
157 |
"external_gateway_info": {"network_id": net2.id} |
158 |
} |
159 |
} |
160 |
url = join_urls(ROUTERS_URL, str(router.id))
|
161 |
response = self.put(url, params=json.dumps(request),
|
162 |
user=router.userid) |
163 |
info = json.loads(response.content) |
164 |
self.assertEqual(info['router']['external_gateway_info']['network_id'], |
165 |
net2.id) |
166 |
self.assertEqual(info['router']['name'], "new_name") |
167 |
|
168 |
def test_remove_interface_no_body(self): |
169 |
url = join_urls(join_urls(ROUTERS_URL, "123"),
|
170 |
"remove_router_interface")
|
171 |
|
172 |
response = self.put(url, params="") |
173 |
self.assertEqual(response.status_code, 400) |
174 |
|
175 |
def test_remove_interface_unfound_port(self): |
176 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
177 |
request = {"port_id": "123"} |
178 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
179 |
"remove_router_interface")
|
180 |
response = self.put(url, params=json.dumps(request),
|
181 |
user=router.userid) |
182 |
self.assertEqual(response.status_code, 404) |
183 |
|
184 |
def test_remove_interface_unfound_subnet(self): |
185 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
186 |
request = {"subnet_id": "123"} |
187 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
188 |
"remove_router_interface")
|
189 |
response = self.put(url, params=json.dumps(request),
|
190 |
user=router.userid) |
191 |
self.assertEqual(response.status_code, 404) |
192 |
|
193 |
def test_remove_interface_no_info(self): |
194 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
195 |
request = {"wrong": "123"} |
196 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
197 |
"remove_router_interface")
|
198 |
response = self.put(url, params=json.dumps(request),
|
199 |
user=router.userid) |
200 |
self.assertEqual(response.status_code, 400) |
201 |
|
202 |
def test_remove_interface_both_info_wrong(self): |
203 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
204 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
205 |
subnet = mf.SubnetFactory.create(network=net1) |
206 |
subnet2 = mf.SubnetFactory.create(network=net1) |
207 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router, |
208 |
subnet=subnet2) |
209 |
request = {"subnet_id": subnet.id, "port_id": nic.id} |
210 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
211 |
"remove_router_interface")
|
212 |
response = self.put(url, params=json.dumps(request),
|
213 |
user=router.userid) |
214 |
self.assertEqual(response.status_code, 409) |
215 |
|
216 |
def test_remove_interface_subnet(self): |
217 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
218 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
219 |
subnet = mf.SubnetFactory.create(network=net1) |
220 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router, |
221 |
subnet=subnet) |
222 |
request = {"subnet_id": subnet.id}
|
223 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
224 |
"remove_router_interface")
|
225 |
response = self.put(url, params=json.dumps(request),
|
226 |
user=router.userid) |
227 |
self.assertEqual(response.status_code, 200) |
228 |
|
229 |
def test_remove_interface_port(self): |
230 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
231 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
232 |
subnet = mf.SubnetFactory.create(network=net1) |
233 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router, |
234 |
subnet=subnet) |
235 |
request = {"port_id": nic.id}
|
236 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
237 |
"remove_router_interface")
|
238 |
response = self.put(url, params=json.dumps(request),
|
239 |
user=router.userid) |
240 |
self.assertEqual(response.status_code, 200) |
241 |
|
242 |
def test_remove_interface_both_info(self): |
243 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
244 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
245 |
subnet = mf.SubnetFactory.create(network=net1) |
246 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router, |
247 |
subnet=subnet) |
248 |
request = {"subnet_id": subnet.id, "port_id": nic.id} |
249 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
250 |
"remove_router_interface")
|
251 |
response = self.put(url, params=json.dumps(request),
|
252 |
user=router.userid) |
253 |
self.assertEqual(response.status_code, 200) |
254 |
|
255 |
def test_add_interface_no_info(self): |
256 |
url = join_urls(join_urls(ROUTERS_URL, "123"), "add_router_interface") |
257 |
response = self.put(url, params="") |
258 |
self.assertEqual(response.status_code, 400) |
259 |
|
260 |
def test_add_interface_wrong_info(self): |
261 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
262 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
263 |
"add_router_interface")
|
264 |
request = {} |
265 |
response = self.put(url, params=json.dumps(request),
|
266 |
user=router.userid) |
267 |
self.assertEqual(response.status_code, 400) |
268 |
|
269 |
def test_add_interface_unfound_port(self): |
270 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
271 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
272 |
"add_router_interface")
|
273 |
request = {"port_id": "123"} |
274 |
response = self.put(url, params=json.dumps(request),
|
275 |
user=router.userid) |
276 |
self.assertEqual(response.status_code, 404) |
277 |
|
278 |
def test_add_interface_unfound_subnet(self): |
279 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
280 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
281 |
"add_router_interface")
|
282 |
request = {"subnet_id": "123"} |
283 |
response = self.put(url, params=json.dumps(request),
|
284 |
user=router.userid) |
285 |
self.assertEqual(response.status_code, 404) |
286 |
|
287 |
def test_add_interface_both(self): |
288 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
289 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
290 |
subnet = mf.SubnetFactory.create(network=net1) |
291 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
292 |
"add_router_interface")
|
293 |
request = {"subnet_id": subnet.id, "port_id": "123"} |
294 |
response = self.put(url, params=json.dumps(request),
|
295 |
user=router.userid) |
296 |
self.assertEqual(response.status_code, 400) |
297 |
|
298 |
def test_add_interface_subnet(self): |
299 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
300 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
301 |
subnet = mf.SubnetFactory.create(network=net1) |
302 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
303 |
"add_router_interface")
|
304 |
request = {"subnet_id": subnet.id}
|
305 |
response = self.put(url, params=json.dumps(request),
|
306 |
user=router.userid) |
307 |
self.assertEqual(response.status_code, 200) |
308 |
|
309 |
def test_add_interface_port_no_ip(self): |
310 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
311 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
312 |
subnet = mf.SubnetFactory.create(network=net1) |
313 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router, |
314 |
subnet=subnet) |
315 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
316 |
"add_router_interface")
|
317 |
request = {"port_id": nic.id}
|
318 |
response = self.put(url, params=json.dumps(request),
|
319 |
user=router.userid) |
320 |
self.assertEqual(response.status_code, 400) |
321 |
|
322 |
def test_add_interface_port_connected(self): |
323 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
324 |
vm = dbmf.VirtualMachineFactory.create() |
325 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
326 |
subnet = mf.SubnetFactory.create(network=net1) |
327 |
nic = mf.NetworkInterfaceFactory.create(network=net1, machine=vm, |
328 |
subnet=subnet, |
329 |
ipv4="192.168.0.1")
|
330 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
331 |
"add_router_interface")
|
332 |
request = {"port_id": nic.id}
|
333 |
response = self.put(url, params=json.dumps(request),
|
334 |
user=router.userid) |
335 |
self.assertEqual(response.status_code, 409) |
336 |
|
337 |
def test_add_interface_port(self): |
338 |
router = dbmf.VirtualMachineFactory.create(router=True)
|
339 |
net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
|
340 |
subnet = mf.SubnetFactory.create(network=net1) |
341 |
nic = mf.NetworkInterfaceFactory.create(network=net1, |
342 |
machine=None,
|
343 |
subnet=subnet, |
344 |
ipv4="192.168.0.1")
|
345 |
url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
|
346 |
"add_router_interface")
|
347 |
request = {"port_id": nic.id}
|
348 |
response = self.put(url, params=json.dumps(request),
|
349 |
user=router.userid) |
350 |
self.assertEqual(response.status_code, 200) |
351 |
|
352 |
|
353 |
class SubnetTest(BaseAPITest): |
354 |
def test_list_subnets(self): |
355 |
'''Test list subnets without data'''
|
356 |
response = self.get(SUBNETS_URL)
|
357 |
self.assertSuccess(response)
|
358 |
subnets = json.loads(response.content) |
359 |
self.assertEqual(subnets, {'subnets': []}) |
360 |
|
361 |
def test_list_subnets_data(self): |
362 |
'''Test list subnets with data'''
|
363 |
test_net = mf.NetworkFactory() |
364 |
test_subnet_ipv4 = mf.SubnetFactory(network=test_net) |
365 |
test_subnet_ipv6 = mf.SubnetFactory(network=test_net, ipversion=6,
|
366 |
cidr='2620:0:2d0:200::7/32')
|
367 |
response = self.get(SUBNETS_URL, user=test_net.userid)
|
368 |
self.assertSuccess(response)
|
369 |
|
370 |
def test_get_subnet(self): |
371 |
'''Test get info of a single subnet'''
|
372 |
test_net = mf.NetworkFactory() |
373 |
test_subnet = mf.SubnetFactory(network=test_net) |
374 |
url = join_urls(SUBNETS_URL, str(test_subnet.id))
|
375 |
response = self.get(url, user=test_net.userid)
|
376 |
self.assertSuccess(response)
|
377 |
|
378 |
def test_get_subnet_404(self): |
379 |
'''Test get info of a subnet that doesn't exist'''
|
380 |
url = join_urls(SUBNETS_URL, '42')
|
381 |
response = self.get(url)
|
382 |
self.assertItemNotFound(response)
|
383 |
|
384 |
def test_subnet_delete(self): |
385 |
'''Test delete a subnet -- not supported'''
|
386 |
url = join_urls(SUBNETS_URL, '42')
|
387 |
response = self.delete(url)
|
388 |
self.assertBadRequest(response)
|
389 |
|
390 |
def test_create_subnet_success_ipv4(self): |
391 |
'''Test create a subnet successfully'''
|
392 |
test_net = mf.NetworkFactory() |
393 |
request = { |
394 |
'subnet': {
|
395 |
'network_id': test_net.id,
|
396 |
'cidr': '10.0.3.0/24', |
397 |
'ip_version': 4} |
398 |
} |
399 |
response = self.post(SUBNETS_URL, test_net.userid,
|
400 |
json.dumps(request), "json")
|
401 |
self.assertSuccess(response)
|
402 |
|
403 |
def test_create_subnet_success_ipv6(self): |
404 |
'''Test create an IPv6 subnet successfully'''
|
405 |
test_net = mf.NetworkFactory() |
406 |
request = { |
407 |
'subnet': {
|
408 |
'network_id': test_net.id,
|
409 |
'cidr': 'fdc1:4992:1130:fc0b::/64', |
410 |
'ip_version': 6} |
411 |
} |
412 |
response = self.post(SUBNETS_URL, test_net.userid,
|
413 |
json.dumps(request), "json")
|
414 |
self.assertSuccess(response)
|
415 |
|
416 |
def test_create_subnet_with_invalid_network_id(self): |
417 |
'''Test create a subnet with a network id that doesn't exist'''
|
418 |
test_net = mf.NetworkFactory() |
419 |
request = { |
420 |
'subnet': {
|
421 |
'network_id': '42', |
422 |
'cidr': '10.0.3.0/24', |
423 |
'ip_version': 4} |
424 |
} |
425 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
426 |
"json")
|
427 |
self.assertItemNotFound(response)
|
428 |
|
429 |
def test_create_subnet_with_malformed_ipversion(self): |
430 |
'''Create a subnet with a malformed ip_version type'''
|
431 |
test_net = mf.NetworkFactory() |
432 |
request = { |
433 |
'subnet': {
|
434 |
'network_id': test_net.id,
|
435 |
'cidr': '10.0.3.0/24', |
436 |
'ip_version': 8} |
437 |
} |
438 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
439 |
"json")
|
440 |
self.assertBadRequest(response)
|
441 |
|
442 |
def test_create_subnet_with_invalid_cidr(self): |
443 |
'''Create a subnet with an invalid cidr'''
|
444 |
test_net = mf.NetworkFactory() |
445 |
request = { |
446 |
'subnet': {
|
447 |
'network_id': test_net.id,
|
448 |
'cidr': '192.168.3.0/8'} |
449 |
} |
450 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
451 |
"json")
|
452 |
self.assertBadRequest(response)
|
453 |
|
454 |
def test_create_subnet_with_invalid_gateway(self): |
455 |
'''Create a subnet with a gateway outside of the subnet range'''
|
456 |
test_net = mf.NetworkFactory() |
457 |
request = { |
458 |
'subnet': {
|
459 |
'network_id': test_net.id,
|
460 |
'cidr': '192.168.3.0/24', |
461 |
'gateway_ip': '192.168.0.1'} |
462 |
} |
463 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
464 |
"json")
|
465 |
self.assertBadRequest(response)
|
466 |
|
467 |
def test_create_subnet_with_invalid_name(self): |
468 |
'''Create a subnet with an invalid subnet name'''
|
469 |
test_net = mf.NetworkFactory() |
470 |
request = { |
471 |
'subnet': {
|
472 |
'network_id': test_net.id,
|
473 |
'cidr': '192.168.3.0/24', |
474 |
'name': 'a' * 300} |
475 |
} |
476 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
477 |
"json")
|
478 |
self.assertBadRequest(response)
|
479 |
|
480 |
def test_create_subnet_with_invalid_dhcp(self): |
481 |
'''Create a subnet with an invalid dhcp value'''
|
482 |
test_net = mf.NetworkFactory() |
483 |
request = { |
484 |
'subnet': {
|
485 |
'network_id': test_net.id,
|
486 |
'cidr': '192.168.3.0/24', |
487 |
'enable_dhcp': 'None'} |
488 |
} |
489 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
490 |
"json")
|
491 |
self.assertBadRequest(response)
|
492 |
|
493 |
def test_create_subnet_with_dns_nameservers(self): |
494 |
'''Create a subnet with dns nameservers -- raises 400 BadRequest'''
|
495 |
test_net = mf.NetworkFactory() |
496 |
request = { |
497 |
'subnet': {
|
498 |
'network_id': test_net.id,
|
499 |
'cidr': '192.168.3.0/24', |
500 |
'dns_nameservers': '[]'} |
501 |
} |
502 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
503 |
"json")
|
504 |
self.assertBadRequest(response)
|
505 |
|
506 |
def test_create_subnet_with_host_routes(self): |
507 |
'''Create a subnet with host routes -- raises 400 BadRequest'''
|
508 |
test_net = mf.NetworkFactory() |
509 |
request = { |
510 |
'subnet': {
|
511 |
'network_id': test_net.id,
|
512 |
'cidr': '192.168.3.0/24', |
513 |
'host_routes': '[]'} |
514 |
} |
515 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
516 |
"json")
|
517 |
self.assertBadRequest(response)
|
518 |
|
519 |
def test_create_subnet_with_same_ipversion(self): |
520 |
'''
|
521 |
Create a subnet in a network with another subnet of the same
|
522 |
ipversion type
|
523 |
'''
|
524 |
test_net = mf.NetworkFactory() |
525 |
test_sub = mf.SubnetFactory(network=test_net) |
526 |
request = { |
527 |
'subnet': {
|
528 |
'network_id': test_net.id,
|
529 |
'cidr': '192.168.3.0/24'} |
530 |
} |
531 |
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
|
532 |
"json")
|
533 |
self.assertBadRequest(response)
|
534 |
|
535 |
def test_update_subnet_ip_version(self): |
536 |
'''Update the IP version of a subnet, raises 400 BadRequest'''
|
537 |
test_net = mf.NetworkFactory() |
538 |
test_sub = mf.SubnetFactory(network=test_net) |
539 |
request = { |
540 |
'subnet': {
|
541 |
'ip_version': '6'} |
542 |
} |
543 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
544 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
545 |
self.assertBadRequest(response)
|
546 |
|
547 |
def test_update_subnet_cidr(self): |
548 |
'''Update the cidr of a subnet, raises 400 BadRequest'''
|
549 |
test_net = mf.NetworkFactory() |
550 |
test_sub = mf.SubnetFactory(network=test_net) |
551 |
request = { |
552 |
'subnet': {
|
553 |
'cidr': '192.168.42.0/24'} |
554 |
} |
555 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
556 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
557 |
self.assertBadRequest(response)
|
558 |
|
559 |
def test_update_subnet_allocation_pools(self): |
560 |
'''Update the allocation pools of a subnet, raises 400 BadRequest'''
|
561 |
test_net = mf.NetworkFactory() |
562 |
test_sub = mf.SubnetFactory(network=test_net) |
563 |
request = { |
564 |
'subnet': {
|
565 |
'allocation_pools': '[]'} |
566 |
} |
567 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
568 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
569 |
self.assertBadRequest(response)
|
570 |
|
571 |
def test_update_subnet_add_dns(self): |
572 |
'''Update the dns nameservers of a subnet, raises 400 BadRequest'''
|
573 |
test_net = mf.NetworkFactory() |
574 |
test_sub = mf.SubnetFactory(network=test_net) |
575 |
request = { |
576 |
'subnet': {
|
577 |
'dns_nameservers': '[]'} |
578 |
} |
579 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
580 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
581 |
self.assertBadRequest(response)
|
582 |
|
583 |
def test_update_subnet_add_host_routes(self): |
584 |
'''Update the host routes of a subnet, raises 400 BadRequest'''
|
585 |
test_net = mf.NetworkFactory() |
586 |
test_sub = mf.SubnetFactory(network=test_net) |
587 |
request = { |
588 |
'subnet': {
|
589 |
'host_routes': '[]'} |
590 |
} |
591 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
592 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
593 |
self.assertBadRequest(response)
|
594 |
|
595 |
def test_update_subnet_with_invalid_dhcp_value(self): |
596 |
'''Update a subnet with an invalid dhcp value'''
|
597 |
test_net = mf.NetworkFactory() |
598 |
test_sub = mf.SubnetFactory(network=test_net) |
599 |
request = { |
600 |
'subnet': {
|
601 |
'enable_dhcp': 'Random'} |
602 |
} |
603 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
604 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
605 |
self.assertBadRequest(response)
|
606 |
|
607 |
def test_update_subnet_with_invalid_name(self): |
608 |
'''Update a subnet with an invalid name value'''
|
609 |
test_net = mf.NetworkFactory() |
610 |
test_sub = mf.SubnetFactory(network=test_net) |
611 |
request = { |
612 |
'subnet': {
|
613 |
'name': 'a' * 300} |
614 |
} |
615 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
616 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
617 |
self.assertBadRequest(response)
|
618 |
|
619 |
def test_update_subnet_with_invalid_gateway(self): |
620 |
'''Update a subnet with an invalid gateway value'''
|
621 |
test_net = mf.NetworkFactory() |
622 |
test_sub = mf.SubnetFactory(network=test_net) |
623 |
request = { |
624 |
'subnet': {
|
625 |
'gateway_ip': '192.168.200.0/24'} |
626 |
} |
627 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
628 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
629 |
self.assertBadRequest(response)
|
630 |
|
631 |
def test_update_subnet_gateway(self): |
632 |
'''Update the gateway of a subnet'''
|
633 |
test_net = mf.NetworkFactory() |
634 |
test_sub = mf.SubnetFactory(network=test_net) |
635 |
request = { |
636 |
'subnet': {
|
637 |
'gateway_ip': str(IPv4Network(test_sub.gateway).network + 1)} |
638 |
} |
639 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
640 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
641 |
self.assertSuccess(response)
|
642 |
|
643 |
def test_update_subnet_name(self): |
644 |
'''Update the name of a subnet'''
|
645 |
test_net = mf.NetworkFactory() |
646 |
test_sub = mf.SubnetFactory(network=test_net) |
647 |
request = { |
648 |
'subnet': {
|
649 |
'name': 'Updated Name'} |
650 |
} |
651 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
652 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
653 |
self.assertSuccess(response)
|
654 |
|
655 |
def test_update_subnet_dhcp(self): |
656 |
'''Update the dhcp flag of a subnet'''
|
657 |
test_net = mf.NetworkFactory() |
658 |
test_sub = mf.SubnetFactory(network=test_net) |
659 |
request = { |
660 |
'subnet': {
|
661 |
'enable_dhcp': False} |
662 |
} |
663 |
url = join_urls(SUBNETS_URL, str(test_sub.id))
|
664 |
response = self.put(url, test_net.userid, json.dumps(request), "json") |
665 |
self.assertSuccess(response)
|