748 lines
28 KiB
Python
748 lines
28 KiB
Python
# Copyright 2013 OpenStack Foundation
|
|
# Copyright (c) 2015 Mirantis inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
Tests for manila.api.v2.quota_sets.py
|
|
"""
|
|
|
|
from unittest import mock
|
|
|
|
import ddt
|
|
from oslo_config import cfg
|
|
import webob.exc
|
|
import webob.response
|
|
|
|
from manila.api.openstack import api_version_request as api_version
|
|
from manila.api.v2 import quota_sets
|
|
from manila import context
|
|
from manila import exception
|
|
from manila import policy
|
|
from manila import test
|
|
from manila.tests.api import fakes
|
|
from manila import utils
|
|
|
|
CONF = cfg.CONF
|
|
sg_quota_keys = ['share_groups', 'share_group_snapshots']
|
|
replica_quota_keys = ['share_replicas']
|
|
|
|
|
|
def _get_request(is_admin, user_in_url):
|
|
req = mock.MagicMock(
|
|
api_version_request=api_version.APIVersionRequest("2.40"))
|
|
req.environ = {'manila.context': context.get_admin_context()}
|
|
req.environ['manila.context'].is_admin = is_admin
|
|
req.environ['manila.context'].auth_token = 'foo_auth_token'
|
|
req.environ['manila.context'].project_id = 'foo_project_id'
|
|
if user_in_url:
|
|
req.environ['manila.context'].user_id = 'foo_user_id'
|
|
req.environ['QUERY_STRING'] = 'user_id=foo_user_id'
|
|
return req
|
|
|
|
|
|
@ddt.ddt
|
|
class QuotaSetsControllerTest(test.TestCase):
|
|
|
|
def setUp(self):
|
|
super(QuotaSetsControllerTest, self).setUp()
|
|
self.controller = quota_sets.QuotaSetsController()
|
|
self.resource_name = self.controller.resource_name
|
|
self.project_id = 'foo_project_id'
|
|
self.mock_policy_check = self.mock_object(
|
|
policy, 'check_policy', mock.Mock(return_value=True))
|
|
|
|
@ddt.data(
|
|
{"shares": 3, "snapshots": 4, "gigabytes": 5,
|
|
"snapshot_gigabytes": 6, "share_networks": 7},
|
|
{"shares": -1, "snapshots": -1, "gigabytes": -1,
|
|
"snapshot_gigabytes": -1, "share_networks": -1},
|
|
{"shares": 13},
|
|
{"snapshots": 24},
|
|
{"gigabytes": 7},
|
|
{"snapshot_gigabytes": 10001},
|
|
{"share_networks": 12345},
|
|
{"share_groups": 123456},
|
|
{"share_group_snapshots": 123456},
|
|
)
|
|
def test_defaults(self, quotas):
|
|
req = _get_request(True, False)
|
|
for k, v in quotas.items():
|
|
CONF.set_default('quota_' + k, v)
|
|
expected = {
|
|
'quota_set': {
|
|
'id': self.project_id,
|
|
'shares': quotas.get('shares', 50),
|
|
'gigabytes': quotas.get('gigabytes', 1000),
|
|
'snapshots': quotas.get('snapshots', 50),
|
|
'snapshot_gigabytes': quotas.get('snapshot_gigabytes', 1000),
|
|
'share_networks': quotas.get('share_networks', 10),
|
|
'share_groups': quotas.get('share_groups', 50),
|
|
'share_group_snapshots': quotas.get(
|
|
'share_group_snapshots', 50),
|
|
}
|
|
}
|
|
|
|
result = self.controller.defaults(req, self.project_id)
|
|
|
|
self.assertEqual(expected, result)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'show')
|
|
|
|
@ddt.data(
|
|
('os-', '1.0', quota_sets.QuotaSetsControllerLegacy, 'defaults'),
|
|
('os-', '2.6', quota_sets.QuotaSetsControllerLegacy, 'defaults'),
|
|
('', '2.7', quota_sets.QuotaSetsController, 'defaults'),
|
|
('os-', '1.0', quota_sets.QuotaSetsControllerLegacy, 'show'),
|
|
('os-', '2.6', quota_sets.QuotaSetsControllerLegacy, 'show'),
|
|
('', '2.7', quota_sets.QuotaSetsController, 'show'),
|
|
)
|
|
@ddt.unpack
|
|
def test_get_quotas_with_different_api_versions(self, url, version,
|
|
controller, method_name):
|
|
expected = {
|
|
'quota_set': {
|
|
'id': self.project_id,
|
|
'shares': 50,
|
|
'gigabytes': 1000,
|
|
'snapshots': 50,
|
|
'snapshot_gigabytes': 1000,
|
|
'share_networks': 10,
|
|
}
|
|
}
|
|
req = fakes.HTTPRequest.blank(
|
|
'/fooproject/%squota-sets' % url,
|
|
version=version, use_admin_context=True)
|
|
|
|
result = getattr(controller(), method_name)(req, self.project_id)
|
|
|
|
self.assertEqual(expected, result)
|
|
|
|
@staticmethod
|
|
def _get_share_type_request_object(microversion=None):
|
|
req = _get_request(True, False)
|
|
req.environ['QUERY_STRING'] = 'share_type=fake_share_type_name_or_id'
|
|
req.api_version_request = api_version.APIVersionRequest(
|
|
microversion or '2.39')
|
|
return req
|
|
|
|
@ddt.data('2.39', '2.40')
|
|
def test_share_type_quota_detail(self, microversion):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(return_value={'id': 'fake_st_id'}))
|
|
req = self._get_share_type_request_object(microversion)
|
|
quotas = {
|
|
"shares": 23,
|
|
"snapshots": 34,
|
|
"gigabytes": 45,
|
|
"snapshot_gigabytes": 56,
|
|
}
|
|
expected = {'quota_set': {
|
|
'id': self.project_id,
|
|
'shares': {
|
|
'in_use': 0,
|
|
'limit': quotas['shares'],
|
|
'reserved': 0,
|
|
},
|
|
'gigabytes': {
|
|
'in_use': 0,
|
|
'limit': quotas['gigabytes'],
|
|
'reserved': 0,
|
|
},
|
|
'snapshots': {
|
|
'in_use': 0,
|
|
'limit': quotas['snapshots'],
|
|
'reserved': 0,
|
|
},
|
|
'snapshot_gigabytes': {
|
|
'in_use': 0,
|
|
'limit': quotas['snapshot_gigabytes'],
|
|
'reserved': 0,
|
|
},
|
|
}}
|
|
|
|
for k, v in quotas.items():
|
|
CONF.set_default('quota_' + k, v)
|
|
|
|
result = self.controller.detail(req, self.project_id)
|
|
|
|
self.assertEqual(expected, result)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'show')
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_called_once_with(
|
|
req.environ['manila.context'], 'fake_share_type_name_or_id')
|
|
|
|
@ddt.data('2.39', '2.40')
|
|
def test_show_share_type_quota(self, microversion):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(return_value={'id': 'fake_st_id'}))
|
|
req = self._get_share_type_request_object(microversion)
|
|
quotas = {
|
|
"shares": 23,
|
|
"snapshots": 34,
|
|
"gigabytes": 45,
|
|
"snapshot_gigabytes": 56,
|
|
}
|
|
expected = {
|
|
'quota_set': {
|
|
'id': self.project_id,
|
|
'shares': quotas.get('shares', 50),
|
|
'gigabytes': quotas.get('gigabytes', 1000),
|
|
'snapshots': quotas.get('snapshots', 50),
|
|
'snapshot_gigabytes': quotas.get('snapshot_gigabytes', 1000),
|
|
}
|
|
}
|
|
for k, v in quotas.items():
|
|
CONF.set_default('quota_' + k, v)
|
|
|
|
result = self.controller.show(req, self.project_id)
|
|
|
|
self.assertEqual(expected, result)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'show')
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_called_once_with(
|
|
req.environ['manila.context'], 'fake_share_type_name_or_id')
|
|
|
|
@ddt.data('show', 'detail')
|
|
def test_get_share_type_quota_with_old_microversion(self, method):
|
|
req = self._get_share_type_request_object('2.38')
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
getattr(self.controller, method),
|
|
req, self.project_id)
|
|
|
|
@ddt.data((None, None), (None, 'foo'), ('bar', None))
|
|
@ddt.unpack
|
|
def test__validate_user_id_and_share_type_args(self, user_id, st_id):
|
|
result = self.controller._validate_user_id_and_share_type_args(
|
|
user_id, st_id)
|
|
|
|
self.assertIsNone(result)
|
|
|
|
def test__validate_user_id_and_share_type_args_exception(self):
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller._validate_user_id_and_share_type_args,
|
|
'foo', 'bar')
|
|
|
|
def test__get_share_type_id_found(self):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(return_value={'id': 'fake_st_id'}))
|
|
ctxt = 'fake_context'
|
|
share_type = 'fake_share_type_name_or_id'
|
|
|
|
result = self.controller._get_share_type_id(ctxt, share_type)
|
|
|
|
self.assertEqual('fake_st_id', result)
|
|
|
|
def test__get_share_type_id_not_found(self):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(return_value=None))
|
|
ctxt = 'fake_context'
|
|
share_type = 'fake_share_type_name_or_id'
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPNotFound,
|
|
self.controller._get_share_type_id,
|
|
ctxt, share_type)
|
|
|
|
def test__get_share_type_id_is_not_provided(self):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(return_value={'id': 'fake_st_id'}))
|
|
ctxt = 'fake_context'
|
|
|
|
result = self.controller._get_share_type_id(ctxt, None)
|
|
|
|
self.assertIsNone(result)
|
|
|
|
@ddt.data(
|
|
({}, sg_quota_keys, '2.40'),
|
|
({"quota_set": {}}, sg_quota_keys, '2.40'),
|
|
({"quota_set": {"foo": "bar"}}, sg_quota_keys, '2.40'),
|
|
({"foo": "bar"}, replica_quota_keys, '2.53'),
|
|
({"quota_set": {"foo": "bar"}}, replica_quota_keys, '2.53'),
|
|
)
|
|
@ddt.unpack
|
|
def test__ensure_specific_microversion_args_are_absent_success(
|
|
self, body, keys, microversion):
|
|
result = self.controller._ensure_specific_microversion_args_are_absent(
|
|
body, keys, microversion)
|
|
|
|
self.assertIsNone(result)
|
|
|
|
@ddt.data(
|
|
({"share_groups": 5}, sg_quota_keys, '2.40'),
|
|
({"share_group_snapshots": 6}, sg_quota_keys, '2.40'),
|
|
({"quota_set": {"share_groups": 7}}, sg_quota_keys, '2.40'),
|
|
({"quota_set": {"share_group_snapshots": 8}}, sg_quota_keys, '2.40'),
|
|
({"quota_set": {"share_replicas": 9}}, replica_quota_keys, '2.53'),
|
|
({"quota_set": {"share_replicas": 10}}, replica_quota_keys, '2.53'),
|
|
)
|
|
@ddt.unpack
|
|
def test__ensure_specific_microversion_args_are_absent_error(
|
|
self, body, keys, microversion):
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller._ensure_specific_microversion_args_are_absent,
|
|
body,
|
|
keys,
|
|
microversion
|
|
)
|
|
|
|
@ddt.data(_get_request(True, True), _get_request(True, False))
|
|
def test__ensure_share_type_arg_is_absent(self, req):
|
|
result = self.controller._ensure_share_type_arg_is_absent(req)
|
|
|
|
self.assertIsNone(result)
|
|
|
|
def test__ensure_share_type_arg_is_absent_exception(self):
|
|
req = self._get_share_type_request_object('2.39')
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller._ensure_share_type_arg_is_absent,
|
|
req)
|
|
|
|
@ddt.data(_get_request(True, True), _get_request(True, False))
|
|
def test_quota_detail(self, request):
|
|
request.api_version_request = api_version.APIVersionRequest('2.25')
|
|
quotas = {
|
|
"shares": 23,
|
|
"snapshots": 34,
|
|
"gigabytes": 45,
|
|
"snapshot_gigabytes": 56,
|
|
"share_networks": 67,
|
|
}
|
|
expected = {
|
|
'quota_set': {
|
|
'id': self.project_id,
|
|
'shares': {'in_use': 0,
|
|
'limit': quotas['shares'],
|
|
'reserved': 0},
|
|
'gigabytes': {'in_use': 0,
|
|
'limit': quotas['gigabytes'], 'reserved': 0},
|
|
'snapshots': {'in_use': 0,
|
|
'limit': quotas['snapshots'], 'reserved': 0},
|
|
'snapshot_gigabytes': {
|
|
'in_use': 0,
|
|
'limit': quotas['snapshot_gigabytes'],
|
|
'reserved': 0,
|
|
},
|
|
'share_networks': {
|
|
'in_use': 0,
|
|
'limit': quotas['share_networks'],
|
|
'reserved': 0
|
|
},
|
|
}
|
|
}
|
|
|
|
for k, v in quotas.items():
|
|
CONF.set_default('quota_' + k, v)
|
|
|
|
result = self.controller.detail(request, self.project_id)
|
|
|
|
self.assertEqual(expected, result)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
request.environ['manila.context'], self.resource_name, 'show')
|
|
|
|
@ddt.data(_get_request(True, True), _get_request(True, False))
|
|
def test_show_quota(self, request):
|
|
quotas = {
|
|
"shares": 23,
|
|
"snapshots": 34,
|
|
"gigabytes": 45,
|
|
"snapshot_gigabytes": 56,
|
|
"share_networks": 67,
|
|
"share_groups": 53,
|
|
"share_group_snapshots": 57,
|
|
}
|
|
expected = {
|
|
'quota_set': {
|
|
'id': self.project_id,
|
|
'shares': quotas.get('shares', 50),
|
|
'gigabytes': quotas.get('gigabytes', 1000),
|
|
'snapshots': quotas.get('snapshots', 50),
|
|
'snapshot_gigabytes': quotas.get('snapshot_gigabytes', 1000),
|
|
'share_networks': quotas.get('share_networks', 10),
|
|
'share_groups': quotas.get('share_groups', 50),
|
|
'share_group_snapshots': quotas.get(
|
|
'share_group_snapshots', 50),
|
|
}
|
|
}
|
|
for k, v in quotas.items():
|
|
CONF.set_default('quota_' + k, v)
|
|
|
|
result = self.controller.show(request, self.project_id)
|
|
|
|
self.assertEqual(expected, result)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
request.environ['manila.context'], self.resource_name, 'show')
|
|
|
|
def test_show_quota_not_authorized(self):
|
|
req = _get_request(True, False)
|
|
self.mock_object(
|
|
quota_sets.db,
|
|
'authorize_project_context',
|
|
mock.Mock(side_effect=exception.NotAuthorized))
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPForbidden,
|
|
self.controller.show,
|
|
req, self.project_id)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'show')
|
|
|
|
@ddt.data(_get_request(True, True), _get_request(True, False))
|
|
def test_update_quota(self, request):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(
|
|
return_value={'id': 'fake_st_id', 'name': 'fake_st_name'}))
|
|
CONF.set_default('quota_shares', 789)
|
|
body = {'quota_set': {'tenant_id': self.project_id, 'shares': 788}}
|
|
expected = {
|
|
'quota_set': {
|
|
'shares': body['quota_set']['shares'],
|
|
'gigabytes': 1000,
|
|
'snapshots': 50,
|
|
'snapshot_gigabytes': 1000,
|
|
'share_networks': 10,
|
|
'share_groups': 50,
|
|
'share_group_snapshots': 50,
|
|
}
|
|
}
|
|
mock_policy_update_check_call = mock.call(
|
|
request.environ['manila.context'], self.resource_name, 'update')
|
|
mock_policy_show_check_call = mock.call(
|
|
request.environ['manila.context'], self.resource_name, 'show')
|
|
|
|
update_result = self.controller.update(
|
|
request, self.project_id, body=body)
|
|
|
|
self.assertEqual(expected, update_result)
|
|
|
|
show_result = self.controller.show(request, self.project_id)
|
|
|
|
expected['quota_set']['id'] = self.project_id
|
|
self.assertEqual(expected, show_result)
|
|
self.mock_policy_check.assert_has_calls([
|
|
mock_policy_update_check_call, mock_policy_show_check_call])
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_not_called()
|
|
|
|
@ddt.data('2.39', '2.40')
|
|
def test_update_share_type_quota(self, microversion):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(
|
|
return_value={'id': 'fake_st_id', 'name': 'fake_st_name'}))
|
|
req = self._get_share_type_request_object(microversion)
|
|
|
|
CONF.set_default('quota_shares', 789)
|
|
body = {'quota_set': {'tenant_id': self.project_id, 'shares': 788}}
|
|
expected = {
|
|
'quota_set': {
|
|
'shares': body['quota_set']['shares'],
|
|
'gigabytes': 1000,
|
|
'snapshots': 50,
|
|
'snapshot_gigabytes': 1000,
|
|
}
|
|
}
|
|
|
|
update_result = self.controller.update(req, self.project_id, body=body)
|
|
|
|
self.assertEqual(expected, update_result)
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_called_once_with(
|
|
req.environ['manila.context'],
|
|
req.environ['QUERY_STRING'].split('=')[-1])
|
|
quota_sets.db.share_type_get_by_name_or_id.reset_mock()
|
|
|
|
show_result = self.controller.show(req, self.project_id)
|
|
|
|
expected['quota_set']['id'] = self.project_id
|
|
self.assertEqual(expected, show_result)
|
|
self.mock_policy_check.assert_has_calls([
|
|
mock.call(req.environ['manila.context'], self.resource_name, key)
|
|
for key in ('update', 'show')
|
|
])
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_called_once_with(
|
|
req.environ['manila.context'],
|
|
req.environ['QUERY_STRING'].split('=')[-1])
|
|
|
|
def test_update_share_type_quota_using_too_old_microversion(self):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(
|
|
return_value={'id': 'fake_st_id', 'name': 'fake_st_name'}))
|
|
req = self._get_share_type_request_object('2.38')
|
|
body = {'quota_set': {'tenant_id': self.project_id, 'shares': 788}}
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller.update,
|
|
req, self.project_id, body=body)
|
|
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_not_called()
|
|
|
|
def test_update_share_type_quota_for_share_networks(self):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(
|
|
return_value={'id': 'fake_st_id', 'name': 'fake_st_name'}))
|
|
req = self._get_share_type_request_object('2.39')
|
|
body = {'quota_set': {
|
|
'tenant_id': self.project_id, 'share_networks': 788,
|
|
}}
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller.update,
|
|
req, self.project_id, body=body)
|
|
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_called_once_with(
|
|
req.environ['manila.context'],
|
|
req.environ['QUERY_STRING'].split('=')[-1])
|
|
|
|
@ddt.data(-2, 'foo', {1: 2}, [1])
|
|
def test_update_quota_with_invalid_value(self, value):
|
|
req = _get_request(True, False)
|
|
body = {'quota_set': {'tenant_id': self.project_id, 'shares': value}}
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller.update,
|
|
req, self.project_id, body=body)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'update')
|
|
|
|
def test_user_quota_can_not_be_bigger_than_tenant_quota(self):
|
|
value = 777
|
|
CONF.set_default('quota_shares', value)
|
|
body = {
|
|
'quota_set': {
|
|
'tenant_id': self.project_id,
|
|
'shares': value + 1,
|
|
}
|
|
}
|
|
req = _get_request(True, True)
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller.update,
|
|
req, self.project_id, body=body)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'update')
|
|
|
|
def test_update_inexistent_quota(self):
|
|
body = {
|
|
'quota_set': {
|
|
'tenant_id': self.project_id,
|
|
'fake_quota': 13,
|
|
}
|
|
}
|
|
req = _get_request(True, False)
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller.update,
|
|
req, self.project_id, body=body)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'update')
|
|
|
|
def test_update_quota_not_authorized(self):
|
|
body = {'quota_set': {'tenant_id': self.project_id, 'shares': 13}}
|
|
req = _get_request(False, False)
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPForbidden,
|
|
self.controller.update,
|
|
req, self.project_id, body=body)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'update')
|
|
|
|
@ddt.data(
|
|
('os-quota-sets', '1.0', quota_sets.QuotaSetsControllerLegacy),
|
|
('os-quota-sets', '2.6', quota_sets.QuotaSetsControllerLegacy),
|
|
('quota-sets', '2.7', quota_sets.QuotaSetsController),
|
|
)
|
|
@ddt.unpack
|
|
def test_update_all_quotas_with_force(self, url, version, controller):
|
|
req = fakes.HTTPRequest.blank(
|
|
'/fooproject/%s' % url, version=version, use_admin_context=True)
|
|
quotas = (
|
|
('quota_shares', 13),
|
|
('quota_gigabytes', 14),
|
|
('quota_snapshots', 15),
|
|
('quota_snapshot_gigabytes', 16),
|
|
('quota_share_networks', 17),
|
|
)
|
|
for quota, value in quotas:
|
|
CONF.set_default(quota, value)
|
|
expected = {
|
|
'quota_set': {
|
|
'tenant_id': self.project_id,
|
|
'shares': quotas[0][1],
|
|
'gigabytes': quotas[1][1],
|
|
'snapshots': quotas[2][1],
|
|
'snapshot_gigabytes': quotas[3][1],
|
|
'share_networks': quotas[4][1],
|
|
'force': True,
|
|
}
|
|
}
|
|
|
|
update_result = controller().update(
|
|
req, self.project_id, body=expected)
|
|
|
|
expected['quota_set'].pop('force')
|
|
expected['quota_set'].pop('tenant_id')
|
|
self.assertEqual(expected, update_result)
|
|
|
|
show_result = controller().show(req, self.project_id)
|
|
|
|
expected['quota_set']['id'] = self.project_id
|
|
self.assertEqual(expected, show_result)
|
|
self.mock_policy_check.assert_has_calls([
|
|
mock.call(req.environ['manila.context'],
|
|
self.resource_name, action)
|
|
for action in ('update', 'show')
|
|
])
|
|
|
|
@ddt.data(
|
|
('os-quota-sets', '1.0', quota_sets.QuotaSetsControllerLegacy),
|
|
('os-quota-sets', '2.6', quota_sets.QuotaSetsControllerLegacy),
|
|
('quota-sets', '2.7', quota_sets.QuotaSetsController),
|
|
)
|
|
@ddt.unpack
|
|
def test_delete_tenant_quota(self, url, version, controller):
|
|
self.mock_object(quota_sets.QUOTAS, 'destroy_all_by_project_and_user')
|
|
self.mock_object(quota_sets.QUOTAS, 'destroy_all_by_project')
|
|
req = fakes.HTTPRequest.blank(
|
|
'/fooproject/%s' % url, version=version, use_admin_context=True)
|
|
|
|
result = controller().delete(req, self.project_id)
|
|
|
|
self.assertTrue(
|
|
utils.IsAMatcher(webob.response.Response) == result
|
|
)
|
|
self.assertTrue(hasattr(result, 'status_code'))
|
|
self.assertEqual(202, result.status_code)
|
|
self.assertFalse(
|
|
quota_sets.QUOTAS.destroy_all_by_project_and_user.called)
|
|
quota_sets.QUOTAS.destroy_all_by_project.assert_called_once_with(
|
|
req.environ['manila.context'], self.project_id)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'delete')
|
|
|
|
def test_delete_user_quota(self):
|
|
project_id = 'foo_project_id'
|
|
self.mock_object(quota_sets.QUOTAS, 'destroy_all_by_project_and_user')
|
|
self.mock_object(quota_sets.QUOTAS, 'destroy_all_by_project')
|
|
req = _get_request(True, True)
|
|
|
|
result = self.controller.delete(req, project_id)
|
|
|
|
self.assertTrue(
|
|
utils.IsAMatcher(webob.response.Response) == result
|
|
)
|
|
self.assertTrue(hasattr(result, 'status_code'))
|
|
self.assertEqual(202, result.status_code)
|
|
(quota_sets.QUOTAS.destroy_all_by_project_and_user.
|
|
assert_called_once_with(
|
|
req.environ['manila.context'],
|
|
project_id,
|
|
req.environ['manila.context'].user_id))
|
|
self.assertFalse(quota_sets.QUOTAS.destroy_all_by_project.called)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'delete')
|
|
|
|
def test_delete_share_type_quota(self):
|
|
req = self._get_share_type_request_object('2.39')
|
|
self.mock_object(quota_sets.QUOTAS, 'destroy_all_by_project')
|
|
self.mock_object(quota_sets.QUOTAS, 'destroy_all_by_project_and_user')
|
|
mock_delete_st_quotas = self.mock_object(
|
|
quota_sets.QUOTAS, 'destroy_all_by_project_and_share_type')
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(
|
|
return_value={'id': 'fake_st_id', 'name': 'fake_st_name'}))
|
|
|
|
result = self.controller.delete(req, self.project_id)
|
|
|
|
self.assertEqual(utils.IsAMatcher(webob.response.Response), result)
|
|
self.assertTrue(hasattr(result, 'status_code'))
|
|
self.assertEqual(202, result.status_code)
|
|
mock_delete_st_quotas.assert_called_once_with(
|
|
req.environ['manila.context'], self.project_id, 'fake_st_id')
|
|
quota_sets.QUOTAS.destroy_all_by_project.assert_not_called()
|
|
quota_sets.QUOTAS.destroy_all_by_project_and_user.assert_not_called()
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'delete')
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_called_once_with(
|
|
req.environ['manila.context'],
|
|
req.environ['QUERY_STRING'].split('=')[-1])
|
|
|
|
def test_delete_share_type_quota_using_too_old_microversion(self):
|
|
self.mock_object(
|
|
quota_sets.db, 'share_type_get_by_name_or_id',
|
|
mock.Mock(
|
|
return_value={'id': 'fake_st_id', 'name': 'fake_st_name'}))
|
|
req = self._get_share_type_request_object('2.38')
|
|
|
|
self.assertRaises(
|
|
webob.exc.HTTPBadRequest,
|
|
self.controller.delete,
|
|
req, self.project_id)
|
|
|
|
quota_sets.db.share_type_get_by_name_or_id.assert_not_called()
|
|
|
|
def test_delete_not_authorized(self):
|
|
req = _get_request(False, False)
|
|
self.assertRaises(
|
|
webob.exc.HTTPForbidden,
|
|
self.controller.delete,
|
|
req, self.project_id)
|
|
self.mock_policy_check.assert_called_once_with(
|
|
req.environ['manila.context'], self.resource_name, 'delete')
|
|
|
|
@ddt.data(
|
|
('os-quota-sets', '2.7', quota_sets.QuotaSetsControllerLegacy),
|
|
('quota-sets', '2.6', quota_sets.QuotaSetsController),
|
|
('quota-sets', '2.0', quota_sets.QuotaSetsController),
|
|
)
|
|
@ddt.unpack
|
|
def test_api_not_found(self, url, version, controller):
|
|
req = fakes.HTTPRequest.blank('/fooproject/%s' % url, version=version)
|
|
for method_name in ('show', 'defaults', 'delete'):
|
|
self.assertRaises(
|
|
exception.VersionNotFoundForAPIMethod,
|
|
getattr(controller(), method_name),
|
|
req, self.project_id)
|
|
|
|
@ddt.data(
|
|
('os-quota-sets', '2.7', quota_sets.QuotaSetsControllerLegacy),
|
|
('quota-sets', '2.6', quota_sets.QuotaSetsController),
|
|
('quota-sets', '2.0', quota_sets.QuotaSetsController),
|
|
)
|
|
@ddt.unpack
|
|
def test_update_api_not_found(self, url, version, controller):
|
|
req = fakes.HTTPRequest.blank('/fooproject/%s' % url, version=version)
|
|
self.assertRaises(
|
|
exception.VersionNotFoundForAPIMethod,
|
|
controller().update,
|
|
req, self.project_id)
|