def test_serialize(self):
class JSONSerializer(object):
def serialize(self, obj):
return 'json'
class XMLSerializer(object):
def serialize(self, obj):
return 'xml'
class AtomSerializer(object):
def serialize(self, obj):
return 'atom'
robj = wsgi.ResponseObject({},
code=202,
json=JSONSerializer,
xml=XMLSerializer,
atom=AtomSerializer)
robj['X-header1'] = 'header1'
robj['X-header2'] = 'header2'
for content_type, mtype in wsgi._MEDIA_TYPE_MAP.items():
request = wsgi.Request.blank('/tests/123')
response = robj.serialize(request, content_type)
self.assertEqual(response.headers['Content-Type'], content_type)
self.assertEqual(response.headers['X-header1'], 'header1')
self.assertEqual(response.headers['X-header2'], 'header2')
self.assertEqual(response.status_int, 202)
self.assertEqual(response.body, mtype)
def test_used_limits(self):
fake_req = FakeRequest(fakes.FakeRequestContext('fake', 'fake'))
obj = {
"limits": {
"rate": [],
"absolute": {},
},
}
res = wsgi.ResponseObject(obj)
quota_map = {
'totalVolumesUsed': 'volumes',
'totalGigabytesUsed': 'gigabytes',
}
limits = {}
for display_name, q in quota_map.iteritems():
limits[q] = {'limit': 2, 'in_use': 1}
def stub_get_project_quotas(context, project_id, usages=True):
return limits
self.stubs.Set(quota.QUOTAS, "get_project_quotas",
stub_get_project_quotas)
self.mox.ReplayAll()
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
for used_limit, value in abs_limits.iteritems():
self.assertEqual(value, limits[quota_map[used_limit]]['in_use'])
def test_used_limits(self, _mock_policy_enforce, _mock_get_project_quotas):
fake_req = FakeRequest(
fakes.FakeRequestContext(fake.USER_ID, fake.PROJECT_ID))
obj = {
"limits": {
"rate": [],
"absolute": {},
},
}
res = wsgi.ResponseObject(obj)
quota_map = {
'totalVolumesUsed': 'volumes',
'totalGigabytesUsed': 'gigabytes',
'totalSnapshotsUsed': 'snapshots',
}
limits = {}
for display_name, q in quota_map.items():
limits[q] = {'limit': 2, 'in_use': 1}
_mock_get_project_quotas.return_value = limits
# allow user to access used limits
_mock_policy_enforce.return_value = None
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
for used_limit, value in abs_limits.items():
self.assertEqual(value, limits[quota_map[used_limit]]['in_use'])
obj = {
"limits": {
"rate": [],
"absolute": {},
},
}
res = wsgi.ResponseObject(obj)
# unallow user to access used limits
_mock_policy_enforce.side_effect = exception.NotAuthorized
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
self.assertNotIn('totalVolumesUsed', abs_limits)
self.assertNotIn('totalGigabytesUsed', abs_limits)
self.assertNotIn('totalSnapshotsUsed', abs_limits)
def test_get_serializer_defaults(self):
robj = wsgi.ResponseObject({})
default_serializers = dict(json='json', xml='xml', atom='atom')
for content_type, mtype in wsgi._MEDIA_TYPE_MAP.items():
self.assertRaises(exception.InvalidContentType,
robj.get_serializer, content_type)
_mtype, serializer = robj.get_serializer(content_type,
default_serializers)
self.assertEqual(serializer, mtype)
def test_used_limits_negative(self, ver_project, _mock_policy_enforce,
_mock_get_project_quotas):
version, has_project = ver_project
fake_req = FakeRequest(fakes.FakeRequestContext(fake.USER_ID,
fake.PROJECT_ID,
is_admin=True),
api_version=version)
if has_project:
fake_req = FakeRequest(fakes.FakeRequestContext(fake.USER_ID,
fake.PROJECT_ID,
is_admin=True),
filter={'project_id': fake.UUID1},
api_version=version)
obj = {
"limits": {
"rate": [],
"absolute": {},
},
}
res = wsgi.ResponseObject(obj)
def get_project_quotas(context, project_id, quota_class=None,
defaults=True, usages=True):
if project_id == fake.UUID1:
return {"gigabytes": {'limit': 5, 'in_use': -1}}
return {"gigabytes": {'limit': 10, 'in_use': -2}}
_mock_get_project_quotas.side_effect = get_project_quotas
# allow user to access used limits
_mock_policy_enforce.return_value = None
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
# if admin, only 3.39 and req contains project_id filter, cinder
# returns the specified project's quota.
if version == '3.39' and has_project:
self.assertEqual(0, abs_limits['totalGigabytesUsed'])
else:
self.assertEqual(0, abs_limits['totalGigabytesUsed'])
fake_req = FakeRequest(fakes.FakeRequestContext(fake.USER_ID,
fake.PROJECT_ID),
api_version=version)
if has_project:
fake_req = FakeRequest(fakes.FakeRequestContext(fake.USER_ID,
fake.PROJECT_ID),
filter={'project_id': fake.UUID1},
api_version=version)
# if non-admin, cinder always returns self quota.
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
self.assertEqual(0, abs_limits['totalGigabytesUsed'])
def test_bind_serializers(self):
robj = wsgi.ResponseObject({}, json='foo')
robj._bind_method_serializers(dict(xml='bar', json='baz'))
self.assertEqual(robj.serializers, dict(xml='bar', json='foo'))
def test_header_isolation(self):
robj = wsgi.ResponseObject({})
robj['Header'] = 'foo'
hdrs = robj.headers
hdrs['hEADER'] = 'bar'
self.assertEqual(robj['hEADER'], 'foo')
def test_default_serializers(self):
robj = wsgi.ResponseObject({})
self.assertEqual(robj.serializers, {})
def test_get_header(self):
robj = wsgi.ResponseObject({})
robj['Header'] = 'foo'
self.assertEqual(robj['hEADER'], 'foo')
def test_del_header(self):
robj = wsgi.ResponseObject({})
robj['Header'] = 'foo'
del robj['hEADER']
self.assertNotIn('header', robj.headers)
def test_default_code(self):
robj = wsgi.ResponseObject({})
self.assertEqual(http_client.OK, robj.code)
def test_used_limits(self, ver_project, _mock_policy_authorize,
_mock_get_project_quotas):
version, has_project = ver_project
fake_req = FakeRequest(fakes.FakeRequestContext(fake.USER_ID,
fake.PROJECT_ID,
is_admin=True),
api_version=version)
if has_project:
fake_req = FakeRequest(fakes.FakeRequestContext(fake.USER_ID,
fake.PROJECT_ID,
is_admin=True),
filter={'project_id': fake.UUID1},
api_version=version)
obj = {
"limits": {
"rate": [],
"absolute": {},
},
}
res = wsgi.ResponseObject(obj)
def get_project_quotas(context,
project_id,
quota_class=None,
defaults=True,
usages=True):
if project_id == fake.UUID1:
return {"gigabytes": {'limit': 5, 'in_use': 1}}
return {"gigabytes": {'limit': 10, 'in_use': 2}}
_mock_get_project_quotas.side_effect = get_project_quotas
# allow user to access used limits
_mock_policy_authorize.return_value = True
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
# if admin, only LIMITS_ADMIN_FILTER and req contains project_id
# filter, cinder returns the specified project's quota.
if version == mv.LIMITS_ADMIN_FILTER and has_project:
self.assertEqual(1, abs_limits['totalGigabytesUsed'])
else:
self.assertEqual(2, abs_limits['totalGigabytesUsed'])
fake_req = FakeRequest(fakes.FakeRequestContext(
fake.USER_ID, fake.PROJECT_ID),
api_version=version)
if has_project:
fake_req = FakeRequest(fakes.FakeRequestContext(
fake.USER_ID, fake.PROJECT_ID),
filter={'project_id': fake.UUID1},
api_version=version)
# if non-admin, cinder always returns self quota.
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
self.assertEqual(2, abs_limits['totalGigabytesUsed'])
obj = {
"limits": {
"rate": [],
"absolute": {},
},
}
res = wsgi.ResponseObject(obj)
# unallow user to access used limits
_mock_policy_authorize.return_value = False
self.controller.index(fake_req, res)
abs_limits = res.obj['limits']['absolute']
self.assertNotIn('totalVolumesUsed', abs_limits)
self.assertNotIn('totalGigabytesUsed', abs_limits)
self.assertNotIn('totalSnapshotsUsed', abs_limits)
def test_override_default_code(self):
robj = wsgi.ResponseObject({}, code=http_client.NOT_FOUND)
self.assertEqual(http_client.NOT_FOUND, robj.code)
def test_modified_code(self):
robj = wsgi.ResponseObject({})
robj._default_code = 202
self.assertEqual(robj.code, 202)
def test_override_modified_code(self):
robj = wsgi.ResponseObject({}, code=HTTPStatus.NOT_FOUND)
robj._default_code = HTTPStatus.ACCEPTED
self.assertEqual(HTTPStatus.NOT_FOUND, robj.code)
def test_override_default_code(self):
robj = wsgi.ResponseObject({}, code=404)
self.assertEqual(404, robj.code)
def test_override_default_code(self):
robj = wsgi.ResponseObject({}, code=HTTPStatus.NOT_FOUND)
self.assertEqual(HTTPStatus.NOT_FOUND, robj.code)
def test_modified_code(self):
robj = wsgi.ResponseObject({})
robj._default_code = HTTPStatus.ACCEPTED
self.assertEqual(HTTPStatus.ACCEPTED, robj.code)
def test_default_code(self):
robj = wsgi.ResponseObject({})
self.assertEqual(HTTPStatus.OK, robj.code)
def test_get_serializer(self):
robj = wsgi.ResponseObject({}, json='json', xml='xml', atom='atom')
for content_type, mtype in wsgi._MEDIA_TYPE_MAP.items():
_mtype, serializer = robj.get_serializer(content_type)
self.assertEqual(serializer, mtype)
def test_override_modified_code(self):
robj = wsgi.ResponseObject({}, code=404)
robj._default_code = 202
self.assertEqual(robj.code, 404)
def test_modified_code(self):
robj = wsgi.ResponseObject({})
robj._default_code = http_client.ACCEPTED
self.assertEqual(http_client.ACCEPTED, robj.code)
def test_set_header(self):
robj = wsgi.ResponseObject({})
robj['Header'] = 'foo'
self.assertEqual(robj.headers, {'header': 'foo'})
def test_default_code(self):
robj = wsgi.ResponseObject({})
self.assertEqual(robj.code, 200)
def test_override_modified_code(self):
robj = wsgi.ResponseObject({}, code=http_client.NOT_FOUND)
robj._default_code = http_client.ACCEPTED
self.assertEqual(http_client.NOT_FOUND, robj.code)
