cls.ethertype = "IPv" + str(cls._ip_version)
cls.address_scopes = []
cls.admin_address_scopes = []
+ cls.subnetpools = []
+ cls.admin_subnetpools = []
@classmethod
def resource_cleanup(cls):
cls._try_delete_resource(cls.admin_client.delete_network,
network['id'])
+ for subnetpool in cls.subnetpools:
+ cls._try_delete_resource(cls.client.delete_subnetpool,
+ subnetpool['id'])
+
+ for subnetpool in cls.admin_subnetpools:
+ cls._try_delete_resource(cls.admin_client.delete_subnetpool,
+ subnetpool['id'])
+
for address_scope in cls.address_scopes:
cls._try_delete_resource(cls.client.delete_address_scope,
address_scope['id'])
cls.address_scopes.append(body['address_scope'])
return body['address_scope']
+ @classmethod
+ def create_subnetpool(cls, name, is_admin=False, **kwargs):
+ if is_admin:
+ body = cls.admin_client.create_subnetpool(name=name, **kwargs)
+ cls.admin_subnetpools.append(body['subnetpool'])
+ else:
+ body = cls.client.create_subnetpool(name=name, **kwargs)
+ cls.subnetpools.append(body['subnetpool'])
+ return body['subnetpool']
+
class BaseAdminNetworkTest(BaseNetworkTest):
def test_delete_address_scope_associated_with_subnetpool(self):
address_scope = self._create_address_scope(ip_version=4)
prefixes = [u'10.11.12.0/24']
- subnetpool_data = {'subnetpool': {
+ subnetpool_data = {
'name': 'foo-subnetpool',
'min_prefixlen': '29', 'prefixes': prefixes,
- 'address_scope_id': address_scope['id']}}
- body = self.client.create_subnetpool(subnetpool_data)
- subnetpool = body['subnetpool']
- self.addCleanup(self.client.delete_subnetpool, subnetpool['id'])
+ 'address_scope_id': address_scope['id']}
+ self.create_subnetpool(**subnetpool_data)
self.assertRaises(lib_exc.Conflict, self.client.delete_address_scope,
address_scope['id'])
# License for the specific language governing permissions and limitations
# under the License.
-import copy
-
from tempest_lib.common.utils import data_utils
from neutron.tests.api import base
SUBNET_NAME = 'smoke-subnet'
-class SubnetPoolsTest(base.BaseNetworkTest):
+class SubnetPoolsTestBase(base.BaseNetworkTest):
+
+ @classmethod
+ def resource_setup(cls):
+ super(SubnetPoolsTestBase, cls).resource_setup()
+ min_prefixlen = '29'
+ prefixes = [u'10.11.12.0/24']
+ cls._subnetpool_data = {'prefixes': prefixes,
+ 'min_prefixlen': min_prefixlen}
+ try:
+ creds = cls.isolated_creds.get_admin_creds()
+ cls.os_adm = clients.Manager(credentials=creds)
+ except NotImplementedError:
+ msg = ("Missing Administrative Network API credentials "
+ "in configuration.")
+ raise cls.skipException(msg)
+ cls.admin_client = cls.os_adm.network_client
+
+ def _create_subnetpool(self, is_admin=False, **kwargs):
+ if 'name' not in kwargs:
+ name = data_utils.rand_name(SUBNETPOOL_NAME)
+ else:
+ name = kwargs.pop('name')
+
+ if 'prefixes' not in kwargs:
+ kwargs['prefixes'] = self._subnetpool_data['prefixes']
+
+ if 'min_prefixlen' not in kwargs:
+ kwargs['min_prefixlen'] = self._subnetpool_data['min_prefixlen']
+
+ return self.create_subnetpool(name=name, is_admin=is_admin, **kwargs)
+
+
+class SubnetPoolsTest(SubnetPoolsTestBase):
min_prefixlen = '28'
max_prefixlen = '31'
"""
- @classmethod
- def resource_setup(cls):
- super(SubnetPoolsTest, cls).resource_setup()
- prefixes = [u'10.11.12.0/24']
- cls._subnetpool_data = {'subnetpool': {'min_prefixlen': '29',
- 'prefixes': prefixes}}
- try:
- creds = cls.isolated_creds.get_admin_creds()
- cls.os_adm = clients.Manager(credentials=creds)
- except NotImplementedError:
- msg = ("Missing Administrative Network API credentials "
- "in configuration.")
- raise cls.skipException(msg)
- cls.admin_client = cls.os_adm.network_client
-
- def _create_subnetpool(self, client, pool_values=None):
- name = data_utils.rand_name(SUBNETPOOL_NAME)
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- if pool_values:
- subnetpool_data['subnetpool'].update(pool_values)
- subnetpool_data['subnetpool']['name'] = name
- body = client.create_subnetpool(subnetpool_data)
- created_subnetpool = body['subnetpool']
- subnetpool_id = created_subnetpool['id']
- return name, subnetpool_id
-
def _new_subnetpool_attributes(self):
new_name = data_utils.rand_name(SUBNETPOOL_NAME)
- subnetpool_data = {'subnetpool': {'name': new_name,
- 'min_prefixlen': self.min_prefixlen,
- 'max_prefixlen': self.max_prefixlen}}
- return subnetpool_data
+ return {'name': new_name, 'min_prefixlen': self.min_prefixlen,
+ 'max_prefixlen': self.max_prefixlen}
def _check_equality_updated_subnetpool(self, expected_values,
updated_pool):
@test.attr(type='smoke')
@test.idempotent_id('6e1781ec-b45b-4042-aebe-f485c022996e')
def test_create_list_subnetpool(self):
- name, pool_id = self._create_subnetpool(self.client)
+ created_subnetpool = self._create_subnetpool()
body = self.client.list_subnetpools()
subnetpools = body['subnetpools']
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- self.assertIn(pool_id, [sp['id'] for sp in subnetpools],
+ self.assertIn(created_subnetpool['id'],
+ [sp['id'] for sp in subnetpools],
"Created subnetpool id should be in the list")
- self.assertIn(name, [sp['name'] for sp in subnetpools],
+ self.assertIn(created_subnetpool['name'],
+ [sp['name'] for sp in subnetpools],
"Created subnetpool name should be in the list")
@test.attr(type='smoke')
@test.idempotent_id('741d08c2-1e3f-42be-99c7-0ea93c5b728c')
def test_get_subnetpool(self):
- name, pool_id = self._create_subnetpool(self.client)
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- prefixlen = self._subnetpool_data['subnetpool']['min_prefixlen']
- body = self.client.get_subnetpool(pool_id)
+ created_subnetpool = self._create_subnetpool()
+ prefixlen = self._subnetpool_data['min_prefixlen']
+ body = self.client.show_subnetpool(created_subnetpool['id'])
subnetpool = body['subnetpool']
- self.assertEqual(name, subnetpool['name'])
- self.assertEqual(pool_id, subnetpool['id'])
+ self.assertEqual(created_subnetpool['name'], subnetpool['name'])
+ self.assertEqual(created_subnetpool['id'], subnetpool['id'])
self.assertEqual(prefixlen, subnetpool['min_prefixlen'])
self.assertEqual(prefixlen, subnetpool['default_prefixlen'])
self.assertFalse(subnetpool['shared'])
@test.attr(type='smoke')
@test.idempotent_id('764f1b93-1c4a-4513-9e7b-6c2fc5e9270c')
def test_tenant_update_subnetpool(self):
- name, pool_id = self._create_subnetpool(self.client)
+ created_subnetpool = self._create_subnetpool()
+ pool_id = created_subnetpool['id']
subnetpool_data = self._new_subnetpool_attributes()
- self.client.update_subnetpool(pool_id, subnetpool_data)
+ self.client.update_subnetpool(created_subnetpool['id'],
+ **subnetpool_data)
- body = self.client.get_subnetpool(pool_id)
+ body = self.client.show_subnetpool(pool_id)
subnetpool = body['subnetpool']
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- self._check_equality_updated_subnetpool(subnetpool_data['subnetpool'],
+ self._check_equality_updated_subnetpool(subnetpool_data,
subnetpool)
self.assertFalse(subnetpool['shared'])
@test.idempotent_id('4b496082-c992-4319-90be-d4a7ce646290')
def test_update_subnetpool_prefixes_append(self):
# We can append new prefixes to subnetpool
- name, pool_id = self._create_subnetpool(self.client)
- old_prefixes = self._subnetpool_data['subnetpool']['prefixes']
+ create_subnetpool = self._create_subnetpool()
+ pool_id = create_subnetpool['id']
+ old_prefixes = self._subnetpool_data['prefixes']
new_prefixes = old_prefixes[:]
new_prefixes.append(self.new_prefix)
- subnetpool_data = {'subnetpool': {'prefixes': new_prefixes}}
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- self.client.update_subnetpool(pool_id, subnetpool_data)
- body = self.client.get_subnetpool(pool_id)
+ subnetpool_data = {'prefixes': new_prefixes}
+ self.client.update_subnetpool(pool_id, **subnetpool_data)
+ body = self.client.show_subnetpool(pool_id)
prefixes = body['subnetpool']['prefixes']
self.assertIn(self.new_prefix, prefixes)
self.assertIn(old_prefixes[0], prefixes)
@test.idempotent_id('2cae5d6a-9d32-42d8-8067-f13970ae13bb')
def test_update_subnetpool_prefixes_extend(self):
# We can extend current subnetpool prefixes
- name, pool_id = self._create_subnetpool(self.client)
- old_prefixes = self._subnetpool_data['subnetpool']['prefixes']
- subnetpool_data = {'subnetpool': {'prefixes': [self.larger_prefix]}}
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- self.client.update_subnetpool(pool_id, subnetpool_data)
- body = self.client.get_subnetpool(pool_id)
+ created_subnetpool = self._create_subnetpool()
+ pool_id = created_subnetpool['id']
+ old_prefixes = self._subnetpool_data['prefixes']
+ subnetpool_data = {'prefixes': [self.larger_prefix]}
+ self.client.update_subnetpool(pool_id, **subnetpool_data)
+ body = self.client.show_subnetpool(pool_id)
prefixes = body['subnetpool']['prefixes']
self.assertIn(self.larger_prefix, prefixes)
self.assertNotIn(old_prefixes[0], prefixes)
@test.attr(type='smoke')
@test.idempotent_id('d70c6c35-913b-4f24-909f-14cd0d29b2d2')
def test_admin_create_shared_subnetpool(self):
- pool_values = {'shared': 'True'}
- name, pool_id = self._create_subnetpool(self.admin_client,
- pool_values)
+ created_subnetpool = self._create_subnetpool(is_admin=True,
+ shared=True)
+ pool_id = created_subnetpool['id']
# Shared subnetpool can be retrieved by tenant user.
- body = self.client.get_subnetpool(pool_id)
- self.addCleanup(self.admin_client.delete_subnetpool, pool_id)
+ body = self.client.show_subnetpool(pool_id)
subnetpool = body['subnetpool']
- self.assertEqual(name, subnetpool['name'])
+ self.assertEqual(created_subnetpool['name'], subnetpool['name'])
self.assertTrue(subnetpool['shared'])
def _create_subnet_from_pool(self, subnet_values=None, pool_values=None):
- pool_name, pool_id = self._create_subnetpool(self.client, pool_values)
+ if pool_values is None:
+ pool_values = {}
+
+ created_subnetpool = self._create_subnetpool(**pool_values)
+ pool_id = created_subnetpool['id']
subnet_name = data_utils.rand_name(SUBNETPOOL_NAME)
network = self.create_network()
- network_id = network['id']
- kwargs = {'name': subnet_name,
- 'subnetpool_id': pool_id}
+ subnet_kwargs = {'name': subnet_name,
+ 'subnetpool_id': pool_id}
if subnet_values:
- kwargs.update(subnet_values)
+ subnet_kwargs.update(subnet_values)
+ # not creating the subnet using the base.create_subnet because
+ # that function needs to be enhanced to support subnet_create when
+ # prefixlen and subnetpool_id is specified.
body = self.client.create_subnet(
- network_id=network_id,
+ network_id=network['id'],
ip_version=self._ip_version,
- **kwargs)
+ **subnet_kwargs)
subnet = body['subnet']
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- self.addCleanup(self.client.delete_network, network_id)
return pool_id, subnet
@test.attr(type='smoke')
@test.idempotent_id('1362ed7d-3089-42eb-b3a5-d6cb8398ee77')
def test_create_subnet_from_pool_with_prefixlen(self):
subnet_values = {"prefixlen": self.max_prefixlen}
- pool_id, subnet = self._create_subnet_from_pool(subnet_values)
+ pool_id, subnet = self._create_subnet_from_pool(
+ subnet_values=subnet_values)
cidr = str(subnet['cidr'])
self.assertEqual(pool_id, subnet['subnetpool_id'])
self.assertTrue(cidr.endswith(str(self.max_prefixlen)))
@test.idempotent_id('86b86189-9789-4582-9c3b-7e2bfe5735ee')
def test_create_subnet_from_pool_with_subnet_cidr(self):
subnet_values = {"cidr": self.subnet_cidr}
- pool_id, subnet = self._create_subnet_from_pool(subnet_values)
+ pool_id, subnet = self._create_subnet_from_pool(
+ subnet_values=subnet_values)
cidr = str(subnet['cidr'])
self.assertEqual(pool_id, subnet['subnetpool_id'])
self.assertEqual(cidr, self.subnet_cidr)
pool_id, subnet = self._create_subnet_from_pool()
cidr = str(subnet['cidr'])
self.assertEqual(pool_id, subnet['subnetpool_id'])
- prefixlen = self._subnetpool_data['subnetpool']['min_prefixlen']
+ prefixlen = self._subnetpool_data['min_prefixlen']
self.assertTrue(cidr.endswith(str(prefixlen)))
@test.attr(type='smoke')
def test_create_subnet_from_pool_with_quota(self):
pool_values = {'default_quota': 4}
subnet_values = {"prefixlen": self.max_prefixlen}
- pool_id, subnet = self._create_subnet_from_pool(subnet_values,
- pool_values)
+ pool_id, subnet = self._create_subnet_from_pool(
+ subnet_values=subnet_values, pool_values=pool_values)
cidr = str(subnet['cidr'])
self.assertEqual(pool_id, subnet['subnetpool_id'])
self.assertTrue(cidr.endswith(str(self.max_prefixlen)))
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'),
ip_version=self._ip_version)
- name, pool_id = self._create_subnetpool(
- self.client, pool_values={'address_scope_id': address_scope['id']})
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- body = self.client.get_subnetpool(pool_id)
+ created_subnetpool = self._create_subnetpool(
+ address_scope_id=address_scope['id'])
+ body = self.client.show_subnetpool(created_subnetpool['id'])
self.assertEqual(address_scope['id'],
body['subnetpool']['address_scope_id'])
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'),
ip_version=self._ip_version)
- name, pool_id = self._create_subnetpool(self.client)
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- body = self.client.get_subnetpool(pool_id)
+ created_subnetpool = self._create_subnetpool()
+ pool_id = created_subnetpool['id']
+ body = self.client.show_subnetpool(pool_id)
self.assertIsNone(body['subnetpool']['address_scope_id'])
- subnetpool_data = {'subnetpool': {'address_scope_id':
- address_scope['id']}}
- self.client.update_subnetpool(pool_id, subnetpool_data)
- body = self.client.get_subnetpool(pool_id)
+ self.client.update_subnetpool(pool_id,
+ address_scope_id=address_scope['id'])
+ body = self.client.show_subnetpool(pool_id)
self.assertEqual(address_scope['id'],
body['subnetpool']['address_scope_id'])
another_address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'),
ip_version=self._ip_version)
- name, pool_id = self._create_subnetpool(
- self.client, pool_values={'address_scope_id':
- address_scope['id']})
- self.addCleanup(self.client.delete_subnetpool, pool_id)
-
- body = self.client.get_subnetpool(pool_id)
+ created_subnetpool = self._create_subnetpool(
+ address_scope_id=address_scope['id'])
+ pool_id = created_subnetpool['id']
+ body = self.client.show_subnetpool(pool_id)
self.assertEqual(address_scope['id'],
body['subnetpool']['address_scope_id'])
- subnetpool_data = {'subnetpool': {'address_scope_id':
- another_address_scope['id']}}
- self.client.update_subnetpool(pool_id, subnetpool_data)
- body = self.client.get_subnetpool(pool_id)
+ self.client.update_subnetpool(
+ pool_id, address_scope_id=another_address_scope['id'])
+ body = self.client.show_subnetpool(pool_id)
self.assertEqual(another_address_scope['id'],
body['subnetpool']['address_scope_id'])
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'),
ip_version=self._ip_version)
- name, pool_id = self._create_subnetpool(
- self.client, pool_values={'address_scope_id': address_scope['id']})
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- body = self.client.get_subnetpool(pool_id)
+ created_subnetpool = self._create_subnetpool(
+ address_scope_id=address_scope['id'])
+ pool_id = created_subnetpool['id']
+ body = self.client.show_subnetpool(pool_id)
self.assertEqual(address_scope['id'],
body['subnetpool']['address_scope_id'])
- subnetpool_data = {'subnetpool': {'address_scope_id': None}}
- self.client.update_subnetpool(pool_id, subnetpool_data)
- body = self.client.get_subnetpool(pool_id)
+ self.client.update_subnetpool(pool_id,
+ address_scope_id=None)
+ body = self.client.show_subnetpool(pool_id)
self.assertIsNone(body['subnetpool']['address_scope_id'])
super(SubnetPoolsTestV6, cls).resource_setup()
min_prefixlen = '64'
prefixes = [u'2001:db8:3::/48']
- cls._subnetpool_data = {'subnetpool': {'min_prefixlen': min_prefixlen,
- 'prefixes': prefixes}}
+ cls._subnetpool_data = {'min_prefixlen': min_prefixlen,
+ 'prefixes': prefixes}
@test.attr(type='smoke')
@test.idempotent_id('f62d73dc-cf6f-4879-b94b-dab53982bf3b')
def test_create_dual_stack_subnets_from_subnetpools(self):
pool_id_v6, subnet_v6 = self._create_subnet_from_pool()
- self.addCleanup(self.client.delete_subnet, subnet_v6['id'])
pool_values_v4 = {'prefixes': ['192.168.0.0/16'],
'min_prefixlen': 21,
'max_prefixlen': 32}
- pool_name_v4, pool_id_v4 = self._create_subnetpool(self.client,
- pool_values=pool_values_v4)
+ create_v4_subnetpool = self._create_subnetpool(**pool_values_v4)
+ pool_id_v4 = create_v4_subnetpool['id']
subnet_v4 = self.client.create_subnet(
- network_id=subnet_v6['network_id'],
- ip_version=4,
- subnetpool_id=pool_id_v4)['subnet']
- self.addCleanup(self.client.delete_subnet, subnet_v4['id'])
+ network_id=subnet_v6['network_id'], ip_version=4,
+ subnetpool_id=pool_id_v4)['subnet']
self.assertEqual(subnet_v4['network_id'], subnet_v6['network_id'])
# License for the specific language governing permissions and limitations
# under the License.
-import copy
+import netaddr
import uuid
from tempest_lib.common.utils import data_utils
from tempest_lib import exceptions as lib_exc
-from neutron.tests.api import base
-from neutron.tests.api import clients
+from neutron.tests.api import test_subnetpools
from neutron.tests.tempest import config
from neutron.tests.tempest import test
SUBNETPOOL_NAME = 'smoke-subnetpool'
-class SubnetPoolsNegativeTestJSON(base.BaseNetworkTest):
+class SubnetPoolsNegativeTestJSON(test_subnetpools.SubnetPoolsTestBase):
smaller_prefix = u'10.11.12.0/26'
- @classmethod
- def resource_setup(cls):
- super(SubnetPoolsNegativeTestJSON, cls).resource_setup()
- min_prefixlen = '29'
- prefixes = [u'10.11.12.0/24']
- name = data_utils.rand_name(SUBNETPOOL_NAME)
- cls._subnetpool_data = {'subnetpool': {'name': name,
- 'prefixes': prefixes,
- 'min_prefixlen': min_prefixlen}}
- try:
- creds = cls.isolated_creds.get_admin_creds()
- cls.os_adm = clients.Manager(credentials=creds)
- except NotImplementedError:
- msg = ("Missing Administrative Network API credentials "
- "in configuration.")
- raise cls.skipException(msg)
- cls.admin_client = cls.os_adm.network_client
-
- def _create_subnetpool(self, client, pool_values=None):
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- if pool_values:
- subnetpool_data['subnetpool'].update(pool_values)
- body = client.create_subnetpool(subnetpool_data)
- created_subnetpool = body['subnetpool']
- subnetpool_id = created_subnetpool['id']
- return subnetpool_id
-
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('0212a042-603a-4f46-99e0-e37de9374d30')
def test_get_non_existent_subnetpool(self):
non_exist_id = data_utils.rand_name('subnetpool')
- self.assertRaises(lib_exc.NotFound, self.client.get_subnetpool,
+ self.assertRaises(lib_exc.NotFound, self.client.show_subnetpool,
non_exist_id)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('dc9336e5-f28f-4658-a0b0-cc79e607007d')
def test_tenant_get_not_shared_admin_subnetpool(self):
- pool_id = self._create_subnetpool(self.admin_client)
- self.addCleanup(self.admin_client.delete_subnetpool, pool_id)
+ created_subnetpool = self._create_subnetpool(is_admin=True)
# None-shared admin subnetpool cannot be retrieved by tenant user.
- self.assertRaises(lib_exc.NotFound, self.client.get_subnetpool,
- pool_id)
+ self.assertRaises(lib_exc.NotFound, self.client.show_subnetpool,
+ created_subnetpool['id'])
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('5e1f2f86-d81a-498c-82ed-32a49f4dc4d3')
@test.idempotent_id('d1143fe2-212b-4e23-a308-d18f7d8d78d6')
def test_tenant_create_shared_subnetpool(self):
# 'shared' subnetpool can only be created by admin.
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- subnetpool_data['subnetpool']['shared'] = 'True'
- self.assertRaises(lib_exc.Forbidden, self.client.create_subnetpool,
- subnetpool_data)
+ self.assertRaises(lib_exc.Forbidden, self._create_subnetpool,
+ is_admin=False, shared=True)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('4be84d30-60ca-4bd3-8512-db5b36ce1378')
def test_update_non_existent_subnetpool(self):
non_exist_id = data_utils.rand_name('subnetpool')
self.assertRaises(lib_exc.NotFound, self.client.update_subnetpool,
- non_exist_id, self._subnetpool_data)
+ non_exist_id, name='foo-name')
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('e6cd6d87-6173-45dd-bf04-c18ea7ec7537')
def test_update_subnetpool_not_modifiable_shared(self):
# 'shared' attributes can be specified during creation.
# But this attribute is not modifiable after creation.
- pool_id = self._create_subnetpool(self.admin_client)
- self.addCleanup(self.admin_client.delete_subnetpool, pool_id)
- subnetpool_data = {'subnetpool': {'shared': True}}
+ created_subnetpool = self._create_subnetpool(is_admin=True)
+ pool_id = created_subnetpool['id']
self.assertRaises(lib_exc.BadRequest, self.client.update_subnetpool,
- pool_id, subnetpool_data)
+ pool_id, shared=True)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('62f7c43b-bff1-4def-8bb7-4754b840aaad')
def test_update_subnetpool_prefixes_shrink(self):
# Shrink current subnetpool prefixes is not supported
- pool_id = self._create_subnetpool(self.client)
- subnetpool_data = {'subnetpool': {'prefixes': [self.smaller_prefix]}}
- self.addCleanup(self.client.delete_subnetpool, pool_id)
+ created_subnetpool = self._create_subnetpool()
self.assertRaises(lib_exc.BadRequest,
self.client.update_subnetpool,
- pool_id, subnetpool_data)
+ created_subnetpool['id'],
+ prefixes=[self.smaller_prefix])
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('fc011824-153e-4469-97ad-9808eb88cae1')
def test_create_subnet_different_pools_same_network(self):
network = self.create_network(network_name='smoke-network')
- subnetpool_data = {'prefixes': ['192.168.0.0/16'],
- 'name': 'test-pool'}
- pool_id = self._create_subnetpool(self.admin_client, subnetpool_data)
- subnet = self.admin_client.create_subnet(
- network_id=network['id'],
- cidr='10.10.10.0/24',
- ip_version=4,
- gateway_ip=None)
- subnet_id = subnet['subnet']['id']
- self.addCleanup(self.admin_client.delete_subnet, subnet_id)
- self.addCleanup(self.admin_client.delete_subnetpool, pool_id)
- self.assertRaises(lib_exc.BadRequest,
- self.admin_client.create_subnet,
- network_id=network['id'],
+ created_subnetpool = self._create_subnetpool(
+ is_admin=True, prefixes=['192.168.0.0/16'])
+ subnet = self.create_subnet(
+ network, cidr=netaddr.IPNetwork('10.10.10.0/24'), ip_version=4,
+ gateway=None, client=self.admin_client)
+ # add the subnet created by admin to the cleanUp because the
+ # the base.py doesn't delete it using the admin client
+ self.addCleanup(self.admin_client.delete_subnet, subnet['id'])
+ self.assertRaises(lib_exc.BadRequest, self.create_subnet, network,
ip_version=4,
- subnetpool_id=pool_id)
+ subnetpool_id=created_subnetpool['id'],
+ client=self.admin_client)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('9589e332-638e-476e-81bd-013d964aa3cb')
@test.requires_ext(extension='address-scope', service='network')
def test_create_subnetpool_associate_invalid_address_scope(self):
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- subnetpool_data['subnetpool']['address_scope_id'] = 'foo-addr-scope'
- self.assertRaises(lib_exc.BadRequest, self.client.create_subnetpool,
- subnetpool_data)
+ self.assertRaises(lib_exc.BadRequest, self._create_subnetpool,
+ address_scope_id='foo-addr-scope')
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('3b6c5942-485d-4964-a560-55608af020b5')
@test.requires_ext(extension='address-scope', service='network')
def test_create_subnetpool_associate_non_exist_address_scope(self):
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- non_exist_address_scope_id = str(uuid.uuid4())
- subnetpool_data['subnetpool']['address_scope_id'] = (
- non_exist_address_scope_id)
- self.assertRaises(lib_exc.NotFound, self.client.create_subnetpool,
- subnetpool_data)
+ self.assertRaises(lib_exc.NotFound, self._create_subnetpool,
+ address_scope_id=str(uuid.uuid4()))
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('2dfb4269-8657-485a-a053-b022e911456e')
name=data_utils.rand_name('smoke-address-scope'),
ip_version=4)
addr_scope_id = address_scope['id']
- pool_id = self._create_subnetpool(
- self.client, pool_values={'address_scope_id': addr_scope_id})
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- subnetpool_data = {'subnetpool': {'name': 'foo-subnetpool',
- 'prefixes': [u'10.11.12.13/24'],
- 'min_prefixlen': '29',
- 'address_scope_id': addr_scope_id}}
- self.assertRaises(lib_exc.Conflict, self.client.create_subnetpool,
- subnetpool_data)
+ self._create_subnetpool(address_scope_id=addr_scope_id)
+ subnetpool_data = {'name': 'foo-subnetpool',
+ 'prefixes': [u'10.11.12.13/24'],
+ 'min_prefixlen': '29',
+ 'address_scope_id': addr_scope_id}
+ self.assertRaises(lib_exc.Conflict, self._create_subnetpool,
+ **subnetpool_data)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('83a19a13-5384-42e2-b579-43fc69c80914')
name=data_utils.rand_name('smoke-address-scope'),
ip_version=4)
addr_scope_id = address_scope['id']
- pool_values = {'address_scope_id': addr_scope_id,
- 'prefixes': [u'20.0.0.0/18', u'30.0.0.0/18']}
-
- pool_id = self._create_subnetpool(
- self.client, pool_values=pool_values)
- self.addCleanup(self.client.delete_subnetpool, pool_id)
+ self._create_subnetpool(prefixes=[u'20.0.0.0/18', u'30.0.0.0/18'],
+ address_scope_id=addr_scope_id)
prefixes = [u'40.0.0.0/18', u'50.0.0.0/18', u'30.0.0.0/12']
- subnetpool_data = {'subnetpool': {'name': 'foo-subnetpool',
- 'prefixes': prefixes,
- 'min_prefixlen': '29',
- 'address_scope_id': addr_scope_id}}
- self.assertRaises(lib_exc.Conflict, self.client.create_subnetpool,
- subnetpool_data)
+ subnetpool_data = {'name': 'foo-subnetpool',
+ 'prefixes': prefixes,
+ 'min_prefixlen': '29',
+ 'address_scope_id': addr_scope_id}
+ self.assertRaises(lib_exc.Conflict, self._create_subnetpool,
+ **subnetpool_data)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('f06d8e7b-908b-4e94-b570-8156be6a4bf1')
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'), is_admin=True,
ip_version=4)
- address_scope_id = address_scope['id']
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- subnetpool_data['subnetpool']['address_scope_id'] = address_scope_id
- self.assertRaises(lib_exc.NotFound, self.client.create_subnetpool,
- subnetpool_data)
+ self.assertRaises(lib_exc.NotFound, self._create_subnetpool,
+ address_scope_id=address_scope['id'])
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('3396ec6c-cb80-4ebe-b897-84e904580bdf')
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'), is_admin=True,
shared=True, ip_version=4)
- subnetpool_data = copy.deepcopy(self._subnetpool_data)
- subnetpool_data['subnetpool']['address_scope_id'] = (
- address_scope['id'])
- self.assertRaises(lib_exc.BadRequest, self.client.create_subnetpool,
- subnetpool_data)
+ self.assertRaises(lib_exc.BadRequest, self._create_subnetpool,
+ address_scope_id=address_scope['id'])
@test.attr(type='smoke')
@test.idempotent_id('6d3d9ad5-32d4-4d63-aa00-8c62f73e2881')
name=data_utils.rand_name('smoke-address-scope'), is_admin=True,
ip_version=4)
address_scope_id = address_scope['id']
- pool_id = self._create_subnetpool(self.client)
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- subnetpool_data = {'subnetpool': {'address_scope_id':
- address_scope_id}}
+ created_subbnetpool = self._create_subnetpool(self.client)
self.assertRaises(lib_exc.NotFound, self.client.update_subnetpool,
- pool_id, subnetpool_data)
+ created_subbnetpool['id'],
+ address_scope_id=address_scope_id)
def _test_update_subnetpool_prefix_intersect_helper(
self, pool_1_prefixes, pool_2_prefixes, pool_1_updated_prefixes):
addr_scope_id = address_scope['id']
pool_values = {'address_scope_id': addr_scope_id,
'prefixes': pool_1_prefixes}
- pool_id_1 = self._create_subnetpool(self.client,
- pool_values=pool_values)
- self.addCleanup(self.client.delete_subnetpool, pool_id_1)
+ created_subnetpool_1 = self._create_subnetpool(**pool_values)
+ pool_id_1 = created_subnetpool_1['id']
pool_values = {'address_scope_id': addr_scope_id,
'prefixes': pool_2_prefixes}
- pool_id_2 = self._create_subnetpool(self.client,
- pool_values=pool_values)
-
- self.addCleanup(self.client.delete_subnetpool, pool_id_2)
-
+ self._create_subnetpool(**pool_values)
# now update the pool_id_1 with the prefix intersecting with
# pool_id_2
- subnetpool_data = {'subnetpool': {'prefixes':
- pool_1_updated_prefixes}}
self.assertRaises(lib_exc.Conflict, self.client.update_subnetpool,
- pool_id_1, subnetpool_data)
+ pool_id_1, prefixes=pool_1_updated_prefixes)
@test.attr(type=['negative', 'smoke'])
@test.idempotent_id('96006292-7214-40e0-a471-153fb76e6b31')
addr_scope_id = address_scope['id']
pool_values = {'prefixes': [u'20.0.0.0/18', u'30.0.0.0/18']}
- pool_id = self._create_subnetpool(
- self.client, pool_values=pool_values)
- self.addCleanup(self.client.delete_subnetpool, pool_id)
-
+ created_subnetpool = self._create_subnetpool(**pool_values)
+ pool_id = created_subnetpool['id']
# associate the subnetpool to the address scope as an admin
- subnetpool_data = {'subnetpool': {'address_scope_id':
- addr_scope_id}}
- self.admin_client.update_subnetpool(pool_id, subnetpool_data)
- body = self.admin_client.get_subnetpool(pool_id)
+ self.admin_client.update_subnetpool(pool_id,
+ address_scope_id=addr_scope_id)
+ body = self.admin_client.show_subnetpool(pool_id)
self.assertEqual(addr_scope_id,
body['subnetpool']['address_scope_id'])
# updating the subnetpool prefix by the tenant user should fail
# since the tenant is not the owner of address scope
update_prefixes = [u'20.0.0.0/18', u'30.0.0.0/18', u'40.0.0.0/18']
- subnetpool_data = {'subnetpool': {'prefixes': update_prefixes}}
self.assertRaises(lib_exc.BadRequest, self.client.update_subnetpool,
- pool_id, subnetpool_data)
+ pool_id, prefixes=update_prefixes)
# admin can update the prefixes
- self.admin_client.update_subnetpool(pool_id, subnetpool_data)
- body = self.admin_client.get_subnetpool(pool_id)
+ self.admin_client.update_subnetpool(pool_id, prefixes=update_prefixes)
+ body = self.admin_client.show_subnetpool(pool_id)
self.assertEqual(update_prefixes,
body['subnetpool']['prefixes'])
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'),
ip_version=6)
- pool_id = self._create_subnetpool(self.client)
- self.addCleanup(self.client.delete_subnetpool, pool_id)
- subnetpool_data = {'subnetpool': {'address_scope_id':
- address_scope['id']}}
+ created_subnetpool = self._create_subnetpool()
self.assertRaises(lib_exc.BadRequest, self.client.update_subnetpool,
- pool_id, subnetpool_data)
+ created_subnetpool['id'],
+ address_scope_id=address_scope['id'])
return method_functors[index](name[prefix_len:])
raise AttributeError(name)
- # Subnetpool methods
- def create_subnetpool(self, post_data):
- body = self.serialize_list(post_data, "subnetpools", "subnetpool")
- uri = self.get_uri("subnetpools")
- resp, body = self.post(uri, body)
- body = {'subnetpool': self.deserialize_list(body)}
- self.expected_success(201, resp.status)
- return service_client.ResponseBody(resp, body)
-
- def get_subnetpool(self, id):
- uri = self.get_uri("subnetpools")
- subnetpool_uri = '%s/%s' % (uri, id)
- resp, body = self.get(subnetpool_uri)
- body = {'subnetpool': self.deserialize_list(body)}
- self.expected_success(200, resp.status)
- return service_client.ResponseBody(resp, body)
-
- def delete_subnetpool(self, id):
- uri = self.get_uri("subnetpools")
- subnetpool_uri = '%s/%s' % (uri, id)
- resp, body = self.delete(subnetpool_uri)
- self.expected_success(204, resp.status)
- return service_client.ResponseBody(resp, body)
-
- def list_subnetpools(self):
- uri = self.get_uri("subnetpools")
- resp, body = self.get(uri)
- body = {'subnetpools': self.deserialize_list(body)}
- self.expected_success(200, resp.status)
- return service_client.ResponseBody(resp, body)
-
- def update_subnetpool(self, id, post_data):
- body = self.serialize_list(post_data, "subnetpools", "subnetpool")
- uri = self.get_uri("subnetpools")
- subnetpool_uri = '%s/%s' % (uri, id)
- resp, body = self.put(subnetpool_uri, body)
- body = {'subnetpool': self.deserialize_list(body)}
- self.expected_success(200, resp.status)
- return service_client.ResponseBody(resp, body)
-
# Common methods that are hard to automate
def create_bulk_network(self, names, shared=False):
network_list = [{'name': name, 'shared': shared} for name in names]
Code Review / openstack-build / neutron-build.git / commitdiff