def test_slots_response(self):
resp = Response()
try:
resp.doesnt = 'exist'
except AttributeError:
pytest.fail('Unable to add additional variables dynamically')
def it_should_have_a_default_get_method(self):
plugin = GenericPlugin()
resp, req = Response(), object()
plugin.on_get(req=req, resp=resp)
assert resp.status == HTTP_200
assert resp.body == AbstractPlugin.API_HELP
def test_on_put_error_result(self):
"""
Test if we will receive correct response
"""
resource = CollectionResource(objects_class=FakeObjectClass)
env = create_environ(path='/')
req = Request(env)
req.context = {
'doc': {
'id': 1,
}
}
def clean(data):
if 'name' not in data:
return {}, {'name': ['Test Error Message']}
resource.clean = clean
resp = Response()
resource.on_put(req=req, resp=resp)
self.assertEqual(resp.body,
{'errors': {
'name': ['Test Error Message']
}})
def create_response(data,
status_code=200,
content_type='application/json'):
options = ResponseOptions()
resp = Response(options)
resp.body = data
resp.content_type = content_type
resp.status = HTTP_200
return resp
def should_have_a_default_get_method(self):
plugin = GenericPlugin()
resp, req = Response(), object()
plugin.on_get(req=req, resp=resp)
json_body = json.loads(resp.body)
expect(resp.status).to.equal(HTTP_200)
expect(json_body['help']).to.equal(AbstractPlugin.API_HELP)
def test_oauth_middleware_request_auth_valid():
auth_middleware = JwtMiddleware()
auth_middleware._verification_key = RSA_2048_PUB_KEY
test_req = Request(
create_environ(headers={'Authorization': TEST_AUTH_HEADER}))
test_resp = Response()
auth_middleware.process_resource(test_req, test_resp, None, None)
auth_middleware.process_request(test_req, test_resp)
auth_middleware.process_response(test_req, test_resp, None)
def create_response(data,
status_code=200,
headers=None,
content_type="application/json"):
options = ResponseOptions()
resp = Response(options)
resp.body = data
resp.content_type = content_type
resp.status = HTTP_200
resp.set_headers(headers or {})
return resp
def test_default_response_context(self):
resp = Response()
assert type(resp.context).__name__ == 'ResponseContext'
resp.context.hello = 'World!'
assert resp.context.hello == 'World!'
assert 'hello' not in resp.context
resp.context['note'] = 'Default Response.context_type used to be dict.'
assert 'note' in resp.context
assert resp.context.get('note') == resp.context['note']
def test_on_put_success_result(self):
"""
Test if we will receive correct response
"""
resource = CollectionResource(objects_class=FakeObjectClass)
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {'id': 1, 'name': 'Opentopic'}}
resp = Response()
resource.on_put(req=req, resp=resp)
self.assertEqual(resp.body, {'id': 1, 'name': 'Opentopic'})
def test_default_response_context(self):
resp = Response()
resp.context.hello = 'World!'
assert resp.context.hello == 'World!'
assert resp.context['hello'] == 'World!'
resp.context['note'] = 'Default Response.context_type used to be dict.'
assert 'note' in resp.context
assert hasattr(resp.context, 'note')
assert resp.context.get('note') == resp.context['note']
def test_render_response_status_200(self):
"""
need to check if status of the response is set for 200 and
"""
env = create_environ(path='/')
req = Request(env)
resp = Response()
result = None
BaseResource.render_response(
result=result, req=req, resp=resp
)
self.assertTrue(resp.status, 200)
def test_render_response_result(self):
"""
check if result is available request context
"""
env = create_environ(path='/')
req = Request(env)
resp = Response()
result = 'Cognitive Digital Marketing :)'
BaseResource.render_response(
result=result, req=req, resp=resp
)
self.assertEqual(resp.body, 'Cognitive Digital Marketing :)')
def test_update_withtout_pk(self):
"""
test how update function will handle when we are not going to pass pk value
"""
resource = SingleResource(objects_class=None)
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {}}
resp = Response()
with self.assertRaises(Exception):
resource.on_patch(req, resp)
def test_update_get_object(self):
"""
Test `get_object` func
"""
resource = SingleResource(objects_class=None)
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {'pk': 1}}
resp = Response()
resource.objects_class = FakeObjectList()
obj = resource.get_object(req=req, resp=resp, path_params={})
self.assertEqual(obj.pk, 1)
def test_on_head(self):
"""
need to check if status of the response is set for 200 and
"""
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {}}
req.params[mongoengine.CollectionResource.PARAM_TOTAL_COUNT] = '1'
resp = Response()
resource = mongoengine.CollectionResource(
objects_class=Mock(return_value=[1, 2, 3]), max_limit=2)
resource.get_object_list = Mock(return_value=[1, 2])
resource.get_total_objects = Mock(return_value={'total_count': 3})
resource.on_head(req=req, resp=resp)
self.assertIsNot(resp.body, [1, 2, 3])
self.assertEqual(resp.get_header('x-api-total'), '3')
self.assertEqual(resp.get_header('x-api-returned'), '2')
def test_on_options(self):
"""
need to check if status of the response is set for 200 and
"""
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {}}
resp = Response()
resource = mongoengine.CollectionResource(objects_class=FakeObjectList,
max_limit=2)
resource.on_options(req=req, resp=resp)
self.assertEqual(resp.get_header('Allow'),
'GET, HEAD, OPTIONS, POST, PUT')
self.assertEqual(
resp.body, {
'name': 'FakeObjectList',
'description':
'Extend list to match interface of List resource',
})
def test_clean_check_error_raising(self):
"""
Check if clean function returns errors dict when `clean_param_name` raise `ParamException`
"""
resource = CollectionResource(objects_class=None)
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {'id': 1, 'name': 'Opentopic'}}
Response()
def clean_name_test(self):
raise ParamException('Test Error Message')
resource.clean_name = clean_name_test
data, errors = resource.clean(req.context['doc'])
self.assertEqual(data, {
'id': 1,
})
self.assertEqual(errors, {'name': ['Test Error Message']})
def test_auth_middleware_basic():
middleware = AuthenticateMiddleware()
req = Request({
'wsgi.errors': '',
'wsgi.input': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'PATH_INFO': '',
'SERVER_PROTOCOL': 'HTTP/1.1',
'HTTP_AUTHORIZATION': 'Basic {}'.format(basic_token)
})
resp = Response()
middleware.process_request(req, resp)
assert 'user' in req.context
assert 'dataset' in req.context['user']
assert 'sub' in req.context['user']
assert req.context['user']['dataset'] == 'ds002404'
assert req.context['user']['sub'] == 'fd44f5c5-b21b-420b-9555-af856efc9452'
def test_update_params(self):
"""
Test if param is updated and returned
"""
resource = SingleResource(objects_class=None)
env = create_environ(path='/')
req = Request(env)
req.context = {
'doc': {
'pk': 1,
'name': 'TestNewName'
},
}
resp = Response()
resource.objects_class = FakeObjectList()
resource.serialize = fake_serialize
resource.on_patch(req, resp)
self.assertEqual({
'pk': 1,
'name': 'TestNewName',
'_saved': True
}, resp.body)
def test_update_when_no_expected_params_is_set(self):
"""
Test if update func will not update param if it's not defined in expected params
"""
resource = SingleResource(objects_class=None)
env = create_environ(path='/')
req = Request(env)
req.context = {'doc': {'pk': 1, 'name': 'TestNewName'}}
def clean(data):
return {}, {}
resource.clean = clean
resp = Response()
resource.objects_class = FakeObjectList()
resource.serialize = fake_serialize
resource.on_patch(req, resp)
self.assertEqual({
'pk': 1,
'name': 'OldName',
'_saved': True
}, resp.body)
def test_default_response_context(self):
resp = Response()
assert isinstance(resp.context, dict)
def test_on_get(self):
resp = Response()
hello_resource = HelloResource()
hello_resource.on_get(None, resp)
self.assertEqual(resp.media, {'message': 'Hello'})
def hello_world(self, request):
resp = Response()
self.on_get(request, resp)
return resp.body
def hello_world():
resp = Response()
impl.on_get(request, resp)
return resp.body
def resp():
"""Simple empty Response fixture."""
return Response()
def index(self):
resp = Response()
self.impl.on_get(cherrypy.request, resp)
return resp.body
def test_default_response_context(self):
resp = Response()
self.assertIsInstance(resp.context, dict)
