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))