snaps/openstack/tests/create_network_tests.py

   1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   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:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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.
  15 import unittest
  16 import uuid
  17
  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
  28 from snaps.openstack.utils.tests import neutron_utils_tests
  29 from snaps.openstack.create_network import IPv6Mode as IPv6Mode_old
  30
  31 __author__ = 'spisarski'
  32
  33
  34 class NetworkSettingsUnitTests(unittest.TestCase):
  35     """
  36     Tests the construction of the NetworkSettings class
  37     """
  38
  39     def test_no_params(self):
  40         with self.assertRaises(NetworkConfigError):
  41             NetworkSettings()
  42
  43     def test_empty_config(self):
  44         with self.assertRaises(NetworkConfigError):
  45             NetworkSettings(**dict())
  46
  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))
  57
  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))
  68
  69     def test_all(self):
  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',
  73                                    external=True,
  74                                    network_type='vlan', physical_network='phy',
  75                                    segmentation_id=2366,
  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)
  87
  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,
  94                'subnets':
  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)
 107
 108
 109 class SubnetSettingsUnitTests(unittest.TestCase):
 110     """
 111     Tests the construction of the SubnetSettings class
 112     """
 113
 114     def test_no_params(self):
 115         with self.assertRaises(SubnetConfigError):
 116             SubnetSettings()
 117
 118     def test_empty_config(self):
 119         with self.assertRaises(SubnetConfigError):
 120             SubnetSettings(**dict())
 121
 122     def test_name_only(self):
 123         with self.assertRaises(SubnetConfigError):
 124             SubnetSettings(name='foo')
 125
 126     def test_config_with_name_only(self):
 127         with self.assertRaises(SubnetConfigError):
 128             SubnetSettings(**{'name': 'foo'})
 129
 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(1, len(settings.dns_nameservers))
 140         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 141         self.assertIsNone(settings.host_routes)
 142         self.assertIsNone(settings.destination)
 143         self.assertIsNone(settings.nexthop)
 144         self.assertIsNone(settings.ipv6_ra_mode)
 145         self.assertIsNone(settings.ipv6_address_mode)
 146
 147     def test_config_with_name_cidr_only(self):
 148         settings = SubnetSettings(**{'name': 'foo', 'cidr': '10.0.0.0/24'})
 149         self.assertEqual('foo', settings.name)
 150         self.assertEqual('10.0.0.0/24', settings.cidr)
 151         self.assertEqual(4, settings.ip_version)
 152         self.assertIsNone(settings.project_name)
 153         self.assertIsNone(settings.start)
 154         self.assertIsNone(settings.end)
 155         self.assertIsNone(settings.gateway_ip)
 156         self.assertIsNone(settings.enable_dhcp)
 157         self.assertEqual(1, len(settings.dns_nameservers))
 158         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 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)
 164
 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)
 192
 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)
 220
 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',
 226                'end': '10.0.0.101',
 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)
 249
 250
 251 class PortSettingsUnitTests(unittest.TestCase):
 252     """
 253     Tests the construction of the PortSettings class
 254     """
 255
 256     def test_no_params(self):
 257         with self.assertRaises(PortConfigError):
 258             PortSettings()
 259
 260     def test_empty_config(self):
 261         with self.assertRaises(PortConfigError):
 262             PortSettings(**dict())
 263
 264     def test_name_only(self):
 265         with self.assertRaises(PortConfigError):
 266             PortSettings(name='foo')
 267
 268     def test_config_name_only(self):
 269         with self.assertRaises(PortConfigError):
 270             PortSettings(**{'name': 'foo'})
 271
 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)
 286
 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)
 301
 302     def test_all(self):
 303         ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
 304         allowed_address_pairs = {'10.0.0.101', '1234.5678'}
 305
 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)
 328
 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'}
 332
 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)
 353
 354
 355 class CreateNetworkSuccessTests(OSIntegrationTestCase):
 356     """
 357     Test for the CreateNetwork class defined in create_nework.py
 358     """
 359
 360     def setUp(self):
 361         """
 362         Sets up object for test
 363         """
 364         super(self.__class__, self).__start__()
 365
 366         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 367         self.net_config = openstack_tests.get_pub_net_config(
 368             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
 369             router_name=guid + '-pub-router', external_net=self.ext_net_name)
 370
 371         self.neutron = neutron_utils.neutron_client(self.os_creds)
 372
 373         # Initialize for cleanup
 374         self.net_creator = None
 375         self.router_creator = None
 376
 377     def tearDown(self):
 378         """
 379         Cleans the network
 380         """
 381         if self.router_creator:
 382             self.router_creator.clean()
 383
 384         if self.net_creator:
 385             self.net_creator.clean()
 386
 387         super(self.__class__, self).__clean__()
 388
 389     def test_create_network_without_router(self):
 390         """
 391         Tests the creation of an OpenStack network without a router.
 392         """
 393         # Create Network
 394         self.net_creator = OpenStackNetwork(self.os_creds,
 395                                             self.net_config.network_settings)
 396         self.net_creator.create()
 397
 398         # Validate network was created
 399         self.assertTrue(neutron_utils_tests.validate_network(
 400             self.neutron, self.net_creator.network_settings.name, True))
 401
 402         # Validate subnets
 403         self.assertTrue(neutron_utils_tests.validate_subnet(
 404             self.neutron,
 405             self.net_creator.network_settings.subnet_settings[0].name,
 406             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 407
 408     def test_create_delete_network(self):
 409         """
 410         Tests the creation of an OpenStack network, it's deletion, then cleanup
 411         """
 412         # Create Network
 413         self.net_creator = OpenStackNetwork(self.os_creds,
 414                                             self.net_config.network_settings)
 415         self.net_creator.create()
 416
 417         # Validate network was created
 418         self.assertTrue(neutron_utils_tests.validate_network(
 419             self.neutron, self.net_creator.network_settings.name, True))
 420
 421         neutron_utils.delete_network(self.neutron,
 422                                      self.net_creator.get_network())
 423         self.assertIsNone(neutron_utils.get_network(
 424             self.neutron, network_settings=self.net_creator.network_settings))
 425
 426         # This shall not throw an exception here
 427         self.net_creator.clean()
 428
 429     def test_create_network_with_router(self):
 430         """
 431         Tests the creation of an OpenStack network with a router.
 432         """
 433         # Create Network
 434         self.net_creator = OpenStackNetwork(self.os_creds,
 435                                             self.net_config.network_settings)
 436         self.net_creator.create()
 437
 438         # Create Router
 439         self.router_creator = create_router.OpenStackRouter(
 440             self.os_creds, self.net_config.router_settings)
 441         self.router_creator.create()
 442
 443         # Validate network was created
 444         self.assertTrue(neutron_utils_tests.validate_network(
 445             self.neutron, self.net_creator.network_settings.name, True))
 446
 447         # Validate subnets
 448         self.assertTrue(neutron_utils_tests.validate_subnet(
 449             self.neutron,
 450             self.net_creator.network_settings.subnet_settings[0].name,
 451             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 452
 453         # Validate routers
 454         neutron_utils_tests.validate_router(
 455             self.neutron, self.router_creator.router_settings.name, True)
 456
 457         neutron_utils_tests.validate_interface_router(
 458             self.router_creator.get_internal_router_interface(),
 459             self.router_creator.get_router(),
 460             self.net_creator.get_network().subnets[0])
 461
 462     def test_create_networks_same_name(self):
 463         """
 464         Tests the creation of an OpenStack network and ensures that the
 465         OpenStackNetwork object will not create a second.
 466         """
 467         # Create Network
 468         self.net_creator = OpenStackNetwork(self.os_creds,
 469                                             self.net_config.network_settings)
 470         self.net_creator.create()
 471
 472         self.net_creator2 = OpenStackNetwork(self.os_creds,
 473                                              self.net_config.network_settings)
 474         self.net_creator2.create()
 475
 476         self.assertEqual(self.net_creator.get_network().id,
 477                          self.net_creator2.get_network().id)
 478
 479     def test_create_network_router_admin_user_to_new_project(self):
 480         """
 481         Tests the creation of an OpenStack network and router with the current
 482         user to the admin project.
 483         """
 484         # Create Network/Subnet where the project names have been changed
 485         admin_project_name = self.admin_os_creds.project_name
 486         self.net_config.network_settings.project_name = admin_project_name
 487         self.net_config.network_settings.subnet_settings[0].project_name = \
 488             admin_project_name
 489         self.net_creator = OpenStackNetwork(self.os_creds,
 490                                             self.net_config.network_settings)
 491         self.net_creator.create()
 492
 493         retrieved_net = neutron_utils.get_network(
 494             self.neutron, network_settings=self.net_config.network_settings)
 495
 496         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 497
 498         # Create Router
 499         self.net_config.router_settings.project_name = admin_project_name
 500         self.router_creator = create_router.OpenStackRouter(
 501             self.os_creds, self.net_config.router_settings)
 502         self.router_creator.create()
 503
 504         retrieved_router = neutron_utils.get_router(
 505             self.neutron, router_settings=self.router_creator.router_settings)
 506         self.assertEqual(
 507             self.router_creator.get_router().id, retrieved_router.id)
 508
 509     def test_create_network_router_new_user_to_admin_project(self):
 510         """
 511         Tests the creation of an OpenStack network and router with the admin
 512         user to the new project.
 513         """
 514         # Create Network/Subnet where the project names have been changed
 515         new_project_name = self.os_creds.project_name
 516         self.net_config.network_settings.project_name = new_project_name
 517         self.net_config.network_settings.subnet_settings[0].project_name = \
 518             new_project_name
 519         self.net_creator = OpenStackNetwork(self.admin_os_creds,
 520                                             self.net_config.network_settings)
 521         self.net_creator.create()
 522
 523         retrieved_net = neutron_utils.get_network(
 524             self.neutron, network_settings=self.net_config.network_settings)
 525
 526         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 527
 528         # Create Router
 529         self.net_config.router_settings.project_name = new_project_name
 530         self.router_creator = create_router.OpenStackRouter(
 531             self.admin_os_creds, self.net_config.router_settings)
 532         self.router_creator.create()
 533
 534         retrieved_router = neutron_utils.get_router(
 535             self.neutron, router_settings=self.router_creator.router_settings)
 536         self.assertEqual(
 537             self.router_creator.get_router().id, retrieved_router.id)
 538
 539
 540 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
 541     """
 542     Test for the CreateNetwork class defined in create_nework.py when
 543     """
 544
 545     def setUp(self):
 546         """
 547         Sets up object for test
 548         """
 549         super(self.__class__, self).__start__()
 550
 551         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 552         self.neutron = neutron_utils.neutron_client(self.os_creds)
 553
 554         # Initialize for cleanup
 555         self.net_creator = None
 556
 557     def tearDown(self):
 558         """
 559         Cleans the network
 560         """
 561         if self.net_creator:
 562             self.net_creator.clean()
 563
 564         super(self.__class__, self).__clean__()
 565
 566     def test_create_network_one_ipv6_subnet(self):
 567         """
 568         Tests the creation of an OpenStack network without a router.
 569         """
 570         # Create Network
 571         subnet_settings = SubnetConfig(
 572             name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
 573             ip_version=6)
 574         network_settings = NetworkConfig(
 575             name=self.guid + '-net', subnet_settings=[subnet_settings])
 576
 577         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 578         self.net_creator.create()
 579
 580         # Validate network was created
 581         self.assertTrue(neutron_utils_tests.validate_network(
 582             self.neutron, self.net_creator.network_settings.name, True))
 583
 584         network = self.net_creator.get_network()
 585         self.assertEqual(1, len(network.subnets))
 586         subnet = network.subnets[0]
 587
 588         self.assertEqual(network.id, subnet.network_id)
 589         self.assertEqual(subnet_settings.name, subnet.name)
 590         self.assertEqual('1:1::/64', subnet.cidr)
 591         self.assertEqual(6, subnet.ip_version)
 592         self.assertEqual(0, len(subnet.dns_nameservers))
 593
 594     def test_create_network_ipv4_ipv6_subnet(self):
 595         """
 596         Tests the creation of an OpenStack network without a router.
 597         """
 598         # Create Network
 599         subnet4_settings = SubnetConfig(
 600             name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
 601         subnet6_settings = SubnetConfig(
 602             name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
 603             ip_version=6)
 604
 605         network_settings = NetworkConfig(
 606             name=self.guid + '-net',
 607             subnet_settings=[subnet4_settings, subnet6_settings])
 608
 609         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 610         self.net_creator.create()
 611
 612         # Validate network was created
 613         network = self.net_creator.get_network()
 614         self.assertEqual(2, len(network.subnets))
 615
 616         subnet4 = None
 617         subnet6 = None
 618         for subnet in network.subnets:
 619             if subnet.name == subnet4_settings.name:
 620                 subnet4 = subnet
 621             if subnet.name == subnet6_settings.name:
 622                 subnet6 = subnet
 623
 624         # Validate IPv4 subnet
 625         self.assertEqual(network.id, subnet4.network_id)
 626         self.assertEqual(subnet4_settings.name, subnet4.name)
 627         self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
 628         self.assertEqual(4, subnet4.ip_version)
 629         self.assertEqual(1, len(subnet4.dns_nameservers))
 630
 631         # Validate IPv6 subnet
 632         self.assertEqual(network.id, subnet6.network_id)
 633         self.assertEqual(subnet6_settings.name, subnet6.name)
 634         self.assertEqual('1:1::/64', subnet6.cidr)
 635         self.assertEqual(6, subnet6.ip_version)
 636         self.assertEqual(0, len(subnet6.dns_nameservers))
 637
 638
 639 class CreateNetworkTypeTests(OSComponentTestCase):
 640     """
 641     Test for the CreateNetwork class defined in create_nework.py for testing
 642     creating networks of different types
 643     """
 644
 645     def setUp(self):
 646         """
 647         Sets up object for test
 648         """
 649         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 650         self.net_config = openstack_tests.get_pub_net_config(
 651             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
 652
 653         self.neutron = neutron_utils.neutron_client(self.os_creds)
 654
 655         # Initialize for cleanup
 656         self.net_creator = None
 657
 658     def tearDown(self):
 659         """
 660         Cleans the network
 661         """
 662         if self.net_creator:
 663             self.net_creator.clean()
 664
 665     def test_create_network_type_vlan(self):
 666         """
 667         Tests the creation of an OpenStack network of type vlan.
 668         """
 669         # Create Network
 670         network_type = 'vlan'
 671         net_settings = NetworkConfig(
 672             name=self.net_config.network_settings.name,
 673             subnet_settings=self.net_config.network_settings.subnet_settings,
 674             network_type=network_type)
 675
 676         # When setting the network_type, creds must be admin
 677         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 678         network = self.net_creator.create()
 679
 680         # Validate network was created
 681         self.assertTrue(neutron_utils_tests.validate_network(
 682             self.neutron, net_settings.name, True))
 683
 684         self.assertEquals(network_type, network.type)
 685
 686     def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
 687         """
 688         Tests the creation of an OpenStack network of type vlan with
 689         specified physical network and segmentation id.
 690         """
 691         # Create Network
 692         network_type = 'vlan'
 693
 694         # The two values must be variable to work on all OpenStack pods
 695         physical_network = 'datacentre'
 696         segmentation_id = 2366
 697
 698         net_settings = NetworkConfig(
 699             name=self.net_config.network_settings.name,
 700             subnet_settings=self.net_config.network_settings.subnet_settings,
 701             network_type=network_type,
 702             physical_network=physical_network,
 703             segmentation_id=segmentation_id)
 704
 705         # When setting the network_type, creds must be admin
 706         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 707         network = self.net_creator.create()
 708
 709         # Validate network was created
 710         self.assertTrue(neutron_utils_tests.validate_network(
 711             self.neutron, net_settings.name, True))
 712
 713         self.assertEquals(network_type, network.type)
 714
 715     def test_create_network_type_vxlan(self):
 716         """
 717         Tests the creation of an OpenStack network of type vxlan.
 718         """
 719         # Create Network
 720         network_type = 'vxlan'
 721         net_settings = NetworkConfig(
 722             name=self.net_config.network_settings.name,
 723             subnet_settings=self.net_config.network_settings.subnet_settings,
 724             network_type=network_type)
 725
 726         # When setting the network_type, creds must be admin
 727         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 728         network = self.net_creator.create()
 729
 730         # Validate network was created
 731         self.assertTrue(neutron_utils_tests.validate_network(
 732             self.neutron, net_settings.name, True))
 733
 734         self.assertEqual(network_type, network.type)
 735
 736     def test_create_network_type_flat(self):
 737         """
 738         Tests the creation of an OpenStack network of type flat.
 739         """
 740         # Create Network
 741         network_type = 'flat'
 742
 743         # This value must be variable to work on all OpenStack pods
 744         physical_network = 'datacentre'
 745
 746         net_settings = NetworkConfig(
 747             name=self.net_config.network_settings.name,
 748             subnet_settings=self.net_config.network_settings.subnet_settings,
 749             network_type=network_type, physical_network=physical_network)
 750         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 751         network = self.net_creator.create()
 752
 753         # Validate network was created
 754         self.assertTrue(neutron_utils_tests.validate_network(
 755             self.neutron, net_settings.name, True))
 756
 757         self.assertEquals(network_type, network.type)
 758
 759     def test_create_network_type_foo(self):
 760         """
 761         Tests the creation of an OpenStack network of type foo which should
 762         raise an exception.
 763         """
 764         # Create Network
 765         network_type = 'foo'
 766         net_settings = NetworkConfig(
 767             name=self.net_config.network_settings.name,
 768             subnet_settings=self.net_config.network_settings.subnet_settings,
 769             network_type=network_type)
 770         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 771         with self.assertRaises(Exception):
 772             self.net_creator.create()