Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 1 | # Copyright 2013 OpenStack Foundation |
| 2 | # All Rights Reserved. |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 5 | # not use this file except in compliance with the License. You may obtain |
| 6 | # 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, WITHOUT |
| 12 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 13 | # License for the specific language governing permissions and limitations |
| 14 | # under the License. |
| 15 | |
| 16 | import testtools |
| 17 | |
| 18 | from tempest.api.network import base |
Andrea Frittoli | e1ed695 | 2017-09-14 06:31:52 -0600 | [diff] [blame] | 19 | from tempest.common import identity |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 20 | from tempest.common import utils |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 21 | from tempest import config |
| 22 | from tempest.lib.common.utils import data_utils |
Slawek Kaplonski | 748dd8d | 2019-04-16 23:38:35 +0200 | [diff] [blame] | 23 | from tempest.lib.common.utils import test_utils |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 24 | from tempest.lib import decorators |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 25 | |
| 26 | CONF = config.CONF |
| 27 | |
| 28 | |
| 29 | class RoutersAdminTest(base.BaseAdminNetworkTest): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 30 | """Test routers operation supported by admin""" |
| 31 | |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 32 | # NOTE(salv-orlando): This class inherits from BaseAdminNetworkTest |
| 33 | # as some router operations, such as enabling or disabling SNAT |
| 34 | # require admin credentials by default |
| 35 | |
| 36 | def _cleanup_router(self, router): |
| 37 | self.delete_router(router) |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 38 | |
| 39 | def _create_router(self, name=None, admin_state_up=False, |
| 40 | external_network_id=None, enable_snat=None): |
| 41 | # associate a cleanup with created routers to avoid quota limits |
| 42 | router = self.create_router(name, admin_state_up, |
| 43 | external_network_id, enable_snat) |
Slawek Kaplonski | 748dd8d | 2019-04-16 23:38:35 +0200 | [diff] [blame] | 44 | self.addCleanup(test_utils.call_and_ignore_notfound_exc, |
| 45 | self._cleanup_router, router) |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 46 | return router |
| 47 | |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 48 | @classmethod |
| 49 | def skip_checks(cls): |
| 50 | super(RoutersAdminTest, cls).skip_checks() |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 51 | if not utils.is_extension_enabled('router', 'network'): |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 52 | msg = "router extension not enabled." |
| 53 | raise cls.skipException(msg) |
| 54 | |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 55 | @decorators.idempotent_id('e54dd3a3-4352-4921-b09d-44369ae17397') |
| 56 | def test_create_router_setting_project_id(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 57 | """Test creating router from admin user setting project_id.""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 58 | project = data_utils.rand_name('test_tenant_') |
| 59 | description = data_utils.rand_name('desc_') |
Andrea Frittoli | e1ed695 | 2017-09-14 06:31:52 -0600 | [diff] [blame] | 60 | project = identity.identity_utils(self.os_admin).create_project( |
| 61 | name=project, description=description) |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 62 | project_id = project['id'] |
Andrea Frittoli | e1ed695 | 2017-09-14 06:31:52 -0600 | [diff] [blame] | 63 | self.addCleanup(identity.identity_utils(self.os_admin).delete_project, |
| 64 | project_id) |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 65 | |
| 66 | name = data_utils.rand_name('router-') |
| 67 | create_body = self.admin_routers_client.create_router( |
Rodolfo Alonso Hernandez | c1449d4 | 2020-02-15 13:24:28 +0000 | [diff] [blame] | 68 | name=name, project_id=project_id) |
Slawek Kaplonski | 748dd8d | 2019-04-16 23:38:35 +0200 | [diff] [blame] | 69 | self.addCleanup(test_utils.call_and_ignore_notfound_exc, |
| 70 | self.admin_routers_client.delete_router, |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 71 | create_body['router']['id']) |
Rodolfo Alonso Hernandez | c1449d4 | 2020-02-15 13:24:28 +0000 | [diff] [blame] | 72 | self.assertEqual(project_id, create_body['router']['project_id']) |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 73 | |
| 74 | @decorators.idempotent_id('847257cc-6afd-4154-b8fb-af49f5670ce8') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 75 | @utils.requires_ext(extension='ext-gw-mode', service='network') |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 76 | @testtools.skipUnless(CONF.network.public_network_id, |
| 77 | 'The public_network_id option must be specified.') |
| 78 | def test_create_router_with_default_snat_value(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 79 | """Create a router with default snat rule""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 80 | router = self._create_router( |
| 81 | external_network_id=CONF.network.public_network_id) |
| 82 | self._verify_router_gateway( |
| 83 | router['id'], {'network_id': CONF.network.public_network_id, |
| 84 | 'enable_snat': True}) |
| 85 | |
| 86 | @decorators.idempotent_id('ea74068d-09e9-4fd7-8995-9b6a1ace920f') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 87 | @utils.requires_ext(extension='ext-gw-mode', service='network') |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 88 | @testtools.skipUnless(CONF.network.public_network_id, |
| 89 | 'The public_network_id option must be specified.') |
| 90 | def test_create_router_with_snat_explicit(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 91 | """Test creating router with specified enable_snat value""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 92 | name = data_utils.rand_name('snat-router') |
| 93 | # Create a router enabling snat attributes |
| 94 | enable_snat_states = [False, True] |
| 95 | for enable_snat in enable_snat_states: |
| 96 | external_gateway_info = { |
| 97 | 'network_id': CONF.network.public_network_id, |
| 98 | 'enable_snat': enable_snat} |
| 99 | create_body = self.admin_routers_client.create_router( |
| 100 | name=name, external_gateway_info=external_gateway_info) |
Slawek Kaplonski | 748dd8d | 2019-04-16 23:38:35 +0200 | [diff] [blame] | 101 | self.addCleanup(test_utils.call_and_ignore_notfound_exc, |
| 102 | self.admin_routers_client.delete_router, |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 103 | create_body['router']['id']) |
| 104 | # Verify snat attributes after router creation |
| 105 | self._verify_router_gateway(create_body['router']['id'], |
| 106 | exp_ext_gw_info=external_gateway_info) |
| 107 | |
| 108 | def _verify_router_gateway(self, router_id, exp_ext_gw_info=None): |
| 109 | show_body = self.admin_routers_client.show_router(router_id) |
| 110 | actual_ext_gw_info = show_body['router']['external_gateway_info'] |
| 111 | if exp_ext_gw_info is None: |
| 112 | self.assertIsNone(actual_ext_gw_info) |
| 113 | return |
| 114 | # Verify only keys passed in exp_ext_gw_info |
| 115 | for k, v in exp_ext_gw_info.items(): |
| 116 | self.assertEqual(v, actual_ext_gw_info[k]) |
| 117 | |
| 118 | def _verify_gateway_port(self, router_id): |
| 119 | list_body = self.admin_ports_client.list_ports( |
| 120 | network_id=CONF.network.public_network_id, |
Kamil Mankowski | e973da9 | 2018-12-07 11:01:51 +0100 | [diff] [blame] | 121 | device_id=router_id, |
| 122 | device_owner="network:router_gateway") |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 123 | self.assertEqual(len(list_body['ports']), 1) |
| 124 | gw_port = list_body['ports'][0] |
| 125 | fixed_ips = gw_port['fixed_ips'] |
Ferenc Horváth | 268ccce | 2017-06-08 12:39:02 +0200 | [diff] [blame] | 126 | self.assertNotEmpty(fixed_ips) |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 127 | # Assert that all of the IPs from the router gateway port |
| 128 | # are allocated from a valid public subnet. |
| 129 | public_net_body = self.admin_networks_client.show_network( |
| 130 | CONF.network.public_network_id) |
| 131 | public_subnet_ids = public_net_body['network']['subnets'] |
| 132 | for fixed_ip in fixed_ips: |
| 133 | subnet_id = fixed_ip['subnet_id'] |
| 134 | self.assertIn(subnet_id, public_subnet_ids) |
| 135 | |
| 136 | @decorators.idempotent_id('6cc285d8-46bf-4f36-9b1a-783e3008ba79') |
| 137 | @testtools.skipUnless(CONF.network.public_network_id, |
| 138 | 'The public_network_id option must be specified.') |
| 139 | def test_update_router_set_gateway(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 140 | """Test updating router's gateway info""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 141 | router = self._create_router() |
| 142 | self.routers_client.update_router( |
| 143 | router['id'], |
| 144 | external_gateway_info={ |
| 145 | 'network_id': CONF.network.public_network_id}) |
| 146 | # Verify operation - router |
| 147 | self._verify_router_gateway( |
| 148 | router['id'], |
| 149 | {'network_id': CONF.network.public_network_id}) |
| 150 | self._verify_gateway_port(router['id']) |
| 151 | |
| 152 | @decorators.idempotent_id('b386c111-3b21-466d-880c-5e72b01e1a33') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 153 | @utils.requires_ext(extension='ext-gw-mode', service='network') |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 154 | @testtools.skipUnless(CONF.network.public_network_id, |
| 155 | 'The public_network_id option must be specified.') |
| 156 | def test_update_router_set_gateway_with_snat_explicit(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 157 | """Test setting router's gateway with snat enabled""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 158 | router = self._create_router() |
| 159 | self.admin_routers_client.update_router( |
| 160 | router['id'], |
| 161 | external_gateway_info={ |
| 162 | 'network_id': CONF.network.public_network_id, |
| 163 | 'enable_snat': True}) |
| 164 | self._verify_router_gateway( |
| 165 | router['id'], |
| 166 | {'network_id': CONF.network.public_network_id, |
| 167 | 'enable_snat': True}) |
| 168 | self._verify_gateway_port(router['id']) |
| 169 | |
| 170 | @decorators.idempotent_id('96536bc7-8262-4fb2-9967-5c46940fa279') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 171 | @utils.requires_ext(extension='ext-gw-mode', service='network') |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 172 | @testtools.skipUnless(CONF.network.public_network_id, |
| 173 | 'The public_network_id option must be specified.') |
| 174 | def test_update_router_set_gateway_without_snat(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 175 | """Test setting router's gateway with snat not enabled""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 176 | router = self._create_router() |
| 177 | self.admin_routers_client.update_router( |
| 178 | router['id'], |
| 179 | external_gateway_info={ |
| 180 | 'network_id': CONF.network.public_network_id, |
| 181 | 'enable_snat': False}) |
| 182 | self._verify_router_gateway( |
| 183 | router['id'], |
| 184 | {'network_id': CONF.network.public_network_id, |
| 185 | 'enable_snat': False}) |
| 186 | self._verify_gateway_port(router['id']) |
| 187 | |
| 188 | @decorators.idempotent_id('ad81b7ee-4f81-407b-a19c-17e623f763e8') |
| 189 | @testtools.skipUnless(CONF.network.public_network_id, |
| 190 | 'The public_network_id option must be specified.') |
| 191 | def test_update_router_unset_gateway(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 192 | """Test unsetting router's gateway""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 193 | router = self._create_router( |
| 194 | external_network_id=CONF.network.public_network_id) |
| 195 | self.routers_client.update_router(router['id'], |
| 196 | external_gateway_info={}) |
| 197 | self._verify_router_gateway(router['id']) |
| 198 | # No gateway port expected |
| 199 | list_body = self.admin_ports_client.list_ports( |
| 200 | network_id=CONF.network.public_network_id, |
| 201 | device_id=router['id']) |
| 202 | self.assertFalse(list_body['ports']) |
| 203 | |
| 204 | @decorators.idempotent_id('f2faf994-97f4-410b-a831-9bc977b64374') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 205 | @utils.requires_ext(extension='ext-gw-mode', service='network') |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 206 | @testtools.skipUnless(CONF.network.public_network_id, |
| 207 | 'The public_network_id option must be specified.') |
| 208 | def test_update_router_reset_gateway_without_snat(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 209 | """Test updating router's gateway to be with snat not enabled""" |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 210 | router = self._create_router( |
| 211 | external_network_id=CONF.network.public_network_id) |
| 212 | self.admin_routers_client.update_router( |
| 213 | router['id'], |
| 214 | external_gateway_info={ |
| 215 | 'network_id': CONF.network.public_network_id, |
| 216 | 'enable_snat': False}) |
| 217 | self._verify_router_gateway( |
| 218 | router['id'], |
| 219 | {'network_id': CONF.network.public_network_id, |
| 220 | 'enable_snat': False}) |
| 221 | self._verify_gateway_port(router['id']) |
| 222 | |
Paras Babbar | 7ac89c9 | 2020-03-15 19:59:45 -0400 | [diff] [blame] | 223 | @decorators.idempotent_id('cbe42f84-04c2-11e7-8adb-fa163e4fa634') |
| 224 | @utils.requires_ext(extension='ext-gw-mode', service='network') |
| 225 | def test_create_router_set_gateway_with_fixed_ip(self): |
zhufl | 05fc4f7 | 2020-04-26 09:13:54 +0800 | [diff] [blame] | 226 | """Test creating router setting gateway with fixed ip""" |
Paras Babbar | 7ac89c9 | 2020-03-15 19:59:45 -0400 | [diff] [blame] | 227 | # At first create an external network and then use that |
| 228 | # to create address and delete |
| 229 | network_name = data_utils.rand_name(self.__class__.__name__) |
| 230 | network_1 = self.admin_networks_client.create_network( |
| 231 | name=network_name, **{'router:external': True})['network'] |
| 232 | self.addCleanup(test_utils.call_and_ignore_notfound_exc, |
| 233 | self.admin_networks_client.delete_network, |
| 234 | network_1['id']) |
| 235 | subnet = self.create_subnet( |
| 236 | network_1, client=self.admin_subnets_client, enable_dhcp=False) |
| 237 | self.addCleanup(test_utils.call_and_ignore_notfound_exc, |
| 238 | self.admin_subnets_client.delete_subnet, subnet['id']) |
| 239 | port = self.admin_ports_client.create_port( |
| 240 | name=data_utils.rand_name(self.__class__.__name__), |
| 241 | network_id=network_1['id'])['port'] |
| 242 | self.admin_ports_client.delete_port(port_id=port['id']) |
| 243 | fixed_ip = { |
| 244 | 'subnet_id': port['fixed_ips'][0]['subnet_id'], |
| 245 | 'ip_address': port['fixed_ips'][0]['ip_address'] |
| 246 | } |
| 247 | external_gateway_info = { |
| 248 | 'network_id': network_1['id'], |
| 249 | 'external_fixed_ips': [fixed_ip] |
| 250 | } |
| 251 | # Create a router and set gateway to fixed_ip |
| 252 | router = self.admin_routers_client.create_router( |
| 253 | external_gateway_info=external_gateway_info)['router'] |
| 254 | self.admin_routers_client.delete_router(router['id']) |
| 255 | # Examine router's gateway is equal to fixed_ip |
| 256 | self.assertEqual(router['external_gateway_info'][ |
| 257 | 'external_fixed_ips'][0]['ip_address'], |
| 258 | fixed_ip['ip_address']) |
| 259 | |
Ken'ichi Ohmichi | 3204a0e | 2017-05-04 18:44:28 -0700 | [diff] [blame] | 260 | |
| 261 | class RoutersIpV6AdminTest(RoutersAdminTest): |
| 262 | _ip_version = 6 |