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 snaps.config.network import (
19 NetworkConfig, SubnetConfig, SubnetConfigError, NetworkConfigError,
20 PortConfigError, IPv6Mode)
21 from snaps.openstack import create_router
22 from snaps.openstack.create_network import (
23 OpenStackNetwork, NetworkSettings, SubnetSettings, PortSettings)
24 from snaps.openstack.tests import openstack_tests
25 from snaps.openstack.tests.os_source_file_test import (
26 OSIntegrationTestCase, OSComponentTestCase)
27 from snaps.openstack.utils import neutron_utils, keystone_utils
28 from snaps.openstack.utils.tests import neutron_utils_tests
29 from snaps.openstack.create_network import IPv6Mode as IPv6Mode_old
31 __author__ = 'spisarski'
34 class NetworkSettingsUnitTests(unittest.TestCase):
36 Tests the construction of the NetworkSettings class
39 def test_no_params(self):
40 with self.assertRaises(NetworkConfigError):
43 def test_empty_config(self):
44 with self.assertRaises(NetworkConfigError):
45 NetworkSettings(**dict())
47 def test_name_only(self):
48 settings = NetworkSettings(name='foo')
49 self.assertEqual('foo', settings.name)
50 self.assertTrue(settings.admin_state_up)
51 self.assertIsNone(settings.shared)
52 self.assertIsNone(settings.project_name)
53 self.assertFalse(settings.external)
54 self.assertIsNone(settings.network_type)
55 self.assertIsNone(settings.segmentation_id)
56 self.assertEqual(0, len(settings.subnet_settings))
58 def test_config_with_name_only(self):
59 settings = NetworkSettings(**{'name': 'foo'})
60 self.assertEqual('foo', settings.name)
61 self.assertTrue(settings.admin_state_up)
62 self.assertIsNone(settings.shared)
63 self.assertIsNone(settings.project_name)
64 self.assertFalse(settings.external)
65 self.assertIsNone(settings.network_type)
66 self.assertIsNone(settings.segmentation_id)
67 self.assertEqual(0, len(settings.subnet_settings))
70 sub_settings = SubnetSettings(name='foo-subnet', cidr='10.0.0.0/24')
71 settings = NetworkSettings(name='foo', admin_state_up=False,
72 shared=True, project_name='bar',
74 network_type='vlan', physical_network='phy',
76 subnet_settings=[sub_settings])
77 self.assertEqual('foo', settings.name)
78 self.assertFalse(settings.admin_state_up)
79 self.assertTrue(settings.shared)
80 self.assertEqual('bar', settings.project_name)
81 self.assertTrue(settings.external)
82 self.assertEqual('vlan', settings.network_type)
83 self.assertEqual('phy', settings.physical_network)
84 self.assertEqual(2366, settings.segmentation_id)
85 self.assertEqual(1, len(settings.subnet_settings))
86 self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
88 def test_config_all(self):
89 settings = NetworkSettings(
90 **{'name': 'foo', 'admin_state_up': False, 'shared': True,
91 'project_name': 'bar', 'external': True, 'network_type': 'vlan',
92 'physical_network': 'phy',
93 'segmentation_id': 2366,
95 [{'subnet': {'name': 'foo-subnet',
96 'cidr': '10.0.0.0/24'}}]})
97 self.assertEqual('foo', settings.name)
98 self.assertFalse(settings.admin_state_up)
99 self.assertTrue(settings.shared)
100 self.assertEqual('bar', settings.project_name)
101 self.assertTrue(settings.external)
102 self.assertEqual('vlan', settings.network_type)
103 self.assertEqual('phy', settings.physical_network)
104 self.assertEqual(2366, settings.segmentation_id)
105 self.assertEqual(1, len(settings.subnet_settings))
106 self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
109 class SubnetSettingsUnitTests(unittest.TestCase):
111 Tests the construction of the SubnetSettings class
114 def test_no_params(self):
115 with self.assertRaises(SubnetConfigError):
118 def test_empty_config(self):
119 with self.assertRaises(SubnetConfigError):
120 SubnetSettings(**dict())
122 def test_name_only(self):
123 with self.assertRaises(SubnetConfigError):
124 SubnetSettings(name='foo')
126 def test_config_with_name_only(self):
127 with self.assertRaises(SubnetConfigError):
128 SubnetSettings(**{'name': 'foo'})
130 def test_name_cidr_only(self):
131 settings = SubnetSettings(name='foo', cidr='10.0.0.0/24')
132 self.assertEqual('foo', settings.name)
133 self.assertEqual('10.0.0.0/24', settings.cidr)
134 self.assertEqual(4, settings.ip_version)
135 self.assertIsNone(settings.project_name)
136 self.assertIsNone(settings.start)
137 self.assertIsNone(settings.end)
138 self.assertIsNone(settings.enable_dhcp)
139 self.assertEqual(0, len(settings.dns_nameservers))
140 self.assertIsNone(settings.host_routes)
141 self.assertIsNone(settings.destination)
142 self.assertIsNone(settings.nexthop)
143 self.assertIsNone(settings.ipv6_ra_mode)
144 self.assertIsNone(settings.ipv6_address_mode)
146 def test_config_with_name_cidr_only(self):
147 settings = SubnetSettings(**{'name': 'foo', 'cidr': '10.0.0.0/24'})
148 self.assertEqual('foo', settings.name)
149 self.assertEqual('10.0.0.0/24', settings.cidr)
150 self.assertEqual(4, settings.ip_version)
151 self.assertIsNone(settings.project_name)
152 self.assertIsNone(settings.start)
153 self.assertIsNone(settings.end)
154 self.assertIsNone(settings.gateway_ip)
155 self.assertIsNone(settings.enable_dhcp)
156 self.assertEqual(0, len(settings.dns_nameservers))
157 self.assertIsNone(settings.host_routes)
158 self.assertIsNone(settings.destination)
159 self.assertIsNone(settings.nexthop)
160 self.assertIsNone(settings.ipv6_ra_mode)
161 self.assertIsNone(settings.ipv6_address_mode)
163 def test_all_string_enums(self):
164 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
165 settings = SubnetSettings(
166 name='foo', cidr='10.0.0.0/24', ip_version=6,
167 project_name='bar-project', start='10.0.0.2', end='10.0.0.101',
168 gateway_ip='10.0.0.1', enable_dhcp=False,
169 dns_nameservers=['8.8.8.8'], host_routes=[host_routes],
170 destination='dest', nexthop='hop', ipv6_ra_mode='dhcpv6-stateful',
171 ipv6_address_mode='slaac')
172 self.assertEqual('foo', settings.name)
173 self.assertEqual('10.0.0.0/24', settings.cidr)
174 self.assertEqual(6, settings.ip_version)
175 self.assertEqual('bar-project', settings.project_name)
176 self.assertEqual('10.0.0.2', settings.start)
177 self.assertEqual('10.0.0.101', settings.end)
178 self.assertEqual('10.0.0.1', settings.gateway_ip)
179 self.assertEqual(False, settings.enable_dhcp)
180 self.assertEqual(1, len(settings.dns_nameservers))
181 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
182 self.assertEqual(1, len(settings.host_routes))
183 self.assertEqual(host_routes, settings.host_routes[0])
184 self.assertEqual('dest', settings.destination)
185 self.assertEqual('hop', settings.nexthop)
186 self.assertEqual(IPv6Mode_old.stateful.value,
187 settings.ipv6_ra_mode.value)
188 self.assertEqual(IPv6Mode_old.slaac.value,
189 settings.ipv6_address_mode.value)
191 def test_all_type_enums(self):
192 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
193 settings = SubnetSettings(
194 name='foo', cidr='10.0.0.0/24', ip_version=6,
195 project_name='bar-project', start='10.0.0.2', end='10.0.0.101',
196 gateway_ip='10.0.0.1', enable_dhcp=False,
197 dns_nameservers=['8.8.8.8'], host_routes=[host_routes],
198 destination='dest', nexthop='hop',
199 ipv6_ra_mode=IPv6Mode_old.stateful,
200 ipv6_address_mode=IPv6Mode.slaac)
201 self.assertEqual('foo', settings.name)
202 self.assertEqual('10.0.0.0/24', settings.cidr)
203 self.assertEqual(6, settings.ip_version)
204 self.assertEqual('bar-project', settings.project_name)
205 self.assertEqual('10.0.0.2', settings.start)
206 self.assertEqual('10.0.0.101', settings.end)
207 self.assertEqual('10.0.0.1', settings.gateway_ip)
208 self.assertEqual(False, settings.enable_dhcp)
209 self.assertEqual(1, len(settings.dns_nameservers))
210 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
211 self.assertEqual(1, len(settings.host_routes))
212 self.assertEqual(host_routes, settings.host_routes[0])
213 self.assertEqual('dest', settings.destination)
214 self.assertEqual('hop', settings.nexthop)
215 self.assertEqual(IPv6Mode.stateful.value, settings.ipv6_ra_mode.value)
216 self.assertEqual(IPv6Mode.slaac.value,
217 settings.ipv6_address_mode.value)
219 def test_config_all(self):
220 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
221 settings = SubnetSettings(
222 **{'name': 'foo', 'cidr': '10.0.0.0/24', 'ip_version': 6,
223 'project_name': 'bar-project', 'start': '10.0.0.2',
225 'gateway_ip': '10.0.0.1', 'enable_dhcp': False,
226 'dns_nameservers': ['8.8.8.8'], 'host_routes': [host_routes],
227 'destination': 'dest', 'nexthop': 'hop',
228 'ipv6_ra_mode': 'dhcpv6-stateless',
229 'ipv6_address_mode': 'slaac'})
230 self.assertEqual('foo', settings.name)
231 self.assertEqual('10.0.0.0/24', settings.cidr)
232 self.assertEqual(6, settings.ip_version)
233 self.assertEqual('bar-project', settings.project_name)
234 self.assertEqual('10.0.0.2', settings.start)
235 self.assertEqual('10.0.0.101', settings.end)
236 self.assertEqual('10.0.0.1', settings.gateway_ip)
237 self.assertEqual(False, settings.enable_dhcp)
238 self.assertEqual(1, len(settings.dns_nameservers))
239 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
240 self.assertEqual(1, len(settings.host_routes))
241 self.assertEqual(host_routes, settings.host_routes[0])
242 self.assertEqual('dest', settings.destination)
243 self.assertEqual('hop', settings.nexthop)
244 self.assertEqual(IPv6Mode.stateless.value, settings.ipv6_ra_mode.value)
245 self.assertEqual(IPv6Mode.slaac.value,
246 settings.ipv6_address_mode.value)
249 class PortSettingsUnitTests(unittest.TestCase):
251 Tests the construction of the PortSettings class
254 def test_no_params(self):
255 with self.assertRaises(PortConfigError):
258 def test_empty_config(self):
259 with self.assertRaises(PortConfigError):
260 PortSettings(**dict())
262 def test_name_only(self):
263 with self.assertRaises(PortConfigError):
264 PortSettings(name='foo')
266 def test_config_name_only(self):
267 with self.assertRaises(PortConfigError):
268 PortSettings(**{'name': 'foo'})
270 def test_name_netname_only(self):
271 settings = PortSettings(name='foo', network_name='bar')
272 self.assertEqual('foo', settings.name)
273 self.assertEqual('bar', settings.network_name)
274 self.assertTrue(settings.admin_state_up)
275 self.assertIsNone(settings.project_name)
276 self.assertIsNone(settings.mac_address)
277 self.assertIsNone(settings.ip_addrs)
278 self.assertIsNone(settings.security_groups)
279 self.assertIsNone(settings.allowed_address_pairs)
280 self.assertIsNone(settings.opt_value)
281 self.assertIsNone(settings.opt_name)
282 self.assertIsNone(settings.device_owner)
283 self.assertIsNone(settings.device_id)
285 def test_config_with_name_netname_only(self):
286 settings = PortSettings(**{'name': 'foo', 'network_name': 'bar'})
287 self.assertEqual('foo', settings.name)
288 self.assertEqual('bar', settings.network_name)
289 self.assertTrue(settings.admin_state_up)
290 self.assertIsNone(settings.project_name)
291 self.assertIsNone(settings.mac_address)
292 self.assertIsNone(settings.ip_addrs)
293 self.assertIsNone(settings.security_groups)
294 self.assertIsNone(settings.allowed_address_pairs)
295 self.assertIsNone(settings.opt_value)
296 self.assertIsNone(settings.opt_name)
297 self.assertIsNone(settings.device_owner)
298 self.assertIsNone(settings.device_id)
301 ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
302 allowed_address_pairs = {'10.0.0.101', '1234.5678'}
304 settings = PortSettings(name='foo', network_name='bar',
305 admin_state_up=False,
306 project_name='foo-project',
307 mac_address='1234', ip_addrs=ip_addrs,
308 security_groups=['foo_grp_id'],
309 allowed_address_pairs=allowed_address_pairs,
310 opt_value='opt value', opt_name='opt name',
311 device_owner='owner',
312 device_id='device number')
313 self.assertEqual('foo', settings.name)
314 self.assertEqual('bar', settings.network_name)
315 self.assertFalse(settings.admin_state_up)
316 self.assertEqual('foo-project', settings.project_name)
317 self.assertEqual('1234', settings.mac_address)
318 self.assertEqual(ip_addrs, settings.ip_addrs)
319 self.assertEqual(1, len(settings.security_groups))
320 self.assertEqual('foo_grp_id', settings.security_groups[0])
321 self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
322 self.assertEqual('opt value', settings.opt_value)
323 self.assertEqual('opt name', settings.opt_name)
324 self.assertEqual('owner', settings.device_owner)
325 self.assertEqual('device number', settings.device_id)
327 def test_config_all(self):
328 ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
329 allowed_address_pairs = {'10.0.0.101', '1234.5678'}
331 settings = PortSettings(
332 **{'name': 'foo', 'network_name': 'bar', 'admin_state_up': False,
333 'project_name': 'foo-project', 'mac_address': '1234',
334 'ip_addrs': ip_addrs, 'security_groups': ['foo_grp_id'],
335 'allowed_address_pairs': allowed_address_pairs,
336 'opt_value': 'opt value', 'opt_name': 'opt name',
337 'device_owner': 'owner', 'device_id': 'device number'})
338 self.assertEqual('foo', settings.name)
339 self.assertEqual('bar', settings.network_name)
340 self.assertFalse(settings.admin_state_up)
341 self.assertEqual('foo-project', settings.project_name)
342 self.assertEqual('1234', settings.mac_address)
343 self.assertEqual(ip_addrs, settings.ip_addrs)
344 self.assertEqual(1, len(settings.security_groups))
345 self.assertEqual('foo_grp_id', settings.security_groups[0])
346 self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
347 self.assertEqual('opt value', settings.opt_value)
348 self.assertEqual('opt name', settings.opt_name)
349 self.assertEqual('owner', settings.device_owner)
350 self.assertEqual('device number', settings.device_id)
353 class CreateNetworkSuccessTests(OSIntegrationTestCase):
355 Test for the CreateNetwork class defined in create_nework.py
360 Sets up object for test
362 super(self.__class__, self).__start__()
364 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
365 self.net_config = openstack_tests.get_pub_net_config(
366 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
367 router_name=guid + '-pub-router', external_net=self.ext_net_name,
368 netconf_override=self.netconf_override)
370 self.neutron = neutron_utils.neutron_client(self.os_creds)
372 # Initialize for cleanup
373 self.net_creator = None
374 self.router_creator = None
380 if self.router_creator:
381 self.router_creator.clean()
384 self.net_creator.clean()
386 super(self.__class__, self).__clean__()
388 def test_create_network_without_router(self):
390 Tests the creation of an OpenStack network without a router.
393 self.net_creator = OpenStackNetwork(
394 self.os_creds, self.net_config.network_settings)
395 self.net_creator.create()
397 # Validate network was created
398 self.assertTrue(neutron_utils_tests.validate_network(
399 self.neutron, self.keystone,
400 self.net_creator.network_settings.name, True,
401 self.os_creds.project_name))
404 self.assertTrue(neutron_utils_tests.validate_subnet(
406 self.net_creator.network_settings.subnet_settings[0].name,
407 self.net_creator.network_settings.subnet_settings[0].cidr, True))
409 def test_create_delete_network(self):
411 Tests the creation of an OpenStack network, it's deletion, then cleanup
414 self.net_creator = OpenStackNetwork(
415 self.os_creds, self.net_config.network_settings)
416 self.net_creator.create()
418 # Validate network was created
419 self.assertTrue(neutron_utils_tests.validate_network(
420 self.neutron, self.keystone,
421 self.net_creator.network_settings.name, True,
422 self.os_creds.project_name))
424 neutron_utils.delete_network(
425 self.neutron, self.net_creator.get_network())
426 self.assertIsNone(neutron_utils.get_network(
427 self.neutron, self.keystone,
428 network_settings=self.net_creator.network_settings,
429 project_name=self.os_creds.project_name))
431 # This shall not throw an exception here
432 self.net_creator.clean()
434 def test_create_network_with_router(self):
436 Tests the creation of an OpenStack network with a router.
439 self.net_creator = OpenStackNetwork(
440 self.os_creds, self.net_config.network_settings)
441 self.net_creator.create()
444 self.router_creator = create_router.OpenStackRouter(
445 self.os_creds, self.net_config.router_settings)
446 self.router_creator.create()
448 # Validate network was created
449 self.assertTrue(neutron_utils_tests.validate_network(
450 self.neutron, self.keystone,
451 self.net_creator.network_settings.name, True,
452 self.os_creds.project_name))
455 self.assertTrue(neutron_utils_tests.validate_subnet(
457 self.net_creator.network_settings.subnet_settings[0].name,
458 self.net_creator.network_settings.subnet_settings[0].cidr, True))
461 neutron_utils_tests.validate_router(
462 self.neutron, self.router_creator.router_settings.name, True)
464 neutron_utils_tests.validate_interface_router(
465 self.router_creator.get_internal_router_interface(),
466 self.router_creator.get_router(),
467 self.net_creator.get_network().subnets[0])
469 def test_create_networks_same_name(self):
471 Tests the creation of an OpenStack network and ensures that the
472 OpenStackNetwork object will not create a second.
475 self.net_creator = OpenStackNetwork(
476 self.os_creds, self.net_config.network_settings)
477 self.net_creator.create()
479 self.net_creator2 = OpenStackNetwork(
480 self.os_creds, self.net_config.network_settings)
481 self.net_creator2.create()
483 self.assertEqual(self.net_creator.get_network().id,
484 self.net_creator2.get_network().id)
486 def test_create_network_router_admin_user_to_new_project(self):
488 Tests the creation of an OpenStack network to the the current using
489 the credentials to the admin project.
491 # Create Network/Subnet where the project names have been changed
492 project_name = self.os_creds.project_name
493 config = self.net_config.network_settings
494 config.project_name = project_name
495 config.subnet_settings[0].project_name = project_name
497 self.net_creator = OpenStackNetwork(self.admin_os_creds, config)
498 self.net_creator.create()
500 retrieved_net = neutron_utils.get_network(
501 self.neutron, self.keystone,
502 network_name=self.net_config.network_settings.name,
503 project_name=self.os_creds.project_name)
505 self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
507 # Initialize with actual credentials
508 config.project_name = None
509 config.subnet_settings[0].project_name = None
510 proj_net_creator = OpenStackNetwork(self.os_creds, config)
511 proj_net = proj_net_creator.create()
512 self.assertEqual(retrieved_net, proj_net)
515 self.net_config.router_settings.project_name = project_name
516 self.router_creator = create_router.OpenStackRouter(
517 self.admin_os_creds, self.net_config.router_settings)
518 self.router_creator.create()
520 retrieved_router = neutron_utils.get_router(
521 self.neutron, router_settings=self.router_creator.router_settings)
523 self.router_creator.get_router().id, retrieved_router.id)
525 def test_create_network_router_new_user_to_admin_project(self):
527 Tests the creation of an OpenStack network and router with the admin
528 user to the new project.
530 # Create Network/Subnet where the project names have been changed
531 new_project_name = self.os_creds.project_name
532 self.net_config.network_settings.project_name = new_project_name
533 self.net_config.network_settings.subnet_settings[0].project_name = \
535 self.net_creator = OpenStackNetwork(
536 self.admin_os_creds, self.net_config.network_settings)
537 self.net_creator.create()
539 retrieved_net = neutron_utils.get_network(
540 self.neutron, self.keystone,
541 network_settings=self.net_config.network_settings,
542 project_name=self.os_creds.project_name)
544 self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
547 self.net_config.router_settings.project_name = new_project_name
548 self.router_creator = create_router.OpenStackRouter(
549 self.admin_os_creds, self.net_config.router_settings)
550 self.router_creator.create()
552 retrieved_router = neutron_utils.get_router(
553 self.neutron, router_settings=self.router_creator.router_settings)
555 self.router_creator.get_router().id, retrieved_router.id)
558 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
560 Test for the CreateNetwork class defined in create_nework.py when
565 Sets up object for test
567 super(self.__class__, self).__start__()
569 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
570 self.neutron = neutron_utils.neutron_client(self.os_creds)
572 # Initialize for cleanup
573 self.net_creator = None
580 self.net_creator.clean()
582 super(self.__class__, self).__clean__()
584 def test_create_network_one_ipv6_subnet(self):
586 Tests the creation of an OpenStack network without a router.
589 subnet_settings = SubnetConfig(
590 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
592 network_settings = NetworkConfig(
593 name=self.guid + '-net', subnet_settings=[subnet_settings])
595 self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
596 self.net_creator.create()
598 # Validate network was created
599 self.assertTrue(neutron_utils_tests.validate_network(
600 self.neutron, self.keystone,
601 self.net_creator.network_settings.name, True,
602 self.os_creds.project_name))
604 network = self.net_creator.get_network()
605 self.assertEqual(1, len(network.subnets))
606 subnet = network.subnets[0]
608 self.assertEqual(network.id, subnet.network_id)
609 self.assertEqual(subnet_settings.name, subnet.name)
610 self.assertEqual('1:1::/64', subnet.cidr)
611 self.assertEqual(6, subnet.ip_version)
612 self.assertEqual(0, len(subnet.dns_nameservers))
614 def test_create_network_ipv4_ipv6_subnet(self):
616 Tests the creation of an OpenStack network without a router.
619 subnet4_settings = SubnetConfig(
620 name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
621 subnet6_settings = SubnetConfig(
622 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
625 network_settings = NetworkConfig(
626 name=self.guid + '-net',
627 subnet_settings=[subnet4_settings, subnet6_settings])
629 self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
630 self.net_creator.create()
632 # Validate network was created
633 network = self.net_creator.get_network()
634 self.assertEqual(2, len(network.subnets))
638 for subnet in network.subnets:
639 if subnet.name == subnet4_settings.name:
641 if subnet.name == subnet6_settings.name:
644 # Validate IPv4 subnet
645 self.assertEqual(network.id, subnet4.network_id)
646 self.assertEqual(subnet4_settings.name, subnet4.name)
647 self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
648 self.assertEqual(4, subnet4.ip_version)
649 self.assertEqual(0, len(subnet4.dns_nameservers))
651 # Validate IPv6 subnet
652 self.assertEqual(network.id, subnet6.network_id)
653 self.assertEqual(subnet6_settings.name, subnet6.name)
654 self.assertEqual('1:1::/64', subnet6.cidr)
655 self.assertEqual(6, subnet6.ip_version)
656 self.assertEqual(0, len(subnet6.dns_nameservers))
659 class CreateNetworkTypeTests(OSComponentTestCase):
661 Test for the CreateNetwork class defined in create_nework.py for testing
662 creating networks of different types
667 Sets up object for test
669 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
670 self.net_config = openstack_tests.get_pub_net_config(
671 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
673 self.neutron = neutron_utils.neutron_client(self.os_creds)
674 self.keystone = keystone_utils.keystone_client(self.os_creds)
676 # Initialize for cleanup
677 self.net_creator = None
684 self.net_creator.clean()
686 def test_create_network_type_vlan(self):
688 Tests the creation of an OpenStack network of type vlan.
691 network_type = 'vlan'
692 net_settings = NetworkConfig(
693 name=self.net_config.network_settings.name,
694 subnet_settings=self.net_config.network_settings.subnet_settings,
695 network_type=network_type)
697 # When setting the network_type, creds must be admin
698 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
699 network = self.net_creator.create()
701 # Validate network was created
702 self.assertTrue(neutron_utils_tests.validate_network(
703 self.neutron, self.keystone, net_settings.name, True,
704 self.os_creds.project_name))
706 self.assertEquals(network_type, network.type)
708 def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
710 Tests the creation of an OpenStack network of type vlan with
711 specified physical network and segmentation id.
714 network_type = 'vlan'
716 # The two values must be variable to work on all OpenStack pods
717 physical_network = 'datacentre'
718 segmentation_id = 2366
720 net_settings = NetworkConfig(
721 name=self.net_config.network_settings.name,
722 subnet_settings=self.net_config.network_settings.subnet_settings,
723 network_type=network_type,
724 physical_network=physical_network,
725 segmentation_id=segmentation_id)
727 # When setting the network_type, creds must be admin
728 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
729 network = self.net_creator.create()
731 # Validate network was created
732 self.assertTrue(neutron_utils_tests.validate_network(
733 self.neutron, self.keystone, net_settings.name, True,
734 self.os_creds.project_name))
736 self.assertEquals(network_type, network.type)
738 def test_create_network_type_vxlan(self):
740 Tests the creation of an OpenStack network of type vxlan.
743 network_type = 'vxlan'
744 net_settings = NetworkConfig(
745 name=self.net_config.network_settings.name,
746 subnet_settings=self.net_config.network_settings.subnet_settings,
747 network_type=network_type)
749 # When setting the network_type, creds must be admin
750 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
751 network = self.net_creator.create()
753 # Validate network was created
754 self.assertTrue(neutron_utils_tests.validate_network(
755 self.neutron, self.keystone, net_settings.name, True,
756 self.os_creds.project_name))
758 self.assertEqual(network_type, network.type)
760 def test_create_network_type_flat(self):
762 Tests the creation of an OpenStack network of type flat.
765 network_type = 'flat'
767 # This value must be variable to work on all OpenStack pods
768 physical_network = 'datacentre'
770 net_settings = NetworkConfig(
771 name=self.net_config.network_settings.name,
772 subnet_settings=self.net_config.network_settings.subnet_settings,
773 network_type=network_type, physical_network=physical_network)
774 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
775 network = self.net_creator.create()
777 # Validate network was created
778 self.assertTrue(neutron_utils_tests.validate_network(
779 self.neutron, self.keystone, net_settings.name, True,
780 self.os_creds.project_name))
782 self.assertEquals(network_type, network.type)
784 def test_create_network_type_foo(self):
786 Tests the creation of an OpenStack network of type foo which should
791 net_settings = NetworkConfig(
792 name=self.net_config.network_settings.name,
793 subnet_settings=self.net_config.network_settings.subnet_settings,
794 network_type=network_type)
795 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
796 with self.assertRaises(Exception):
797 self.net_creator.create()
800 class CreateMultipleNetworkTests(OSIntegrationTestCase):
802 Test for the CreateNetwork class and how it interacts with networks
803 groups within other projects with the same name
808 Sets up object for test
810 super(self.__class__, self).__start__()
812 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
813 self.net_config = openstack_tests.get_pub_net_config(
814 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
816 self.neutron = neutron_utils.neutron_client(self.os_creds)
818 # Initialize for cleanup
819 self.admin_net_creator = None
820 self.proj_net_creator = None
826 if self.admin_net_creator:
827 self.admin_net_creator.clean()
828 if self.proj_net_creator:
829 self.proj_net_creator.clean()
831 super(self.__class__, self).__clean__()
833 def test_network_same_name_diff_proj(self):
835 Tests the creation of an OpenStackNetwork with the same name
836 within a different project/tenant when not configured but implied by
841 self.admin_net_creator = OpenStackNetwork(
842 self.admin_os_creds, self.net_config.network_settings)
843 self.admin_net_creator.create()
845 self.proj_net_creator = OpenStackNetwork(
846 self.os_creds, self.net_config.network_settings)
847 self.proj_net_creator.create()
850 self.admin_net_creator.get_network().id,
851 self.proj_net_creator.get_network().id)
853 admin_creator2 = OpenStackNetwork(
854 self.admin_os_creds, self.net_config.network_settings)
855 admin_creator2.create()
857 self.admin_net_creator.get_network(), admin_creator2.get_network())
859 proj_creator2 = OpenStackNetwork(
860 self.os_creds, self.net_config.network_settings)
861 proj_creator2.create()
862 self.assertEqual(self.proj_net_creator.get_network(),
863 proj_creator2.get_network())
865 def test_network_create_by_admin_to_different_project(self):
867 Tests the creation of an OpenStackNetwork by the admin user and
868 initialize again with tenant credentials.
872 net_settings = self.net_config.network_settings
874 net_settings.project_name = self.os_creds.project_name
876 self.admin_net_creator = OpenStackNetwork(
877 self.admin_os_creds, net_settings)
878 self.admin_net_creator.create()
880 self.proj_net_creator = OpenStackNetwork(
881 self.os_creds, self.net_config.network_settings)
882 self.proj_net_creator.create()
885 self.admin_net_creator.get_network().id,
886 self.proj_net_creator.get_network().id)