snaps/openstack/tests/create_router_tests.py

   1 # Copyright (c) 2016 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
  16 import uuid
  17
  18 from snaps.openstack import create_network
  19 from snaps.openstack import create_router
  20 from snaps.openstack.create_network import NetworkSettings
  21 from snaps.openstack.create_network import OpenStackNetwork
  22 from snaps.openstack.create_router import RouterSettings
  23 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
  24 from snaps.openstack.utils import neutron_utils
  25
  26 __author__ = 'mmakati'
  27
  28 cidr1 = '10.200.201.0/24'
  29 cidr2 = '10.200.202.0/24'
  30 static_gateway_ip1 = '10.200.201.1'
  31 static_gateway_ip2 = '10.200.202.1'
  32
  33
  34 class CreateRouterSuccessTests(OSIntegrationTestCase):
  35     """
  36     Class for testing routers with various positive scenarios expected to
  37     succeed
  38     """
  39
  40     def setUp(self):
  41         """
  42         Initializes objects used for router testing
  43         """
  44         super(self.__class__, self).__start__()
  45
  46         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
  47         self.router_creator = None
  48         self.network_creator1 = None
  49         self.network_creator2 = None
  50         self.neutron = neutron_utils.neutron_client(self.os_creds)
  51
  52     def tearDown(self):
  53         """
  54         Cleans the remote OpenStack objects used for router testing
  55         """
  56         if self.router_creator:
  57             self.router_creator.clean()
  58
  59         if self.network_creator1:
  60             self.network_creator1.clean()
  61
  62         if self.network_creator2:
  63             self.network_creator2.clean()
  64
  65         super(self.__class__, self).__clean__()
  66
  67     def test_create_router_vanilla(self):
  68         """
  69         Test creation of a most basic router with minimal options.
  70         """
  71         router_settings = RouterSettings(name=self.guid + '-pub-router',
  72                                          external_gateway=self.ext_net_name)
  73
  74         self.router_creator = create_router.OpenStackRouter(self.os_creds,
  75                                                             router_settings)
  76         self.router_creator.create()
  77
  78         router = neutron_utils.get_router_by_name(self.neutron,
  79                                                   router_settings.name)
  80         self.assertIsNotNone(router)
  81
  82         self.assertTrue(verify_router_attributes(
  83             router, self.router_creator, ext_gateway=self.ext_net_name))
  84
  85     def test_create_delete_router(self):
  86         """
  87         Test that clean() will not raise an exception if the router is deleted
  88         by another process.
  89         """
  90         self.router_settings = RouterSettings(
  91             name=self.guid + '-pub-router', external_gateway=self.ext_net_name)
  92
  93         self.router_creator = create_router.OpenStackRouter(
  94             self.os_creds, self.router_settings)
  95         created_router = self.router_creator.create()
  96         self.assertIsNotNone(created_router)
  97         retrieved_router = neutron_utils.get_router_by_name(
  98             self.neutron, self.router_settings.name)
  99         self.assertIsNotNone(retrieved_router)
 100
 101         neutron_utils.delete_router(self.neutron, created_router)
 102
 103         retrieved_router = neutron_utils.get_router_by_name(
 104             self.neutron, self.router_settings.name)
 105         self.assertIsNone(retrieved_router)
 106
 107         # Should not raise an exception
 108         self.router_creator.clean()
 109
 110     def test_create_router_admin_state_false(self):
 111         """
 112         Test creation of a basic router with admin state down.
 113         """
 114         router_settings = RouterSettings(name=self.guid + '-pub-router',
 115                                          admin_state_up=False)
 116
 117         self.router_creator = create_router.OpenStackRouter(self.os_creds,
 118                                                             router_settings)
 119         self.router_creator.create()
 120
 121         router = neutron_utils.get_router_by_name(self.neutron,
 122                                                   router_settings.name)
 123         self.assertIsNotNone(router)
 124
 125         self.assertTrue(verify_router_attributes(router, self.router_creator,
 126                                                  admin_state=False))
 127
 128     def test_create_router_admin_state_True(self):
 129         """
 130         Test creation of a basic router with admin state Up.
 131         """
 132         router_settings = RouterSettings(name=self.guid + '-pub-router',
 133                                          admin_state_up=True)
 134
 135         self.router_creator = create_router.OpenStackRouter(self.os_creds,
 136                                                             router_settings)
 137         self.router_creator.create()
 138
 139         router = neutron_utils.get_router_by_name(self.neutron,
 140                                                   router_settings.name)
 141         self.assertIsNotNone(router)
 142
 143         self.assertTrue(verify_router_attributes(router, self.router_creator,
 144                                                  admin_state=True))
 145
 146     def test_create_router_private_network(self):
 147         """
 148         Test creation of a router connected with two private networks and no
 149         external gateway
 150         """
 151         network_settings1 = NetworkSettings(
 152             name=self.guid + '-pub-net1',
 153             subnet_settings=[
 154                 create_network.SubnetSettings(
 155                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 156                     gateway_ip=static_gateway_ip1)])
 157         network_settings2 = NetworkSettings(
 158             name=self.guid + '-pub-net2',
 159             subnet_settings=[
 160                 create_network.SubnetSettings(
 161                     cidr=cidr2, name=self.guid + '-pub-subnet2',
 162                     gateway_ip=static_gateway_ip2)])
 163
 164         self.network_creator1 = OpenStackNetwork(self.os_creds,
 165                                                  network_settings1)
 166         self.network_creator2 = OpenStackNetwork(self.os_creds,
 167                                                  network_settings2)
 168
 169         self.network_creator1.create()
 170         self.network_creator2.create()
 171
 172         port_settings = [
 173             create_network.PortSettings(name=self.guid + '-port1', ip_addrs=[
 174                 {'subnet_name': network_settings1.subnet_settings[0].name,
 175                  'ip': static_gateway_ip1}],
 176                                         network_name=network_settings1.name),
 177             create_network.PortSettings(name=self.guid + '-port2', ip_addrs=[
 178                 {'subnet_name': network_settings2.subnet_settings[0].name,
 179                  'ip': static_gateway_ip2}],
 180                                           network_name=network_settings2.name)]
 181
 182         router_settings = RouterSettings(name=self.guid + '-pub-router',
 183                                          port_settings=port_settings)
 184         self.router_creator = create_router.OpenStackRouter(self.os_creds,
 185                                                             router_settings)
 186         self.router_creator.create()
 187
 188         router = neutron_utils.get_router_by_name(self.neutron,
 189                                                   router_settings.name)
 190
 191         self.assertTrue(verify_router_attributes(router, self.router_creator))
 192
 193     def test_create_router_external_network(self):
 194         """
 195         Test creation of a router connected to an external network and a
 196         private network.
 197         """
 198         network_settings = NetworkSettings(
 199             name=self.guid + '-pub-net1',
 200             subnet_settings=[
 201                 create_network.SubnetSettings(
 202                     cidr=cidr1, name=self.guid + '-pub-subnet1',
 203                     gateway_ip=static_gateway_ip1)])
 204         self.network_creator1 = OpenStackNetwork(self.os_creds,
 205                                                  network_settings)
 206         self.network_creator1.create()
 207
 208         port_settings = [
 209             create_network.PortSettings(name=self.guid + '-port1', ip_addrs=[
 210                 {'subnet_name': network_settings.subnet_settings[0].name,
 211                  'ip': static_gateway_ip1}],
 212                                         network_name=network_settings.name)]
 213
 214         router_settings = RouterSettings(name=self.guid + '-pub-router',
 215                                          external_gateway=self.ext_net_name,
 216                                          port_settings=port_settings)
 217         self.router_creator = create_router.OpenStackRouter(self.os_creds,
 218                                                             router_settings)
 219         self.router_creator.create()
 220
 221         router = neutron_utils.get_router_by_name(self.neutron,
 222                                                   router_settings.name)
 223
 224         self.assertTrue(verify_router_attributes(
 225             router, self.router_creator, ext_gateway=self.ext_net_name))
 226
 227
 228 class CreateRouterNegativeTests(OSIntegrationTestCase):
 229     """
 230     Class for testing routers with various negative scenarios expected to fail.
 231     """
 232
 233     def setUp(self):
 234         """
 235         Initializes objects used for router testing
 236         """
 237         super(self.__class__, self).__start__()
 238
 239         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 240         self.router_creator = None
 241
 242     def tearDown(self):
 243         """
 244         Cleans the remote OpenStack objects used for router testing
 245         """
 246         if self.router_creator:
 247             self.router_creator.clean()
 248
 249         super(self.__class__, self).__clean__()
 250
 251     def test_create_router_noname(self):
 252         """
 253         Test creating a router without a name.
 254         """
 255         with self.assertRaises(Exception):
 256             router_settings = RouterSettings(
 257                 name=None, external_gateway=self.ext_net_name)
 258             self.router_creator = create_router.OpenStackRouter(
 259                 self.os_creds, router_settings)
 260             self.router_creator.create()
 261
 262     def test_create_router_invalid_gateway_name(self):
 263         """
 264         Test creating a router without a valid network gateway name.
 265         """
 266         with self.assertRaises(Exception):
 267             router_settings = RouterSettings(name=self.guid + '-pub-router',
 268                                              external_gateway="Invalid_name")
 269             self.router_creator = create_router.OpenStackRouter(
 270                 self.os_creds, router_settings)
 271             self.router_creator.create()
 272
 273
 274 def verify_router_attributes(router_operational, router_creator,
 275                              admin_state=True, ext_gateway=None):
 276     """
 277     Helper function to validate the attributes of router created with the one
 278     operational
 279     :param router_operational: Operational Router object returned from neutron
 280                                utils
 281     :param router_creator: router_creator object returned from creating a
 282                            router in the router test functions
 283     :param admin_state: True if router is expected to be Up, else False
 284     :param ext_gateway: None if router is not connected to external gateway
 285     :return:
 286     """
 287
 288     router = router_creator.get_router()
 289
 290     if not router_operational:
 291         return False
 292     elif not router_creator:
 293         return False
 294     elif not (router_operational['router'][
 295                   'name'] == router_creator.router_settings.name):
 296         return False
 297     elif not (router_operational['router']['id'] == router['router']['id']):
 298         return False
 299     elif not (router_operational['router']['status'] == router['router']['status']):
 300         return False
 301     elif not (router_operational['router']['tenant_id'] == router['router']['tenant_id']):
 302         return False
 303     elif not (admin_state == router_operational['router']['admin_state_up']):
 304         return False
 305     elif (ext_gateway is None) and \
 306             (router_operational['router']['external_gateway_info'] is not None):
 307         return False
 308     elif ext_gateway is not None:
 309         if router_operational['router']['external_gateway_info'] is None:
 310             return False
 311     return True