snaps/openstack/tests/create_router_tests.py

   1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15 import unittest
  16 import uuid
  17
  18 from snaps.config.network import PortConfig, NetworkConfig, PortConfigError
  19 from snaps.config.router import RouterConfigError, RouterConfig
  20 from snaps.config.security_group import SecurityGroupConfig
  21 from snaps.openstack import create_network
  22 from snaps.openstack import create_router
  23 from snaps.openstack.create_network import OpenStackNetwork
  24 from snaps.openstack.create_router import (
  25     RouterSettings, OpenStackRouter, RouterCreationError)
  26 from snaps.openstack.create_security_group import OpenStackSecurityGroup
  27 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
  28 from snaps.openstack.utils import neutron_utils, settings_utils, keystone_utils
  29
  30 __author__ = 'mmakati'
  31
  32 cidr1 = '10.200.201.0/24'
  33 cidr2 = '10.200.202.0/24'
  34 cidr3 = '10.200.203.0/24'
  35 static_gateway_ip1 = '10.200.201.1'
  36 static_gateway_ip2 = '10.200.202.1'
  37
  38
  39 class RouterSettingsUnitTests(unittest.TestCase):
  40     """
  41     Class for testing the RouterSettings class
  42     """
  43
  44     def test_no_params(self):
  45         with self.assertRaises(RouterConfigError):
  46             RouterSettings()
  47
  48     def test_empty_config(self):
  49         with self.assertRaises(RouterConfigError):
  50             RouterSettings(**dict())
  51
  52     def test_name_only(self):
  53         settings = RouterSettings(name='foo')
  54         self.assertEqual('foo', settings.name)
  55         self.assertIsNone(settings.project_name)
  56         self.assertIsNone(settings.external_gateway)
  57         self.assertTrue(settings.admin_state_up)
  58         self.assertIsNone(settings.enable_snat)
  59         self.assertIsNotNone(settings.internal_subnets)
  60         self.assertTrue(isinstance(settings.internal_subnets, list))
  61         self.assertEqual(0, len(settings.internal_subnets))
  62         self.assertIsNotNone(settings.port_settings)
  63         self.assertTrue(isinstance(settings.port_settings, list))
  64         self.assertEqual(0, len(settings.port_settings))
  65
  66     def test_config_with_name_only(self):
  67         settings = RouterSettings(**{'name': 'foo'})
  68         self.assertEqual('foo', settings.name)
  69         self.assertIsNone(settings.project_name)
  70         self.assertIsNone(settings.external_gateway)
  71         self.assertTrue(settings.admin_state_up)
  72         self.assertIsNone(settings.enable_snat)
  73         self.assertIsNotNone(settings.internal_subnets)
  74         self.assertTrue(isinstance(settings.internal_subnets, list))
  75         self.assertEqual(0, len(settings.internal_subnets))
  76         self.assertIsNotNone(settings.port_settings)
  77         self.assertTrue(isinstance(settings.port_settings, list))
  78         self.assertEqual(0, len(settings.port_settings))
  79
  80     def test_all(self):
  81         port_settings = PortConfig(name='foo', network_name='bar')
  82         settings = RouterSettings(
  83             name='foo', project_name='bar', external_gateway='foo_gateway',
  84             admin_state_up=True, enable_snat=False,
  85             internal_subnets=['10.0.0.1/24'], interfaces=[port_settings])
  86         self.assertEqual('foo', settings.name)
  87         self.assertEqual('bar', settings.project_name)
  88         self.assertEqual('foo_gateway', settings.external_gateway)
  89         self.assertTrue(settings.admin_state_up)
  90         self.assertFalse(settings.enable_snat)
  91         self.assertIsNotNone(settings.internal_subnets)
  92         self.assertTrue(isinstance(settings.internal_subnets, list))
  93         self.assertEqual(1, len(settings.internal_subnets))
  94         self.assertEqual(['10.0.0.1/24'], settings.internal_subnets)
  95         self.assertEqual([port_settings], settings.port_settings)
  96
  97     def test_config_all(self):
  98         settings = RouterSettings(
  99             **{'name': 'foo', 'project_name': 'bar',
 100                'external_gateway': 'foo_gateway', 'admin_state_up': True,
 101                'enable_snat': False, 'internal_subnets': ['10.0.0.1/24'],
 102                'interfaces':
 103                    [{'port': {'name': 'foo-port',
 104                               'network_name': 'bar-net'}}]})
 105         self.assertEqual('foo', settings.name)
 106         self.assertEqual('bar', settings.project_name)
 107         self.assertEqual('foo_gateway', settings.external_gateway)
 108         self.assertTrue(settings.admin_state_up)
 109         self.assertFalse(settings.enable_snat)
 110         self.assertIsNotNone(settings.internal_subnets)
 111         self.assertTrue(isinstance(settings.internal_subnets, list))
 112         self.assertEqual(1, len(settings.internal_subnets))
 113         self.assertEqual(['10.0.0.1/24'], settings.internal_subnets)
 114         self.assertEqual(
 115             [PortConfig(**{'name': 'foo-port', 'network_name': 'bar-net'})],
 116             settings.port_settings)
 117
 118
 119 class CreateRouterSuccessTests(OSIntegrationTestCase):
 120     """
 121     Class for testing routers with various positive scenarios expected to
 122     succeed
 123     """
 124
 125     def setUp(self):
 126         """
 127         Initializes objects used for router testing
 128         """
 129         super(self.__class__, self).__start__()
 130
 131         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 132         self.router_creator = None
 133         self.network_creator1 = None
 134         self.network_creator2 = None
 135         self.neutron = neutron_utils.neutron_client(
 136             self.os_creds, self.os_session)
 137
 138     def tearDown(self):
 139         """
 140         Cleans the remote OpenStack objects used for router testing
 141         """
 142         if self.router_creator:
 143             self.router_creator.clean()
 144
 145         if self.network_creator1:
 146             self.network_creator1.clean()
 147
 148         if self.network_creator2:
 149             self.network_creator2.clean()
 150
 151         super(self.__class__, self).__clean__()
 152
 153     def test_create_router_vanilla(self):
 154         """
 155         Test creation of a most basic router with minimal options.
 156         """
 157         router_settings = RouterConfig(
 158             name=self.guid + '-pub-router', external_gateway=self.ext_net_name)
 159
 160         self.router_creator = create_router.OpenStackRouter(
 161             self.os_creds, router_settings)
 162         self.router_creator.create()
 163
 164         router = neutron_utils.get_router(
 165             self.neutron, self.keystone, router_settings=router_settings,
 166             project_name=self.os_creds.project_name)
 167         self.assertIsNotNone(router)
 168
 169         self.assertEqual(self.router_creator.get_router(), router)
 170
 171         self.check_router_recreation(router, router_settings)
 172
 173     def test_create_router_admin_user_to_new_project(self):
 174         """
 175         Test creation of a most basic router with the admin user pointing
 176         to the new project.
 177         """
 178         router_settings = RouterConfig(
 179             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 180             project_name=self.os_creds.project_name)
 181
 182         self.router_creator = create_router.OpenStackRouter(
 183             self.admin_os_creds, router_settings)
 184         self.router_creator.create()
 185
 186         router = neutron_utils.get_router(
 187             self.neutron, self.keystone, router_settings=router_settings,
 188             project_name=self.os_creds.project_name)
 189         self.assertIsNotNone(router)
 190
 191         self.assertEqual(self.router_creator.get_router().id, router.id)
 192
 193         self.check_router_recreation(router, router_settings)
 194
 195     def test_create_router_new_user_as_admin_project(self):
 196         """
 197         Test creation of a most basic router with the new user pointing
 198         to the admin project.
 199         """
 200         router_settings = RouterConfig(
 201             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 202             project_name=self.os_creds.project_name)
 203
 204         self.router_creator = create_router.OpenStackRouter(
 205             self.admin_os_creds, router_settings)
 206         self.router_creator.create()
 207
 208         router = neutron_utils.get_router(
 209             self.neutron, self.keystone, router_settings=router_settings,
 210             project_name=self.os_creds.project_name)
 211         self.assertIsNotNone(router)
 212
 213         self.assertEqual(self.router_creator.get_router().id, router.id)
 214
 215         self.check_router_recreation(router, router_settings)
 216
 217     def test_create_delete_router(self):
 218         """
 219         Test that clean() will not raise an exception if the router is deleted
 220         by another process.
 221         """
 222         self.router_settings = RouterConfig(
 223             name=self.guid + '-pub-router', external_gateway=self.ext_net_name)
 224
 225         self.router_creator = create_router.OpenStackRouter(
 226             self.os_creds, self.router_settings)
 227         created_router = self.router_creator.create()
 228         self.assertIsNotNone(created_router)
 229         retrieved_router = neutron_utils.get_router(
 230             self.neutron, self.keystone, router_settings=self.router_settings,
 231             project_name=self.os_creds.project_name)
 232         self.assertIsNotNone(retrieved_router)
 233
 234         neutron_utils.delete_router(self.neutron, created_router)
 235
 236         retrieved_router = neutron_utils.get_router(
 237             self.neutron, self.keystone, router_settings=self.router_settings,
 238             project_name=self.os_creds.project_name)
 239         self.assertIsNone(retrieved_router)
 240
 241         # Should not raise an exception
 242         self.router_creator.clean()
 243
 244     def test_create_with_internal_sub(self):
 245         """
 246         Test internal_subnets works.
 247         """
 248         network_settings1 = NetworkConfig(
 249             name=self.guid + '-pub-net1',
 250             subnet_settings=[
 251                 create_network.SubnetConfig(
 252                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 253                     gateway_ip=static_gateway_ip1)])
 254         self.network_creator1 = OpenStackNetwork(self.os_creds,
 255                                                  network_settings1)
 256
 257         self.network_creator1.create()
 258         self.router_settings = RouterConfig(
 259             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 260             internal_subnets=[network_settings1.subnet_settings[0].name])
 261
 262         self.router_creator = create_router.OpenStackRouter(
 263             self.os_creds, self.router_settings)
 264         created_router = self.router_creator.create()
 265         self.assertIsNotNone(created_router)
 266
 267     def test_create_with_invalid_internal_sub(self):
 268         """
 269         Test adding an internal subnet owned by admin which should fail.
 270         """
 271         network_settings1 = NetworkConfig(
 272             name=self.guid + '-pub-net1',
 273             subnet_settings=[
 274                 create_network.SubnetConfig(
 275                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 276                     gateway_ip=static_gateway_ip1)])
 277         self.network_creator1 = OpenStackNetwork(self.admin_os_creds,
 278                                                  network_settings1)
 279
 280         self.network_creator1.create()
 281         self.router_settings = RouterConfig(
 282             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 283             internal_subnets=[network_settings1.subnet_settings[0].name])
 284
 285         self.router_creator = create_router.OpenStackRouter(
 286             self.os_creds, self.router_settings)
 287
 288         with self.assertRaises(RouterCreationError):
 289             self.router_creator.create()
 290
 291     def test_create_router_admin_state_false(self):
 292         """
 293         Test creation of a basic router with admin state down.
 294         """
 295         router_settings = RouterConfig(
 296             name=self.guid + '-pub-router', admin_state_up=False)
 297
 298         self.router_creator = create_router.OpenStackRouter(self.os_creds,
 299                                                             router_settings)
 300         self.router_creator.create()
 301
 302         router = neutron_utils.get_router(
 303             self.neutron, self.keystone, router_settings=router_settings,
 304             project_name=self.os_creds.project_name)
 305         self.assertIsNotNone(router)
 306
 307         self.assertEqual(self.router_creator.get_router(), router)
 308
 309         self.check_router_recreation(router, router_settings)
 310
 311     def test_create_router_admin_state_True(self):
 312         """
 313         Test creation of a basic router with admin state Up.
 314         """
 315         router_settings = RouterConfig(
 316             name=self.guid + '-pub-router', admin_state_up=True)
 317
 318         self.router_creator = create_router.OpenStackRouter(
 319             self.os_creds, router_settings)
 320         self.router_creator.create()
 321
 322         router = neutron_utils.get_router(
 323             self.neutron, self.keystone, router_settings=router_settings,
 324             project_name=self.os_creds.project_name)
 325         self.assertIsNotNone(router)
 326
 327         self.assertEqual(self.router_creator.get_router(), router)
 328
 329         self.check_router_recreation(router, router_settings)
 330
 331     def test_create_router_private_network(self):
 332         """
 333         Test creation of a router connected with two private networks and no
 334         external gateway
 335         """
 336         network_settings1 = NetworkConfig(
 337             name=self.guid + '-pub-net1',
 338             subnet_settings=[
 339                 create_network.SubnetConfig(
 340                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 341                     gateway_ip=static_gateway_ip1)])
 342         network_settings2 = NetworkConfig(
 343             name=self.guid + '-pub-net2',
 344             subnet_settings=[
 345                 create_network.SubnetConfig(
 346                     cidr=cidr2, name=self.guid + '-pub-subnet2',
 347                     gateway_ip=static_gateway_ip2)])
 348
 349         self.network_creator1 = OpenStackNetwork(self.os_creds,
 350                                                  network_settings1)
 351         self.network_creator2 = OpenStackNetwork(self.os_creds,
 352                                                  network_settings2)
 353
 354         self.network_creator1.create()
 355         self.network_creator2.create()
 356
 357         port_settings = [
 358             create_network.PortConfig(
 359                 name=self.guid + '-port1',
 360                 ip_addrs=[{
 361                     'subnet_name':
 362                         network_settings1.subnet_settings[0].name,
 363                     'ip': static_gateway_ip1
 364                 }],
 365                 network_name=network_settings1.name),
 366             create_network.PortConfig(
 367                 name=self.guid + '-port2',
 368                 ip_addrs=[{
 369                     'subnet_name': network_settings2.subnet_settings[0].name,
 370                     'ip': static_gateway_ip2
 371                 }],
 372                 network_name=network_settings2.name)]
 373
 374         router_settings = RouterConfig(
 375             name=self.guid + '-pub-router', port_settings=port_settings)
 376         self.router_creator = create_router.OpenStackRouter(
 377             self.os_creds, router_settings)
 378         self.router_creator.create()
 379
 380         router = neutron_utils.get_router(
 381             self.neutron, self.keystone, router_settings=router_settings,
 382             project_name=self.os_creds.project_name)
 383
 384         self.assertEqual(router, self.router_creator.get_router())
 385
 386         # Instantiate second identical creator to ensure a second router
 387         # has not been created
 388         router_creator2 = create_router.OpenStackRouter(
 389             self.os_creds, router_settings)
 390         router2 = router_creator2.create()
 391         self.assertIsNotNone(self.router_creator.get_router(), router2)
 392
 393         self.check_router_recreation(router2, router_settings)
 394
 395     def test_create_router_external_network(self):
 396         """
 397         Test creation of a router connected to an external network and a
 398         private network.
 399         """
 400         network_settings = NetworkConfig(
 401             name=self.guid + '-pub-net1',
 402             subnet_settings=[
 403                 create_network.SubnetConfig(
 404                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 405                     gateway_ip=static_gateway_ip1)])
 406         self.network_creator1 = OpenStackNetwork(self.os_creds,
 407                                                  network_settings)
 408         self.network_creator1.create()
 409
 410         port_settings = [
 411             create_network.PortConfig(
 412                 name=self.guid + '-port1',
 413                 ip_addrs=[{
 414                     'subnet_name': network_settings.subnet_settings[0].name,
 415                     'ip': static_gateway_ip1}],
 416                 network_name=network_settings.name)]
 417
 418         router_settings = RouterConfig(
 419             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 420             port_settings=port_settings)
 421         self.router_creator = create_router.OpenStackRouter(
 422             self.os_creds, router_settings)
 423         self.router_creator.create()
 424
 425         router = neutron_utils.get_router(
 426             self.neutron, self.keystone, router_settings=router_settings,
 427             project_name=self.os_creds.project_name)
 428
 429         self.assertEquals(router, self.router_creator.get_router())
 430
 431         self.check_router_recreation(router, router_settings)
 432
 433     def test_create_router_with_ext_port(self):
 434         """
 435         Test creation of a router with a port to an external network as an
 436         'admin' user.
 437         """
 438         port_settings = [
 439             create_network.PortConfig(
 440                 name=self.guid + '-port1',
 441                 network_name=self.ext_net_name)]
 442
 443         router_settings = RouterConfig(
 444             name=self.guid + '-pub-router', port_settings=port_settings)
 445         self.router_creator = create_router.OpenStackRouter(
 446             self.admin_os_creds, router_settings)
 447         self.router_creator.create()
 448
 449         admin_neutron = neutron_utils.neutron_client(
 450             self.admin_os_creds, self.admin_os_session)
 451         admin_keystone = keystone_utils.keystone_client(
 452             self.admin_os_creds, self.admin_os_session)
 453         router = neutron_utils.get_router(
 454             admin_neutron, admin_keystone, router_settings=router_settings,
 455             project_name=self.admin_os_creds.project_name)
 456
 457         self.assertIsNotNone(router)
 458         self.assertEquals(router, self.router_creator.get_router())
 459
 460         ext_net = neutron_utils.get_network(
 461             admin_neutron, admin_keystone, network_name=self.ext_net_name)
 462
 463         self.assertIsNotNone(ext_net)
 464         self.assertIsNotNone(router.port_subnets)
 465
 466         id_found = False
 467         for port, subnets in router.port_subnets:
 468             self.assertIsNotNone(subnets)
 469             self.assertIsNotNone(port)
 470
 471             if ext_net.id == port.network_id:
 472                 id_found = True
 473                 for subnet in subnets:
 474                     self.assertIsNotNone(subnet)
 475                     self.assertEqual(ext_net.id, subnet.network_id)
 476         self.assertTrue(id_found)
 477
 478     def check_router_recreation(self, router, orig_settings):
 479         """
 480         Validates the derived RouterConfig with the original
 481         :param router: the Router domain object to test
 482         :param orig_settings: the original RouterConfig object that was
 483                               responsible for creating the router
 484         :return: the derived RouterConfig object
 485         """
 486         derived_settings = settings_utils.create_router_config(
 487             self.neutron, router)
 488         self.assertIsNotNone(derived_settings)
 489         self.assertEqual(
 490             orig_settings.enable_snat, derived_settings.enable_snat)
 491         self.assertEqual(orig_settings.external_gateway,
 492                          derived_settings.external_gateway)
 493         self.assertEqual(orig_settings.name, derived_settings.name)
 494         self.assertEqual(orig_settings.internal_subnets,
 495                          derived_settings.internal_subnets)
 496
 497         if orig_settings.external_gateway:
 498             self.assertEqual(len(orig_settings.port_settings),
 499                              len(derived_settings.port_settings))
 500         else:
 501             self.assertEqual(len(orig_settings.port_settings),
 502                              len(derived_settings.port_settings))
 503
 504         if len(orig_settings.port_settings) > 0:
 505             self.assertEqual(orig_settings.port_settings[0].name,
 506                              derived_settings.port_settings[0].name)
 507
 508         if len(orig_settings.port_settings) > 1:
 509             self.assertEqual(orig_settings.port_settings[1].name,
 510                              derived_settings.port_settings[1].name)
 511
 512         return derived_settings
 513
 514
 515 class CreateRouterNegativeTests(OSIntegrationTestCase):
 516     """
 517     Class for testing routers with various negative scenarios expected to fail.
 518     """
 519
 520     def setUp(self):
 521         """
 522         Initializes objects used for router testing
 523         """
 524         super(self.__class__, self).__start__()
 525
 526         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 527         self.network_creator = None
 528         self.router_creator = None
 529
 530     def tearDown(self):
 531         """
 532         Cleans the remote OpenStack objects used for router testing
 533         """
 534         if self.router_creator:
 535             self.router_creator.clean()
 536
 537         if self.network_creator:
 538             self.network_creator.clean()
 539
 540         super(self.__class__, self).__clean__()
 541
 542     def test_create_router_noname(self):
 543         """
 544         Test creating a router without a name.
 545         """
 546         with self.assertRaises(RouterConfigError):
 547             router_settings = RouterConfig(
 548                 name=None, external_gateway=self.ext_net_name)
 549             self.router_creator = create_router.OpenStackRouter(
 550                 self.os_creds, router_settings)
 551             self.router_creator.create()
 552
 553     def test_create_router_invalid_gateway_name(self):
 554         """
 555         Test creating a router without a valid network gateway name.
 556         """
 557         with self.assertRaises(RouterConfigError):
 558             router_settings = RouterConfig(
 559                 name=self.guid + '-pub-router',
 560                 external_gateway="Invalid_name")
 561             self.router_creator = create_router.OpenStackRouter(
 562                 self.os_creds, router_settings)
 563             self.router_creator.create()
 564
 565     def test_create_router_admin_ports(self):
 566         """
 567         Test creation of a router with ports to subnets owned by the admin
 568         project
 569         """
 570         network_settings = NetworkConfig(
 571             name=self.guid + '-pub-net1',
 572             subnet_settings=[
 573                 create_network.SubnetConfig(
 574                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 575                     gateway_ip=static_gateway_ip1)])
 576         self.network_creator = OpenStackNetwork(
 577             self.admin_os_creds, network_settings)
 578         self.network_creator.create()
 579
 580         port_settings = [
 581             create_network.PortConfig(
 582                 name=self.guid + '-port1',
 583                 ip_addrs=[{
 584                     'subnet_name': network_settings.subnet_settings[0].name,
 585                     'ip': static_gateway_ip1}],
 586                 network_name=network_settings.name)]
 587
 588         router_settings = RouterConfig(
 589             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 590             port_settings=port_settings)
 591         self.router_creator = create_router.OpenStackRouter(
 592             self.os_creds, router_settings)
 593
 594         with self.assertRaises(PortConfigError):
 595             self.router_creator.create()
 596
 597
 598 class CreateMultipleRouterTests(OSIntegrationTestCase):
 599     """
 600     Test for the OpenStackRouter class and how it interacts with routers
 601     groups within other projects with the same name
 602     """
 603
 604     def setUp(self):
 605         """
 606         Initializes objects used for router testing
 607         """
 608         super(self.__class__, self).__start__()
 609
 610         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 611         self.admin_router_creator = None
 612         self.proj_router_creator = None
 613         self.neutron = neutron_utils.neutron_client(
 614             self.os_creds, self.os_session)
 615
 616         network_settings = NetworkConfig(
 617             name=self.guid + '-pub-net', shared=True,
 618             subnet_settings=[
 619                 create_network.SubnetConfig(
 620                     cidr=cidr1, name=self.guid + '-pub-subnet',
 621                     gateway_ip=static_gateway_ip1)])
 622
 623         self.network_creator = OpenStackNetwork(
 624             self.admin_os_creds, network_settings)
 625         self.network_creator.create()
 626
 627     def tearDown(self):
 628         """
 629         Cleans the remote OpenStack objects used for router testing
 630         """
 631         if self.admin_router_creator:
 632             self.admin_router_creator.clean()
 633
 634         if self.proj_router_creator:
 635             self.proj_router_creator.clean()
 636
 637         if self.network_creator:
 638             self.network_creator.clean()
 639
 640         super(self.__class__, self).__clean__()
 641
 642     def test_router_same_name_diff_proj(self):
 643         """
 644         Tests the creation of an OpenStackNetwork with the same name
 645         within a different project/tenant when not configured but implied by
 646         the OSCreds.
 647         """
 648         # Create Router
 649
 650         router_config = RouterConfig(name=self.guid + '-router')
 651         self.admin_router_creator = OpenStackRouter(
 652             self.admin_os_creds, router_config)
 653         self.admin_router_creator.create()
 654
 655         self.proj_router_creator = OpenStackRouter(
 656             self.os_creds, router_config)
 657         self.proj_router_creator.create()
 658
 659         self.assertNotEqual(
 660             self.admin_router_creator.get_router().id,
 661             self.proj_router_creator.get_router().id)
 662
 663         admin_creator2 = OpenStackRouter(
 664             self.admin_os_creds, router_config)
 665         admin_creator2.create()
 666         self.assertEqual(
 667             self.admin_router_creator.get_router(),
 668             admin_creator2.get_router())
 669
 670         proj_creator2 = OpenStackRouter(self.os_creds, router_config)
 671         proj_creator2.create()
 672         self.assertEqual(self.proj_router_creator.get_router(),
 673                          proj_creator2.get_router())
 674
 675     def test_router_create_by_admin_to_different_project(self):
 676         """
 677         Tests the creation of an OpenStackRouter by the admin user and
 678         initialize again with tenant credentials.
 679         """
 680         # Create Network
 681
 682         admin_router_config = RouterConfig(
 683             name=self.guid + '-router',
 684             project_name=self.os_creds.project_name)
 685
 686         self.admin_router_creator = OpenStackRouter(
 687             self.admin_os_creds, admin_router_config)
 688         self.admin_router_creator.create()
 689
 690         proj_router_config = RouterConfig(
 691             name=self.guid + '-router',
 692             project_name=self.os_creds.project_name)
 693
 694         self.proj_router_creator = OpenStackRouter(
 695             self.os_creds, proj_router_config)
 696         self.proj_router_creator.create()
 697
 698         self.assertEqual(
 699             self.admin_router_creator.get_router().id,
 700             self.proj_router_creator.get_router().id)
 701
 702
 703 class CreateRouterSecurityGroupTests(OSIntegrationTestCase):
 704     """
 705     Class for testing routers with ports containing security groups
 706     """
 707
 708     def setUp(self):
 709         """
 710         Initializes objects used for router testing
 711         """
 712         super(self.__class__, self).__start__()
 713
 714         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 715         self.router_creator = None
 716         self.network_creator = None
 717
 718         self.sec_grp_creator = OpenStackSecurityGroup(
 719             self.os_creds, SecurityGroupConfig(name=self.guid + '-sec_grp'))
 720         self.sec_grp_creator.create()
 721
 722         self.neutron = neutron_utils.neutron_client(
 723             self.os_creds, self.os_session)
 724
 725     def tearDown(self):
 726         """
 727         Cleans the remote OpenStack objects used for router testing
 728         """
 729         if self.router_creator:
 730             self.router_creator.clean()
 731
 732         if self.network_creator:
 733             self.network_creator.clean()
 734
 735         if self.sec_grp_creator:
 736             self.sec_grp_creator.clean()
 737
 738         super(self.__class__, self).__clean__()
 739
 740     def test_create_router_secure_port(self):
 741         """
 742         Test creation of a router with a port that has a security group.
 743         """
 744         network_settings = NetworkConfig(
 745             name=self.guid + '-pub-net1',
 746             subnet_settings=[
 747                 create_network.SubnetConfig(
 748                     cidr=cidr1, name=self.guid + '-pub-subnet1')])
 749         self.network_creator = OpenStackNetwork(
 750             self.os_creds, network_settings)
 751         self.network_creator.create()
 752
 753         port_settings = [
 754             create_network.PortConfig(
 755                 name=self.guid + '-port1',
 756                 ip_addrs=[{
 757                     'subnet_name': network_settings.subnet_settings[0].name,
 758                     'ip': static_gateway_ip1}],
 759                 network_name=network_settings.name,
 760                 security_groups=[self.sec_grp_creator.sec_grp_settings.name])]
 761
 762         router_settings = RouterConfig(
 763             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
 764             port_settings=port_settings)
 765         self.router_creator = create_router.OpenStackRouter(
 766             self.os_creds, router_settings)
 767         self.router_creator.create()
 768
 769
 770 class CreateRouterSharedNetworksTests(OSIntegrationTestCase):
 771     """
 772     Class for testing routers external and/or shared networks
 773     """
 774
 775     def setUp(self):
 776         """
 777         Initializes objects used for router testing
 778         """
 779         super(self.__class__, self).__start__()
 780
 781         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 782         self.router_creator = None
 783
 784         ext_network_settings = NetworkConfig(
 785             name=self.guid + '-ext-net',
 786             external=True,
 787             subnet_settings=[
 788                 create_network.SubnetConfig(
 789                     cidr=cidr1, name=self.guid + '-ext-subnet1')])
 790         self.ext_network_creator = OpenStackNetwork(
 791             self.admin_os_creds, ext_network_settings)
 792         self.ext_network_creator.create()
 793
 794         shared_network_settings = NetworkConfig(
 795             name=self.guid + '-shared-net',
 796             shared=True,
 797             subnet_settings=[
 798                 create_network.SubnetConfig(
 799                     cidr=cidr2, name=self.guid + '-shared-subnet1')])
 800         self.shared_network_creator = OpenStackNetwork(
 801             self.admin_os_creds, shared_network_settings)
 802         self.shared_network_creator.create()
 803
 804         overlay_network_settings = NetworkConfig(
 805             name=self.guid + '-overlay-net',
 806             subnet_settings=[
 807                 create_network.SubnetConfig(
 808                     cidr=cidr3, name=self.guid + '-overlay-subnet1')])
 809         self.overlay_network_creator = OpenStackNetwork(
 810             self.os_creds, overlay_network_settings)
 811         self.overlay_network_creator.create()
 812
 813         self.neutron = neutron_utils.neutron_client(
 814             self.os_creds, self.os_session)
 815
 816     def tearDown(self):
 817         """
 818         Cleans the remote OpenStack objects used for router testing
 819         """
 820         if self.router_creator:
 821             self.router_creator.clean()
 822
 823         if self.overlay_network_creator:
 824             self.overlay_network_creator.clean()
 825
 826         if self.shared_network_creator:
 827             self.shared_network_creator.clean()
 828
 829         if self.ext_network_creator:
 830             self.ext_network_creator.clean()
 831
 832         super(self.__class__, self).__clean__()
 833
 834     def test_create_router_external(self):
 835         """
 836         Test creation of a router with a custom external network created by
 837         admin.
 838         """
 839         router_settings = RouterConfig(
 840             name=self.guid + '-pub-router',
 841             external_gateway=self.ext_network_creator.get_network().name)
 842         self.router_creator = create_router.OpenStackRouter(
 843             self.os_creds, router_settings)
 844         self.router_creator.create()
 845
 846     def test_create_router_port_external(self):
 847         """
 848         Test creation of a router with a port to an custom external network
 849         created by admin.
 850         """
 851         router_settings = RouterConfig(
 852             name=self.guid + '-pub-router',
 853             network_name=self.ext_network_creator.get_network().name)
 854         self.router_creator = create_router.OpenStackRouter(
 855             self.os_creds, router_settings)
 856         self.router_creator.create()
 857
 858     def test_create_router_port_shared(self):
 859         """
 860         Test creation of a router with a port to an custom shared network
 861         created by admin.
 862         """
 863         port_settings = [
 864             create_network.PortConfig(
 865                 name=self.guid + '-port1',
 866                 network_name=self.shared_network_creator.get_network().name)]
 867
 868         router_settings = RouterConfig(
 869             name=self.guid + '-pub-router',
 870             port_settings=port_settings)
 871         self.router_creator = create_router.OpenStackRouter(
 872             self.os_creds, router_settings)
 873         self.router_creator.create()