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.openstack import create_router
19 from snaps.openstack.create_network import (
20 OpenStackNetwork, NetworkSettings, SubnetSettings, PortSettings,
21 NetworkSettingsError, SubnetSettingsError, PortSettingsError, IPv6Mode)
22 from snaps.openstack.tests import openstack_tests
23 from snaps.openstack.tests.os_source_file_test import (
24 OSIntegrationTestCase, OSComponentTestCase)
25 from snaps.openstack.utils import neutron_utils
26 from snaps.openstack.utils.tests import neutron_utils_tests
28 __author__ = 'spisarski'
31 class NetworkSettingsUnitTests(unittest.TestCase):
33 Tests the construction of the NetworkSettings class
36 def test_no_params(self):
37 with self.assertRaises(NetworkSettingsError):
40 def test_empty_config(self):
41 with self.assertRaises(NetworkSettingsError):
42 NetworkSettings(**dict())
44 def test_name_only(self):
45 settings = NetworkSettings(name='foo')
46 self.assertEqual('foo', settings.name)
47 self.assertTrue(settings.admin_state_up)
48 self.assertIsNone(settings.shared)
49 self.assertIsNone(settings.project_name)
50 self.assertFalse(settings.external)
51 self.assertIsNone(settings.network_type)
52 self.assertIsNone(settings.segmentation_id)
53 self.assertEqual(0, len(settings.subnet_settings))
55 def test_config_with_name_only(self):
56 settings = NetworkSettings(**{'name': 'foo'})
57 self.assertEqual('foo', settings.name)
58 self.assertTrue(settings.admin_state_up)
59 self.assertIsNone(settings.shared)
60 self.assertIsNone(settings.project_name)
61 self.assertFalse(settings.external)
62 self.assertIsNone(settings.network_type)
63 self.assertIsNone(settings.segmentation_id)
64 self.assertEqual(0, len(settings.subnet_settings))
67 sub_settings = SubnetSettings(name='foo-subnet', cidr='10.0.0.0/24')
68 settings = NetworkSettings(name='foo', admin_state_up=False,
69 shared=True, project_name='bar',
71 network_type='vlan', physical_network='phy',
73 subnet_settings=[sub_settings])
74 self.assertEqual('foo', settings.name)
75 self.assertFalse(settings.admin_state_up)
76 self.assertTrue(settings.shared)
77 self.assertEqual('bar', settings.project_name)
78 self.assertTrue(settings.external)
79 self.assertEqual('vlan', settings.network_type)
80 self.assertEqual('phy', settings.physical_network)
81 self.assertEqual(2366, settings.segmentation_id)
82 self.assertEqual(1, len(settings.subnet_settings))
83 self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
85 def test_config_all(self):
86 settings = NetworkSettings(
87 **{'name': 'foo', 'admin_state_up': False, 'shared': True,
88 'project_name': 'bar', 'external': True, 'network_type': 'vlan',
89 'physical_network': 'phy',
90 'segmentation_id': 2366,
92 [{'subnet': {'name': 'foo-subnet',
93 'cidr': '10.0.0.0/24'}}]})
94 self.assertEqual('foo', settings.name)
95 self.assertFalse(settings.admin_state_up)
96 self.assertTrue(settings.shared)
97 self.assertEqual('bar', settings.project_name)
98 self.assertTrue(settings.external)
99 self.assertEqual('vlan', settings.network_type)
100 self.assertEqual('phy', settings.physical_network)
101 self.assertEqual(2366, settings.segmentation_id)
102 self.assertEqual(1, len(settings.subnet_settings))
103 self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
106 class SubnetSettingsUnitTests(unittest.TestCase):
108 Tests the construction of the SubnetSettings class
111 def test_no_params(self):
112 with self.assertRaises(SubnetSettingsError):
115 def test_empty_config(self):
116 with self.assertRaises(SubnetSettingsError):
117 SubnetSettings(**dict())
119 def test_name_only(self):
120 with self.assertRaises(SubnetSettingsError):
121 SubnetSettings(name='foo')
123 def test_config_with_name_only(self):
124 with self.assertRaises(SubnetSettingsError):
125 SubnetSettings(**{'name': 'foo'})
127 def test_name_cidr_only(self):
128 settings = SubnetSettings(name='foo', cidr='10.0.0.0/24')
129 self.assertEqual('foo', settings.name)
130 self.assertEqual('10.0.0.0/24', settings.cidr)
131 self.assertEqual(4, settings.ip_version)
132 self.assertIsNone(settings.project_name)
133 self.assertIsNone(settings.start)
134 self.assertIsNone(settings.end)
135 self.assertIsNone(settings.enable_dhcp)
136 self.assertEqual(1, len(settings.dns_nameservers))
137 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
138 self.assertIsNone(settings.host_routes)
139 self.assertIsNone(settings.destination)
140 self.assertIsNone(settings.nexthop)
141 self.assertIsNone(settings.ipv6_ra_mode)
142 self.assertIsNone(settings.ipv6_address_mode)
144 def test_config_with_name_cidr_only(self):
145 settings = SubnetSettings(**{'name': 'foo', 'cidr': '10.0.0.0/24'})
146 self.assertEqual('foo', settings.name)
147 self.assertEqual('10.0.0.0/24', settings.cidr)
148 self.assertEqual(4, settings.ip_version)
149 self.assertIsNone(settings.project_name)
150 self.assertIsNone(settings.start)
151 self.assertIsNone(settings.end)
152 self.assertIsNone(settings.gateway_ip)
153 self.assertIsNone(settings.enable_dhcp)
154 self.assertEqual(1, len(settings.dns_nameservers))
155 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
156 self.assertIsNone(settings.host_routes)
157 self.assertIsNone(settings.destination)
158 self.assertIsNone(settings.nexthop)
159 self.assertIsNone(settings.ipv6_ra_mode)
160 self.assertIsNone(settings.ipv6_address_mode)
162 def test_all_string_enums(self):
163 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
164 settings = SubnetSettings(name='foo', cidr='10.0.0.0/24', ip_version=6,
165 project_name='bar-project',
166 start='10.0.0.2', end='10.0.0.101',
167 gateway_ip='10.0.0.1', enable_dhcp=False,
168 dns_nameservers=['8.8.8.8'],
169 host_routes=[host_routes],
172 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.stateful, settings.ipv6_ra_mode)
189 self.assertEqual(IPv6Mode.slaac, settings.ipv6_address_mode)
191 def test_all_type_enums(self):
192 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
193 settings = SubnetSettings(name='foo', cidr='10.0.0.0/24', ip_version=6,
194 project_name='bar-project',
195 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'],
198 host_routes=[host_routes],
201 ipv6_ra_mode=IPv6Mode.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, settings.ipv6_ra_mode)
218 self.assertEqual(IPv6Mode.slaac, settings.ipv6_address_mode)
220 def test_config_all(self):
221 host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
222 settings = SubnetSettings(
223 **{'name': 'foo', 'cidr': '10.0.0.0/24', 'ip_version': 6,
224 'project_name': 'bar-project', 'start': '10.0.0.2',
226 'gateway_ip': '10.0.0.1', 'enable_dhcp': False,
227 'dns_nameservers': ['8.8.8.8'], 'host_routes': [host_routes],
228 'destination': 'dest', 'nexthop': 'hop',
229 'ipv6_ra_mode': 'dhcpv6-stateless',
230 'ipv6_address_mode': 'slaac'})
231 self.assertEqual('foo', settings.name)
232 self.assertEqual('10.0.0.0/24', settings.cidr)
233 self.assertEqual(6, settings.ip_version)
234 self.assertEqual('bar-project', settings.project_name)
235 self.assertEqual('10.0.0.2', settings.start)
236 self.assertEqual('10.0.0.101', settings.end)
237 self.assertEqual('10.0.0.1', settings.gateway_ip)
238 self.assertEqual(False, settings.enable_dhcp)
239 self.assertEqual(1, len(settings.dns_nameservers))
240 self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
241 self.assertEqual(1, len(settings.host_routes))
242 self.assertEqual(host_routes, settings.host_routes[0])
243 self.assertEqual('dest', settings.destination)
244 self.assertEqual('hop', settings.nexthop)
245 self.assertEqual(IPv6Mode.stateless, settings.ipv6_ra_mode)
246 self.assertEqual(IPv6Mode.slaac, settings.ipv6_address_mode)
249 class PortSettingsUnitTests(unittest.TestCase):
251 Tests the construction of the PortSettings class
254 def test_no_params(self):
255 with self.assertRaises(PortSettingsError):
258 def test_empty_config(self):
259 with self.assertRaises(PortSettingsError):
260 PortSettings(**dict())
262 def test_name_only(self):
263 with self.assertRaises(PortSettingsError):
264 PortSettings(name='foo')
266 def test_config_name_only(self):
267 with self.assertRaises(PortSettingsError):
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)
369 self.neutron = neutron_utils.neutron_client(self.os_creds)
371 # Initialize for cleanup
372 self.net_creator = None
373 self.router_creator = None
379 if self.router_creator:
380 self.router_creator.clean()
383 self.net_creator.clean()
385 super(self.__class__, self).__clean__()
387 def test_create_network_without_router(self):
389 Tests the creation of an OpenStack network without a router.
392 self.net_creator = OpenStackNetwork(self.os_creds,
393 self.net_config.network_settings)
394 self.net_creator.create()
396 # Validate network was created
397 self.assertTrue(neutron_utils_tests.validate_network(
398 self.neutron, self.net_creator.network_settings.name, True))
401 self.assertTrue(neutron_utils_tests.validate_subnet(
403 self.net_creator.network_settings.subnet_settings[0].name,
404 self.net_creator.network_settings.subnet_settings[0].cidr, True))
406 def test_create_delete_network(self):
408 Tests the creation of an OpenStack network, it's deletion, then cleanup
411 self.net_creator = OpenStackNetwork(self.os_creds,
412 self.net_config.network_settings)
413 self.net_creator.create()
415 # Validate network was created
416 self.assertTrue(neutron_utils_tests.validate_network(
417 self.neutron, self.net_creator.network_settings.name, True))
419 neutron_utils.delete_network(self.neutron,
420 self.net_creator.get_network())
421 self.assertIsNone(neutron_utils.get_network(
422 self.neutron, network_settings=self.net_creator.network_settings))
424 # This shall not throw an exception here
425 self.net_creator.clean()
427 def test_create_network_with_router(self):
429 Tests the creation of an OpenStack network with a router.
432 self.net_creator = OpenStackNetwork(self.os_creds,
433 self.net_config.network_settings)
434 self.net_creator.create()
437 self.router_creator = create_router.OpenStackRouter(
438 self.os_creds, self.net_config.router_settings)
439 self.router_creator.create()
441 # Validate network was created
442 self.assertTrue(neutron_utils_tests.validate_network(
443 self.neutron, self.net_creator.network_settings.name, True))
446 self.assertTrue(neutron_utils_tests.validate_subnet(
448 self.net_creator.network_settings.subnet_settings[0].name,
449 self.net_creator.network_settings.subnet_settings[0].cidr, True))
452 neutron_utils_tests.validate_router(
453 self.neutron, self.router_creator.router_settings.name, True)
455 neutron_utils_tests.validate_interface_router(
456 self.router_creator.get_internal_router_interface(),
457 self.router_creator.get_router(),
458 self.net_creator.get_network().subnets[0])
460 def test_create_networks_same_name(self):
462 Tests the creation of an OpenStack network and ensures that the
463 OpenStackNetwork object will not create a second.
466 self.net_creator = OpenStackNetwork(self.os_creds,
467 self.net_config.network_settings)
468 self.net_creator.create()
470 self.net_creator2 = OpenStackNetwork(self.os_creds,
471 self.net_config.network_settings)
472 self.net_creator2.create()
474 self.assertEqual(self.net_creator.get_network().id,
475 self.net_creator2.get_network().id)
477 def test_create_network_router_admin_user_to_new_project(self):
479 Tests the creation of an OpenStack network and router with the current
480 user to the admin project.
482 # Create Network/Subnet where the project names have been changed
483 admin_project_name = self.admin_os_creds.project_name
484 self.net_config.network_settings.project_name = admin_project_name
485 self.net_config.network_settings.subnet_settings[0].project_name = \
487 self.net_creator = OpenStackNetwork(self.os_creds,
488 self.net_config.network_settings)
489 self.net_creator.create()
491 retrieved_net = neutron_utils.get_network(
492 self.neutron, network_settings=self.net_config.network_settings)
494 self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
497 self.net_config.router_settings.project_name = admin_project_name
498 self.router_creator = create_router.OpenStackRouter(
499 self.os_creds, self.net_config.router_settings)
500 self.router_creator.create()
502 retrieved_router = neutron_utils.get_router(
503 self.neutron, router_settings=self.router_creator.router_settings)
505 self.router_creator.get_router().id, retrieved_router.id)
507 def test_create_network_router_new_user_to_admin_project(self):
509 Tests the creation of an OpenStack network and router with the admin
510 user to the new project.
512 # Create Network/Subnet where the project names have been changed
513 new_project_name = self.os_creds.project_name
514 self.net_config.network_settings.project_name = new_project_name
515 self.net_config.network_settings.subnet_settings[0].project_name = \
517 self.net_creator = OpenStackNetwork(self.admin_os_creds,
518 self.net_config.network_settings)
519 self.net_creator.create()
521 retrieved_net = neutron_utils.get_network(
522 self.neutron, network_settings=self.net_config.network_settings)
524 self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
527 self.net_config.router_settings.project_name = new_project_name
528 self.router_creator = create_router.OpenStackRouter(
529 self.admin_os_creds, self.net_config.router_settings)
530 self.router_creator.create()
532 retrieved_router = neutron_utils.get_router(
533 self.neutron, router_settings=self.router_creator.router_settings)
535 self.router_creator.get_router().id, retrieved_router.id)
538 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
540 Test for the CreateNetwork class defined in create_nework.py when
545 Sets up object for test
547 super(self.__class__, self).__start__()
549 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
550 self.neutron = neutron_utils.neutron_client(self.os_creds)
552 # Initialize for cleanup
553 self.net_creator = None
560 self.net_creator.clean()
562 super(self.__class__, self).__clean__()
564 def test_create_network_one_ipv6_subnet(self):
566 Tests the creation of an OpenStack network without a router.
569 subnet_settings = SubnetSettings(
570 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
572 network_settings = NetworkSettings(
573 name=self.guid + '-net', subnet_settings=[subnet_settings])
575 self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
576 self.net_creator.create()
578 # Validate network was created
579 self.assertTrue(neutron_utils_tests.validate_network(
580 self.neutron, self.net_creator.network_settings.name, True))
582 network = self.net_creator.get_network()
583 self.assertEqual(1, len(network.subnets))
584 subnet = network.subnets[0]
586 self.assertEqual(network.id, subnet.network_id)
587 self.assertEqual(subnet_settings.name, subnet.name)
588 self.assertEqual('1:1::/64', subnet.cidr)
589 self.assertEqual(6, subnet.ip_version)
590 self.assertEqual(0, len(subnet.dns_nameservers))
592 def test_create_network_ipv4_ipv6_subnet(self):
594 Tests the creation of an OpenStack network without a router.
597 subnet4_settings = SubnetSettings(
598 name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
599 subnet6_settings = SubnetSettings(
600 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
603 network_settings = NetworkSettings(
604 name=self.guid + '-net',
605 subnet_settings=[subnet4_settings, subnet6_settings])
607 self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
608 self.net_creator.create()
610 # Validate network was created
611 network = self.net_creator.get_network()
612 self.assertEqual(2, len(network.subnets))
616 for subnet in network.subnets:
617 if subnet.name == subnet4_settings.name:
619 if subnet.name == subnet6_settings.name:
622 # Validate IPv4 subnet
623 self.assertEqual(network.id, subnet4.network_id)
624 self.assertEqual(subnet4_settings.name, subnet4.name)
625 self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
626 self.assertEqual(4, subnet4.ip_version)
627 self.assertEqual(1, len(subnet4.dns_nameservers))
629 # Validate IPv6 subnet
630 self.assertEqual(network.id, subnet6.network_id)
631 self.assertEqual(subnet6_settings.name, subnet6.name)
632 self.assertEqual('1:1::/64', subnet6.cidr)
633 self.assertEqual(6, subnet6.ip_version)
634 self.assertEqual(0, len(subnet6.dns_nameservers))
637 class CreateNetworkTypeTests(OSComponentTestCase):
639 Test for the CreateNetwork class defined in create_nework.py for testing
640 creating networks of different types
645 Sets up object for test
647 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
648 self.net_config = openstack_tests.get_pub_net_config(
649 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
651 self.neutron = neutron_utils.neutron_client(self.os_creds)
653 # Initialize for cleanup
654 self.net_creator = None
661 self.net_creator.clean()
663 def test_create_network_type_vlan(self):
665 Tests the creation of an OpenStack network of type vlan.
668 network_type = 'vlan'
669 net_settings = NetworkSettings(
670 name=self.net_config.network_settings.name,
671 subnet_settings=self.net_config.network_settings.subnet_settings,
672 network_type=network_type)
674 # When setting the network_type, creds must be admin
675 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
676 network = self.net_creator.create()
678 # Validate network was created
679 self.assertTrue(neutron_utils_tests.validate_network(
680 self.neutron, net_settings.name, True))
682 self.assertEquals(network_type, network.type)
684 def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
686 Tests the creation of an OpenStack network of type vlan with
687 specified physical network and segmentation id.
690 network_type = 'vlan'
692 # The two values must be variable to work on all OpenStack pods
693 physical_network = 'datacentre'
694 segmentation_id = 2366
696 net_settings = NetworkSettings(
697 name=self.net_config.network_settings.name,
698 subnet_settings=self.net_config.network_settings.subnet_settings,
699 network_type=network_type,
700 physical_network=physical_network,
701 segmentation_id=segmentation_id)
703 # When setting the network_type, creds must be admin
704 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
705 network = self.net_creator.create()
707 # Validate network was created
708 self.assertTrue(neutron_utils_tests.validate_network(
709 self.neutron, net_settings.name, True))
711 self.assertEquals(network_type, network.type)
713 def test_create_network_type_vxlan(self):
715 Tests the creation of an OpenStack network of type vxlan.
718 network_type = 'vxlan'
719 net_settings = NetworkSettings(
720 name=self.net_config.network_settings.name,
721 subnet_settings=self.net_config.network_settings.subnet_settings,
722 network_type=network_type)
724 # When setting the network_type, creds must be admin
725 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
726 network = self.net_creator.create()
728 # Validate network was created
729 self.assertTrue(neutron_utils_tests.validate_network(
730 self.neutron, net_settings.name, True))
732 self.assertEqual(network_type, network.type)
734 def test_create_network_type_flat(self):
736 Tests the creation of an OpenStack network of type flat.
739 network_type = 'flat'
741 # This value must be variable to work on all OpenStack pods
742 physical_network = 'datacentre'
744 net_settings = NetworkSettings(
745 name=self.net_config.network_settings.name,
746 subnet_settings=self.net_config.network_settings.subnet_settings,
747 network_type=network_type, physical_network=physical_network)
748 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
749 network = self.net_creator.create()
751 # Validate network was created
752 self.assertTrue(neutron_utils_tests.validate_network(
753 self.neutron, net_settings.name, True))
755 self.assertEquals(network_type, network.type)
757 def test_create_network_type_foo(self):
759 Tests the creation of an OpenStack network of type foo which should
764 net_settings = NetworkSettings(
765 name=self.net_config.network_settings.name,
766 subnet_settings=self.net_config.network_settings.subnet_settings,
767 network_type=network_type)
768 self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
769 with self.assertRaises(Exception):
770 self.net_creator.create()