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=b"/"), method=b"GET") self.assertEqual(render(get), b"foo") put = Request(url=URL(path=b"/"), 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"}{"))
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_flash(self): self.request = request.Request(url=URL(path=b"/")) self.assertEqual(self.request.messages, []) self.request.flash(b"Hello World") self.assertEqual( self.request.messages, [request._Message(content=b"Hello World")], )
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)
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_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_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_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_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_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_single_level(self): root = LineDelimiterResource() request = Request(url=URL(path=b"/foo")) renderer = traversal.traverse( path=b"/foo", resource=root, request=request, ) self.assertEqual(renderer.render(request), b"foo")
def test_it_traverses_resources(self): root = LineDelimiterResource() request = Request(url=URL(path=b"/foo/bar/baz")) renderer = traversal.traverse( path=b"/foo/bar/baz", resource=root, request=request, ) self.assertEqual(renderer.render(request), b"foo\nbar\nbaz")
def url(self): environ = self.environ return URL.normalized( host=environ.get("HTTP_HOST") or environ["SERVER_NAME"], port=int(environ["SERVER_PORT"]), path=environ.get("SCRIPT_NAME", "") + environ.get("PATH_INFO", ""), query=parse_qs(environ.get("QUERY_STRING", "")), scheme=environ["wsgi.url_scheme"], )
def url(self): environ = self.environ return URL.normalized( host=environ.get("HTTP_HOST") or environ["SERVER_NAME"], port=int(environ["SERVER_PORT"]), path=environ.get("SCRIPT_NAME", "") + environ.get("PATH_INFO", ""), query=parse_qs(environ.get("QUERY_STRING", "")), scheme=environ["wsgi.url_scheme"], )
def test_zero_levels(self): root = LineDelimiterResource() request = Request(url=URL(path=b"/")) renderer = traversal.traverse( path=b"/", resource=root, request=request, ) self.assertIs(renderer, root)
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_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_non_default_port(self): environ = { "SERVER_NAME": "localhost", "SERVER_PORT": "8080", "wsgi.url_scheme": "http", } self.assertEqual( wsgi.Request(environ).url, URL(scheme=b"http", host=b"localhost", port=8080), )
def test_no_host_no_path_no_query_string(self): environ = { "SERVER_NAME": "localhost", "SERVER_PORT": "80", "wsgi.url_scheme": "http", } self.assertEqual( wsgi.Request(environ).url, URL(scheme=b"http", host=b"localhost"), )
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"))
def test_script_name(self): environ = { "HTTP_HOST": "example.org", "SCRIPT_NAME": "/stuff", "PATH_INFO": "/things", "SERVER_PORT": "443", "wsgi.url_scheme": "https", } self.assertEqual( wsgi.Request(environ).url, URL(scheme=b"https", host=b"example.org", path=b"/stuff/things"), )
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"])]), ), )
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_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_it_parses_the_url(self): request = self.get_request( b"/respond?foo=bar#baz", headers=Headers([(b"Host", [b"example.com"])]), ) self.assertEqual( request.url, URL( scheme=b"http", host=b"example.com", path=b"/respond", query={b"foo" : [b"bar"]}, fragment=b"", # Fragments should be ignored by servers. ), )
def test_query_string(self): environ = { "SERVER_NAME": "example.com", "SERVER_PORT": "80", "QUERY_STRING": "foo=bar", "wsgi.url_scheme": "http", } self.assertEqual( wsgi.Request(environ).url, URL( scheme=b"http", host=b"example.com", query={b"foo": [b"bar"]}, ), )
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=b"/0/1/2/3/4/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