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