def test_api_version_request_header_none(self):
request = wsgi.Request.blank('/')
request.set_api_version_request()
self.assertEqual(api_version.APIVersionRequest(
api_version.DEFAULT_API_VERSION), request.api_version_request)
def index(self, req):
if req.api_version_request != \
api_version.APIVersionRequest(version):
raise webob.exc.HTTPInternalServerError()
return 'success'
def test_validate_request_unicode_decode_failure(self):
req = fakes.HTTPRequest.blank("/tests?foo=%88")
req.api_version_request = api_version.APIVersionRequest("2.1")
ex = self.assertRaises(exception.ValidationError, self.controller.get,
req)
self.assertIn("Query string is not UTF-8 encoded", six.text_type(ex))
def setUp(self):
super(LockServerTestsV273, self).setUp()
self.req.api_version_request = api_version_request.APIVersionRequest(
'2.73')
def __init__(self, *args, **kwargs):
super(Request, self).__init__(*args, **kwargs)
if not hasattr(self, 'api_version_request'):
self.api_version_request = api_version.APIVersionRequest()
def test_validate_request_with_multiple_values_fails(self):
req = fakes.HTTPRequest.blank("/tests?foo=%s&foo=%s" %
(fakes.FAKE_UUID, fakes.FAKE_UUID))
req.api_version_request = api_version.APIVersionRequest("2.3")
self.assertRaises(exception.ValidationError, self.controller.get, req)
def _schema_validation_helper(schema,
target,
min_version,
max_version,
args,
kwargs,
is_body=True):
"""A helper method to execute JSON-Schema Validation.
This method checks the request version whether matches the specified max
version and min_version. It also takes a care of legacy v2 request.
If the version range matches the request, we validate the schema against
the target and a failure will result in a ValidationError being raised.
:param schema: A dict, the JSON-Schema is used to validate the target.
:param target: A dict, the target is validated by the JSON-Schema.
:param min_version: A string of two numerals. X.Y indicating the minimum
version of the JSON-Schema to validate against.
:param max_version: A string of two numerals. X.Y indicating the maximum
version of the JSON-Schema to validate against.
:param args: Positional arguments which passed into original method.
:param kwargs: Keyword arguments which passed into original method.
:param is_body: A boolean. Indicating whether the target is HTTP request
body or not.
:returns: A boolean. `True` if and only if the version range matches the
request AND the schema is successfully validated. `False` if the
version range does not match the request and no validation is
performed.
:raises: ValidationError, when the validation fails.
"""
min_ver = api_version.APIVersionRequest(min_version)
max_ver = api_version.APIVersionRequest(max_version)
# The request object is always the second argument.
# However numerous unittests pass in the request object
# via kwargs instead so we handle that as well.
# TODO(cyeoh): cleanup unittests so we don't have to
# to do this
if 'req' in kwargs:
ver = kwargs['req'].api_version_request
legacy_v2 = kwargs['req'].is_legacy_v2()
else:
ver = args[1].api_version_request
legacy_v2 = args[1].is_legacy_v2()
if legacy_v2:
# NOTE: For v2.0 compatible API, here should work like
# client | schema min_version | schema
# -----------+--------------------+--------
# legacy_v2 | None | work
# legacy_v2 | 2.0 | work
# legacy_v2 | 2.1+ | don't
if min_version is None or min_version == '2.0':
schema_validator = validators._SchemaValidator(
schema, legacy_v2, is_body)
schema_validator.validate(target)
return True
elif ver.matches(min_ver, max_ver):
# Only validate against the schema if it lies within
# the version range specified. Note that if both min
# and max are not specified the validator will always
# be run.
schema_validator = validators._SchemaValidator(schema, legacy_v2,
is_body)
schema_validator.validate(target)
return True
return False
def setUp(self):
super(ConsoleAuthTokensExtensionTestV231, self).setUp()
self.req.api_version_request = api_version_request.APIVersionRequest(
'2.31')
def __init__(self, version=os_wsgi.DEFAULT_API_VERSION): # version='2.1'):
super(FakeRequest, self).__init__()
self.api_version_request = api_version.APIVersionRequest(version)
class FakeRequestWithNovaZone(object):
environ = {"nova.context": context_maker.get_admin_context()}
GET = {"zone": "nova"}
api_version_request = api_version.APIVersionRequest('2.1')
class FakeRequest(object):
environ = {"nova.context": context.get_admin_context()}
api_version_request = api_version.APIVersionRequest("2.1")
def is_legacy_v2(self):
return False
def test_null_version(self):
v = api_version_request.APIVersionRequest()
self.assertTrue(v.is_null())
def _test_string(version, exp_major, exp_minor):
v = api_version_request.APIVersionRequest(version)
self.assertEqual(v.ver_major, exp_major)
self.assertEqual(v.ver_minor, exp_minor)
def __init__(self, *args, **kwargs):
super(Request, self).__init__(*args, **kwargs)
self._extension_data = {'db_items': {}}
if not hasattr(self, 'api_version_request'):
self.api_version_request = api_version.APIVersionRequest()
def test_validate_request(self):
req = fakes.HTTPRequest.blank("/tests?foo=%s" % fakes.FAKE_UUID)
req.api_version_request = api_version.APIVersionRequest("2.3")
self.assertEqual(['foo'], self.controller.get(req))
def _test_list_server_group(self, mock_get_all, mock_get_by_project,
path, api_version='2.1', limited=None):
policies = ['anti-affinity']
policy = "anti-affinity"
members = []
metadata = {} # always empty
names = ['default-x', 'test']
p_id = fakes.FAKE_PROJECT_ID
u_id = fakes.FAKE_USER_ID
ver = avr.APIVersionRequest(api_version)
if ver >= avr.APIVersionRequest("2.64"):
sg1 = server_group_resp_template(id=uuidsentinel.sg1_id,
name=names[0],
policy=policy,
rules={},
members=members,
project_id=p_id,
user_id=u_id)
sg2 = server_group_resp_template(id=uuidsentinel.sg2_id,
name=names[1],
policy=policy,
rules={},
members=members,
project_id=p_id,
user_id=u_id)
elif ver >= avr.APIVersionRequest("2.13"):
sg1 = server_group_resp_template(id=uuidsentinel.sg1_id,
name=names[0],
policies=policies,
members=members,
metadata=metadata,
project_id=p_id,
user_id=u_id)
sg2 = server_group_resp_template(id=uuidsentinel.sg2_id,
name=names[1],
policies=policies,
members=members,
metadata=metadata,
project_id=p_id,
user_id=u_id)
else:
sg1 = server_group_resp_template(id=uuidsentinel.sg1_id,
name=names[0],
policies=policies,
members=members,
metadata=metadata)
sg2 = server_group_resp_template(id=uuidsentinel.sg2_id,
name=names[1],
policies=policies,
members=members,
metadata=metadata)
tenant_groups = [sg2]
all_groups = [sg1, sg2]
if limited:
all = {'server_groups': [sg2]}
tenant_specific = {'server_groups': []}
else:
all = {'server_groups': all_groups}
tenant_specific = {'server_groups': tenant_groups}
def return_all_server_groups():
return objects.InstanceGroupList(
objects=[objects.InstanceGroup(
**server_group_db(sg)) for sg in all_groups])
mock_get_all.return_value = return_all_server_groups()
def return_tenant_server_groups():
return objects.InstanceGroupList(
objects=[objects.InstanceGroup(
**server_group_db(sg)) for sg in tenant_groups])
mock_get_by_project.return_value = return_tenant_server_groups()
path = '/os-server-groups?all_projects=True'
if limited:
path += limited
req = fakes.HTTPRequest.blank(path, version=api_version)
admin_req = fakes.HTTPRequest.blank(path, use_admin_context=True,
version=api_version)
# test as admin
res_dict = self.controller.index(admin_req)
self.assertEqual(all, res_dict)
# test as non-admin
res_dict = self.controller.index(req)
self.assertEqual(tenant_specific, res_dict)
def test_validate_request_with_multiple_values(self):
req = fakes.HTTPRequest.blank("/tests?foos=abc")
req.api_version_request = api_version.APIVersionRequest("2.3")
self.assertEqual(['foos'], self.controller.get(req))
req = fakes.HTTPRequest.blank("/tests?foos=abc&foos=def")
self.assertEqual(['foos'], self.controller.get(req))
def setUp(self):
super(MigrateServerTestsV256, self).setUp()
self.req.api_version_request = api_version_request.APIVersionRequest(
'2.56')
class FakeRequest(object):
environ = {"nova.context": context.get_admin_context()}
api_version_request = api_version.APIVersionRequest("2.1")
def get_db_flavor(self, flavor_id):
return INSTANCE_TYPES[flavor_id]
