neutron/tests/api/test_subnetpools.py

   1 # Copyright 2015 Hewlett-Packard Development Company, L.P.
   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 from tempest_lib.common.utils import data_utils
  17
  18 from neutron.tests.api import base
  19 from neutron.tests.api import clients
  20 from neutron.tests.tempest import config
  21 from neutron.tests.tempest import test
  22
  23 CONF = config.CONF
  24 SUBNETPOOL_NAME = 'smoke-subnetpool'
  25 SUBNET_NAME = 'smoke-subnet'
  26
  27
  28 class SubnetPoolsTestBase(base.BaseNetworkTest):
  29
  30     @classmethod
  31     def resource_setup(cls):
  32         super(SubnetPoolsTestBase, cls).resource_setup()
  33         min_prefixlen = '29'
  34         prefixes = [u'10.11.12.0/24']
  35         cls._subnetpool_data = {'prefixes': prefixes,
  36                                 'min_prefixlen': min_prefixlen}
  37         try:
  38             creds = cls.isolated_creds.get_admin_creds()
  39             cls.os_adm = clients.Manager(credentials=creds)
  40         except NotImplementedError:
  41             msg = ("Missing Administrative Network API credentials "
  42                    "in configuration.")
  43             raise cls.skipException(msg)
  44         cls.admin_client = cls.os_adm.network_client
  45
  46     def _create_subnetpool(self, is_admin=False, **kwargs):
  47         if 'name' not in kwargs:
  48             name = data_utils.rand_name(SUBNETPOOL_NAME)
  49         else:
  50             name = kwargs.pop('name')
  51
  52         if 'prefixes' not in kwargs:
  53             kwargs['prefixes'] = self._subnetpool_data['prefixes']
  54
  55         if 'min_prefixlen' not in kwargs:
  56             kwargs['min_prefixlen'] = self._subnetpool_data['min_prefixlen']
  57
  58         return self.create_subnetpool(name=name, is_admin=is_admin, **kwargs)
  59
  60
  61 class SubnetPoolsTest(SubnetPoolsTestBase):
  62
  63     min_prefixlen = '28'
  64     max_prefixlen = '31'
  65     _ip_version = 4
  66     subnet_cidr = u'10.11.12.0/31'
  67     new_prefix = u'10.11.15.0/24'
  68     larger_prefix = u'10.11.0.0/16'
  69
  70     """
  71     Tests the following operations in the Neutron API using the REST client for
  72     Neutron:
  73
  74         create a subnetpool for a tenant
  75         list tenant's subnetpools
  76         show a tenant subnetpool details
  77         subnetpool update
  78         delete a subnetpool
  79
  80         All subnetpool tests are run once with ipv4 and once with ipv6.
  81
  82     v2.0 of the Neutron API is assumed.
  83
  84     """
  85
  86     def _new_subnetpool_attributes(self):
  87         new_name = data_utils.rand_name(SUBNETPOOL_NAME)
  88         return {'name': new_name, 'min_prefixlen': self.min_prefixlen,
  89                 'max_prefixlen': self.max_prefixlen}
  90
  91     def _check_equality_updated_subnetpool(self, expected_values,
  92                                            updated_pool):
  93         self.assertEqual(expected_values['name'],
  94                          updated_pool['name'])
  95         self.assertEqual(expected_values['min_prefixlen'],
  96                          updated_pool['min_prefixlen'])
  97         self.assertEqual(expected_values['max_prefixlen'],
  98                          updated_pool['max_prefixlen'])
  99         # expected_values may not contains all subnetpool values
 100         if 'prefixes' in expected_values:
 101             self.assertEqual(expected_values['prefixes'],
 102                              updated_pool['prefixes'])
 103
 104     @test.attr(type='smoke')
 105     @test.idempotent_id('6e1781ec-b45b-4042-aebe-f485c022996e')
 106     def test_create_list_subnetpool(self):
 107         created_subnetpool = self._create_subnetpool()
 108         body = self.client.list_subnetpools()
 109         subnetpools = body['subnetpools']
 110         self.assertIn(created_subnetpool['id'],
 111                       [sp['id'] for sp in subnetpools],
 112                       "Created subnetpool id should be in the list")
 113         self.assertIn(created_subnetpool['name'],
 114                       [sp['name'] for sp in subnetpools],
 115                       "Created subnetpool name should be in the list")
 116
 117     @test.attr(type='smoke')
 118     @test.idempotent_id('741d08c2-1e3f-42be-99c7-0ea93c5b728c')
 119     def test_get_subnetpool(self):
 120         created_subnetpool = self._create_subnetpool()
 121         prefixlen = self._subnetpool_data['min_prefixlen']
 122         body = self.client.show_subnetpool(created_subnetpool['id'])
 123         subnetpool = body['subnetpool']
 124         self.assertEqual(created_subnetpool['name'], subnetpool['name'])
 125         self.assertEqual(created_subnetpool['id'], subnetpool['id'])
 126         self.assertEqual(prefixlen, subnetpool['min_prefixlen'])
 127         self.assertEqual(prefixlen, subnetpool['default_prefixlen'])
 128         self.assertFalse(subnetpool['shared'])
 129
 130     @test.attr(type='smoke')
 131     @test.idempotent_id('764f1b93-1c4a-4513-9e7b-6c2fc5e9270c')
 132     def test_tenant_update_subnetpool(self):
 133         created_subnetpool = self._create_subnetpool()
 134         pool_id = created_subnetpool['id']
 135         subnetpool_data = self._new_subnetpool_attributes()
 136         self.client.update_subnetpool(created_subnetpool['id'],
 137                                       **subnetpool_data)
 138
 139         body = self.client.show_subnetpool(pool_id)
 140         subnetpool = body['subnetpool']
 141         self._check_equality_updated_subnetpool(subnetpool_data,
 142                                                 subnetpool)
 143         self.assertFalse(subnetpool['shared'])
 144
 145     @test.attr(type='smoke')
 146     @test.idempotent_id('4b496082-c992-4319-90be-d4a7ce646290')
 147     def test_update_subnetpool_prefixes_append(self):
 148         # We can append new prefixes to subnetpool
 149         create_subnetpool = self._create_subnetpool()
 150         pool_id = create_subnetpool['id']
 151         old_prefixes = self._subnetpool_data['prefixes']
 152         new_prefixes = old_prefixes[:]
 153         new_prefixes.append(self.new_prefix)
 154         subnetpool_data = {'prefixes': new_prefixes}
 155         self.client.update_subnetpool(pool_id, **subnetpool_data)
 156         body = self.client.show_subnetpool(pool_id)
 157         prefixes = body['subnetpool']['prefixes']
 158         self.assertIn(self.new_prefix, prefixes)
 159         self.assertIn(old_prefixes[0], prefixes)
 160
 161     @test.attr(type='smoke')
 162     @test.idempotent_id('2cae5d6a-9d32-42d8-8067-f13970ae13bb')
 163     def test_update_subnetpool_prefixes_extend(self):
 164         # We can extend current subnetpool prefixes
 165         created_subnetpool = self._create_subnetpool()
 166         pool_id = created_subnetpool['id']
 167         old_prefixes = self._subnetpool_data['prefixes']
 168         subnetpool_data = {'prefixes': [self.larger_prefix]}
 169         self.client.update_subnetpool(pool_id, **subnetpool_data)
 170         body = self.client.show_subnetpool(pool_id)
 171         prefixes = body['subnetpool']['prefixes']
 172         self.assertIn(self.larger_prefix, prefixes)
 173         self.assertNotIn(old_prefixes[0], prefixes)
 174
 175     @test.attr(type='smoke')
 176     @test.idempotent_id('d70c6c35-913b-4f24-909f-14cd0d29b2d2')
 177     def test_admin_create_shared_subnetpool(self):
 178         created_subnetpool = self._create_subnetpool(is_admin=True,
 179                                                      shared=True)
 180         pool_id = created_subnetpool['id']
 181         # Shared subnetpool can be retrieved by tenant user.
 182         body = self.client.show_subnetpool(pool_id)
 183         subnetpool = body['subnetpool']
 184         self.assertEqual(created_subnetpool['name'], subnetpool['name'])
 185         self.assertTrue(subnetpool['shared'])
 186
 187     def _create_subnet_from_pool(self, subnet_values=None, pool_values=None):
 188         if pool_values is None:
 189             pool_values = {}
 190
 191         created_subnetpool = self._create_subnetpool(**pool_values)
 192         pool_id = created_subnetpool['id']
 193         subnet_name = data_utils.rand_name(SUBNETPOOL_NAME)
 194         network = self.create_network()
 195         subnet_kwargs = {'name': subnet_name,
 196                          'subnetpool_id': pool_id}
 197         if subnet_values:
 198             subnet_kwargs.update(subnet_values)
 199         # not creating the subnet using the base.create_subnet because
 200         # that function needs to be enhanced to support subnet_create when
 201         # prefixlen and subnetpool_id is specified.
 202         body = self.client.create_subnet(
 203             network_id=network['id'],
 204             ip_version=self._ip_version,
 205             **subnet_kwargs)
 206         subnet = body['subnet']
 207         return pool_id, subnet
 208
 209     @test.attr(type='smoke')
 210     @test.idempotent_id('1362ed7d-3089-42eb-b3a5-d6cb8398ee77')
 211     def test_create_subnet_from_pool_with_prefixlen(self):
 212         subnet_values = {"prefixlen": self.max_prefixlen}
 213         pool_id, subnet = self._create_subnet_from_pool(
 214             subnet_values=subnet_values)
 215         cidr = str(subnet['cidr'])
 216         self.assertEqual(pool_id, subnet['subnetpool_id'])
 217         self.assertTrue(cidr.endswith(str(self.max_prefixlen)))
 218
 219     @test.attr(type='smoke')
 220     @test.idempotent_id('86b86189-9789-4582-9c3b-7e2bfe5735ee')
 221     def test_create_subnet_from_pool_with_subnet_cidr(self):
 222         subnet_values = {"cidr": self.subnet_cidr}
 223         pool_id, subnet = self._create_subnet_from_pool(
 224             subnet_values=subnet_values)
 225         cidr = str(subnet['cidr'])
 226         self.assertEqual(pool_id, subnet['subnetpool_id'])
 227         self.assertEqual(cidr, self.subnet_cidr)
 228
 229     @test.attr(type='smoke')
 230     @test.idempotent_id('83f76e3a-9c40-40c2-a015-b7c5242178d8')
 231     def test_create_subnet_from_pool_with_default_prefixlen(self):
 232         # If neither cidr nor prefixlen is specified,
 233         # subnet will use subnetpool default_prefixlen for cidr.
 234         pool_id, subnet = self._create_subnet_from_pool()
 235         cidr = str(subnet['cidr'])
 236         self.assertEqual(pool_id, subnet['subnetpool_id'])
 237         prefixlen = self._subnetpool_data['min_prefixlen']
 238         self.assertTrue(cidr.endswith(str(prefixlen)))
 239
 240     @test.attr(type='smoke')
 241     @test.idempotent_id('a64af292-ec52-4bde-b654-a6984acaf477')
 242     def test_create_subnet_from_pool_with_quota(self):
 243         pool_values = {'default_quota': 4}
 244         subnet_values = {"prefixlen": self.max_prefixlen}
 245         pool_id, subnet = self._create_subnet_from_pool(
 246             subnet_values=subnet_values, pool_values=pool_values)
 247         cidr = str(subnet['cidr'])
 248         self.assertEqual(pool_id, subnet['subnetpool_id'])
 249         self.assertTrue(cidr.endswith(str(self.max_prefixlen)))
 250
 251     @test.attr(type='smoke')
 252     @test.idempotent_id('49b44c64-1619-4b29-b527-ffc3c3115dc4')
 253     @test.requires_ext(extension='address-scope', service='network')
 254     def test_create_subnetpool_associate_address_scope(self):
 255         address_scope = self.create_address_scope(
 256             name=data_utils.rand_name('smoke-address-scope'),
 257             ip_version=self._ip_version)
 258         created_subnetpool = self._create_subnetpool(
 259             address_scope_id=address_scope['id'])
 260         body = self.client.show_subnetpool(created_subnetpool['id'])
 261         self.assertEqual(address_scope['id'],
 262                          body['subnetpool']['address_scope_id'])
 263
 264     @test.attr(type='smoke')
 265     @test.idempotent_id('910b6393-db24-4f6f-87dc-b36892ad6c8c')
 266     @test.requires_ext(extension='address-scope', service='network')
 267     def test_update_subnetpool_associate_address_scope(self):
 268         address_scope = self.create_address_scope(
 269             name=data_utils.rand_name('smoke-address-scope'),
 270             ip_version=self._ip_version)
 271         created_subnetpool = self._create_subnetpool()
 272         pool_id = created_subnetpool['id']
 273         body = self.client.show_subnetpool(pool_id)
 274         self.assertIsNone(body['subnetpool']['address_scope_id'])
 275         self.client.update_subnetpool(pool_id,
 276                                       address_scope_id=address_scope['id'])
 277         body = self.client.show_subnetpool(pool_id)
 278         self.assertEqual(address_scope['id'],
 279                          body['subnetpool']['address_scope_id'])
 280
 281     @test.attr(type='smoke')
 282     @test.idempotent_id('18302e80-46a3-4563-82ac-ccd1dd57f652')
 283     @test.requires_ext(extension='address-scope', service='network')
 284     def test_update_subnetpool_associate_another_address_scope(self):
 285         address_scope = self.create_address_scope(
 286             name=data_utils.rand_name('smoke-address-scope'),
 287             ip_version=self._ip_version)
 288         another_address_scope = self.create_address_scope(
 289             name=data_utils.rand_name('smoke-address-scope'),
 290             ip_version=self._ip_version)
 291         created_subnetpool = self._create_subnetpool(
 292             address_scope_id=address_scope['id'])
 293         pool_id = created_subnetpool['id']
 294         body = self.client.show_subnetpool(pool_id)
 295         self.assertEqual(address_scope['id'],
 296                          body['subnetpool']['address_scope_id'])
 297         self.client.update_subnetpool(
 298             pool_id, address_scope_id=another_address_scope['id'])
 299         body = self.client.show_subnetpool(pool_id)
 300         self.assertEqual(another_address_scope['id'],
 301                          body['subnetpool']['address_scope_id'])
 302
 303     @test.attr(type='smoke')
 304     @test.idempotent_id('f8970048-e41b-42d6-934b-a1297b07706a')
 305     @test.requires_ext(extension='address-scope', service='network')
 306     def test_update_subnetpool_disassociate_address_scope(self):
 307         address_scope = self.create_address_scope(
 308             name=data_utils.rand_name('smoke-address-scope'),
 309             ip_version=self._ip_version)
 310         created_subnetpool = self._create_subnetpool(
 311             address_scope_id=address_scope['id'])
 312         pool_id = created_subnetpool['id']
 313         body = self.client.show_subnetpool(pool_id)
 314         self.assertEqual(address_scope['id'],
 315                          body['subnetpool']['address_scope_id'])
 316         self.client.update_subnetpool(pool_id,
 317                                       address_scope_id=None)
 318         body = self.client.show_subnetpool(pool_id)
 319         self.assertIsNone(body['subnetpool']['address_scope_id'])
 320
 321
 322 class SubnetPoolsTestV6(SubnetPoolsTest):
 323
 324     min_prefixlen = '48'
 325     max_prefixlen = '64'
 326     _ip_version = 6
 327     subnet_cidr = '2001:db8:3::/64'
 328     new_prefix = u'2001:db8:5::/64'
 329     larger_prefix = u'2001:db8::/32'
 330
 331     @classmethod
 332     def resource_setup(cls):
 333         super(SubnetPoolsTestV6, cls).resource_setup()
 334         min_prefixlen = '64'
 335         prefixes = [u'2001:db8:3::/48']
 336         cls._subnetpool_data = {'min_prefixlen': min_prefixlen,
 337                                 'prefixes': prefixes}
 338
 339     @test.attr(type='smoke')
 340     @test.idempotent_id('f62d73dc-cf6f-4879-b94b-dab53982bf3b')
 341     def test_create_dual_stack_subnets_from_subnetpools(self):
 342         pool_id_v6, subnet_v6 = self._create_subnet_from_pool()
 343         pool_values_v4 = {'prefixes': ['192.168.0.0/16'],
 344                           'min_prefixlen': 21,
 345                           'max_prefixlen': 32}
 346         create_v4_subnetpool = self._create_subnetpool(**pool_values_v4)
 347         pool_id_v4 = create_v4_subnetpool['id']
 348         subnet_v4 = self.client.create_subnet(
 349             network_id=subnet_v6['network_id'], ip_version=4,
 350             subnetpool_id=pool_id_v4)['subnet']
 351         self.assertEqual(subnet_v4['network_id'], subnet_v6['network_id'])