def test_create_limit_return_count(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
r = self.post(
'/limits',
body={'limits': [ref1]},
expected_status=http_client.CREATED)
limits = r.result['limits']
self.assertEqual(1, len(limits))
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='snapshot')
ref3 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='backup')
r = self.post(
'/limits',
body={'limits': [ref2, ref3]},
expected_status=http_client.CREATED)
limits = r.result['limits']
self.assertEqual(2, len(limits))
def test_create_limit(self):
# create one, return it.
limit_1 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex,
description='test description')
limits = PROVIDERS.unified_limit_api.create_limits([limit_1])
self.assertDictEqual(limit_1, limits[0])
# create another two, return them.
limit_2 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot',
resource_limit=5,
id=uuid.uuid4().hex)
limit_3 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='backup',
resource_limit=5,
id=uuid.uuid4().hex)
limits = PROVIDERS.unified_limit_api.create_limits([limit_2, limit_3])
for limit in limits:
if limit['id'] == limit_2['id']:
self.assertDictEqual(limit_2, limit)
if limit['id'] == limit_3['id']:
self.assertDictEqual(limit_3, limit)
def test_create_project_limit(self):
# create one, return it.
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex,
description='test description',
domain_id=None)
limits = PROVIDERS.unified_limit_api.create_limits([limit_1])
self.assertDictEqual(limit_1, limits[0])
# create another two, return them.
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex,
domain_id=None)
limit_3 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='backup', resource_limit=5, id=uuid.uuid4().hex,
domain_id=None)
limits = PROVIDERS.unified_limit_api.create_limits([limit_2, limit_3])
for limit in limits:
if limit['id'] == limit_2['id']:
self.assertDictEqual(limit_2, limit)
if limit['id'] == limit_3['id']:
self.assertDictEqual(limit_3, limit)
def test_update_limit(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
expect_limit = 8
limit_update = {'id': limit_1['id'],
'resource_limit': expect_limit}
res = PROVIDERS.unified_limit_api.update_limit(limit_1['id'],
limit_update)
self.assertEqual(expect_limit, res['resource_limit'])
# 'id' can be omitted in the update body
limit_update = {'resource_limit': expect_limit}
res = PROVIDERS.unified_limit_api.update_limit(limit_2['id'],
limit_update)
self.assertEqual(expect_limit, res['resource_limit'])
def test_list_limits(self):
# create two limits
limit_1 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot',
resource_limit=5,
id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# list
hints = driver_hints.Hints()
hints.add_filter('project_id', self.tenant_bar['id'])
limits = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(2, len(limits))
for re in limits:
if re['id'] == limit_1['id']:
self.assertDictEqual(limit_1, re)
if re['id'] == limit_2['id']:
self.assertDictEqual(limit_2, re)
def test_list_limit_by_filter(self):
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
hints = driver_hints.Hints()
hints.add_filter('service_id', self.service_one['id'])
hints.add_filter('project_id', self.tenant_bar['id'])
res = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(2, len(res))
hints = driver_hints.Hints()
hints.add_filter('region_id', self.region_one['id'])
hints.add_filter('project_id', self.tenant_bar['id'])
res = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(1, len(res))
self.assertDictEqual(limit_1, res[0])
hints = driver_hints.Hints()
hints.add_filter('resource_name', 'backup')
hints.add_filter('project_id', self.tenant_bar['id'])
res = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(0, len(res))
def test_update_limit(self):
# create two limits
limit_1 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot',
resource_limit=5,
id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
expect_limit = 8
limit_update = {'id': limit_1['id'], 'resource_limit': expect_limit}
res = PROVIDERS.unified_limit_api.update_limit(limit_1['id'],
limit_update)
self.assertEqual(expect_limit, res['resource_limit'])
# 'id' can be omitted in the update body
limit_update = {'resource_limit': expect_limit}
res = PROVIDERS.unified_limit_api.update_limit(limit_2['id'],
limit_update)
self.assertEqual(expect_limit, res['resource_limit'])
def test_list_limit_by_filter(self):
limit_1 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot',
resource_limit=10,
id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
hints = driver_hints.Hints()
hints.add_filter('service_id', self.service_one['id'])
hints.add_filter('project_id', self.tenant_bar['id'])
res = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(2, len(res))
hints = driver_hints.Hints()
hints.add_filter('region_id', self.region_one['id'])
hints.add_filter('project_id', self.tenant_bar['id'])
res = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(1, len(res))
self.assertDictEqual(limit_1, res[0])
hints = driver_hints.Hints()
hints.add_filter('resource_name', 'backup')
hints.add_filter('project_id', self.tenant_bar['id'])
res = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(0, len(res))
def test_list_limit_by_limit(self):
self.config_fixture.config(list_limit=1)
# create two limits
limit_1 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot',
resource_limit=5,
id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# list, limit is 1
hints = driver_hints.Hints()
limits = PROVIDERS.unified_limit_api.list_limits(hints=hints)
self.assertEqual(1, len(limits))
if limits[0]['id'] == limit_1['id']:
self.assertDictEqual(limit_1, limits[0])
else:
self.assertDictEqual(limit_2, limits[0])
def test_list_limit_by_limit(self):
self.config_fixture.config(list_limit=1)
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex,
domain_id=None)
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex,
domain_id=None)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# list, limit is 1
hints = driver_hints.Hints()
limits = PROVIDERS.unified_limit_api.list_limits(hints=hints)
self.assertEqual(1, len(limits))
if limits[0]['id'] == limit_1['id']:
self.assertDictEqual(limit_1, limits[0])
else:
self.assertDictEqual(limit_2, limits[0])
def test_update_multi_limit(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
resource_limit=10)
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot',
resource_limit=10)
r = self.post('/limits',
body={'limits': [ref, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
update_ref = {'id': id1, 'resource_limit': 5}
update_ref2 = {'id': r.result['limits'][1]['id'], 'resource_limit': 6}
r = self.put('/limits',
body={'limits': [update_ref, update_ref2]},
expected_status=http_client.OK)
new_limits = r.result['limits']
for limit in new_limits:
if limit['id'] == id1:
self.assertEqual(limit['resource_limit'],
update_ref['resource_limit'])
else:
self.assertEqual(limit['resource_limit'],
update_ref2['resource_limit'])
def test_delete_registered_limit_when_reference_limit_exist(self):
registered_limit_1 = unit.new_registered_limit_ref(
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', default_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit_1])
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1])
self.assertRaises(exception.RegisteredLimitError,
PROVIDERS.unified_limit_api.delete_registered_limit,
registered_limit_1['id'])
registered_limit_2 = unit.new_registered_limit_ref(
service_id=self.service_one['id'],
resource_name='volume', default_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit_2])
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_2])
self.assertRaises(exception.RegisteredLimitError,
PROVIDERS.unified_limit_api.delete_registered_limit,
registered_limit_2['id'])
def test_list_limits(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex,
domain_id=None)
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex,
domain_id=None)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# list
hints = driver_hints.Hints()
hints.add_filter('project_id', self.project_bar['id'])
limits = PROVIDERS.unified_limit_api.list_limits(hints)
self.assertEqual(2, len(limits))
for re in limits:
if re['id'] == limit_1['id']:
self.assertDictEqual(limit_1, re)
if re['id'] == limit_2['id']:
self.assertDictEqual(limit_2, re)
def test_delete_registered_limit_when_reference_limit_exist(self):
registered_limit_1 = unit.new_registered_limit_ref(
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', default_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit_1])
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1])
self.assertRaises(exception.RegisteredLimitError,
PROVIDERS.unified_limit_api.delete_registered_limit,
registered_limit_1['id'])
registered_limit_2 = unit.new_registered_limit_ref(
service_id=self.service_one['id'],
resource_name='volume', default_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit_2])
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_2])
self.assertRaises(exception.RegisteredLimitError,
PROVIDERS.unified_limit_api.delete_registered_limit,
registered_limit_2['id'])
def test_create_limit_return_count(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
r = self.post(
'/limits',
body={'limits': [ref1]},
expected_status=http_client.CREATED)
limits = r.result['limits']
self.assertEqual(1, len(limits))
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='snapshot')
ref3 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='backup')
r = self.post(
'/limits',
body={'limits': [ref2, ref3]},
expected_status=http_client.CREATED)
limits = r.result['limits']
self.assertEqual(2, len(limits))
def test_update_multi_limit(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
resource_limit=10)
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot',
resource_limit=10)
r = self.post(
'/limits',
body={'limits': [ref, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
update_ref = {
'id': id1,
'resource_limit': 5
}
update_ref2 = {
'id': r.result['limits'][1]['id'],
'resource_limit': 6
}
r = self.put(
'/limits',
body={'limits': [update_ref, update_ref2]},
expected_status=http_client.OK)
new_limits = r.result['limits']
for limit in new_limits:
if limit['id'] == id1:
self.assertEqual(limit['resource_limit'],
update_ref['resource_limit'])
else:
self.assertEqual(limit['resource_limit'],
update_ref2['resource_limit'])
def test_list_limit(self):
r = self.get('/limits', expected_status=http_client.OK)
self.assertEqual([], r.result.get('limits'))
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post('/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
r = self.get('/limits', expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 2)
if limits[0]['id'] == id1:
self.assertEqual(limits[0]['region_id'], ref1['region_id'])
self.assertIsNone(limits[1].get('region_id'))
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref1[key])
self.assertEqual(limits[1][key], ref2[key])
else:
self.assertEqual(limits[1]['region_id'], ref1['region_id'])
self.assertIsNone(limits[0].get('region_id'))
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[1][key], ref1[key])
self.assertEqual(limits[0][key], ref2[key])
r = self.get('/limits?service_id=%s' % self.service_id2,
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref2[key])
r = self.get('/limits?region_id=%s' % self.region_id,
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
for key in [
'service_id', 'region_id', 'resource_name', 'resource_limit'
]:
self.assertEqual(limits[0][key], ref1[key])
r = self.get('/limits?resource_name=volume',
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
for key in [
'service_id', 'region_id', 'resource_name', 'resource_limit'
]:
self.assertEqual(limits[0][key], ref1[key])
def test_create_limit_with_invalid_input(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
resource_limit='not_int')
ref2 = unit.new_limit_ref(project_id=self.project_id,
resource_name=123)
ref3 = unit.new_limit_ref(project_id=self.project_id,
region_id='fake_region')
for input_limit in [ref1, ref2, ref3]:
self.post('/limits',
body={'limits': [input_limit]},
expected_status=http_client.BAD_REQUEST)
def test_create_limit_with_invalid_input(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
resource_limit='not_int')
ref2 = unit.new_limit_ref(project_id=self.project_id,
resource_name=123)
ref3 = unit.new_limit_ref(project_id=self.project_id,
region_id='fake_region')
for input_limit in [ref1, ref2, ref3]:
self.post(
'/limits',
body={'limits': [input_limit]},
expected_status=http_client.BAD_REQUEST)
def test_user_cannot_create_limits(self):
service = PROVIDERS.catalog_api.create_service(uuid.uuid4().hex,
unit.new_service_ref())
registered_limit = unit.new_registered_limit_ref(
service_id=service['id'], id=uuid.uuid4().hex)
registered_limits = (
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit]))
registered_limit = registered_limits[0]
project = PROVIDERS.resource_api.create_project(
uuid.uuid4().hex,
unit.new_project_ref(domain_id=CONF.identity.default_domain_id))
create = {
'limits': [
unit.new_limit_ref(
project_id=project['id'],
service_id=service['id'],
resource_name=registered_limit['resource_name'],
resource_limit=5)
]
}
with self.test_client() as c:
c.post('/v3/limits',
json=create,
headers=self.headers,
expected_status_code=http.client.FORBIDDEN)
def test_update_registered_limit_with_referenced_limit(self):
ref = unit.new_registered_limit_ref(service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
default_limit=10)
r = self.post(
'/registered_limits',
body={'registered_limits': [ref]},
expected_status=http_client.CREATED)
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
update_ref = {
'id': r.result['registered_limits'][0]['id'],
'service_id': self.service_id2,
'region_id': self.region_id2,
'resource_name': 'snapshot',
'default_limit': 5
}
self.put(
'/registered_limits',
body={'registered_limits': [update_ref]},
expected_status=http_client.FORBIDDEN)
def test_update_registered_limit_with_referenced_limit(self):
ref = unit.new_registered_limit_ref(service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
default_limit=10)
r = self.post('/registered_limits',
body={'registered_limits': [ref]},
expected_status=http_client.CREATED)
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
self.post('/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
update_ref = {
'service_id': self.service_id2,
'region_id': self.region_id2,
'resource_name': 'snapshot',
'default_limit': 5
}
self.patch('/registered_limits/%s' %
r.result['registered_limits'][0]['id'],
body={'registered_limit': update_ref},
expected_status=http_client.FORBIDDEN)
def _create_limit_and_dependencies():
"""Create a limit and its dependencies to test with."""
service = PROVIDERS.catalog_api.create_service(
uuid.uuid4().hex, unit.new_service_ref()
)
registered_limit = unit.new_registered_limit_ref(
service_id=service['id'], id=uuid.uuid4().hex
)
registered_limits = (
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit]
)
)
registered_limit = registered_limits[0]
project = PROVIDERS.resource_api.create_project(
uuid.uuid4().hex,
unit.new_project_ref(domain_id=CONF.identity.default_domain_id)
)
limit = unit.new_limit_ref(
project_id=project['id'], service_id=service['id'],
resource_name=registered_limit['resource_name'],
resource_limit=5, id=uuid.uuid4().hex
)
limits = PROVIDERS.unified_limit_api.create_limits([limit])
return limits
def test_user_cannot_create_limits(self):
service = PROVIDERS.catalog_api.create_service(
uuid.uuid4().hex, unit.new_service_ref()
)
registered_limit = unit.new_registered_limit_ref(
service_id=service['id'], id=uuid.uuid4().hex
)
registered_limits = (
PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit]
)
)
registered_limit = registered_limits[0]
project = PROVIDERS.resource_api.create_project(
uuid.uuid4().hex,
unit.new_project_ref(domain_id=CONF.identity.default_domain_id)
)
create = {
'limits': [
unit.new_limit_ref(
project_id=project['id'], service_id=service['id'],
resource_name=registered_limit['resource_name'],
resource_limit=5
)
]
}
with self.test_client() as c:
c.post(
'/v3/limits', json=create, headers=self.headers,
expected_status_code=http_client.FORBIDDEN
)
def test_create_multi_limit(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post('/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
limits = r.result['limits']
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref1[key])
self.assertEqual(limits[1][key], ref2[key])
self.assertEqual(limits[0]['region_id'], ref1['region_id'])
self.assertIsNone(limits[1].get('region_id'))
def test_create_limit_without_reference_registered_limit(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id2,
resource_name='volume')
self.post('/limits',
body={'limits': [ref]},
expected_status=http_client.FORBIDDEN)
def test_delete_limit(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post('/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
self.delete('/limits/%s' % id1, expected_status=http_client.NO_CONTENT)
self.delete('/limits/fake_id', expected_status=http_client.NOT_FOUND)
r = self.get('/limits', expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
def test_create_limit_duplicate(self):
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1])
# use different id but the same project_id, service_id and region_id
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
self.assertRaises(exception.Conflict,
PROVIDERS.unified_limit_api.create_limits,
[limit_1])
def test_create_project_limit_duplicate(self):
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1])
# use different id but the same project_id, service_id and region_id
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
self.assertRaises(exception.Conflict,
PROVIDERS.unified_limit_api.create_limits,
[limit_1])
def test_get_limit(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# show one
res = PROVIDERS.unified_limit_api.get_limit(limit_2['id'])
self.assertDictEqual(limit_2, res)
def test_get_limit(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# show one
res = PROVIDERS.unified_limit_api.get_limit(limit_2['id'])
self.assertDictEqual(limit_2, res)
def test_create_limit_without_description(self):
limit = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit.pop('description')
res = PROVIDERS.unified_limit_api.create_limits([limit])
self.assertIsNone(res[0]['description'])
def test_create_limit_without_description(self):
limit = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit.pop('description')
res = PROVIDERS.unified_limit_api.create_limits([limit])
self.assertIsNone(res[0]['description'])
def test_create_limit_without_reference_registered_limit(self):
limit_1 = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex)
self.assertRaises(exception.NoLimitReference,
PROVIDERS.unified_limit_api.create_limits, [limit_1])
def test_create_limit_with_invalid_region_raises_validation_error(self):
limit = unit.new_limit_ref(project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=uuid.uuid4().hex,
resource_name='volume',
resource_limit=10,
id=uuid.uuid4().hex)
self.assertRaises(exception.ValidationError,
PROVIDERS.unified_limit_api.create_limits, [limit])
def test_create_limit_with_invalid_region_raises_validation_error(self):
limit = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=uuid.uuid4().hex,
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
self.assertRaises(exception.ValidationError,
PROVIDERS.unified_limit_api.create_limits,
[limit])
def test_create_limit_without_reference_registered_limit(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id2,
resource_name='volume')
self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.FORBIDDEN)
def test_create_limit_without_reference_registered_limit(self):
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
self.assertRaises(exception.NoLimitReference,
PROVIDERS.unified_limit_api.create_limits,
[limit_1])
def test_create_multi_limit(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post(
'/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
limits = r.result['limits']
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref1[key])
self.assertEqual(limits[1][key], ref2[key])
self.assertEqual(limits[0]['region_id'], ref1['region_id'])
self.assertIsNone(limits[1].get('region_id'))
def test_create_domain_limit(self):
limit_1 = unit.new_limit_ref(
project_id=None,
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex,
description='test description',
domain_id=self.domain_default['id'])
limits = PROVIDERS.unified_limit_api.create_limits([limit_1])
self.assertDictEqual(limit_1, limits[0])
def test_delete_limit(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# delete one
PROVIDERS.unified_limit_api.delete_limit(limit_1['id'])
# delete again
self.assertRaises(exception.LimitNotFound,
PROVIDERS.unified_limit_api.get_limit,
limit_1['id'])
def test_show_limit(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post('/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
self.get('/limits/fake_id', expected_status=http_client.NOT_FOUND)
r = self.get('/limits/%s' % id1, expected_status=http_client.OK)
limit = r.result['limit']
for key in [
'service_id', 'region_id', 'resource_name', 'resource_limit'
]:
self.assertEqual(limit[key], ref1[key])
def test_delete_limit(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# delete one
PROVIDERS.unified_limit_api.delete_limit(limit_1['id'])
# delete again
self.assertRaises(exception.LimitNotFound,
PROVIDERS.unified_limit_api.get_limit,
limit_1['id'])
def _create_limits_and_dependencies(domain_id=None):
"""Create limits and its dependencies for testing."""
if not domain_id:
domain_id = CONF.identity.default_domain_id
service = PROVIDERS.catalog_api.create_service(uuid.uuid4().hex,
unit.new_service_ref())
registered_limit = unit.new_registered_limit_ref(service_id=service['id'],
id=uuid.uuid4().hex)
registered_limits = (PROVIDERS.unified_limit_api.create_registered_limits(
[registered_limit]))
registered_limit = registered_limits[0]
domain_limit = unit.new_limit_ref(
domain_id=domain_id,
service_id=service['id'],
resource_name=registered_limit['resource_name'],
resource_limit=10,
id=uuid.uuid4().hex)
project = PROVIDERS.resource_api.create_project(
uuid.uuid4().hex, unit.new_project_ref(domain_id=domain_id))
project_limit = unit.new_limit_ref(
project_id=project['id'],
service_id=service['id'],
resource_name=registered_limit['resource_name'],
resource_limit=5,
id=uuid.uuid4().hex)
limits = PROVIDERS.unified_limit_api.create_limits(
[domain_limit, project_limit])
project_limit_id = None
domain_limit_id = None
for limit in limits:
if limit.get('domain_id'):
domain_limit_id = limit['id']
else:
project_limit_id = limit['id']
return (project_limit_id, domain_limit_id)
def test_create_limit_duplicate(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
self.post('/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
self.post('/limits',
body={'limits': [ref]},
expected_status=http_client.CONFLICT)
def test_show_limit(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post(
'/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
self.get('/limits/fake_id',
expected_status=http_client.NOT_FOUND)
r = self.get('/limits/%s' % id1,
expected_status=http_client.OK)
limit = r.result['limit']
for key in ['service_id', 'region_id', 'resource_name',
'resource_limit', 'description']:
self.assertEqual(limit[key], ref1[key])
def test_delete_limit(self):
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post(
'/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
self.delete('/limits/%s' % id1,
expected_status=http_client.NO_CONTENT)
self.delete('/limits/fake_id',
expected_status=http_client.NOT_FOUND)
r = self.get(
'/limits',
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
def test_create_limit_duplicate(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.CONFLICT)
def test_create_limit(self):
# create one, return all limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
res1 = PROVIDERS.unified_limit_api.create_limits([limit_1])
self.assertDictEqual(limit_1, res1[0])
# create another, return all limits
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
res2 = PROVIDERS.unified_limit_api.create_limits([limit_2])
for re in res2:
if re['id'] == limit_1['id']:
self.assertDictEqual(limit_1, re)
if re['id'] == limit_2['id']:
self.assertDictEqual(limit_2, re)
def test_update_limits(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# update one, return all limits
limit_update = {'id': limit_1['id'],
'resource_limit': 8}
res = PROVIDERS.unified_limit_api.update_limits([limit_update])
for re in res:
if re['id'] == limit_1['id']:
self.assertEqual(8, re['resource_limit'])
if re['id'] == limit_2['id']:
self.assertDictEqual(limit_2, re)
def test_delete_limit_project(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.project_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# delete a unrelated project, the limits should still be there.
PROVIDERS.resource_api.delete_project(self.project_baz['id'])
ref = PROVIDERS.unified_limit_api.list_limits()
self.assertEqual(2, len(ref))
# delete the referenced project, the limits should be deleted as well.
PROVIDERS.resource_api.delete_project(self.project_bar['id'])
ref = PROVIDERS.unified_limit_api.list_limits()
self.assertEqual([], ref)
def test_update_limits(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# update one, return all limits
limit_update = {'id': limit_1['id'],
'resource_limit': 8}
res = PROVIDERS.unified_limit_api.update_limits([limit_update])
for re in res:
if re['id'] == limit_1['id']:
self.assertEqual(8, re['resource_limit'])
if re['id'] == limit_2['id']:
self.assertDictEqual(limit_2, re)
def test_delete_limit_project(self):
# create two limits
limit_1 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_one['id'],
resource_name='volume', resource_limit=10, id=uuid.uuid4().hex)
limit_2 = unit.new_limit_ref(
project_id=self.tenant_bar['id'],
service_id=self.service_one['id'],
region_id=self.region_two['id'],
resource_name='snapshot', resource_limit=5, id=uuid.uuid4().hex)
PROVIDERS.unified_limit_api.create_limits([limit_1, limit_2])
# delete a unrelated project, the limits should still be there.
PROVIDERS.resource_api.delete_project(self.tenant_baz['id'])
ref = PROVIDERS.unified_limit_api.list_limits()
self.assertEqual(2, len(ref))
# delete the referenced project, the limits should be deleted as well.
PROVIDERS.resource_api.delete_project(self.tenant_bar['id'])
ref = PROVIDERS.unified_limit_api.list_limits()
self.assertEqual([], ref)
def test_create_limit_without_region(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post('/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
limits = r.result['limits']
self.assertIsNotNone(limits[0]['id'])
self.assertIsNotNone(limits[0]['project_id'])
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref[key])
self.assertIsNone(limits[0].get('region_id'))
def test_create_limit_without_region(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
limits = r.result['limits']
self. assertIsNotNone(limits[0]['id'])
self. assertIsNotNone(limits[0]['project_id'])
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref[key])
self.assertIsNone(limits[0].get('region_id'))
def test_update_limit(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
resource_limit=10)
r = self.post('/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
update_ref = {'id': r.result['limits'][0]['id'], 'resource_limit': 5}
r = self.put('/limits',
body={'limits': [update_ref]},
expected_status=http_client.OK)
new_limits = r.result['limits'][0]
self.assertEqual(new_limits['resource_limit'], 5)
def test_delete_registered_limit_with_referenced_limit(self):
ref = unit.new_registered_limit_ref(service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
default_limit=10)
r = self.post(
'/registered_limits',
body={'registered_limits': [ref]},
expected_status=http_client.CREATED)
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
id = r.result['registered_limits'][0]['id']
self.delete('/registered_limits/%s' % id,
expected_status=http_client.FORBIDDEN)
def test_update_limit(self):
ref = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume',
resource_limit=10)
r = self.post(
'/limits',
body={'limits': [ref]},
expected_status=http_client.CREATED)
update_ref = {
'id': r.result['limits'][0]['id'],
'resource_limit': 5,
'description': 'test description'
}
r = self.put(
'/limits',
body={'limits': [update_ref]},
expected_status=http_client.OK)
new_limits = r.result['limits'][0]
self.assertEqual(new_limits['resource_limit'], 5)
self.assertEqual(new_limits['description'], 'test description')
def test_list_limit(self):
r = self.get(
'/limits',
expected_status=http_client.OK)
self.assertEqual([], r.result.get('limits'))
ref1 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id,
region_id=self.region_id,
resource_name='volume')
ref2 = unit.new_limit_ref(project_id=self.project_id,
service_id=self.service_id2,
resource_name='snapshot')
r = self.post(
'/limits',
body={'limits': [ref1, ref2]},
expected_status=http_client.CREATED)
id1 = r.result['limits'][0]['id']
r = self.get(
'/limits',
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 2)
if limits[0]['id'] == id1:
self.assertEqual(limits[0]['region_id'], ref1['region_id'])
self.assertIsNone(limits[1].get('region_id'))
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref1[key])
self.assertEqual(limits[1][key], ref2[key])
else:
self.assertEqual(limits[1]['region_id'], ref1['region_id'])
self.assertIsNone(limits[0].get('region_id'))
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[1][key], ref1[key])
self.assertEqual(limits[0][key], ref2[key])
r = self.get(
'/limits?service_id=%s' % self.service_id2,
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
for key in ['service_id', 'resource_name', 'resource_limit']:
self.assertEqual(limits[0][key], ref2[key])
r = self.get(
'/limits?region_id=%s' % self.region_id,
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
for key in ['service_id', 'region_id', 'resource_name',
'resource_limit']:
self.assertEqual(limits[0][key], ref1[key])
r = self.get(
'/limits?resource_name=volume',
expected_status=http_client.OK)
limits = r.result['limits']
self.assertEqual(len(limits), 1)
for key in ['service_id', 'region_id', 'resource_name',
'resource_limit']:
self.assertEqual(limits[0][key], ref1[key])