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 (OpenStackNetwork, NetworkSettings,
  20                                             SubnetSettings, PortSettings,
  21                                             NetworkSettingsError,
  22                                             SubnetSettingsError,
  23                                             PortSettingsError)
  24 from snaps.openstack.tests import openstack_tests
  25 from snaps.openstack.tests.os_source_file_test import (OSIntegrationTestCase,
  26                                                        OSComponentTestCase)
  27 from snaps.openstack.utils import neutron_utils
  28 from snaps.openstack.utils.tests import neutron_utils_tests
  29
  30 __author__ = 'spisarski'
  31
  32
  33 class NetworkSettingsUnitTests(unittest.TestCase):
  34     """
  35     Tests the construction of the NetworkSettings class
  36     """
  37
  38     def test_no_params(self):
  39         with self.assertRaises(NetworkSettingsError):
  40             NetworkSettings()
  41
  42     def test_empty_config(self):
  43         with self.assertRaises(NetworkSettingsError):
  44             NetworkSettings(**dict())
  45
  46     def test_name_only(self):
  47         settings = NetworkSettings(name='foo')
  48         self.assertEqual('foo', settings.name)
  49         self.assertTrue(settings.admin_state_up)
  50         self.assertIsNone(settings.shared)
  51         self.assertIsNone(settings.project_name)
  52         self.assertFalse(settings.external)
  53         self.assertIsNone(settings.network_type)
  54         self.assertIsNone(settings.segmentation_id)
  55         self.assertEqual(0, len(settings.subnet_settings))
  56
  57     def test_config_with_name_only(self):
  58         settings = NetworkSettings(**{'name': 'foo'})
  59         self.assertEqual('foo', settings.name)
  60         self.assertTrue(settings.admin_state_up)
  61         self.assertIsNone(settings.shared)
  62         self.assertIsNone(settings.project_name)
  63         self.assertFalse(settings.external)
  64         self.assertIsNone(settings.network_type)
  65         self.assertIsNone(settings.segmentation_id)
  66         self.assertEqual(0, len(settings.subnet_settings))
  67
  68     def test_all(self):
  69         sub_settings = SubnetSettings(name='foo-subnet', cidr='10.0.0.0/24')
  70         settings = NetworkSettings(name='foo', admin_state_up=False,
  71                                    shared=True, project_name='bar',
  72                                    external=True,
  73                                    network_type='vlan', physical_network='phy',
  74                                    segmentation_id=2366,
  75                                    subnet_settings=[sub_settings])
  76         self.assertEqual('foo', settings.name)
  77         self.assertFalse(settings.admin_state_up)
  78         self.assertTrue(settings.shared)
  79         self.assertEqual('bar', settings.project_name)
  80         self.assertTrue(settings.external)
  81         self.assertEqual('vlan', settings.network_type)
  82         self.assertEqual('phy', settings.physical_network)
  83         self.assertEqual(2366, settings.segmentation_id)
  84         self.assertEqual(1, len(settings.subnet_settings))
  85         self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
  86
  87     def test_config_all(self):
  88         settings = NetworkSettings(
  89             **{'name': 'foo', 'admin_state_up': False, 'shared': True,
  90                'project_name': 'bar', 'external': True, 'network_type': 'vlan',
  91                'physical_network': 'phy',
  92                'segmentation_id': 2366,
  93                'subnets':
  94                    [{'subnet': {'name': 'foo-subnet',
  95                                 'cidr': '10.0.0.0/24'}}]})
  96         self.assertEqual('foo', settings.name)
  97         self.assertFalse(settings.admin_state_up)
  98         self.assertTrue(settings.shared)
  99         self.assertEqual('bar', settings.project_name)
 100         self.assertTrue(settings.external)
 101         self.assertEqual('vlan', settings.network_type)
 102         self.assertEqual('phy', settings.physical_network)
 103         self.assertEqual(2366, settings.segmentation_id)
 104         self.assertEqual(1, len(settings.subnet_settings))
 105         self.assertEqual('foo-subnet', settings.subnet_settings[0].name)
 106
 107
 108 class SubnetSettingsUnitTests(unittest.TestCase):
 109     """
 110     Tests the construction of the SubnetSettings class
 111     """
 112
 113     def test_no_params(self):
 114         with self.assertRaises(SubnetSettingsError):
 115             SubnetSettings()
 116
 117     def test_empty_config(self):
 118         with self.assertRaises(SubnetSettingsError):
 119             SubnetSettings(**dict())
 120
 121     def test_name_only(self):
 122         with self.assertRaises(SubnetSettingsError):
 123             SubnetSettings(name='foo')
 124
 125     def test_config_with_name_only(self):
 126         with self.assertRaises(SubnetSettingsError):
 127             SubnetSettings(**{'name': 'foo'})
 128
 129     def test_name_cidr_only(self):
 130         settings = SubnetSettings(name='foo', cidr='10.0.0.0/24')
 131         self.assertEqual('foo', settings.name)
 132         self.assertEqual('10.0.0.0/24', settings.cidr)
 133         self.assertEqual(4, settings.ip_version)
 134         self.assertIsNone(settings.project_name)
 135         self.assertIsNone(settings.start)
 136         self.assertIsNone(settings.end)
 137         self.assertIsNone(settings.enable_dhcp)
 138         self.assertEqual(1, len(settings.dns_nameservers))
 139         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 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(1, len(settings.dns_nameservers))
 157         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 158         self.assertIsNone(settings.host_routes)
 159         self.assertIsNone(settings.destination)
 160         self.assertIsNone(settings.nexthop)
 161         self.assertIsNone(settings.ipv6_ra_mode)
 162         self.assertIsNone(settings.ipv6_address_mode)
 163
 164     def test_all(self):
 165         host_routes = {'destination': '0.0.0.0/0', 'nexthop': '123.456.78.9'}
 166         settings = SubnetSettings(name='foo', cidr='10.0.0.0/24', ip_version=6,
 167                                   project_name='bar-project',
 168                                   start='10.0.0.2', end='10.0.0.101',
 169                                   gateway_ip='10.0.0.1', enable_dhcp=False,
 170                                   dns_nameservers=['8.8.8.8'],
 171                                   host_routes=[host_routes],
 172                                   destination='dest',
 173                                   nexthop='hop',
 174                                   ipv6_ra_mode='dhcpv6-stateful',
 175                                   ipv6_address_mode='slaac')
 176         self.assertEqual('foo', settings.name)
 177         self.assertEqual('10.0.0.0/24', settings.cidr)
 178         self.assertEqual(6, settings.ip_version)
 179         self.assertEqual('bar-project', settings.project_name)
 180         self.assertEqual('10.0.0.2', settings.start)
 181         self.assertEqual('10.0.0.101', settings.end)
 182         self.assertEqual('10.0.0.1', settings.gateway_ip)
 183         self.assertEqual(False, settings.enable_dhcp)
 184         self.assertEqual(1, len(settings.dns_nameservers))
 185         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 186         self.assertEqual(1, len(settings.host_routes))
 187         self.assertEqual(host_routes, settings.host_routes[0])
 188         self.assertEqual('dest', settings.destination)
 189         self.assertEqual('hop', settings.nexthop)
 190         self.assertEqual('dhcpv6-stateful', settings.ipv6_ra_mode)
 191         self.assertEqual('slaac', settings.ipv6_address_mode)
 192
 193     def test_config_all(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',
 198                'end': '10.0.0.101',
 199                'gateway_ip': '10.0.0.1', 'enable_dhcp': False,
 200                'dns_nameservers': ['8.8.8.8'], 'host_routes': [host_routes],
 201                'destination': 'dest', 'nexthop': 'hop',
 202                'ipv6_ra_mode': 'dhcpv6-stateful',
 203                'ipv6_address_mode': 'slaac'})
 204         self.assertEqual('foo', settings.name)
 205         self.assertEqual('10.0.0.0/24', settings.cidr)
 206         self.assertEqual(6, settings.ip_version)
 207         self.assertEqual('bar-project', settings.project_name)
 208         self.assertEqual('10.0.0.2', settings.start)
 209         self.assertEqual('10.0.0.101', settings.end)
 210         self.assertEqual('10.0.0.1', settings.gateway_ip)
 211         self.assertEqual(False, settings.enable_dhcp)
 212         self.assertEqual(1, len(settings.dns_nameservers))
 213         self.assertEqual('8.8.8.8', settings.dns_nameservers[0])
 214         self.assertEqual(1, len(settings.host_routes))
 215         self.assertEqual(host_routes, settings.host_routes[0])
 216         self.assertEqual('dest', settings.destination)
 217         self.assertEqual('hop', settings.nexthop)
 218         self.assertEqual('dhcpv6-stateful', settings.ipv6_ra_mode)
 219         self.assertEqual('slaac', settings.ipv6_address_mode)
 220
 221
 222 class PortSettingsUnitTests(unittest.TestCase):
 223     """
 224     Tests the construction of the PortSettings class
 225     """
 226
 227     def test_no_params(self):
 228         with self.assertRaises(PortSettingsError):
 229             PortSettings()
 230
 231     def test_empty_config(self):
 232         with self.assertRaises(PortSettingsError):
 233             PortSettings(**dict())
 234
 235     def test_name_only(self):
 236         with self.assertRaises(PortSettingsError):
 237             PortSettings(name='foo')
 238
 239     def test_config_name_only(self):
 240         with self.assertRaises(PortSettingsError):
 241             PortSettings(**{'name': 'foo'})
 242
 243     def test_name_netname_only(self):
 244         settings = PortSettings(name='foo', network_name='bar')
 245         self.assertEqual('foo', settings.name)
 246         self.assertEqual('bar', settings.network_name)
 247         self.assertTrue(settings.admin_state_up)
 248         self.assertIsNone(settings.project_name)
 249         self.assertIsNone(settings.mac_address)
 250         self.assertIsNone(settings.ip_addrs)
 251         self.assertIsNone(settings.security_groups)
 252         self.assertIsNone(settings.allowed_address_pairs)
 253         self.assertIsNone(settings.opt_value)
 254         self.assertIsNone(settings.opt_name)
 255         self.assertIsNone(settings.device_owner)
 256         self.assertIsNone(settings.device_id)
 257
 258     def test_config_with_name_netname_only(self):
 259         settings = PortSettings(**{'name': 'foo', 'network_name': 'bar'})
 260         self.assertEqual('foo', settings.name)
 261         self.assertEqual('bar', settings.network_name)
 262         self.assertTrue(settings.admin_state_up)
 263         self.assertIsNone(settings.project_name)
 264         self.assertIsNone(settings.mac_address)
 265         self.assertIsNone(settings.ip_addrs)
 266         self.assertIsNone(settings.security_groups)
 267         self.assertIsNone(settings.allowed_address_pairs)
 268         self.assertIsNone(settings.opt_value)
 269         self.assertIsNone(settings.opt_name)
 270         self.assertIsNone(settings.device_owner)
 271         self.assertIsNone(settings.device_id)
 272
 273     def test_all(self):
 274         ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
 275         allowed_address_pairs = {'10.0.0.101', '1234.5678'}
 276
 277         settings = PortSettings(name='foo', network_name='bar',
 278                                 admin_state_up=False,
 279                                 project_name='foo-project',
 280                                 mac_address='1234', ip_addrs=ip_addrs,
 281                                 security_groups=['foo_grp_id'],
 282                                 allowed_address_pairs=allowed_address_pairs,
 283                                 opt_value='opt value', opt_name='opt name',
 284                                 device_owner='owner',
 285                                 device_id='device number')
 286         self.assertEqual('foo', settings.name)
 287         self.assertEqual('bar', settings.network_name)
 288         self.assertFalse(settings.admin_state_up)
 289         self.assertEqual('foo-project', settings.project_name)
 290         self.assertEqual('1234', settings.mac_address)
 291         self.assertEqual(ip_addrs, settings.ip_addrs)
 292         self.assertEqual(1, len(settings.security_groups))
 293         self.assertEqual('foo_grp_id', settings.security_groups[0])
 294         self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
 295         self.assertEqual('opt value', settings.opt_value)
 296         self.assertEqual('opt name', settings.opt_name)
 297         self.assertEqual('owner', settings.device_owner)
 298         self.assertEqual('device number', settings.device_id)
 299
 300     def test_config_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(
 305             **{'name': 'foo', 'network_name': 'bar', 'admin_state_up': False,
 306                'project_name': 'foo-project', 'mac_address': '1234',
 307                'ip_addrs': ip_addrs, 'security_groups': ['foo_grp_id'],
 308                'allowed_address_pairs': allowed_address_pairs,
 309                'opt_value': 'opt value', 'opt_name': 'opt name',
 310                'device_owner': 'owner', 'device_id': 'device number'})
 311         self.assertEqual('foo', settings.name)
 312         self.assertEqual('bar', settings.network_name)
 313         self.assertFalse(settings.admin_state_up)
 314         self.assertEqual('foo-project', settings.project_name)
 315         self.assertEqual('1234', settings.mac_address)
 316         self.assertEqual(ip_addrs, settings.ip_addrs)
 317         self.assertEqual(1, len(settings.security_groups))
 318         self.assertEqual('foo_grp_id', settings.security_groups[0])
 319         self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
 320         self.assertEqual('opt value', settings.opt_value)
 321         self.assertEqual('opt name', settings.opt_name)
 322         self.assertEqual('owner', settings.device_owner)
 323         self.assertEqual('device number', settings.device_id)
 324
 325
 326 class CreateNetworkSuccessTests(OSIntegrationTestCase):
 327     """
 328     Test for the CreateNework class defined in create_nework.py
 329     """
 330
 331     def setUp(self):
 332         """
 333         Sets up object for test
 334         """
 335         super(self.__class__, self).__start__()
 336
 337         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 338         self.net_config = openstack_tests.get_pub_net_config(
 339             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
 340             router_name=guid + '-pub-router', external_net=self.ext_net_name)
 341
 342         self.neutron = neutron_utils.neutron_client(self.os_creds)
 343
 344         # Initialize for cleanup
 345         self.net_creator = None
 346         self.router_creator = None
 347         self.neutron = neutron_utils.neutron_client(self.os_creds)
 348
 349     def tearDown(self):
 350         """
 351         Cleans the network
 352         """
 353         if self.router_creator:
 354             self.router_creator.clean()
 355
 356         if self.net_creator:
 357             self.net_creator.clean()
 358
 359         super(self.__class__, self).__clean__()
 360
 361     def test_create_network_without_router(self):
 362         """
 363         Tests the creation of an OpenStack network without a router.
 364         """
 365         # Create Nework
 366         self.net_creator = OpenStackNetwork(self.os_creds,
 367                                             self.net_config.network_settings)
 368         self.net_creator.create()
 369
 370         # Validate network was created
 371         self.assertTrue(neutron_utils_tests.validate_network(
 372             self.neutron, self.net_creator.network_settings.name, True))
 373
 374         # Validate subnets
 375         self.assertTrue(neutron_utils_tests.validate_subnet(
 376             self.neutron,
 377             self.net_creator.network_settings.subnet_settings[0].name,
 378             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 379
 380     def test_create_delete_network(self):
 381         """
 382         Tests the creation of an OpenStack network, it's deletion, then cleanup
 383         """
 384         # Create Nework
 385         self.net_creator = OpenStackNetwork(self.os_creds,
 386                                             self.net_config.network_settings)
 387         self.net_creator.create()
 388
 389         # Validate network was created
 390         self.assertTrue(neutron_utils_tests.validate_network(
 391             self.neutron, self.net_creator.network_settings.name, True))
 392
 393         neutron_utils.delete_network(self.neutron,
 394                                      self.net_creator.get_network())
 395         self.assertIsNone(neutron_utils.get_network(
 396             self.neutron, network_settings=self.net_creator.network_settings))
 397
 398         # This shall not throw an exception here
 399         self.net_creator.clean()
 400
 401     def test_create_network_with_router(self):
 402         """
 403         Tests the creation of an OpenStack network with a router.
 404         """
 405         # Create Network
 406         self.net_creator = OpenStackNetwork(self.os_creds,
 407                                             self.net_config.network_settings)
 408         self.net_creator.create()
 409
 410         # Create Router
 411         self.router_creator = create_router.OpenStackRouter(
 412             self.os_creds, self.net_config.router_settings)
 413         self.router_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         # Validate subnets
 420         self.assertTrue(neutron_utils_tests.validate_subnet(
 421             self.neutron,
 422             self.net_creator.network_settings.subnet_settings[0].name,
 423             self.net_creator.network_settings.subnet_settings[0].cidr, True))
 424
 425         # Validate routers
 426         neutron_utils_tests.validate_router(
 427             self.neutron, self.router_creator.router_settings.name, True)
 428
 429         neutron_utils_tests.validate_interface_router(
 430             self.router_creator.get_internal_router_interface(),
 431             self.router_creator.get_router(),
 432             self.net_creator.get_subnets()[0])
 433
 434     def test_create_networks_same_name(self):
 435         """
 436         Tests the creation of an OpenStack network and ensures that the
 437         OpenStackNetwork object will not create a second.
 438         """
 439         # Create Nework
 440         self.net_creator = OpenStackNetwork(self.os_creds,
 441                                             self.net_config.network_settings)
 442         self.net_creator.create()
 443
 444         self.net_creator2 = OpenStackNetwork(self.os_creds,
 445                                              self.net_config.network_settings)
 446         self.net_creator2.create()
 447
 448         self.assertEqual(self.net_creator.get_network().id,
 449                          self.net_creator2.get_network().id)
 450
 451     def test_create_network_router_admin_user_to_new_project(self):
 452         """
 453         Tests the creation of an OpenStack network and router with the current
 454         user to the admin project.
 455         """
 456         # Create Network/Subnet where the project names have been changed
 457         admin_project_name = self.admin_os_creds.project_name
 458         self.net_config.network_settings.project_name = admin_project_name
 459         self.net_config.network_settings.subnet_settings[0].project_name = \
 460             admin_project_name
 461         self.net_creator = OpenStackNetwork(self.os_creds,
 462                                             self.net_config.network_settings)
 463         self.net_creator.create()
 464
 465         retrieved_net = neutron_utils.get_network(
 466             self.neutron, network_settings=self.net_config.network_settings)
 467
 468         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 469
 470         # Create Router
 471         self.net_config.router_settings.project_name = admin_project_name
 472         self.router_creator = create_router.OpenStackRouter(
 473             self.os_creds, self.net_config.router_settings)
 474         self.router_creator.create()
 475
 476         retrieved_router = neutron_utils.get_router(
 477             self.neutron, router_settings=self.router_creator.router_settings)
 478         self.assertEqual(
 479             self.router_creator.get_router().id, retrieved_router.id)
 480
 481     def test_create_network_router_new_user_to_admin_project(self):
 482         """
 483         Tests the creation of an OpenStack network and router with the admin
 484         user to the new project.
 485         """
 486         # Create Network/Subnet where the project names have been changed
 487         new_project_name = self.os_creds.project_name
 488         self.net_config.network_settings.project_name = new_project_name
 489         self.net_config.network_settings.subnet_settings[0].project_name = \
 490             new_project_name
 491         self.net_creator = OpenStackNetwork(self.admin_os_creds,
 492                                             self.net_config.network_settings)
 493         self.net_creator.create()
 494
 495         retrieved_net = neutron_utils.get_network(
 496             self.neutron, network_settings=self.net_config.network_settings)
 497
 498         self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
 499
 500         # Create Router
 501         self.net_config.router_settings.project_name = new_project_name
 502         self.router_creator = create_router.OpenStackRouter(
 503             self.admin_os_creds, self.net_config.router_settings)
 504         self.router_creator.create()
 505
 506         retrieved_router = neutron_utils.get_router(
 507             self.neutron, router_settings=self.router_creator.router_settings)
 508         self.assertEqual(
 509             self.router_creator.get_router().id, retrieved_router.id)
 510
 511
 512 class CreateNetworkTypeTests(OSComponentTestCase):
 513     """
 514     Test for the CreateNework class defined in create_nework.py for testing
 515     creating networks of different types
 516     """
 517
 518     def setUp(self):
 519         """
 520         Sets up object for test
 521         """
 522         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 523         self.net_config = openstack_tests.get_pub_net_config(
 524             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
 525
 526         self.neutron = neutron_utils.neutron_client(self.os_creds)
 527
 528         # Initialize for cleanup
 529         self.net_creator = None
 530         self.neutron = neutron_utils.neutron_client(self.os_creds)
 531
 532     def tearDown(self):
 533         """
 534         Cleans the network
 535         """
 536         if self.net_creator:
 537             self.net_creator.clean()
 538
 539     def test_create_network_type_vlan(self):
 540         """
 541         Tests the creation of an OpenStack network of type vlan.
 542         """
 543         # Create Network
 544         network_type = 'vlan'
 545         net_settings = NetworkSettings(
 546             name=self.net_config.network_settings.name,
 547             subnet_settings=self.net_config.network_settings.subnet_settings,
 548             network_type=network_type)
 549
 550         # When setting the network_type, creds must be admin
 551         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 552         network = self.net_creator.create()
 553
 554         # Validate network was created
 555         self.assertTrue(neutron_utils_tests.validate_network(
 556             self.neutron, net_settings.name, True))
 557
 558         self.assertEquals(network_type, network.type)
 559
 560     def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
 561         """
 562         Tests the creation of an OpenStack network of type vlan with
 563         specified physical network and segmentation id.
 564         """
 565         # Create Network
 566         network_type = 'vlan'
 567
 568         # The two values must be variable to work on all OpenStack pods
 569         physical_network = 'datacentre'
 570         segmentation_id = 2366
 571
 572         net_settings = NetworkSettings(
 573             name=self.net_config.network_settings.name,
 574             subnet_settings=self.net_config.network_settings.subnet_settings,
 575             network_type=network_type,
 576             physical_network=physical_network,
 577             segmentation_id=segmentation_id)
 578
 579         # When setting the network_type, creds must be admin
 580         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 581         network = self.net_creator.create()
 582
 583         # Validate network was created
 584         self.assertTrue(neutron_utils_tests.validate_network(
 585             self.neutron, net_settings.name, True))
 586
 587         self.assertEquals(network_type, network.type)
 588
 589     def test_create_network_type_vxlan(self):
 590         """
 591         Tests the creation of an OpenStack network of type vxlan.
 592         """
 593         # Create Network
 594         network_type = 'vxlan'
 595         net_settings = NetworkSettings(
 596             name=self.net_config.network_settings.name,
 597             subnet_settings=self.net_config.network_settings.subnet_settings,
 598             network_type=network_type)
 599
 600         # When setting the network_type, creds must be admin
 601         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 602         network = self.net_creator.create()
 603
 604         # Validate network was created
 605         self.assertTrue(neutron_utils_tests.validate_network(
 606             self.neutron, net_settings.name, True))
 607
 608         self.assertEqual(network_type, network.type)
 609
 610     def test_create_network_type_flat(self):
 611         """
 612         Tests the creation of an OpenStack network of type flat.
 613         """
 614         # Create Network
 615         network_type = 'flat'
 616
 617         # This value must be variable to work on all OpenStack pods
 618         physical_network = 'datacentre'
 619
 620         net_settings = NetworkSettings(
 621             name=self.net_config.network_settings.name,
 622             subnet_settings=self.net_config.network_settings.subnet_settings,
 623             network_type=network_type, physical_network=physical_network)
 624         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 625         network = self.net_creator.create()
 626
 627         # Validate network was created
 628         self.assertTrue(neutron_utils_tests.validate_network(
 629             self.neutron, net_settings.name, True))
 630
 631         self.assertEquals(network_type, network.type)
 632
 633     def test_create_network_type_foo(self):
 634         """
 635         Tests the creation of an OpenStack network of type foo which should
 636         raise an exception.
 637         """
 638         # Create Network
 639         network_type = 'foo'
 640         net_settings = NetworkSettings(
 641             name=self.net_config.network_settings.name,
 642             subnet_settings=self.net_config.network_settings.subnet_settings,
 643             network_type=network_type)
 644         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 645         with self.assertRaises(Exception):
 646             self.net_creator.create()