1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
18 from neutronclient.common.exceptions import BadRequest
20 from snaps.config.network import (
21 NetworkConfig, SubnetConfig, SubnetConfigError, NetworkConfigError,
22 PortConfigError, IPv6Mode)
23 from snaps.openstack import create_router
24 from snaps.openstack.create_network import (
25 OpenStackNetwork, NetworkSettings, SubnetSettings, PortSettings)
26 from snaps.openstack.tests import openstack_tests
27 from snaps.openstack.tests.os_source_file_test import (
28 OSIntegrationTestCase, OSComponentTestCase)
29 from snaps.openstack.utils import neutron_utils, keystone_utils
30 from snaps.openstack.utils.tests import neutron_utils_tests
31 from snaps.openstack.create_network import IPv6Mode as IPv6Mode_old
33 __author__ = 'spisarski'
36 class NetworkSettingsUnitTests(unittest.TestCase):
38 Tests the construction of the NetworkSettings class
41 def test_no_params(self):
42 with self.assertRaises(NetworkConfigError):
45 def test_empty_config(self):
46 with self.assertRaises(NetworkConfigError):
47 NetworkSettings(**dict())
49 def test_name_only(self):
50 settings = NetworkSettings(name='foo')
51 self.assertEqual('foo', settings.name)
52 self.assertTrue(settings.admin_state_up)
53 self.assertIsNone(settings.shared)
54 self.assertIsNone(settings.project_name)
55 self.assertFalse(settings.external)
56 self.assertIsNone(settings.network_type)
57 self.assertIsNone(settings.segmentation_id)
58 self.assertEqual(0, len(settings.subnet_settings))
60 def test_config_with_name_only(self):
61 settings = NetworkSettings(**{'name': 'foo'})
62 self.assertEqual('foo', settings.name)
63 self.assertTrue(settings.admin_state_up)
64 self.assertIsNone(settings.shared)
65 self.assertIsNone(settings.project_name)
66 self.assertFalse(settings.external)
67 self.assertIsNone(settings.network_type)
68 self.assertIsNone(settings.segmentation_id)
69 self.assertEqual(0, len(settings.subnet_settings))
72 sub_settings = SubnetSettings(name='foo-subnet', cidr='10.0.0.0/24')
73 settings = NetworkSettings(name='foo', admin_state_up=False,
74 shared=True, project_name='bar',
76 network_type='vlan', physical_network='phy',
78 subnet_settings=[sub_settings])
79 self.assertEqual('foo', settings.name)
80 self.assertFalse(settings.admin_state_up)
81 self.assertTrue(settings.shared)
82 self.assertEqual('bar', settings.project_name)
83 self.assertTrue(settings.external)
84 self.assertEqual('vlan', settings.network_type)
85 self.assertEqual('phy', settings.physical_network)
86 self.assertEqual(2366, settings.segmentation_id)
87 self.assertEqual(1, len(settings.subnet_settings))
88 self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
90 def test_config_all(self):
91 settings = NetworkSettings(
92 **{'name': 'foo', 'admin_state_up': False, 'shared': True,
93 'project_name': 'bar', 'external': True, 'network_type': 'vlan',
94 'physical_network': 'phy',
95 'segmentation_id': 2366,
97 [{'subnet': {'name': 'foo-subnet',
98 'cidr': '10.0.0.0/24'}}]})
99 self.assertEqual('foo', settings.name)
100 self.assertFalse(settings.admin_state_up)
101 self.assertTrue(settings.shared)
102 self.assertEqual('bar', settings.project_name)
103 self.assertTrue(settings.external)
104 self.assertEqual('vlan', settings.network_type)
105 self.assertEqual('phy', settings.physical_network)
106 self.assertEqual(2366, settings.segmentation_id)
107 self.assertEqual(1, len(settings.subnet_settings))
108 self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
111 class SubnetSettingsUnitTests(unittest.TestCase):
113 Tests the construction of the SubnetSettings class
116 def test_no_params(self):
117 with self.assertRaises(SubnetConfigError):
120 def test_empty_config(self):
121 with self.assertRaises(SubnetConfigError):
122 SubnetSettings(**dict())
124 def test_name_only(self):
125 with self.assertRaises(SubnetConfigError):
126 SubnetSettings(name='foo')
128 def test_config_with_name_only(self):
129 with self.assertRaises(SubnetConfigError):
130 SubnetSettings(**{'name': 'foo'})
132 def test_name_cidr_only(self):
133 settings = SubnetSettings(name='foo', cidr='10.0.0.0/24')
134 self.assertEqual('foo', settings.name)
135 self.assertEqual('10.0.0.0/24', settings.cidr)
136 self.assertEqual(4, settings.ip_version)
137 self.assertIsNone(settings.project_name)
138 self.assertIsNone(settings.start)
139 self.assertIsNone(settings.end)
140 self.assertIsNone(settings.enable_dhcp)
141 self.assertEqual(0, len(settings.dns_nameservers))
142 self.assertIsNone(settings.host_routes)
143 self.assertIsNone(settings.destination)
144 self.assertIsNone(settings.nexthop)
145 self.assertIsNone(settings.ipv6_ra_mode)
146 self.assertIsNone(settings.ipv6_address_mode)
148 def test_config_with_name_cidr_only(self):
149 settings = SubnetSettings(**{'name': 'foo', 'cidr': '10.0.0.0/24'})
150 self.assertEqual('foo', settings.name)
151 self.assertEqual('10.0.0.0/24', settings.cidr)
152 self.assertEqual(4, settings.ip_version)
153 self.assertIsNone(settings.project_name)
154 self.assertIsNone(settings.start)
155 self.assertIsNone(settings.end)
156 self.assertIsNone(settings.gateway_ip)
157 self.assertIsNone(settings.enable_dhcp)
158 self.assertEqual(0, len(settings.dns_nameservers))
159 self.assertIsNone(settings.host_routes)
160 self.assertIsNone(settings.destination)
161 self.assertIsNone(settings.nexthop)
162 self.assertIsNone(settings.ipv6_ra_mode)
163 self.assertIsNone(settings.ipv6_address_mode)
165 def test_all_string_enums(self):
166 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
167 settings = SubnetSettings(
168 name='foo', cidr='10.0.0.0/24', ip_version=6,
169 project_name='bar-project', start='10.0.0.2', end='10.0.0.101',
170 gateway_ip='10.0.0.1', enable_dhcp=False,
171 dns_nameservers=['8.8.8.8'], host_routes=[host_routes],
172 destination='dest', nexthop='hop', ipv6_ra_mode='dhcpv6-stateful',
173 ipv6_address_mode='slaac')
174 self.assertEqual('foo', settings.name)
175 self.assertEqual('10.0.0.0/24', settings.cidr)
176 self.assertEqual(6, settings.ip_version)
177 self.assertEqual('bar-project', settings.project_name)
178 self.assertEqual('10.0.0.2', settings.start)
179 self.assertEqual('10.0.0.101', settings.end)
180 self.assertEqual('10.0.0.1', settings.gateway_ip)
181 self.assertEqual(False, settings.enable_dhcp)
182 self.assertEqual(1, len(settings.dns_nameservers))
183 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
184 self.assertEqual(1, len(settings.host_routes))
185 self.assertEqual(host_routes, settings.host_routes[0])
186 self.assertEqual('dest', settings.destination)
187 self.assertEqual('hop', settings.nexthop)
188 self.assertEqual(IPv6Mode_old.stateful.value,
189 settings.ipv6_ra_mode.value)
190 self.assertEqual(IPv6Mode_old.slaac.value,
191 settings.ipv6_address_mode.value)
193 def test_all_type_enums(self):
194 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
195 settings = SubnetSettings(
196 name='foo', cidr='10.0.0.0/24', ip_version=6,
197 project_name='bar-project', start='10.0.0.2', end='10.0.0.101',
198 gateway_ip='10.0.0.1', enable_dhcp=False,
199 dns_nameservers=['8.8.8.8'], host_routes=[host_routes],
200 destination='dest', nexthop='hop',
201 ipv6_ra_mode=IPv6Mode_old.stateful,
202 ipv6_address_mode=IPv6Mode.slaac)
203 self.assertEqual('foo', settings.name)
204 self.assertEqual('10.0.0.0/24', settings.cidr)
205 self.assertEqual(6, settings.ip_version)
206 self.assertEqual('bar-project', settings.project_name)
207 self.assertEqual('10.0.0.2', settings.start)
208 self.assertEqual('10.0.0.101', settings.end)
209 self.assertEqual('10.0.0.1', settings.gateway_ip)
210 self.assertEqual(False, settings.enable_dhcp)
211 self.assertEqual(1, len(settings.dns_nameservers))
212 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
213 self.assertEqual(1, len(settings.host_routes))
214 self.assertEqual(host_routes, settings.host_routes[0])
215 self.assertEqual('dest', settings.destination)
216 self.assertEqual('hop', settings.nexthop)
217 self.assertEqual(IPv6Mode.stateful.value, settings.ipv6_ra_mode.value)
218 self.assertEqual(IPv6Mode.slaac.value,
219 settings.ipv6_address_mode.value)
221 def test_config_all(self):
222 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
223 settings = SubnetSettings(
224 **{'name': 'foo', 'cidr': '10.0.0.0/24', 'ip_version': 6,
225 'project_name': 'bar-project', 'start': '10.0.0.2',
227 'gateway_ip': '10.0.0.1', 'enable_dhcp': False,
228 'dns_nameservers': ['8.8.8.8'], 'host_routes': [host_routes],
229 'destination': 'dest', 'nexthop': 'hop',
230 'ipv6_ra_mode': 'dhcpv6-stateless',
231 'ipv6_address_mode': 'slaac'})
232 self.assertEqual('foo', settings.name)
233 self.assertEqual('10.0.0.0/24', settings.cidr)
234 self.assertEqual(6, settings.ip_version)
235 self.assertEqual('bar-project', settings.project_name)
236 self.assertEqual('10.0.0.2', settings.start)
237 self.assertEqual('10.0.0.101', settings.end)
238 self.assertEqual('10.0.0.1', settings.gateway_ip)
239 self.assertEqual(False, settings.enable_dhcp)
240 self.assertEqual(1, len(settings.dns_nameservers))
241 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
242 self.assertEqual(1, len(settings.host_routes))
243 self.assertEqual(host_routes, settings.host_routes[0])
244 self.assertEqual('dest', settings.destination)
245 self.assertEqual('hop', settings.nexthop)
246 self.assertEqual(IPv6Mode.stateless.value, settings.ipv6_ra_mode.value)
247 self.assertEqual(IPv6Mode.slaac.value,
248 settings.ipv6_address_mode.value)
251 class PortSettingsUnitTests(unittest.TestCase):
253 Tests the construction of the PortSettings class
256 def test_no_params(self):
257 with self.assertRaises(PortConfigError):
260 def test_empty_config(self):
261 with self.assertRaises(PortConfigError):
262 PortSettings(**dict())
264 def test_name_only(self):
265 with self.assertRaises(PortConfigError):
266 PortSettings(name='foo')
268 def test_config_name_only(self):
269 with self.assertRaises(PortConfigError):
270 PortSettings(**{'name': 'foo'})
272 def test_name_netname_only(self):
273 settings = PortSettings(name='foo', network_name='bar')
274 self.assertEqual('foo', settings.name)
275 self.assertEqual('bar', settings.network_name)
276 self.assertTrue(settings.admin_state_up)
277 self.assertIsNone(settings.project_name)
278 self.assertIsNone(settings.mac_address)
279 self.assertIsNone(settings.ip_addrs)
280 self.assertIsNone(settings.security_groups)
281 self.assertIsNone(settings.allowed_address_pairs)
282 self.assertIsNone(settings.opt_value)
283 self.assertIsNone(settings.opt_name)
284 self.assertIsNone(settings.device_owner)
285 self.assertIsNone(settings.device_id)
287 def test_config_with_name_netname_only(self):
288 settings = PortSettings(**{'name': 'foo', 'network_name': 'bar'})
289 self.assertEqual('foo', settings.name)
290 self.assertEqual('bar', settings.network_name)
291 self.assertTrue(settings.admin_state_up)
292 self.assertIsNone(settings.project_name)
293 self.assertIsNone(settings.mac_address)
294 self.assertIsNone(settings.ip_addrs)
295 self.assertIsNone(settings.security_groups)
296 self.assertIsNone(settings.allowed_address_pairs)
297 self.assertIsNone(settings.opt_value)
298 self.assertIsNone(settings.opt_name)
299 self.assertIsNone(settings.device_owner)
300 self.assertIsNone(settings.device_id)
303 ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
304 allowed_address_pairs = {'10.0.0.101', '1234.5678'}
306 settings = PortSettings(name='foo', network_name='bar',
307 admin_state_up=False,
308 project_name='foo-project',
309 mac_address='1234', ip_addrs=ip_addrs,
310 security_groups=['foo_grp_id'],
311 allowed_address_pairs=allowed_address_pairs,
312 opt_value='opt value', opt_name='opt name',
313 device_owner='owner',
314 device_id='device number')
315 self.assertEqual('foo', settings.name)
316 self.assertEqual('bar', settings.network_name)
317 self.assertFalse(settings.admin_state_up)
318 self.assertEqual('foo-project', settings.project_name)
319 self.assertEqual('1234', settings.mac_address)
320 self.assertEqual(ip_addrs, settings.ip_addrs)
321 self.assertEqual(1, len(settings.security_groups))
322 self.assertEqual('foo_grp_id', settings.security_groups[0])
323 self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
324 self.assertEqual('opt value', settings.opt_value)
325 self.assertEqual('opt name', settings.opt_name)
326 self.assertEqual('owner', settings.device_owner)
327 self.assertEqual('device number', settings.device_id)
329 def test_config_all(self):
330 ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
331 allowed_address_pairs = {'10.0.0.101', '1234.5678'}
333 settings = PortSettings(
334 **{'name': 'foo', 'network_name': 'bar', 'admin_state_up': False,
335 'project_name': 'foo-project', 'mac_address': '1234',
336 'ip_addrs': ip_addrs, 'security_groups': ['foo_grp_id'],
337 'allowed_address_pairs': allowed_address_pairs,
338 'opt_value': 'opt value', 'opt_name': 'opt name',
339 'device_owner': 'owner', 'device_id': 'device number'})
340 self.assertEqual('foo', settings.name)
341 self.assertEqual('bar', settings.network_name)
342 self.assertFalse(settings.admin_state_up)
343 self.assertEqual('foo-project', settings.project_name)
344 self.assertEqual('1234', settings.mac_address)
345 self.assertEqual(ip_addrs, settings.ip_addrs)
346 self.assertEqual(1, len(settings.security_groups))
347 self.assertEqual('foo_grp_id', settings.security_groups[0])
348 self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
349 self.assertEqual('opt value', settings.opt_value)
350 self.assertEqual('opt name', settings.opt_name)
351 self.assertEqual('owner', settings.device_owner)
352 self.assertEqual('device number', settings.device_id)
355 class CreateNetworkSuccessTests(OSIntegrationTestCase):
357 Test for the CreateNetwork class defined in create_nework.py
362 Sets up object for test
364 super(self.__class__, self).__start__()
366 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
367 self.net_config = openstack_tests.get_pub_net_config(
368 project_name=self.os_creds.project_name,
369 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
370 router_name=guid + '-pub-router', external_net=self.ext_net_name,
371 netconf_override=self.netconf_override)
373 self.neutron = neutron_utils.neutron_client(
374 self.os_creds, self.os_session)
376 # Initialize for cleanup
377 self.net_creator = None
378 self.router_creator = None
384 if self.router_creator:
385 self.router_creator.clean()
388 self.net_creator.clean()
390 super(self.__class__, self).__clean__()
392 def test_create_network_without_router(self):
394 Tests the creation of an OpenStack network without a router.
397 self.net_creator = OpenStackNetwork(
398 self.os_creds, self.net_config.network_settings)
399 network = self.net_creator.create()
401 # Validate network was created
402 self.assertTrue(neutron_utils_tests.validate_network(
403 self.neutron, self.keystone,
404 self.net_creator.network_settings.name, True,
405 self.os_creds.project_name))
408 self.assertTrue(neutron_utils_tests.validate_subnet(
409 self.neutron, network,
410 self.net_creator.network_settings.subnet_settings[0].name,
411 self.net_creator.network_settings.subnet_settings[0].cidr, True))
413 def test_create_delete_network(self):
415 Tests the creation of an OpenStack network, it's deletion, then cleanup
418 self.net_creator = OpenStackNetwork(
419 self.os_creds, self.net_config.network_settings)
420 self.net_creator.create()
422 # Validate network was created
423 self.assertTrue(neutron_utils_tests.validate_network(
424 self.neutron, self.keystone,
425 self.net_creator.network_settings.name, True,
426 self.os_creds.project_name))
428 neutron_utils.delete_network(
429 self.neutron, self.net_creator.get_network())
430 self.assertIsNone(neutron_utils.get_network(
431 self.neutron, self.keystone,
432 network_settings=self.net_creator.network_settings,
433 project_name=self.os_creds.project_name))
435 # This shall not throw an exception here
436 self.net_creator.clean()
438 def test_create_network_with_router(self):
440 Tests the creation of an OpenStack network with a router.
443 self.net_creator = OpenStackNetwork(
444 self.os_creds, self.net_config.network_settings)
445 network = self.net_creator.create()
448 self.router_creator = create_router.OpenStackRouter(
449 self.os_creds, self.net_config.router_settings)
450 self.router_creator.create()
452 # Validate network was created
453 self.assertTrue(neutron_utils_tests.validate_network(
454 self.neutron, self.keystone,
455 self.net_creator.network_settings.name, True,
456 self.os_creds.project_name))
459 self.assertTrue(neutron_utils_tests.validate_subnet(
460 self.neutron, network,
461 self.net_creator.network_settings.subnet_settings[0].name,
462 self.net_creator.network_settings.subnet_settings[0].cidr, True))
465 neutron_utils_tests.validate_router(
466 self.neutron, self.keystone,
467 self.router_creator.router_settings.name,
468 self.os_creds.project_name, True)
470 neutron_utils_tests.validate_interface_router(
471 self.router_creator.get_internal_router_interface(),
472 self.router_creator.get_router(),
473 self.net_creator.get_network().subnets[0])
475 def test_create_networks_same_name(self):
477 Tests the creation of an OpenStack network and ensures that the
478 OpenStackNetwork object will not create a second.
481 self.net_creator = OpenStackNetwork(
482 self.os_creds, self.net_config.network_settings)
483 self.net_creator.create()
485 self.net_creator2 = OpenStackNetwork(
486 self.os_creds, self.net_config.network_settings)
487 self.net_creator2.create()
489 self.assertEqual(self.net_creator.get_network().id,
490 self.net_creator2.get_network().id)
492 def test_create_network_router_admin_user_to_new_project(self):
494 Tests the creation of an OpenStack network to the the current using
495 the credentials to the admin project.
497 # Create Network/Subnet where the project names have been changed
498 project_name = self.os_creds.project_name
499 config = self.net_config.network_settings
500 config.project_name = project_name
501 config.subnet_settings[0].project_name = project_name
503 self.net_creator = OpenStackNetwork(self.admin_os_creds, config)
504 self.net_creator.create()
506 retrieved_net = neutron_utils.get_network(
507 self.neutron, self.keystone,
508 network_name=self.net_config.network_settings.name,
509 project_name=self.os_creds.project_name)
511 self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
513 # Initialize with actual credentials
514 config.project_name = None
515 config.subnet_settings[0].project_name = None
516 proj_net_creator = OpenStackNetwork(self.os_creds, config)
517 proj_net = proj_net_creator.create()
518 self.assertEqual(retrieved_net, proj_net)
521 self.net_config.router_settings.project_name = project_name
522 self.router_creator = create_router.OpenStackRouter(
523 self.admin_os_creds, self.net_config.router_settings)
524 self.router_creator.create()
526 retrieved_router = neutron_utils.get_router(
527 self.neutron, self.keystone,
528 router_settings=self.router_creator.router_settings,
529 project_name=self.os_creds.project_name)
531 self.router_creator.get_router().id, retrieved_router.id)
533 def test_create_network_router_new_user_to_admin_project(self):
535 Tests the creation of an OpenStack network and router with the admin
536 user to the new project.
538 # Create Network/Subnet where the project names have been changed
539 new_project_name = self.os_creds.project_name
540 self.net_config.network_settings.project_name = new_project_name
541 self.net_config.network_settings.subnet_settings[0].project_name = \
543 self.net_creator = OpenStackNetwork(
544 self.admin_os_creds, self.net_config.network_settings)
545 self.net_creator.create()
547 retrieved_net = neutron_utils.get_network(
548 self.neutron, self.keystone,
549 network_settings=self.net_config.network_settings,
550 project_name=self.os_creds.project_name)
552 self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
555 self.net_config.router_settings.project_name = new_project_name
556 self.router_creator = create_router.OpenStackRouter(
557 self.admin_os_creds, self.net_config.router_settings)
558 self.router_creator.create()
560 retrieved_router = neutron_utils.get_router(
561 self.neutron, self.keystone,
562 router_settings=self.router_creator.router_settings,
563 project_name=self.os_creds.project_name)
565 self.router_creator.get_router().id, retrieved_router.id)
568 class CreateNetworkGatewayTests(OSIntegrationTestCase):
570 Test for the CreateNetwork class defined in create_nework.py
575 Sets up object for test
577 super(self.__class__, self).__start__()
579 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
581 self.neutron = neutron_utils.neutron_client(
582 self.os_creds, self.os_session)
584 self.ip_prfx = '10.1.0.'
586 # Initialize for cleanup
587 self.net_creator = None
594 self.net_creator.clean()
596 super(self.__class__, self).__clean__()
598 def test_create_subnet_default_gateway_ip(self):
600 Tests the creation of an OpenStack network with a subnet that has a
601 default value assigned to the gateway IP.
604 subnet_config = SubnetConfig(
605 name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24')
606 net_config = NetworkConfig(
607 name=self.guid + '-net', subnets=[subnet_config])
608 self.net_creator = OpenStackNetwork(
609 self.os_creds, net_config)
610 out_net = self.net_creator.create()
612 # Validate network was created
613 self.assertTrue(neutron_utils_tests.validate_network(
614 self.neutron, self.keystone,
615 self.net_creator.network_settings.name, True,
616 self.os_creds.project_name))
619 self.assertTrue(neutron_utils_tests.validate_subnet(
620 self.neutron, out_net,
621 self.net_creator.network_settings.subnet_settings[0].name,
622 self.net_creator.network_settings.subnet_settings[0].cidr, True))
624 self.assertEqual(self.ip_prfx + '1', out_net.subnets[0].gateway_ip)
626 def test_create_subnet_valid_gateway_ip(self):
628 Tests the creation of an OpenStack network with a subnet that has a
629 valid value assigned to the gateway IP.
632 subnet_config = SubnetConfig(
633 name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
634 gateway_ip=self.ip_prfx + '2')
635 net_config = NetworkConfig(
636 name=self.guid + '-net', subnets=[subnet_config])
637 self.net_creator = OpenStackNetwork(
638 self.os_creds, net_config)
639 out_net = self.net_creator.create()
641 # Validate network was created
642 self.assertTrue(neutron_utils_tests.validate_network(
643 self.neutron, self.keystone,
644 self.net_creator.network_settings.name, True,
645 self.os_creds.project_name))
648 self.assertTrue(neutron_utils_tests.validate_subnet(
649 self.neutron, out_net,
650 self.net_creator.network_settings.subnet_settings[0].name,
651 self.net_creator.network_settings.subnet_settings[0].cidr, True))
653 self.assertEqual(self.ip_prfx + '2', out_net.subnets[0].gateway_ip)
655 def test_create_subnet_no_gateway(self):
657 Tests the creation of an OpenStack network with a subnet that has a
658 valid value assigned to the gateway IP.
661 subnet_config = SubnetConfig(
662 name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
664 net_config = NetworkConfig(
665 name=self.guid + '-net', subnets=[subnet_config])
666 self.net_creator = OpenStackNetwork(
667 self.os_creds, net_config)
668 out_net = self.net_creator.create()
670 # Validate network was created
671 self.assertTrue(neutron_utils_tests.validate_network(
672 self.neutron, self.keystone,
673 self.net_creator.network_settings.name, True,
674 self.os_creds.project_name))
677 self.assertTrue(neutron_utils_tests.validate_subnet(
678 self.neutron, out_net,
679 self.net_creator.network_settings.subnet_settings[0].name,
680 self.net_creator.network_settings.subnet_settings[0].cidr, True))
682 self.assertIsNone(out_net.subnets[0].gateway_ip)
684 def test_create_subnet_invalid_gateway_ip(self):
686 Tests the creation of an OpenStack network with a subnet that has an
687 invalid value assigned to the gateway IP.
690 subnet_config = SubnetConfig(
691 name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
693 net_config = NetworkConfig(
694 name=self.guid + '-net', subnets=[subnet_config])
695 self.net_creator = OpenStackNetwork(
696 self.os_creds, net_config)
698 with self.assertRaises(BadRequest):
699 self.net_creator.create()
702 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
704 Test for the CreateNetwork class defined in create_nework.py when
709 Sets up object for test
711 super(self.__class__, self).__start__()
713 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
714 self.neutron = neutron_utils.neutron_client(
715 self.os_creds, self.os_session)
717 # Initialize for cleanup
718 self.net_creator = None
725 self.net_creator.clean()
727 super(self.__class__, self).__clean__()
729 def test_create_network_one_ipv6_subnet(self):
731 Tests the creation of an OpenStack network without a router.
734 subnet_settings = SubnetConfig(
735 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
737 network_settings = NetworkConfig(
738 name=self.guid + '-net', subnet_settings=[subnet_settings])
740 self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
741 self.net_creator.create()
743 # Validate network was created
744 self.assertTrue(neutron_utils_tests.validate_network(
745 self.neutron, self.keystone,
746 self.net_creator.network_settings.name, True,
747 self.os_creds.project_name))
749 network = self.net_creator.get_network()
750 self.assertEqual(1, len(network.subnets))
751 subnet = network.subnets[0]
753 self.assertEqual(network.id, subnet.network_id)
754 self.assertEqual(subnet_settings.name, subnet.name)
755 self.assertEqual('1:1::/64', subnet.cidr)
756 self.assertEqual(6, subnet.ip_version)
757 self.assertEqual(0, len(subnet.dns_nameservers))
759 def test_create_network_ipv4_ipv6_subnet(self):
761 Tests the creation of an OpenStack network without a router.
764 subnet4_settings = SubnetConfig(
765 name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
766 subnet6_settings = SubnetConfig(
767 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
770 network_settings = NetworkConfig(
771 name=self.guid + '-net',
772 subnet_settings=[subnet4_settings, subnet6_settings])
774 self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
775 self.net_creator.create()
777 # Validate network was created
778 network = self.net_creator.get_network()
779 self.assertEqual(2, len(network.subnets))
783 for subnet in network.subnets:
784 if subnet.name == subnet4_settings.name:
786 if subnet.name == subnet6_settings.name:
789 # Validate IPv4 subnet
790 self.assertEqual(network.id, subnet4.network_id)
791 self.assertEqual(subnet4_settings.name, subnet4.name)
792 self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
793 self.assertEqual(4, subnet4.ip_version)
794 self.assertEqual(0, len(subnet4.dns_nameservers))
796 # Validate IPv6 subnet
797 self.assertEqual(network.id, subnet6.network_id)
798 self.assertEqual(subnet6_settings.name, subnet6.name)
799 self.assertEqual('1:1::/64', subnet6.cidr)
800 self.assertEqual(6, subnet6.ip_version)
801 self.assertEqual(0, len(subnet6.dns_nameservers))
804 class CreateNetworkTypeTests(OSComponentTestCase):
806 Test for the CreateNetwork class defined in create_nework.py for testing
807 creating networks of different types
812 Sets up object for test
814 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
815 self.net_config = openstack_tests.get_pub_net_config(
816 project_name=self.os_creds.project_name,
817 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
819 self.neutron = neutron_utils.neutron_client(
820 self.os_creds, self.os_session)
821 self.keystone = keystone_utils.keystone_client(
822 self.os_creds, self.os_session)
824 # Initialize for cleanup
825 self.net_creator = None
832 self.net_creator.clean()
834 super(self.__class__, self).__clean__()
836 def test_create_network_type_vlan(self):
838 Tests the creation of an OpenStack network of type vlan.
841 network_type = 'vlan'
842 net_settings = NetworkConfig(
843 name=self.net_config.network_settings.name,
844 subnet_settings=self.net_config.network_settings.subnet_settings,
845 network_type=network_type)
847 # When setting the network_type, creds must be admin
848 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
849 network = self.net_creator.create()
851 # Validate network was created
852 self.assertTrue(neutron_utils_tests.validate_network(
853 self.neutron, self.keystone, net_settings.name, True,
854 self.os_creds.project_name))
856 self.assertEquals(network_type, network.type)
858 def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
860 Tests the creation of an OpenStack network of type vlan with
861 specified physical network and segmentation id.
864 network_type = 'vlan'
866 # The two values must be variable to work on all OpenStack pods
867 physical_network = 'datacentre'
868 segmentation_id = 2366
870 net_settings = NetworkConfig(
871 name=self.net_config.network_settings.name,
872 subnet_settings=self.net_config.network_settings.subnet_settings,
873 network_type=network_type,
874 physical_network=physical_network,
875 segmentation_id=segmentation_id)
877 # When setting the network_type, creds must be admin
878 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
879 network = self.net_creator.create()
881 # Validate network was created
882 self.assertTrue(neutron_utils_tests.validate_network(
883 self.neutron, self.keystone, net_settings.name, True,
884 self.os_creds.project_name))
886 self.assertEquals(network_type, network.type)
888 def test_create_network_type_vxlan(self):
890 Tests the creation of an OpenStack network of type vxlan.
893 network_type = 'vxlan'
894 net_settings = NetworkConfig(
895 name=self.net_config.network_settings.name,
896 subnet_settings=self.net_config.network_settings.subnet_settings,
897 network_type=network_type)
899 # When setting the network_type, creds must be admin
900 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
901 network = self.net_creator.create()
903 # Validate network was created
904 self.assertTrue(neutron_utils_tests.validate_network(
905 self.neutron, self.keystone, net_settings.name, True,
906 self.os_creds.project_name))
908 self.assertEqual(network_type, network.type)
910 def test_create_network_type_flat(self):
912 Tests the creation of an OpenStack network of type flat.
915 network_type = 'flat'
917 # This value must be variable to work on all OpenStack pods
918 physical_network = 'datacentre'
920 net_settings = NetworkConfig(
921 name=self.net_config.network_settings.name,
922 subnet_settings=self.net_config.network_settings.subnet_settings,
923 network_type=network_type, physical_network=physical_network)
924 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
925 network = self.net_creator.create()
927 # Validate network was created
928 self.assertTrue(neutron_utils_tests.validate_network(
929 self.neutron, self.keystone, net_settings.name, True,
930 self.os_creds.project_name))
932 self.assertEquals(network_type, network.type)
934 def test_create_network_type_foo(self):
936 Tests the creation of an OpenStack network of type foo which should
941 net_settings = NetworkConfig(
942 name=self.net_config.network_settings.name,
943 subnet_settings=self.net_config.network_settings.subnet_settings,
944 network_type=network_type)
945 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
946 with self.assertRaises(Exception):
947 self.net_creator.create()
950 class CreateMultipleNetworkTests(OSIntegrationTestCase):
952 Test for the CreateNetwork class and how it interacts with networks
953 groups within other projects with the same name
958 Sets up object for test
960 super(self.__class__, self).__start__()
962 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
963 self.net_config = openstack_tests.get_pub_net_config(
964 project_name=self.os_creds.project_name,
965 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
967 self.neutron = neutron_utils.neutron_client(
968 self.os_creds, self.os_session)
970 # Initialize for cleanup
971 self.admin_net_creator = None
972 self.proj_net_creator = None
978 if self.admin_net_creator:
979 self.admin_net_creator.clean()
980 if self.proj_net_creator:
981 self.proj_net_creator.clean()
983 super(self.__class__, self).__clean__()
985 def test_network_same_name_diff_proj(self):
987 Tests the creation of an OpenStackNetwork with the same name
988 within a different project/tenant when not configured but implied by
993 self.admin_net_creator = OpenStackNetwork(
994 self.admin_os_creds, self.net_config.network_settings)
995 self.admin_net_creator.create()
997 self.proj_net_creator = OpenStackNetwork(
998 self.os_creds, self.net_config.network_settings)
999 self.proj_net_creator.create()
1001 self.assertNotEqual(
1002 self.admin_net_creator.get_network().id,
1003 self.proj_net_creator.get_network().id)
1005 admin_creator2 = OpenStackNetwork(
1006 self.admin_os_creds, self.net_config.network_settings)
1007 admin_creator2.create()
1009 self.admin_net_creator.get_network(), admin_creator2.get_network())
1011 proj_creator2 = OpenStackNetwork(
1012 self.os_creds, self.net_config.network_settings)
1013 proj_creator2.create()
1014 self.assertEqual(self.proj_net_creator.get_network(),
1015 proj_creator2.get_network())
1017 def test_network_create_by_admin_to_different_project(self):
1019 Tests the creation of an OpenStackNetwork by the admin user and
1020 initialize again with tenant credentials.
1024 net_settings = self.net_config.network_settings
1026 net_settings.project_name = self.os_creds.project_name
1028 self.admin_net_creator = OpenStackNetwork(
1029 self.admin_os_creds, net_settings)
1030 self.admin_net_creator.create()
1032 self.proj_net_creator = OpenStackNetwork(
1033 self.os_creds, self.net_config.network_settings)
1034 self.proj_net_creator.create()
1037 self.admin_net_creator.get_network().id,
1038 self.proj_net_creator.get_network().id)