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, keystone_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(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)
 145
 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)
 162
 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)
 190
 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)
 218
 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',
 224                'end': '10.0.0.101',
 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)
 247
 248
 249 class PortSettingsUnitTests(unittest.TestCase):
 250     """
 251     Tests the construction of the PortSettings class
 252     """
 253
 254     def test_no_params(self):
 255         with self.assertRaises(PortConfigError):
 256             PortSettings()
 257
 258     def test_empty_config(self):
 259         with self.assertRaises(PortConfigError):
 260             PortSettings(**dict())
 261
 262     def test_name_only(self):
 263         with self.assertRaises(PortConfigError):
 264             PortSettings(name='foo')
 265
 266     def test_config_name_only(self):
 267         with self.assertRaises(PortConfigError):
 268             PortSettings(**{'name': 'foo'})
 269
 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)
 284
 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)
 299
 300     def test_all(self):
 301         ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
 302         allowed_address_pairs = {'10.0.0.101', '1234.5678'}
 303
 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)
 326
 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'}
 330
 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)
 351
 352
 353 class CreateNetworkSuccessTests(OSIntegrationTestCase):
 354     """
 355     Test for the CreateNetwork class defined in create_nework.py
 356     """
 357
 358     def setUp(self):
 359         """
 360         Sets up object for test
 361         """
 362         super(self.__class__, self).__start__()
 363
 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)
 369
 370         self.neutron = neutron_utils.neutron_client(self.os_creds)
 371
 372         # Initialize for cleanup
 373         self.net_creator = None
 374         self.router_creator = None
 375
 376     def tearDown(self):
 377         """
 378         Cleans the network
 379         """
 380         if self.router_creator:
 381             self.router_creator.clean()
 382
 383         if self.net_creator:
 384             self.net_creator.clean()
 385
 386         super(self.__class__, self).__clean__()
 387
 388     def test_create_network_without_router(self):
 389         """
 390         Tests the creation of an OpenStack network without a router.
 391         """
 392         # Create Network
 393         self.net_creator = OpenStackNetwork(
 394             self.os_creds, self.net_config.network_settings)
 395         self.net_creator.create()
 396
 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))
 402
 403         # Validate subnets
 404         self.assertTrue(neutron_utils_tests.validate_subnet(
 405             self.neutron,
 406             self.net_creator.network_settings.subnet_settings[0].name,
 407             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 408
 409     def test_create_delete_network(self):
 410         """
 411         Tests the creation of an OpenStack network, it's deletion, then cleanup
 412         """
 413         # Create Network
 414         self.net_creator = OpenStackNetwork(
 415             self.os_creds, self.net_config.network_settings)
 416         self.net_creator.create()
 417
 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))
 423
 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))
 430
 431         # This shall not throw an exception here
 432         self.net_creator.clean()
 433
 434     def test_create_network_with_router(self):
 435         """
 436         Tests the creation of an OpenStack network with a router.
 437         """
 438         # Create Network
 439         self.net_creator = OpenStackNetwork(
 440             self.os_creds, self.net_config.network_settings)
 441         self.net_creator.create()
 442
 443         # Create Router
 444         self.router_creator = create_router.OpenStackRouter(
 445             self.os_creds, self.net_config.router_settings)
 446         self.router_creator.create()
 447
 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))
 453
 454         # Validate subnets
 455         self.assertTrue(neutron_utils_tests.validate_subnet(
 456             self.neutron,
 457             self.net_creator.network_settings.subnet_settings[0].name,
 458             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 459
 460         # Validate routers
 461         neutron_utils_tests.validate_router(
 462             self.neutron, self.router_creator.router_settings.name, True)
 463
 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])
 468
 469     def test_create_networks_same_name(self):
 470         """
 471         Tests the creation of an OpenStack network and ensures that the
 472         OpenStackNetwork object will not create a second.
 473         """
 474         # Create Network
 475         self.net_creator = OpenStackNetwork(
 476             self.os_creds, self.net_config.network_settings)
 477         self.net_creator.create()
 478
 479         self.net_creator2 = OpenStackNetwork(
 480             self.os_creds, self.net_config.network_settings)
 481         self.net_creator2.create()
 482
 483         self.assertEqual(self.net_creator.get_network().id,
 484                          self.net_creator2.get_network().id)
 485
 486     def test_create_network_router_admin_user_to_new_project(self):
 487         """
 488         Tests the creation of an OpenStack network to the the current using
 489         the credentials to the admin project.
 490         """
 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
 496
 497         self.net_creator = OpenStackNetwork(self.admin_os_creds, config)
 498         self.net_creator.create()
 499
 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)
 504
 505         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 506
 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)
 513
 514         # Create Router
 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()
 519
 520         retrieved_router = neutron_utils.get_router(
 521             self.neutron, router_settings=self.router_creator.router_settings)
 522         self.assertEqual(
 523             self.router_creator.get_router().id, retrieved_router.id)
 524
 525     def test_create_network_router_new_user_to_admin_project(self):
 526         """
 527         Tests the creation of an OpenStack network and router with the admin
 528         user to the new project.
 529         """
 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 = \
 534             new_project_name
 535         self.net_creator = OpenStackNetwork(
 536             self.admin_os_creds, self.net_config.network_settings)
 537         self.net_creator.create()
 538
 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)
 543
 544         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 545
 546         # Create Router
 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()
 551
 552         retrieved_router = neutron_utils.get_router(
 553             self.neutron, router_settings=self.router_creator.router_settings)
 554         self.assertEqual(
 555             self.router_creator.get_router().id, retrieved_router.id)
 556
 557
 558 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
 559     """
 560     Test for the CreateNetwork class defined in create_nework.py when
 561     """
 562
 563     def setUp(self):
 564         """
 565         Sets up object for test
 566         """
 567         super(self.__class__, self).__start__()
 568
 569         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 570         self.neutron = neutron_utils.neutron_client(self.os_creds)
 571
 572         # Initialize for cleanup
 573         self.net_creator = None
 574
 575     def tearDown(self):
 576         """
 577         Cleans the network
 578         """
 579         if self.net_creator:
 580             self.net_creator.clean()
 581
 582         super(self.__class__, self).__clean__()
 583
 584     def test_create_network_one_ipv6_subnet(self):
 585         """
 586         Tests the creation of an OpenStack network without a router.
 587         """
 588         # Create Network
 589         subnet_settings = SubnetConfig(
 590             name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
 591             ip_version=6)
 592         network_settings = NetworkConfig(
 593             name=self.guid + '-net', subnet_settings=[subnet_settings])
 594
 595         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 596         self.net_creator.create()
 597
 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))
 603
 604         network = self.net_creator.get_network()
 605         self.assertEqual(1, len(network.subnets))
 606         subnet = network.subnets[0]
 607
 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))
 613
 614     def test_create_network_ipv4_ipv6_subnet(self):
 615         """
 616         Tests the creation of an OpenStack network without a router.
 617         """
 618         # Create Network
 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',
 623             ip_version=6)
 624
 625         network_settings = NetworkConfig(
 626             name=self.guid + '-net',
 627             subnet_settings=[subnet4_settings, subnet6_settings])
 628
 629         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 630         self.net_creator.create()
 631
 632         # Validate network was created
 633         network = self.net_creator.get_network()
 634         self.assertEqual(2, len(network.subnets))
 635
 636         subnet4 = None
 637         subnet6 = None
 638         for subnet in network.subnets:
 639             if subnet.name == subnet4_settings.name:
 640                 subnet4 = subnet
 641             if subnet.name == subnet6_settings.name:
 642                 subnet6 = subnet
 643
 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))
 650
 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))
 657
 658
 659 class CreateNetworkTypeTests(OSComponentTestCase):
 660     """
 661     Test for the CreateNetwork class defined in create_nework.py for testing
 662     creating networks of different types
 663     """
 664
 665     def setUp(self):
 666         """
 667         Sets up object for test
 668         """
 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')
 672
 673         self.neutron = neutron_utils.neutron_client(self.os_creds)
 674         self.keystone = keystone_utils.keystone_client(self.os_creds)
 675
 676         # Initialize for cleanup
 677         self.net_creator = None
 678
 679     def tearDown(self):
 680         """
 681         Cleans the network
 682         """
 683         if self.net_creator:
 684             self.net_creator.clean()
 685
 686     def test_create_network_type_vlan(self):
 687         """
 688         Tests the creation of an OpenStack network of type vlan.
 689         """
 690         # Create Network
 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)
 696
 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()
 700
 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))
 705
 706         self.assertEquals(network_type, network.type)
 707
 708     def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
 709         """
 710         Tests the creation of an OpenStack network of type vlan with
 711         specified physical network and segmentation id.
 712         """
 713         # Create Network
 714         network_type = 'vlan'
 715
 716         # The two values must be variable to work on all OpenStack pods
 717         physical_network = 'datacentre'
 718         segmentation_id = 2366
 719
 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)
 726
 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()
 730
 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))
 735
 736         self.assertEquals(network_type, network.type)
 737
 738     def test_create_network_type_vxlan(self):
 739         """
 740         Tests the creation of an OpenStack network of type vxlan.
 741         """
 742         # Create Network
 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)
 748
 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()
 752
 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))
 757
 758         self.assertEqual(network_type, network.type)
 759
 760     def test_create_network_type_flat(self):
 761         """
 762         Tests the creation of an OpenStack network of type flat.
 763         """
 764         # Create Network
 765         network_type = 'flat'
 766
 767         # This value must be variable to work on all OpenStack pods
 768         physical_network = 'datacentre'
 769
 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()
 776
 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))
 781
 782         self.assertEquals(network_type, network.type)
 783
 784     def test_create_network_type_foo(self):
 785         """
 786         Tests the creation of an OpenStack network of type foo which should
 787         raise an exception.
 788         """
 789         # Create Network
 790         network_type = 'foo'
 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()
 798
 799
 800 class CreateMultipleNetworkTests(OSIntegrationTestCase):
 801     """
 802     Test for the CreateNetwork class and how it interacts with networks
 803     groups within other projects with the same name
 804     """
 805
 806     def setUp(self):
 807         """
 808         Sets up object for test
 809         """
 810         super(self.__class__, self).__start__()
 811
 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')
 815
 816         self.neutron = neutron_utils.neutron_client(self.os_creds)
 817
 818         # Initialize for cleanup
 819         self.admin_net_creator = None
 820         self.proj_net_creator = None
 821
 822     def tearDown(self):
 823         """
 824         Cleans the network
 825         """
 826         if self.admin_net_creator:
 827             self.admin_net_creator.clean()
 828         if self.proj_net_creator:
 829             self.proj_net_creator.clean()
 830
 831         super(self.__class__, self).__clean__()
 832
 833     def test_network_same_name_diff_proj(self):
 834         """
 835         Tests the creation of an OpenStackNetwork with the same name
 836         within a different project/tenant when not configured but implied by
 837         the OSCreds.
 838         """
 839         # Create Network
 840
 841         self.admin_net_creator = OpenStackNetwork(
 842             self.admin_os_creds, self.net_config.network_settings)
 843         self.admin_net_creator.create()
 844
 845         self.proj_net_creator = OpenStackNetwork(
 846             self.os_creds, self.net_config.network_settings)
 847         self.proj_net_creator.create()
 848
 849         self.assertNotEqual(
 850             self.admin_net_creator.get_network().id,
 851             self.proj_net_creator.get_network().id)
 852
 853         admin_creator2 = OpenStackNetwork(
 854             self.admin_os_creds, self.net_config.network_settings)
 855         admin_creator2.create()
 856         self.assertEqual(
 857             self.admin_net_creator.get_network(), admin_creator2.get_network())
 858
 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())
 864
 865     def test_network_create_by_admin_to_different_project(self):
 866         """
 867         Tests the creation of an OpenStackNetwork by the admin user and
 868         initialize again with tenant credentials.
 869         """
 870         # Create Network
 871
 872         net_settings = self.net_config.network_settings
 873
 874         net_settings.project_name = self.os_creds.project_name
 875
 876         self.admin_net_creator = OpenStackNetwork(
 877             self.admin_os_creds, net_settings)
 878         self.admin_net_creator.create()
 879
 880         self.proj_net_creator = OpenStackNetwork(
 881             self.os_creds, self.net_config.network_settings)
 882         self.proj_net_creator.create()
 883
 884         self.assertEqual(
 885             self.admin_net_creator.get_network().id,
 886             self.proj_net_creator.get_network().id)