def test_wrong_content_type_server_error(self):
def my_fault_body_function():
return 'off'
resource = wsgi.Resource(None, my_fault_body_function)
request = wsgi.Request.blank("/",
method='POST',
headers={'Content-Type': "unknow"})
response = resource(request)
self.assertEqual(response.status_int, 500)
def test_dispatch_unknown_controller_action(self):
class Controller(object):
def index(self, request, pants=None):
return pants
def my_fault_body_function():
return 'off'
resource = wsgi.Resource(Controller(), my_fault_body_function)
self.assertRaises(AttributeError, resource.dispatch,
resource.controller, 'create', {})
def test_wrong_content_type_throws_unsupported_media_type_error(self):
def my_fault_body_function():
return 'off'
resource = wsgi.Resource(None, my_fault_body_function)
request = wsgi.Request.blank("/",
body="{some:json}",
method='POST',
headers={'Content-Type': "xxx"})
response = resource(request)
self.assertEqual(response.status_int, 400)
def test_malformed_request_body_throws_bad_request(self):
def my_fault_body_function():
return 'off'
resource = wsgi.Resource(None, my_fault_body_function)
request = wsgi.Request.blank(
"/",
body="{mal:formed",
method='POST',
headers={'Content-Type': "application/json"})
response = resource(request)
self.assertEqual(response.status_int, 400)
def test_dispatch(self):
class Controller(object):
def index(self, request, index=None):
return index
def my_fault_body_function():
return 'off'
resource = wsgi.Resource(Controller(), my_fault_body_function)
actual = resource.dispatch(resource.controller,
'index',
action_args={'index': 'off'})
expected = 'off'
self.assertEqual(actual, expected)
def test_type_error(self):
class Controller(object):
def index(self, request, index=None):
return index
def my_fault_body_function():
return 'off'
resource = wsgi.Resource(Controller(), my_fault_body_function)
request = wsgi.Request.blank("/",
method='POST',
headers={'Content-Type': "xml"})
response = resource.dispatch(request,
action='index',
action_args='test')
self.assertEqual(400, response.status_int)
def create_resource(version, controller_dict):
"""
Generic function for creating a wsgi resource
The function takes as input:
- desired version
- controller and metadata dictionary
e.g.: {'1.0': [ctrl_v10, meta_v10, xml_ns],
'1.1': [ctrl_v11, meta_v11, xml_ns]}
"""
# the first element of the iterable is expected to be the controller
controller = controller_dict[version][0]
# the second element should be the metadata
metadata = controller_dict[version][1]
# and the third element the xml namespace
xmlns = controller_dict[version][2]
# and also the function for building the fault body
fault_body_function = faults.fault_body_function(version)
headers_serializers = {
'1.0': HeaderSerializer10(),
'1.1': HeaderSerializer11()
}
xml_serializer = wsgi.XMLDictSerializer(metadata, xmlns)
json_serializer = wsgi.JSONDictSerializer()
xml_deserializer = wsgi.XMLDeserializer(metadata)
json_deserializer = wsgi.JSONDeserializer()
body_serializers = {
'application/xml': xml_serializer,
'application/json': json_serializer,
}
body_deserializers = {
'application/xml': xml_deserializer,
'application/json': json_deserializer,
}
serializer = wsgi.ResponseSerializer(body_serializers,
headers_serializers[version])
deserializer = wsgi.RequestDeserializer(body_deserializers)
return wsgi.Resource(controller,
fault_body_function,
deserializer,
serializer)
def test_call_resource_class_internal_error(self):
class Controller(object):
def index(self, request, index=None):
return index
def my_fault_body_function():
return 'off'
class FakeRequest():
def __init__(self):
self.url = 'http://where.no'
self.environ = 'environ'
self.body = '{"Content-Type": "xml"}'
def method(self):
pass
def best_match_content_type(self):
return 'application/json'
resource = wsgi.Resource(Controller(), my_fault_body_function)
request = FakeRequest()
result = resource(request)
self.assertEqual(500, result.status_int)