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 neutronclient.common.exceptions import BadRequest
  19
  20 from snaps.config.network import (
  21     NetworkConfig, SubnetConfig, SubnetConfigError, NetworkConfigError,
  22     PortConfigError, IPv6Mode)
  23 from snaps.openstack import create_router
  24 from snaps.openstack.create_network import (
  25     OpenStackNetwork, NetworkSettings, SubnetSettings, PortSettings)
  26 from snaps.openstack.tests import openstack_tests
  27 from snaps.openstack.tests.os_source_file_test import (
  28     OSIntegrationTestCase, OSComponentTestCase)
  29 from snaps.openstack.utils import neutron_utils, keystone_utils
  30 from snaps.openstack.utils.tests import neutron_utils_tests
  31 from snaps.openstack.create_network import IPv6Mode as IPv6Mode_old
  32
  33 __author__ = 'spisarski'
  34
  35
  36 class NetworkSettingsUnitTests(unittest.TestCase):
  37     """
  38     Tests the construction of the NetworkSettings class
  39     """
  40
  41     def test_no_params(self):
  42         with self.assertRaises(NetworkConfigError):
  43             NetworkSettings()
  44
  45     def test_empty_config(self):
  46         with self.assertRaises(NetworkConfigError):
  47             NetworkSettings(**dict())
  48
  49     def test_name_only(self):
  50         settings = NetworkSettings(name='foo')
  51         self.assertEqual('foo', settings.name)
  52         self.assertTrue(settings.admin_state_up)
  53         self.assertIsNone(settings.shared)
  54         self.assertIsNone(settings.project_name)
  55         self.assertFalse(settings.external)
  56         self.assertIsNone(settings.network_type)
  57         self.assertIsNone(settings.segmentation_id)
  58         self.assertEqual(0, len(settings.subnet_settings))
  59
  60     def test_config_with_name_only(self):
  61         settings = NetworkSettings(**{'name': 'foo'})
  62         self.assertEqual('foo', settings.name)
  63         self.assertTrue(settings.admin_state_up)
  64         self.assertIsNone(settings.shared)
  65         self.assertIsNone(settings.project_name)
  66         self.assertFalse(settings.external)
  67         self.assertIsNone(settings.network_type)
  68         self.assertIsNone(settings.segmentation_id)
  69         self.assertEqual(0, len(settings.subnet_settings))
  70
  71     def test_all(self):
  72         sub_settings = SubnetSettings(name='foo-subnet', cidr='10.0.0.0/24')
  73         settings = NetworkSettings(name='foo', admin_state_up=False,
  74                                    shared=True, project_name='bar',
  75                                    external=True,
  76                                    network_type='vlan', physical_network='phy',
  77                                    segmentation_id=2366,
  78                                    subnet_settings=[sub_settings])
  79         self.assertEqual('foo', settings.name)
  80         self.assertFalse(settings.admin_state_up)
  81         self.assertTrue(settings.shared)
  82         self.assertEqual('bar', settings.project_name)
  83         self.assertTrue(settings.external)
  84         self.assertEqual('vlan', settings.network_type)
  85         self.assertEqual('phy', settings.physical_network)
  86         self.assertEqual(2366, settings.segmentation_id)
  87         self.assertEqual(1, len(settings.subnet_settings))
  88         self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
  89
  90     def test_config_all(self):
  91         settings = NetworkSettings(
  92             **{'name': 'foo', 'admin_state_up': False, 'shared': True,
  93                'project_name': 'bar', 'external': True, 'network_type': 'vlan',
  94                'physical_network': 'phy',
  95                'segmentation_id': 2366,
  96                'subnets':
  97                    [{'subnet': {'name': 'foo-subnet',
  98                                 'cidr': '10.0.0.0/24'}}]})
  99         self.assertEqual('foo', settings.name)
 100         self.assertFalse(settings.admin_state_up)
 101         self.assertTrue(settings.shared)
 102         self.assertEqual('bar', settings.project_name)
 103         self.assertTrue(settings.external)
 104         self.assertEqual('vlan', settings.network_type)
 105         self.assertEqual('phy', settings.physical_network)
 106         self.assertEqual(2366, settings.segmentation_id)
 107         self.assertEqual(1, len(settings.subnet_settings))
 108         self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
 109
 110
 111 class SubnetSettingsUnitTests(unittest.TestCase):
 112     """
 113     Tests the construction of the SubnetSettings class
 114     """
 115
 116     def test_no_params(self):
 117         with self.assertRaises(SubnetConfigError):
 118             SubnetSettings()
 119
 120     def test_empty_config(self):
 121         with self.assertRaises(SubnetConfigError):
 122             SubnetSettings(**dict())
 123
 124     def test_name_only(self):
 125         with self.assertRaises(SubnetConfigError):
 126             SubnetSettings(name='foo')
 127
 128     def test_config_with_name_only(self):
 129         with self.assertRaises(SubnetConfigError):
 130             SubnetSettings(**{'name': 'foo'})
 131
 132     def test_name_cidr_only(self):
 133         settings = SubnetSettings(name='foo', cidr='10.0.0.0/24')
 134         self.assertEqual('foo', settings.name)
 135         self.assertEqual('10.0.0.0/24', settings.cidr)
 136         self.assertEqual(4, settings.ip_version)
 137         self.assertIsNone(settings.project_name)
 138         self.assertIsNone(settings.start)
 139         self.assertIsNone(settings.end)
 140         self.assertIsNone(settings.enable_dhcp)
 141         self.assertEqual(0, len(settings.dns_nameservers))
 142         self.assertIsNone(settings.host_routes)
 143         self.assertIsNone(settings.destination)
 144         self.assertIsNone(settings.nexthop)
 145         self.assertIsNone(settings.ipv6_ra_mode)
 146         self.assertIsNone(settings.ipv6_address_mode)
 147
 148     def test_config_with_name_cidr_only(self):
 149         settings = SubnetSettings(**{'name': 'foo', 'cidr': '10.0.0.0/24'})
 150         self.assertEqual('foo', settings.name)
 151         self.assertEqual('10.0.0.0/24', settings.cidr)
 152         self.assertEqual(4, settings.ip_version)
 153         self.assertIsNone(settings.project_name)
 154         self.assertIsNone(settings.start)
 155         self.assertIsNone(settings.end)
 156         self.assertIsNone(settings.gateway_ip)
 157         self.assertIsNone(settings.enable_dhcp)
 158         self.assertEqual(0, len(settings.dns_nameservers))
 159         self.assertIsNone(settings.host_routes)
 160         self.assertIsNone(settings.destination)
 161         self.assertIsNone(settings.nexthop)
 162         self.assertIsNone(settings.ipv6_ra_mode)
 163         self.assertIsNone(settings.ipv6_address_mode)
 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             project_name=self.os_creds.project_name,
 369             net_name="{}-{}".format(guid, 'pub-net'), mtu=999,
 370             subnet_name="{}-{}".format(guid, 'pub-subnet'),
 371             router_name="{}-{}".format(guid, 'pub-router'),
 372             external_net=self.ext_net_name,
 373             netconf_override=self.netconf_override)
 374
 375         self.neutron = neutron_utils.neutron_client(
 376             self.os_creds, self.os_session)
 377
 378         # Initialize for cleanup
 379         self.net_creator = None
 380         self.router_creator = None
 381
 382     def tearDown(self):
 383         """
 384         Cleans the network
 385         """
 386         if self.router_creator:
 387             self.router_creator.clean()
 388
 389         if self.net_creator:
 390             self.net_creator.clean()
 391
 392         super(self.__class__, self).__clean__()
 393
 394     def test_create_network_without_router(self):
 395         """
 396         Tests the creation of an OpenStack network without a router.
 397         """
 398         # Create Network
 399         self.net_creator = OpenStackNetwork(
 400             self.os_creds, self.net_config.network_settings)
 401         network = self.net_creator.create()
 402
 403         # Validate network was created
 404         self.assertTrue(neutron_utils_tests.validate_network(
 405             self.neutron, self.keystone,
 406             self.net_creator.network_settings.name, True,
 407             self.os_creds.project_name, mtu=999))
 408
 409         # Validate subnets
 410         self.assertTrue(neutron_utils_tests.validate_subnet(
 411             self.neutron, network,
 412             self.net_creator.network_settings.subnet_settings[0].name,
 413             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 414
 415     def test_create_delete_network(self):
 416         """
 417         Tests the creation of an OpenStack network, it's deletion, then cleanup
 418         """
 419         # Create Network
 420         self.net_creator = OpenStackNetwork(
 421             self.os_creds, self.net_config.network_settings)
 422         self.net_creator.create()
 423
 424         # Validate network was created
 425         self.assertTrue(neutron_utils_tests.validate_network(
 426             self.neutron, self.keystone,
 427             self.net_creator.network_settings.name, True,
 428             self.os_creds.project_name, mtu=999))
 429
 430         neutron_utils.delete_network(
 431             self.neutron, self.net_creator.get_network())
 432         self.assertIsNone(neutron_utils.get_network(
 433             self.neutron, self.keystone,
 434             network_settings=self.net_creator.network_settings,
 435             project_name=self.os_creds.project_name))
 436
 437         # This shall not throw an exception here
 438         self.net_creator.clean()
 439
 440     def test_create_network_with_router(self):
 441         """
 442         Tests the creation of an OpenStack network with a router.
 443         """
 444         # Create Network
 445         self.net_creator = OpenStackNetwork(
 446             self.os_creds, self.net_config.network_settings)
 447         network = self.net_creator.create()
 448
 449         # Create Router
 450         self.router_creator = create_router.OpenStackRouter(
 451             self.os_creds, self.net_config.router_settings)
 452         self.router_creator.create()
 453
 454         # Validate network was created
 455         self.assertTrue(neutron_utils_tests.validate_network(
 456             self.neutron, self.keystone,
 457             self.net_creator.network_settings.name, True,
 458             self.os_creds.project_name, mtu=999))
 459
 460         # Validate subnets
 461         self.assertTrue(neutron_utils_tests.validate_subnet(
 462             self.neutron, network,
 463             self.net_creator.network_settings.subnet_settings[0].name,
 464             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 465
 466         # Validate routers
 467         neutron_utils_tests.validate_router(
 468             self.neutron, self.keystone,
 469             self.router_creator.router_settings.name,
 470             self.os_creds.project_name, True)
 471
 472         neutron_utils_tests.validate_interface_router(
 473             self.router_creator.get_internal_router_interface(),
 474             self.router_creator.get_router(),
 475             self.net_creator.get_network().subnets[0])
 476
 477     def test_create_networks_same_name(self):
 478         """
 479         Tests the creation of an OpenStack network and ensures that the
 480         OpenStackNetwork object will not create a second.
 481         """
 482         # Create Network
 483         self.net_creator = OpenStackNetwork(
 484             self.os_creds, self.net_config.network_settings)
 485         self.net_creator.create()
 486
 487         self.net_creator2 = OpenStackNetwork(
 488             self.os_creds, self.net_config.network_settings)
 489         self.net_creator2.create()
 490
 491         self.assertEqual(self.net_creator.get_network().id,
 492                          self.net_creator2.get_network().id)
 493
 494     def test_create_network_router_admin_user_to_new_project(self):
 495         """
 496         Tests the creation of an OpenStack network to the the current using
 497         the credentials to the admin project.
 498         """
 499         # Create Network/Subnet where the project names have been changed
 500         project_name = self.os_creds.project_name
 501         config = self.net_config.network_settings
 502         config.project_name = project_name
 503         config.subnet_settings[0].project_name = project_name
 504
 505         self.net_creator = OpenStackNetwork(self.admin_os_creds, config)
 506         self.net_creator.create()
 507
 508         retrieved_net = neutron_utils.get_network(
 509             self.neutron, self.keystone,
 510             network_name=self.net_config.network_settings.name,
 511             project_name=self.os_creds.project_name)
 512
 513         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 514
 515         # Initialize with actual credentials
 516         config.project_name = None
 517         config.subnet_settings[0].project_name = None
 518         proj_net_creator = OpenStackNetwork(self.os_creds, config)
 519         proj_net = proj_net_creator.create()
 520         self.assertEqual(retrieved_net, proj_net)
 521
 522         # Create Router
 523         self.net_config.router_settings.project_name = project_name
 524         self.router_creator = create_router.OpenStackRouter(
 525             self.admin_os_creds, self.net_config.router_settings)
 526         self.router_creator.create()
 527
 528         retrieved_router = neutron_utils.get_router(
 529             self.neutron, self.keystone,
 530             router_settings=self.router_creator.router_settings,
 531             project_name=self.os_creds.project_name)
 532         self.assertEqual(
 533             self.router_creator.get_router().id, retrieved_router.id)
 534
 535     def test_create_network_router_new_user_to_admin_project(self):
 536         """
 537         Tests the creation of an OpenStack network and router with the admin
 538         user to the new project.
 539         """
 540         # Create Network/Subnet where the project names have been changed
 541         new_project_name = self.os_creds.project_name
 542         self.net_config.network_settings.project_name = new_project_name
 543         self.net_config.network_settings.subnet_settings[0].project_name = \
 544             new_project_name
 545         self.net_creator = OpenStackNetwork(
 546             self.admin_os_creds, self.net_config.network_settings)
 547         self.net_creator.create()
 548
 549         retrieved_net = neutron_utils.get_network(
 550             self.neutron, self.keystone,
 551             network_settings=self.net_config.network_settings,
 552             project_name=self.os_creds.project_name)
 553
 554         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 555
 556         # Create Router
 557         self.net_config.router_settings.project_name = new_project_name
 558         self.router_creator = create_router.OpenStackRouter(
 559             self.admin_os_creds, self.net_config.router_settings)
 560         self.router_creator.create()
 561
 562         retrieved_router = neutron_utils.get_router(
 563             self.neutron, self.keystone,
 564             router_settings=self.router_creator.router_settings,
 565             project_name=self.os_creds.project_name)
 566         self.assertEqual(
 567             self.router_creator.get_router().id, retrieved_router.id)
 568
 569
 570 class CreateNetworkGatewayTests(OSIntegrationTestCase):
 571     """
 572     Test for the CreateNetwork class defined in create_nework.py
 573     """
 574
 575     def setUp(self):
 576         """
 577         Sets up object for test
 578         """
 579         super(self.__class__, self).__start__()
 580
 581         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 582
 583         self.neutron = neutron_utils.neutron_client(
 584             self.os_creds, self.os_session)
 585
 586         self.ip_prfx = '10.1.0.'
 587
 588         # Initialize for cleanup
 589         self.net_creator = None
 590
 591     def tearDown(self):
 592         """
 593         Cleans the network
 594         """
 595         if self.net_creator:
 596             self.net_creator.clean()
 597
 598         super(self.__class__, self).__clean__()
 599
 600     def test_create_subnet_default_gateway_ip(self):
 601         """
 602         Tests the creation of an OpenStack network with a subnet that has a
 603         default value assigned to the gateway IP.
 604         """
 605         # Create Network
 606         subnet_config = SubnetConfig(
 607             name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24')
 608         net_config = NetworkConfig(
 609             name=self.guid + '-net', subnets=[subnet_config])
 610         self.net_creator = OpenStackNetwork(
 611             self.os_creds, net_config)
 612         out_net = self.net_creator.create()
 613
 614         # Validate network was created
 615         self.assertTrue(neutron_utils_tests.validate_network(
 616             self.neutron, self.keystone,
 617             self.net_creator.network_settings.name, True,
 618             self.os_creds.project_name))
 619
 620         # Validate subnets
 621         self.assertTrue(neutron_utils_tests.validate_subnet(
 622             self.neutron, out_net,
 623             self.net_creator.network_settings.subnet_settings[0].name,
 624             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 625
 626         self.assertEqual(self.ip_prfx + '1', out_net.subnets[0].gateway_ip)
 627
 628     def test_create_subnet_valid_gateway_ip(self):
 629         """
 630         Tests the creation of an OpenStack network with a subnet that has a
 631         valid value assigned to the gateway IP.
 632         """
 633         # Create Network
 634         subnet_config = SubnetConfig(
 635             name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
 636             gateway_ip=self.ip_prfx + '2')
 637         net_config = NetworkConfig(
 638             name=self.guid + '-net', subnets=[subnet_config])
 639         self.net_creator = OpenStackNetwork(
 640             self.os_creds, net_config)
 641         out_net = self.net_creator.create()
 642
 643         self.assertIsNotNone(out_net)
 644
 645         get_net = neutron_utils.get_network_by_id(self.neutron, out_net.id)
 646         self.assertIsNotNone(get_net)
 647
 648         # Validate subnets
 649         self.assertTrue(neutron_utils_tests.validate_subnet(
 650             self.neutron, out_net,
 651             self.net_creator.network_settings.subnet_settings[0].name,
 652             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 653
 654         self.assertEqual(self.ip_prfx + '2', out_net.subnets[0].gateway_ip)
 655
 656     def test_create_subnet_no_gateway(self):
 657         """
 658         Tests the creation of an OpenStack network with a subnet that has a
 659         valid value assigned to the gateway IP.
 660         """
 661         # Create Network
 662         subnet_config = SubnetConfig(
 663             name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
 664             gateway_ip='none')
 665         net_config = NetworkConfig(
 666             name=self.guid + '-net', subnets=[subnet_config])
 667         self.net_creator = OpenStackNetwork(
 668             self.os_creds, net_config)
 669         out_net = self.net_creator.create()
 670
 671         # Validate network was created
 672         self.assertTrue(neutron_utils_tests.validate_network(
 673             self.neutron, self.keystone,
 674             self.net_creator.network_settings.name, True,
 675             self.os_creds.project_name))
 676
 677         # Validate subnets
 678         self.assertTrue(neutron_utils_tests.validate_subnet(
 679             self.neutron, out_net,
 680             self.net_creator.network_settings.subnet_settings[0].name,
 681             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 682
 683         self.assertIsNone(out_net.subnets[0].gateway_ip)
 684
 685     def test_create_subnet_invalid_gateway_ip(self):
 686         """
 687         Tests the creation of an OpenStack network with a subnet that has an
 688         invalid value assigned to the gateway IP.
 689         """
 690         # Create Network
 691         subnet_config = SubnetConfig(
 692             name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
 693             gateway_ip='foo')
 694         net_config = NetworkConfig(
 695             name=self.guid + '-net', subnets=[subnet_config])
 696         self.net_creator = OpenStackNetwork(
 697             self.os_creds, net_config)
 698
 699         with self.assertRaises(BadRequest):
 700             self.net_creator.create()
 701
 702
 703 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
 704     """
 705     Test for the CreateNetwork class defined in create_nework.py when
 706     """
 707
 708     def setUp(self):
 709         """
 710         Sets up object for test
 711         """
 712         super(self.__class__, self).__start__()
 713
 714         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 715         self.neutron = neutron_utils.neutron_client(
 716             self.os_creds, self.os_session)
 717
 718         # Initialize for cleanup
 719         self.net_creator = None
 720
 721     def tearDown(self):
 722         """
 723         Cleans the network
 724         """
 725         if self.net_creator:
 726             self.net_creator.clean()
 727
 728         super(self.__class__, self).__clean__()
 729
 730     def test_create_network_one_ipv6_subnet(self):
 731         """
 732         Tests the creation of an OpenStack network without a router.
 733         """
 734         # Create Network
 735         subnet_settings = SubnetConfig(
 736             name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
 737             ip_version=6)
 738         network_settings = NetworkConfig(
 739             name=self.guid + '-net', subnet_settings=[subnet_settings])
 740
 741         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 742         self.net_creator.create()
 743
 744         # Validate network was created
 745         self.assertTrue(neutron_utils_tests.validate_network(
 746             self.neutron, self.keystone,
 747             self.net_creator.network_settings.name, True,
 748             self.os_creds.project_name))
 749
 750         network = self.net_creator.get_network()
 751         self.assertEqual(1, len(network.subnets))
 752         subnet = network.subnets[0]
 753
 754         self.assertEqual(network.id, subnet.network_id)
 755         self.assertEqual(subnet_settings.name, subnet.name)
 756         self.assertEqual('1:1::/64', subnet.cidr)
 757         self.assertEqual(6, subnet.ip_version)
 758         self.assertEqual(0, len(subnet.dns_nameservers))
 759
 760     def test_create_network_ipv4_ipv6_subnet(self):
 761         """
 762         Tests the creation of an OpenStack network without a router.
 763         """
 764         # Create Network
 765         subnet4_settings = SubnetConfig(
 766             name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
 767         subnet6_settings = SubnetConfig(
 768             name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
 769             ip_version=6)
 770
 771         network_settings = NetworkConfig(
 772             name=self.guid + '-net',
 773             subnet_settings=[subnet4_settings, subnet6_settings])
 774
 775         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 776         self.net_creator.create()
 777
 778         # Validate network was created
 779         network = self.net_creator.get_network()
 780         self.assertEqual(2, len(network.subnets))
 781
 782         subnet4 = None
 783         subnet6 = None
 784         for subnet in network.subnets:
 785             if subnet.name == subnet4_settings.name:
 786                 subnet4 = subnet
 787             if subnet.name == subnet6_settings.name:
 788                 subnet6 = subnet
 789
 790         # Validate IPv4 subnet
 791         self.assertEqual(network.id, subnet4.network_id)
 792         self.assertEqual(subnet4_settings.name, subnet4.name)
 793         self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
 794         self.assertEqual(4, subnet4.ip_version)
 795         self.assertEqual(0, len(subnet4.dns_nameservers))
 796
 797         # Validate IPv6 subnet
 798         self.assertEqual(network.id, subnet6.network_id)
 799         self.assertEqual(subnet6_settings.name, subnet6.name)
 800         self.assertEqual('1:1::/64', subnet6.cidr)
 801         self.assertEqual(6, subnet6.ip_version)
 802         self.assertEqual(0, len(subnet6.dns_nameservers))
 803
 804
 805 class CreateNetworkTypeTests(OSComponentTestCase):
 806     """
 807     Test for the CreateNetwork class defined in create_nework.py for testing
 808     creating networks of different types
 809     """
 810
 811     def setUp(self):
 812         """
 813         Sets up object for test
 814         """
 815         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 816         self.net_config = openstack_tests.get_pub_net_config(
 817             project_name=self.os_creds.project_name,
 818             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
 819
 820         self.neutron = neutron_utils.neutron_client(
 821             self.os_creds, self.os_session)
 822         self.keystone = keystone_utils.keystone_client(
 823             self.os_creds, self.os_session)
 824
 825         # Initialize for cleanup
 826         self.net_creator = None
 827
 828     def tearDown(self):
 829         """
 830         Cleans the network
 831         """
 832         if self.net_creator:
 833             self.net_creator.clean()
 834
 835         super(self.__class__, self).__clean__()
 836
 837     def test_create_network_type_vlan(self):
 838         """
 839         Tests the creation of an OpenStack network of type vlan.
 840         """
 841         # Create Network
 842         network_type = 'vlan'
 843         net_settings = NetworkConfig(
 844             name=self.net_config.network_settings.name,
 845             subnet_settings=self.net_config.network_settings.subnet_settings,
 846             network_type=network_type)
 847
 848         # When setting the network_type, creds must be admin
 849         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 850         network = self.net_creator.create()
 851
 852         # Validate network was created
 853         self.assertTrue(neutron_utils_tests.validate_network(
 854             self.neutron, self.keystone, net_settings.name, True,
 855             self.os_creds.project_name))
 856
 857         self.assertEquals(network_type, network.type)
 858
 859     def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
 860         """
 861         Tests the creation of an OpenStack network of type vlan with
 862         specified physical network and segmentation id.
 863         """
 864         # Create Network
 865         network_type = 'vlan'
 866
 867         # The two values must be variable to work on all OpenStack pods
 868         physical_network = 'datacentre'
 869         segmentation_id = 2366
 870
 871         net_settings = NetworkConfig(
 872             name=self.net_config.network_settings.name,
 873             subnet_settings=self.net_config.network_settings.subnet_settings,
 874             network_type=network_type,
 875             physical_network=physical_network,
 876             segmentation_id=segmentation_id)
 877
 878         # When setting the network_type, creds must be admin
 879         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 880         network = self.net_creator.create()
 881
 882         # Validate network was created
 883         self.assertTrue(neutron_utils_tests.validate_network(
 884             self.neutron, self.keystone, net_settings.name, True,
 885             self.os_creds.project_name))
 886
 887         self.assertEquals(network_type, network.type)
 888
 889     def test_create_network_type_vxlan(self):
 890         """
 891         Tests the creation of an OpenStack network of type vxlan.
 892         """
 893         # Create Network
 894         network_type = 'vxlan'
 895         net_settings = NetworkConfig(
 896             name=self.net_config.network_settings.name,
 897             subnet_settings=self.net_config.network_settings.subnet_settings,
 898             network_type=network_type)
 899
 900         # When setting the network_type, creds must be admin
 901         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 902         network = self.net_creator.create()
 903
 904         # Validate network was created
 905         self.assertTrue(neutron_utils_tests.validate_network(
 906             self.neutron, self.keystone, net_settings.name, True,
 907             self.os_creds.project_name))
 908
 909         self.assertEqual(network_type, network.type)
 910
 911     def test_create_network_type_flat(self):
 912         """
 913         Tests the creation of an OpenStack network of type flat.
 914         """
 915         # Create Network
 916         network_type = 'flat'
 917
 918         # This value must be variable to work on all OpenStack pods
 919         physical_network = 'datacentre'
 920
 921         net_settings = NetworkConfig(
 922             name=self.net_config.network_settings.name,
 923             subnet_settings=self.net_config.network_settings.subnet_settings,
 924             network_type=network_type, physical_network=physical_network)
 925         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 926         network = self.net_creator.create()
 927
 928         # Validate network was created
 929         self.assertTrue(neutron_utils_tests.validate_network(
 930             self.neutron, self.keystone, net_settings.name, True,
 931             self.os_creds.project_name))
 932
 933         self.assertEquals(network_type, network.type)
 934
 935     def test_create_network_type_foo(self):
 936         """
 937         Tests the creation of an OpenStack network of type foo which should
 938         raise an exception.
 939         """
 940         # Create Network
 941         network_type = 'foo'
 942         net_settings = NetworkConfig(
 943             name=self.net_config.network_settings.name,
 944             subnet_settings=self.net_config.network_settings.subnet_settings,
 945             network_type=network_type)
 946         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 947         with self.assertRaises(Exception):
 948             self.net_creator.create()
 949
 950
 951 class CreateMultipleNetworkTests(OSIntegrationTestCase):
 952     """
 953     Test for the CreateNetwork class and how it interacts with networks
 954     groups within other projects with the same name
 955     """
 956
 957     def setUp(self):
 958         """
 959         Sets up object for test
 960         """
 961         super(self.__class__, self).__start__()
 962
 963         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 964         self.net_config = openstack_tests.get_pub_net_config(
 965             project_name=self.os_creds.project_name,
 966             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
 967
 968         self.neutron = neutron_utils.neutron_client(
 969             self.os_creds, self.os_session)
 970
 971         # Initialize for cleanup
 972         self.admin_net_creator = None
 973         self.proj_net_creator = None
 974
 975     def tearDown(self):
 976         """
 977         Cleans the network
 978         """
 979         if self.admin_net_creator:
 980             self.admin_net_creator.clean()
 981         if self.proj_net_creator:
 982             self.proj_net_creator.clean()
 983
 984         super(self.__class__, self).__clean__()
 985
 986     def test_network_same_name_diff_proj(self):
 987         """
 988         Tests the creation of an OpenStackNetwork with the same name
 989         within a different project/tenant when not configured but implied by
 990         the OSCreds.
 991         """
 992         # Create Network
 993
 994         self.admin_net_creator = OpenStackNetwork(
 995             self.admin_os_creds, self.net_config.network_settings)
 996         self.admin_net_creator.create()
 997
 998         self.proj_net_creator = OpenStackNetwork(
 999             self.os_creds, self.net_config.network_settings)
1000         self.proj_net_creator.create()
1001
1002         self.assertNotEqual(
1003             self.admin_net_creator.get_network().id,
1004             self.proj_net_creator.get_network().id)
1005
1006         admin_creator2 = OpenStackNetwork(
1007             self.admin_os_creds, self.net_config.network_settings)
1008         admin_creator2.create()
1009         self.assertEqual(
1010             self.admin_net_creator.get_network(), admin_creator2.get_network())
1011
1012         proj_creator2 = OpenStackNetwork(
1013             self.os_creds, self.net_config.network_settings)
1014         proj_creator2.create()
1015         self.assertEqual(self.proj_net_creator.get_network(),
1016                          proj_creator2.get_network())
1017
1018     def test_network_create_by_admin_to_different_project(self):
1019         """
1020         Tests the creation of an OpenStackNetwork by the admin user and
1021         initialize again with tenant credentials.
1022         """
1023         # Create Network
1024
1025         net_settings = self.net_config.network_settings
1026
1027         net_settings.project_name = self.os_creds.project_name
1028
1029         self.admin_net_creator = OpenStackNetwork(
1030             self.admin_os_creds, net_settings)
1031         self.admin_net_creator.create()
1032
1033         self.proj_net_creator = OpenStackNetwork(
1034             self.os_creds, self.net_config.network_settings)
1035         self.proj_net_creator.create()
1036
1037         self.assertEqual(
1038             self.admin_net_creator.get_network().id,
1039             self.proj_net_creator.get_network().id)