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.openstack import create_router
  19 from snaps.openstack.create_network import (
  20     OpenStackNetwork, NetworkSettings, SubnetSettings, PortSettings,
  21     NetworkSettingsError, SubnetSettingsError, PortSettingsError, IPv6Mode)
  22 from snaps.openstack.tests import openstack_tests
  23 from snaps.openstack.tests.os_source_file_test import (
  24     OSIntegrationTestCase, OSComponentTestCase)
  25 from snaps.openstack.utils import neutron_utils
  26 from snaps.openstack.utils.tests import neutron_utils_tests
  27
  28 __author__ = 'spisarski'
  29
  30
  31 class NetworkSettingsUnitTests(unittest.TestCase):
  32     """
  33     Tests the construction of the NetworkSettings class
  34     """
  35
  36     def test_no_params(self):
  37         with self.assertRaises(NetworkSettingsError):
  38             NetworkSettings()
  39
  40     def test_empty_config(self):
  41         with self.assertRaises(NetworkSettingsError):
  42             NetworkSettings(**dict())
  43
  44     def test_name_only(self):
  45         settings = NetworkSettings(name='foo')
  46         self.assertEqual('foo', settings.name)
  47         self.assertTrue(settings.admin_state_up)
  48         self.assertIsNone(settings.shared)
  49         self.assertIsNone(settings.project_name)
  50         self.assertFalse(settings.external)
  51         self.assertIsNone(settings.network_type)
  52         self.assertIsNone(settings.segmentation_id)
  53         self.assertEqual(0, len(settings.subnet_settings))
  54
  55     def test_config_with_name_only(self):
  56         settings = NetworkSettings(**{'name': 'foo'})
  57         self.assertEqual('foo', settings.name)
  58         self.assertTrue(settings.admin_state_up)
  59         self.assertIsNone(settings.shared)
  60         self.assertIsNone(settings.project_name)
  61         self.assertFalse(settings.external)
  62         self.assertIsNone(settings.network_type)
  63         self.assertIsNone(settings.segmentation_id)
  64         self.assertEqual(0, len(settings.subnet_settings))
  65
  66     def test_all(self):
  67         sub_settings = SubnetSettings(name='foo-subnet', cidr='10.0.0.0/24')
  68         settings = NetworkSettings(name='foo', admin_state_up=False,
  69                                    shared=True, project_name='bar',
  70                                    external=True,
  71                                    network_type='vlan', physical_network='phy',
  72                                    segmentation_id=2366,
  73                                    subnet_settings=[sub_settings])
  74         self.assertEqual('foo', settings.name)
  75         self.assertFalse(settings.admin_state_up)
  76         self.assertTrue(settings.shared)
  77         self.assertEqual('bar', settings.project_name)
  78         self.assertTrue(settings.external)
  79         self.assertEqual('vlan', settings.network_type)
  80         self.assertEqual('phy', settings.physical_network)
  81         self.assertEqual(2366, settings.segmentation_id)
  82         self.assertEqual(1, len(settings.subnet_settings))
  83         self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
  84
  85     def test_config_all(self):
  86         settings = NetworkSettings(
  87             **{'name': 'foo', 'admin_state_up': False, 'shared': True,
  88                'project_name': 'bar', 'external': True, 'network_type': 'vlan',
  89                'physical_network': 'phy',
  90                'segmentation_id': 2366,
  91                'subnets':
  92                    [{'subnet': {'name': 'foo-subnet',
  93                                 'cidr': '10.0.0.0/24'}}]})
  94         self.assertEqual('foo', settings.name)
  95         self.assertFalse(settings.admin_state_up)
  96         self.assertTrue(settings.shared)
  97         self.assertEqual('bar', settings.project_name)
  98         self.assertTrue(settings.external)
  99         self.assertEqual('vlan', settings.network_type)
 100         self.assertEqual('phy', settings.physical_network)
 101         self.assertEqual(2366, settings.segmentation_id)
 102         self.assertEqual(1, len(settings.subnet_settings))
 103         self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
 104
 105
 106 class SubnetSettingsUnitTests(unittest.TestCase):
 107     """
 108     Tests the construction of the SubnetSettings class
 109     """
 110
 111     def test_no_params(self):
 112         with self.assertRaises(SubnetSettingsError):
 113             SubnetSettings()
 114
 115     def test_empty_config(self):
 116         with self.assertRaises(SubnetSettingsError):
 117             SubnetSettings(**dict())
 118
 119     def test_name_only(self):
 120         with self.assertRaises(SubnetSettingsError):
 121             SubnetSettings(name='foo')
 122
 123     def test_config_with_name_only(self):
 124         with self.assertRaises(SubnetSettingsError):
 125             SubnetSettings(**{'name': 'foo'})
 126
 127     def test_name_cidr_only(self):
 128         settings = SubnetSettings(name='foo', cidr='10.0.0.0/24')
 129         self.assertEqual('foo', settings.name)
 130         self.assertEqual('10.0.0.0/24', settings.cidr)
 131         self.assertEqual(4, settings.ip_version)
 132         self.assertIsNone(settings.project_name)
 133         self.assertIsNone(settings.start)
 134         self.assertIsNone(settings.end)
 135         self.assertIsNone(settings.enable_dhcp)
 136         self.assertEqual(1, len(settings.dns_nameservers))
 137         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 138         self.assertIsNone(settings.host_routes)
 139         self.assertIsNone(settings.destination)
 140         self.assertIsNone(settings.nexthop)
 141         self.assertIsNone(settings.ipv6_ra_mode)
 142         self.assertIsNone(settings.ipv6_address_mode)
 143
 144     def test_config_with_name_cidr_only(self):
 145         settings = SubnetSettings(**{'name': 'foo', 'cidr': '10.0.0.0/24'})
 146         self.assertEqual('foo', settings.name)
 147         self.assertEqual('10.0.0.0/24', settings.cidr)
 148         self.assertEqual(4, settings.ip_version)
 149         self.assertIsNone(settings.project_name)
 150         self.assertIsNone(settings.start)
 151         self.assertIsNone(settings.end)
 152         self.assertIsNone(settings.gateway_ip)
 153         self.assertIsNone(settings.enable_dhcp)
 154         self.assertEqual(1, len(settings.dns_nameservers))
 155         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 156         self.assertIsNone(settings.host_routes)
 157         self.assertIsNone(settings.destination)
 158         self.assertIsNone(settings.nexthop)
 159         self.assertIsNone(settings.ipv6_ra_mode)
 160         self.assertIsNone(settings.ipv6_address_mode)
 161
 162     def test_all_string_enums(self):
 163         host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
 164         settings = SubnetSettings(name='foo', cidr='10.0.0.0/24', ip_version=6,
 165                                   project_name='bar-project',
 166                                   start='10.0.0.2', end='10.0.0.101',
 167                                   gateway_ip='10.0.0.1', enable_dhcp=False,
 168                                   dns_nameservers=['8.8.8.8'],
 169                                   host_routes=[host_routes],
 170                                   destination='dest',
 171                                   nexthop='hop',
 172                                   ipv6_ra_mode='dhcpv6-stateful',
 173                                   ipv6_address_mode='slaac')
 174         self.assertEqual('foo', settings.name)
 175         self.assertEqual('10.0.0.0/24', settings.cidr)
 176         self.assertEqual(6, settings.ip_version)
 177         self.assertEqual('bar-project', settings.project_name)
 178         self.assertEqual('10.0.0.2', settings.start)
 179         self.assertEqual('10.0.0.101', settings.end)
 180         self.assertEqual('10.0.0.1', settings.gateway_ip)
 181         self.assertEqual(False, settings.enable_dhcp)
 182         self.assertEqual(1, len(settings.dns_nameservers))
 183         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 184         self.assertEqual(1, len(settings.host_routes))
 185         self.assertEqual(host_routes, settings.host_routes[0])
 186         self.assertEqual('dest', settings.destination)
 187         self.assertEqual('hop', settings.nexthop)
 188         self.assertEqual(IPv6Mode.stateful, settings.ipv6_ra_mode)
 189         self.assertEqual(IPv6Mode.slaac, settings.ipv6_address_mode)
 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(name='foo', cidr='10.0.0.0/24', ip_version=6,
 194                                   project_name='bar-project',
 195                                   start='10.0.0.2', end='10.0.0.101',
 196                                   gateway_ip='10.0.0.1', enable_dhcp=False,
 197                                   dns_nameservers=['8.8.8.8'],
 198                                   host_routes=[host_routes],
 199                                   destination='dest',
 200                                   nexthop='hop',
 201                                   ipv6_ra_mode=IPv6Mode.stateful,
 202                                   ipv6_address_mode=IPv6Mode.slaac)
 203         self.assertEqual('foo', settings.name)
 204         self.assertEqual('10.0.0.0/24', settings.cidr)
 205         self.assertEqual(6, settings.ip_version)
 206         self.assertEqual('bar-project', settings.project_name)
 207         self.assertEqual('10.0.0.2', settings.start)
 208         self.assertEqual('10.0.0.101', settings.end)
 209         self.assertEqual('10.0.0.1', settings.gateway_ip)
 210         self.assertEqual(False, settings.enable_dhcp)
 211         self.assertEqual(1, len(settings.dns_nameservers))
 212         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 213         self.assertEqual(1, len(settings.host_routes))
 214         self.assertEqual(host_routes, settings.host_routes[0])
 215         self.assertEqual('dest', settings.destination)
 216         self.assertEqual('hop', settings.nexthop)
 217         self.assertEqual(IPv6Mode.stateful, settings.ipv6_ra_mode)
 218         self.assertEqual(IPv6Mode.slaac, settings.ipv6_address_mode)
 219
 220     def test_config_all(self):
 221         host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
 222         settings = SubnetSettings(
 223             **{'name': 'foo', 'cidr': '10.0.0.0/24', 'ip_version': 6,
 224                'project_name': 'bar-project', 'start': '10.0.0.2',
 225                'end': '10.0.0.101',
 226                'gateway_ip': '10.0.0.1', 'enable_dhcp': False,
 227                'dns_nameservers': ['8.8.8.8'], 'host_routes': [host_routes],
 228                'destination': 'dest', 'nexthop': 'hop',
 229                'ipv6_ra_mode': 'dhcpv6-stateless',
 230                'ipv6_address_mode': 'slaac'})
 231         self.assertEqual('foo', settings.name)
 232         self.assertEqual('10.0.0.0/24', settings.cidr)
 233         self.assertEqual(6, settings.ip_version)
 234         self.assertEqual('bar-project', settings.project_name)
 235         self.assertEqual('10.0.0.2', settings.start)
 236         self.assertEqual('10.0.0.101', settings.end)
 237         self.assertEqual('10.0.0.1', settings.gateway_ip)
 238         self.assertEqual(False, settings.enable_dhcp)
 239         self.assertEqual(1, len(settings.dns_nameservers))
 240         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 241         self.assertEqual(1, len(settings.host_routes))
 242         self.assertEqual(host_routes, settings.host_routes[0])
 243         self.assertEqual('dest', settings.destination)
 244         self.assertEqual('hop', settings.nexthop)
 245         self.assertEqual(IPv6Mode.stateless, settings.ipv6_ra_mode)
 246         self.assertEqual(IPv6Mode.slaac, settings.ipv6_address_mode)
 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(PortSettingsError):
 256             PortSettings()
 257
 258     def test_empty_config(self):
 259         with self.assertRaises(PortSettingsError):
 260             PortSettings(**dict())
 261
 262     def test_name_only(self):
 263         with self.assertRaises(PortSettingsError):
 264             PortSettings(name='foo')
 265
 266     def test_config_name_only(self):
 267         with self.assertRaises(PortSettingsError):
 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
 369         self.neutron = neutron_utils.neutron_client(self.os_creds)
 370
 371         # Initialize for cleanup
 372         self.net_creator = None
 373         self.router_creator = None
 374
 375     def tearDown(self):
 376         """
 377         Cleans the network
 378         """
 379         if self.router_creator:
 380             self.router_creator.clean()
 381
 382         if self.net_creator:
 383             self.net_creator.clean()
 384
 385         super(self.__class__, self).__clean__()
 386
 387     def test_create_network_without_router(self):
 388         """
 389         Tests the creation of an OpenStack network without a router.
 390         """
 391         # Create Network
 392         self.net_creator = OpenStackNetwork(self.os_creds,
 393                                             self.net_config.network_settings)
 394         self.net_creator.create()
 395
 396         # Validate network was created
 397         self.assertTrue(neutron_utils_tests.validate_network(
 398             self.neutron, self.net_creator.network_settings.name, True))
 399
 400         # Validate subnets
 401         self.assertTrue(neutron_utils_tests.validate_subnet(
 402             self.neutron,
 403             self.net_creator.network_settings.subnet_settings[0].name,
 404             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 405
 406     def test_create_delete_network(self):
 407         """
 408         Tests the creation of an OpenStack network, it's deletion, then cleanup
 409         """
 410         # Create Network
 411         self.net_creator = OpenStackNetwork(self.os_creds,
 412                                             self.net_config.network_settings)
 413         self.net_creator.create()
 414
 415         # Validate network was created
 416         self.assertTrue(neutron_utils_tests.validate_network(
 417             self.neutron, self.net_creator.network_settings.name, True))
 418
 419         neutron_utils.delete_network(self.neutron,
 420                                      self.net_creator.get_network())
 421         self.assertIsNone(neutron_utils.get_network(
 422             self.neutron, network_settings=self.net_creator.network_settings))
 423
 424         # This shall not throw an exception here
 425         self.net_creator.clean()
 426
 427     def test_create_network_with_router(self):
 428         """
 429         Tests the creation of an OpenStack network with a router.
 430         """
 431         # Create Network
 432         self.net_creator = OpenStackNetwork(self.os_creds,
 433                                             self.net_config.network_settings)
 434         self.net_creator.create()
 435
 436         # Create Router
 437         self.router_creator = create_router.OpenStackRouter(
 438             self.os_creds, self.net_config.router_settings)
 439         self.router_creator.create()
 440
 441         # Validate network was created
 442         self.assertTrue(neutron_utils_tests.validate_network(
 443             self.neutron, self.net_creator.network_settings.name, True))
 444
 445         # Validate subnets
 446         self.assertTrue(neutron_utils_tests.validate_subnet(
 447             self.neutron,
 448             self.net_creator.network_settings.subnet_settings[0].name,
 449             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 450
 451         # Validate routers
 452         neutron_utils_tests.validate_router(
 453             self.neutron, self.router_creator.router_settings.name, True)
 454
 455         neutron_utils_tests.validate_interface_router(
 456             self.router_creator.get_internal_router_interface(),
 457             self.router_creator.get_router(),
 458             self.net_creator.get_network().subnets[0])
 459
 460     def test_create_networks_same_name(self):
 461         """
 462         Tests the creation of an OpenStack network and ensures that the
 463         OpenStackNetwork object will not create a second.
 464         """
 465         # Create Network
 466         self.net_creator = OpenStackNetwork(self.os_creds,
 467                                             self.net_config.network_settings)
 468         self.net_creator.create()
 469
 470         self.net_creator2 = OpenStackNetwork(self.os_creds,
 471                                              self.net_config.network_settings)
 472         self.net_creator2.create()
 473
 474         self.assertEqual(self.net_creator.get_network().id,
 475                          self.net_creator2.get_network().id)
 476
 477     def test_create_network_router_admin_user_to_new_project(self):
 478         """
 479         Tests the creation of an OpenStack network and router with the current
 480         user to the admin project.
 481         """
 482         # Create Network/Subnet where the project names have been changed
 483         admin_project_name = self.admin_os_creds.project_name
 484         self.net_config.network_settings.project_name = admin_project_name
 485         self.net_config.network_settings.subnet_settings[0].project_name = \
 486             admin_project_name
 487         self.net_creator = OpenStackNetwork(self.os_creds,
 488                                             self.net_config.network_settings)
 489         self.net_creator.create()
 490
 491         retrieved_net = neutron_utils.get_network(
 492             self.neutron, network_settings=self.net_config.network_settings)
 493
 494         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 495
 496         # Create Router
 497         self.net_config.router_settings.project_name = admin_project_name
 498         self.router_creator = create_router.OpenStackRouter(
 499             self.os_creds, self.net_config.router_settings)
 500         self.router_creator.create()
 501
 502         retrieved_router = neutron_utils.get_router(
 503             self.neutron, router_settings=self.router_creator.router_settings)
 504         self.assertEqual(
 505             self.router_creator.get_router().id, retrieved_router.id)
 506
 507     def test_create_network_router_new_user_to_admin_project(self):
 508         """
 509         Tests the creation of an OpenStack network and router with the admin
 510         user to the new project.
 511         """
 512         # Create Network/Subnet where the project names have been changed
 513         new_project_name = self.os_creds.project_name
 514         self.net_config.network_settings.project_name = new_project_name
 515         self.net_config.network_settings.subnet_settings[0].project_name = \
 516             new_project_name
 517         self.net_creator = OpenStackNetwork(self.admin_os_creds,
 518                                             self.net_config.network_settings)
 519         self.net_creator.create()
 520
 521         retrieved_net = neutron_utils.get_network(
 522             self.neutron, network_settings=self.net_config.network_settings)
 523
 524         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 525
 526         # Create Router
 527         self.net_config.router_settings.project_name = new_project_name
 528         self.router_creator = create_router.OpenStackRouter(
 529             self.admin_os_creds, self.net_config.router_settings)
 530         self.router_creator.create()
 531
 532         retrieved_router = neutron_utils.get_router(
 533             self.neutron, router_settings=self.router_creator.router_settings)
 534         self.assertEqual(
 535             self.router_creator.get_router().id, retrieved_router.id)
 536
 537
 538 class CreateNetworkIPv6Tests(OSIntegrationTestCase):
 539     """
 540     Test for the CreateNetwork class defined in create_nework.py when
 541     """
 542
 543     def setUp(self):
 544         """
 545         Sets up object for test
 546         """
 547         super(self.__class__, self).__start__()
 548
 549         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 550         self.neutron = neutron_utils.neutron_client(self.os_creds)
 551
 552         # Initialize for cleanup
 553         self.net_creator = None
 554
 555     def tearDown(self):
 556         """
 557         Cleans the network
 558         """
 559         if self.net_creator:
 560             self.net_creator.clean()
 561
 562         super(self.__class__, self).__clean__()
 563
 564     def test_create_network_one_ipv6_subnet(self):
 565         """
 566         Tests the creation of an OpenStack network without a router.
 567         """
 568         # Create Network
 569         subnet_settings = SubnetSettings(
 570             name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
 571             ip_version=6)
 572         network_settings = NetworkSettings(
 573             name=self.guid + '-net', subnet_settings=[subnet_settings])
 574
 575         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 576         self.net_creator.create()
 577
 578         # Validate network was created
 579         self.assertTrue(neutron_utils_tests.validate_network(
 580             self.neutron, self.net_creator.network_settings.name, True))
 581
 582         network = self.net_creator.get_network()
 583         self.assertEqual(1, len(network.subnets))
 584         subnet = network.subnets[0]
 585
 586         self.assertEqual(network.id, subnet.network_id)
 587         self.assertEqual(subnet_settings.name, subnet.name)
 588         self.assertEqual('1:1::/64', subnet.cidr)
 589         self.assertEqual(6, subnet.ip_version)
 590         self.assertEqual(0, len(subnet.dns_nameservers))
 591
 592     def test_create_network_ipv4_ipv6_subnet(self):
 593         """
 594         Tests the creation of an OpenStack network without a router.
 595         """
 596         # Create Network
 597         subnet4_settings = SubnetSettings(
 598             name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
 599         subnet6_settings = SubnetSettings(
 600             name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
 601             ip_version=6)
 602
 603         network_settings = NetworkSettings(
 604             name=self.guid + '-net',
 605             subnet_settings=[subnet4_settings, subnet6_settings])
 606
 607         self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
 608         self.net_creator.create()
 609
 610         # Validate network was created
 611         network = self.net_creator.get_network()
 612         self.assertEqual(2, len(network.subnets))
 613
 614         subnet4 = None
 615         subnet6 = None
 616         for subnet in network.subnets:
 617             if subnet.name == subnet4_settings.name:
 618                 subnet4 = subnet
 619             if subnet.name == subnet6_settings.name:
 620                 subnet6 = subnet
 621
 622         # Validate IPv4 subnet
 623         self.assertEqual(network.id, subnet4.network_id)
 624         self.assertEqual(subnet4_settings.name, subnet4.name)
 625         self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
 626         self.assertEqual(4, subnet4.ip_version)
 627         self.assertEqual(1, len(subnet4.dns_nameservers))
 628
 629         # Validate IPv6 subnet
 630         self.assertEqual(network.id, subnet6.network_id)
 631         self.assertEqual(subnet6_settings.name, subnet6.name)
 632         self.assertEqual('1:1::/64', subnet6.cidr)
 633         self.assertEqual(6, subnet6.ip_version)
 634         self.assertEqual(0, len(subnet6.dns_nameservers))
 635
 636
 637 class CreateNetworkTypeTests(OSComponentTestCase):
 638     """
 639     Test for the CreateNetwork class defined in create_nework.py for testing
 640     creating networks of different types
 641     """
 642
 643     def setUp(self):
 644         """
 645         Sets up object for test
 646         """
 647         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 648         self.net_config = openstack_tests.get_pub_net_config(
 649             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
 650
 651         self.neutron = neutron_utils.neutron_client(self.os_creds)
 652
 653         # Initialize for cleanup
 654         self.net_creator = None
 655
 656     def tearDown(self):
 657         """
 658         Cleans the network
 659         """
 660         if self.net_creator:
 661             self.net_creator.clean()
 662
 663     def test_create_network_type_vlan(self):
 664         """
 665         Tests the creation of an OpenStack network of type vlan.
 666         """
 667         # Create Network
 668         network_type = 'vlan'
 669         net_settings = NetworkSettings(
 670             name=self.net_config.network_settings.name,
 671             subnet_settings=self.net_config.network_settings.subnet_settings,
 672             network_type=network_type)
 673
 674         # When setting the network_type, creds must be admin
 675         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 676         network = self.net_creator.create()
 677
 678         # Validate network was created
 679         self.assertTrue(neutron_utils_tests.validate_network(
 680             self.neutron, net_settings.name, True))
 681
 682         self.assertEquals(network_type, network.type)
 683
 684     def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
 685         """
 686         Tests the creation of an OpenStack network of type vlan with
 687         specified physical network and segmentation id.
 688         """
 689         # Create Network
 690         network_type = 'vlan'
 691
 692         # The two values must be variable to work on all OpenStack pods
 693         physical_network = 'datacentre'
 694         segmentation_id = 2366
 695
 696         net_settings = NetworkSettings(
 697             name=self.net_config.network_settings.name,
 698             subnet_settings=self.net_config.network_settings.subnet_settings,
 699             network_type=network_type,
 700             physical_network=physical_network,
 701             segmentation_id=segmentation_id)
 702
 703         # When setting the network_type, creds must be admin
 704         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 705         network = self.net_creator.create()
 706
 707         # Validate network was created
 708         self.assertTrue(neutron_utils_tests.validate_network(
 709             self.neutron, net_settings.name, True))
 710
 711         self.assertEquals(network_type, network.type)
 712
 713     def test_create_network_type_vxlan(self):
 714         """
 715         Tests the creation of an OpenStack network of type vxlan.
 716         """
 717         # Create Network
 718         network_type = 'vxlan'
 719         net_settings = NetworkSettings(
 720             name=self.net_config.network_settings.name,
 721             subnet_settings=self.net_config.network_settings.subnet_settings,
 722             network_type=network_type)
 723
 724         # When setting the network_type, creds must be admin
 725         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 726         network = self.net_creator.create()
 727
 728         # Validate network was created
 729         self.assertTrue(neutron_utils_tests.validate_network(
 730             self.neutron, net_settings.name, True))
 731
 732         self.assertEqual(network_type, network.type)
 733
 734     def test_create_network_type_flat(self):
 735         """
 736         Tests the creation of an OpenStack network of type flat.
 737         """
 738         # Create Network
 739         network_type = 'flat'
 740
 741         # This value must be variable to work on all OpenStack pods
 742         physical_network = 'datacentre'
 743
 744         net_settings = NetworkSettings(
 745             name=self.net_config.network_settings.name,
 746             subnet_settings=self.net_config.network_settings.subnet_settings,
 747             network_type=network_type, physical_network=physical_network)
 748         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 749         network = self.net_creator.create()
 750
 751         # Validate network was created
 752         self.assertTrue(neutron_utils_tests.validate_network(
 753             self.neutron, net_settings.name, True))
 754
 755         self.assertEquals(network_type, network.type)
 756
 757     def test_create_network_type_foo(self):
 758         """
 759         Tests the creation of an OpenStack network of type foo which should
 760         raise an exception.
 761         """
 762         # Create Network
 763         network_type = 'foo'
 764         net_settings = NetworkSettings(
 765             name=self.net_config.network_settings.name,
 766             subnet_settings=self.net_config.network_settings.subnet_settings,
 767             network_type=network_type)
 768         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 769         with self.assertRaises(Exception):
 770             self.net_creator.create()