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