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_it_serves_mapped_requests(self):
self.router.add(
self.request.url.path,
lambda request: Response(b"Hello"),
)
self.assertEqual(
self.app.serve(self.request, path=self.request.url.path),
Response(b"Hello"),
)
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 assertNotPretty(self, content, response):
self.assertEqual(
response,
Response(
headers=Headers([("Content-Type", ["application/json"])]),
content=json.dumps(content, separators=",:"),
),
)
self.assertNotEqual(
response,
Response(headers=Headers([("Content-Type", ["application/json"])]),
content=json.dumps(content, indent=2, sort_keys=True)),
)
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 login(request, config, jinja):
error = None
if request.method == "POST":
if request.form["username"] != config["credentials"]["user"]:
error = "Invalid username"
elif request.form["password"] != config["credentials"]["password"]:
error = "Invalid password"
else:
# session["logged_in"] = True
# flash("You were logged in")
# return redirect(url_for("show_entries"))
return Response(code=302, headers={"Location": "/"})
content = jinja.get_template("login.html").render(error=error)
return Response(content.encode("utf-8"))
def fooBar(request):
self.assertEqual(request.headers.get(b"X-Foo"), [b"Hello"])
return Response(
code=302,
content=request.url.path,
headers=Headers([(b"Location", [b"http://example.com"])]),
)
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 route(self, request, path):
render = self.mapper.map(request=request, path=path)
if render is not None:
response = render(request=request)
else:
response = Response(code=404)
return response
def test_script_name(self):
self.minion.route(b"/home")(lambda request: Response(b"Hi!"))
app = TestApp(
wsgi.create_app(self.minion),
extra_environ={"SCRIPT_NAME": "/app"},
)
response = app.get(b"/app/home")
self.assertEqual(response.body, b"Hi!")
def path_view(request):
"""
A renderer (view) that returns a response with the request path.
Optionally adds a prefix to the front.
"""
return Response(content=request.url.path)
def add_entry(request, db, jinja):
# if not session.get('logged_in'):
# return Response(code=401)
db.execute("INSERT INTO entries (title, text) VALUES (?, ?)",
[request.form["title"], request.form["text"]])
db.commit()
# flash('New entry was successfully posted')
# return redirect(url_for('show_entries'))
return Response(code=302, headers={"Location": "/"})
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!"))
class TreeResource(object):
"""
A tree resource that supports adding children via :meth:`set_child`\ .
"""
render = attr.ib(default=lambda request: Response(code=404))
_children = attr.ib(default=attr.Factory(dict))
_no_such_child = LeafResource(render=lambda request: Response(code=404))
def get_child(self, name, request):
child = self._children.get(name)
if child is None:
return self._no_such_child
return child
def set_child(self, name, resource):
self._children[name] = resource
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 path_view(request):
"""
A renderer (view) that returns a response with the request path.
Optionally adds a prefix to the front.
"""
path = b"/" + b"/".join(each.encode("ascii") for each in request.url.path)
return Response(content=path)
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 render(self, request):
if request.method == b"GET":
fields = [
field for raw in request.url.get(b"fields")
for field in raw.rstrip(b",").split(b",")
]
content = self.manager.list(fields=fields, )
elif request.method == b"POST":
try:
new = self.from_detail_json(request.content)
except ValueError:
return Response(code=400)
content = self.for_detail_json(self.manager.create(**new))
elif request.method == b"DELETE":
self.manager.delete(id=json.load(request.content)[u"id"])
return Response(code=204)
else:
return Response(code=405)
return self.renderer.render(jsonable=content, request=request)
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 render(self, request, jsonable):
machine_json = request.accept.media_types[-1] == MediaRange(
type="application",
subtype="json",
)
if machine_json:
content = self._dumps(jsonable, separators=",:")
else:
content = self._dumps(jsonable, indent=2, sort_keys=True)
return Response(
content=content,
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})
class TreeResource(object):
"""
A tree resource that supports adding children via :meth:`set_child`\ .
"""
_no_such_child = LeafResource(render=lambda request: Response(code=404))
def __init__(self, render):
self.children = {}
self.render = render
def get_child(self, name, request):
child = self.children.get(name)
if child is None:
return self._no_such_child
return child
def set_child(self, name, resource):
self.children[name] = resource
def view_error(self, request, error):
return Response(error.__class__.__name__)
def render_error(self, request, response, exc):
return Response(response.content + exc.__class__.__name__)
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 get_child(self, name, request):
return LeafResource(
render=lambda request: Response(b"Hello " + name), )
def view(request, **kwargs):
return Response(json.dumps(kwargs))
def render(self, request, response):
return Response(b"".join(reversed(response.content)))
