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