def test_customized_dumps(self):
"""
A customized dumps applies to both pretty and non-pretty responses.
"""
renderer = renderers.JSON(default=lambda obj: 23)
render = renderers.bind(renderer, to=lambda _: {"foo": object()})
request = Request(
url=URL(path=b"/"),
headers=Headers([("Accept", ["application/json"])]),
)
self.assertEqual(
render(request),
Response(
content=b'{"foo":23}',
headers=Headers([("Content-Type", ["application/json"])]),
),
)
self.assertEqual(
render(Request(url=URL(path=b"/"))),
Response(
content=b'{\n "foo": 23\n}',
headers=Headers([("Content-Type", ["application/json"])]),
),
)
def test_known_HTTP_methods_use_associated_renderer(self):
render = traversal.method_delegate(
GET=lambda request: b"foo",
put=lambda request: request.method,
)
get = Request(url=URL(path=[u""]), method=b"GET")
self.assertEqual(render(get), b"foo")
put = Request(url=URL(path=[u""]), method=b"PUT")
self.assertEqual(render(put), b"PUT")
def test_it_maps_multiple_routes_for_specified_methods(self):
self.mapper.add(b"/", lambda r: Response(b"GET"), methods=[b"GET"])
self.mapper.add(b"/", lambda r: Response(b"POST"), methods=[b"POST"])
get = Request(url=URL(path=b"/"), method=b"GET")
post = Request(url=URL(path=b"/"), method=b"POST")
map = self.mapper.map
self.assertEqual(
(map(get, path=b"/")(get), map(post, path=b"/")(post)),
(Response(b"GET"), Response(b"POST")),
)
def test_specified_renderer_multiple_routes(self):
self.router.add(b"/", view, methods=[b"GET"], renderer=None)
self.router.add(
b"/", view, methods=[b"POST"], renderer=ReverseRenderer(),
)
get = Request(url=URL(path=b"/"), method=b"GET")
response = self.router.route(get, path=b"/")
self.assertEqual(response, Response(b"{}"))
post = Request(url=URL(path=b"/"), method=b"POST")
response = self.router.route(post, path=b"/")
self.assertEqual(response, Response(b"}{"))
class TestUnicodeRenderer(TestCase):
request = Request(url=URL(path=b"/"))
def test_it_renders_via_the_given_encoding(self):
renderer = renderers.Unicode(encoding="utf-8")
render = renderers.bind(renderer, to=lambda _: u"שלום")
self.assertEqual(
render(self.request),
Response(u"שלום".encode("utf-8")),
)
def test_encoding_ignoring_errors(self):
renderer = renderers.Unicode(encoding="ascii", errors="ignore")
render = renderers.bind(renderer, to=lambda _: u"שלום")
self.assertEqual(render(self.request), Response(b""))
def test_encoding_errors_by_default(self):
renderer = renderers.Unicode(encoding="ascii")
render = renderers.bind(renderer, to=lambda _: u"שלום")
with self.assertRaises(UnicodeEncodeError):
render(self.request)
def test_UTF8(self):
render = renderers.bind(renderers.UTF8, to=lambda _: u"שלום")
self.assertEqual(
render(self.request),
Response(u"שלום".encode("utf-8")),
)
def test_it_maps_routes_for_specified_methods(self):
self.mapper.add(b"/route", view, methods=[b"POST"])
request = Request(
url=URL(path=[u"route"], rooted=True),
method=b"POST",
)
self.assertEqual(self.mapper.map(request, path=b"/route"), view)
def test_it_handles_routing_redirects(self):
self.mapper.add(b"/<int:year>/", view)
request = Request(url=URL(path=b"/2013"))
render = self.mapper.map(request, path=b"/2013")
self.assertEqual(
render(request), redirect(b"http:///2013/", code=301),
)
def test_it_maps_routes(self):
self.mapper.add(b"/route", view)
render = self.mapper.map(
Request(url=URL(path=b"/route")),
path=b"/route",
)
self.assertIs(render, view)
def render(self, twistedRequest):
path = twistedRequest.uri.lstrip("/").decode("ascii").split(u"/")
request = Request(
content=twistedRequest.content,
headers=Headers(twistedRequest.requestHeaders.getAllRawHeaders()),
method=twistedRequest.method,
url=URL(
scheme=u"https" if twistedRequest.isSecure() else u"http",
host=twistedRequest.getRequestHostname().decode("ascii"),
path=path,
query=[(k.decode("ascii"), each.decode("ascii"))
for k, v in twistedRequest.args.items() for each in v],
),
)
response = self.application.serve(
request=request,
path=b"/" + b"/".join(twistedRequest.postpath),
)
twistedRequest.setResponseCode(response.code)
for k, v in response.headers.canonicalized():
twistedRequest.responseHeaders.setRawHeaders(k, v)
return response.content
def test_dict_sort_keys(self):
content = OrderedDict([("foo", "bar"), ("baz", "quux")])
render = renderers.bind(renderers.JSON(), to=lambda _: content)
request = Request(
url=URL(path=b"/"),
headers=Headers([("Accept", ["*/*"])]),
)
self.assertPretty(content, render(request))
def test_it_dumps_practical_json_for_machines(self):
content = ["a", "b", "c"]
render = renderers.bind(renderers.JSON(), to=lambda _: content)
request = Request(
url=URL(path=b"/"),
headers=Headers([("Accept", ["application/json"])]),
)
self.assertNotPretty(content, render(request))
def test_it_dumps_pretty_json_for_humans(self):
content = ["a", "b", "c"]
render = renderers.bind(renderers.JSON(), to=lambda _: content)
request = Request(
url=URL(path=b"/"),
headers=Headers([("Accept", ["*/*"])]),
)
self.assertPretty(content, render(request))
def test_it_maps_routes_with_arguments(self):
self.mapper.add(b"/route/{year}", view, stuff=b"12")
request = Request(url=URL(path=b"/route/2013"))
render = self.mapper.map(request, path=b"/route/2013")
self.assertEqual(
json.loads(render(request).content),
{b"year" : b"2013", b"stuff" : b"12"},
)
def test_single_level(self):
root = LineDelimiterResource()
request = Request(url=URL(path=[u"foo"]))
renderer = traversal.traverse(
path=b"/foo",
resource=root,
request=request,
)
self.assertEqual(renderer.render(request), b"foo")
def test_zero_levels(self):
root = LineDelimiterResource()
request = Request(url=URL(path=[u""]))
renderer = traversal.traverse(
path=b"/",
resource=root,
request=request,
)
self.assertIs(renderer, root)
def test_it_traverses_resources(self):
root = LineDelimiterResource()
request = Request(url=URL(path=[u"foo", u"bar", u"baz"]))
renderer = traversal.traverse(
path=b"/foo/bar/baz",
resource=root,
request=request,
)
self.assertEqual(renderer.render(request), b"foo\nbar\nbaz")
def test_it_routes_simple_views(self):
minion = Application(router=Router(mapper=SimpleMapper()))
@minion.route(b"/show")
def show(request):
return Response(b"Hello World!")
response = minion.serve(Request(url=URL(path=b"/show")), path=b"/show")
self.assertEqual(response, Response(b"Hello World!"))
def test_it_traverses_children(self):
class Resource(object):
def get_child(self, name, request):
return LeafResource(
render=lambda request: Response(b"Hello " + name), )
mapper = routing.TraversalMapper(root=Resource())
request = Request(url=URL(path=b"/world"))
render = mapper.map(request, path=b"/world")
self.assertEqual(render(request), Response(content=b"Hello world"))
def test_renderer_without_error_handler(self):
class RendererWithoutErrorHandler(object):
def render(self, request, response):
raise ZeroDivisionError()
self.router.add(b"/", view, renderer=RendererWithoutErrorHandler())
request = Request(url=URL(path=b"/"))
with self.assertRaises(ZeroDivisionError):
self.router.route(request, path=b"/")
def test_renderer_with_render_error_handler(self):
class RendererWithErrorHandler(object):
def render(self, request, response):
raise ZeroDivisionError()
def render_error(self, request, response, exc):
return Response(response.content + exc.__class__.__name__)
self.router.add(b"/", view, renderer=RendererWithErrorHandler())
response = self.router.route(Request(url=URL(path=b"/")), path=b"/")
self.assertEqual(response, Response(b"{}ZeroDivisionError"))
class TestSimpleJSON(TestCase):
request = Request(url=URL(path=b"/"))
def test_it_dumps_json(self):
renderer = renderers.SimpleJSON()
render = renderers.bind(renderer, to=lambda _: {"foo": "bar"})
self.assertEqual(render(self.request), Response(b'{"foo": "bar"}'))
def test_customized_dumps(self):
renderer = renderers.SimpleJSON(separators=",:")
render = renderers.bind(renderer, to=lambda _: {"foo": "bar"})
self.assertEqual(render(self.request), Response(b'{"foo":"bar"}'))
def test_separators(self):
render = renderers.bind(renderers.JSON(), to=lambda _: dict(a=1, b=2))
request = Request(
url=URL(path=b"/"),
headers=Headers([("Accept", ["application/json"])]),
)
self.assertEqual(
render(request),
Response(
content=b'{"a":1,"b":2}',
headers=Headers([("Content-Type", ["application/json"])]),
),
)
def test_renderer_with_view_error_handler(self):
class RendererWithErrorHandler(object):
def render(self, request, response):
raise ZeroDivisionError("I won't ever get raised")
def view_error(self, request, error):
return Response(error.__class__.__name__)
def boom(request):
raise IndexError()
self.router.add(b"/", boom, renderer=RendererWithErrorHandler())
response = self.router.route(Request(url=URL(path=b"/")), path=b"/")
self.assertEqual(response, Response(b"IndexError"))
def test_separators(self):
render = renderers.bind(renderers.JSON(), to=lambda _: dict(a=1, b=2))
request = Request(
url=URL(path=[u""]),
headers=Headers([("Accept", ["application/json"])]),
)
response = render(request)
self.assertEqual(
response, Response(
content=response.content,
headers=Headers([("Content-Type", ["application/json"])]),
),
)
self.assertNotIn(response.content, " ")
self.assertEqual(json.loads(response.content), {"a": 1, "b": 2})
def test_leaf_resources_are_not_traversed(self):
class Resource(object):
def __init__(self, name=b""):
self.name = name
def get_child(self, name, request):
resource = Resource(name=name)
if name == b"2":
resource.is_leaf = True
return resource
def render(self, name):
return self.name
root = Resource()
request = Request(url=URL(path=[u"0", u"1", u"2", u"3", u"4", u"5"]))
renderer = traversal.traverse(
path=b"/0/1/2/3/4/5",
resource=root,
request=request,
)
self.assertEqual(renderer.render(request), b"2")
def render(self, twistedRequest):
request = Request(
content=twistedRequest.content,
headers=Headers(twistedRequest.requestHeaders.getAllRawHeaders()),
method=twistedRequest.method,
url=URL(
scheme=b"https" if twistedRequest.isSecure() else b"http",
host=twistedRequest.getRequestHostname(),
path=twistedRequest.uri,
query=twistedRequest.args,
),
)
response = self.application.serve(
request=request,
path=b"/" + b"/".join(twistedRequest.postpath),
)
twistedRequest.setResponseCode(response.code)
for k, v in response.headers.canonicalized():
twistedRequest.responseHeaders.setRawHeaders(k, v)
return response.content
def setUp(self):
self.manager = Manager()
self.router = Router(mapper=SimpleMapper())
self.app = core.Application(manager=self.manager, router=self.router)
self.request = Request(url=URL(path=[u""]))
def test_specified_renderer(self):
self.router.add(b"/", view, renderer=ReverseRenderer())
request = Request(url=URL(path=b"/"))
response = self.router.route(request, path=b"/")
self.assertEqual(response, Response(b"}{"))
def test_unknown_route(self):
request = Request(url=URL(path=b"/404"))
response = self.router.route(request, path=b"/404")
self.assertEqual(response, Response(code=404))
def test_route(self):
self.router.add(b"/", view)
request = Request(url=URL(path=b"/"))
response = self.router.route(request, path=b"/")
self.assertEqual(response, view(request))
