def save_message(message: Message) -> Response:
response = Response(HTTP_302,
content="",
headers={
"location": app.reverse_uri("index"),
})
response.set_cookie(Cookie("message", message.message))
return response
def test_responses_can_set_cookies():
# Given that I have a Response instance
response = Response(HTTP_200)
# When I call set_cookie on it with a couple valid cookies
response.set_cookie(Cookie("a", "b"))
response.set_cookie(Cookie("c", "d"))
# Then both cookies should be added to its headers
assert response.headers.get_all("set-cookie") == ["a=b", "c=d"]
def test_responses_get_content_length_does_not_change_the_streams_position():
# Given that I have a Response instance with some data in it
response = Response(HTTP_200, content="ABCD")
# When I read one byte from that data
response.stream.read(1)
# And get the content length
assert response.get_content_length() == 4
# And read one byte again
# Then it should pick up where it left off
assert response.stream.read(1) == b"B"
def send_message(params: QueryParams, mail: Mail):
"""Emails an email address provided in the query string"""
addresses = params.get_all("email")
if not addresses:
return Response(
HTTP_400,
content="Provide emails in the query params to send a welcome message",
)
msg = Message(
subject="Welcome to Molten!",
body="Welcome to Molten! Glad to have you here.",
recipients=addresses,
)
mail.send(msg)
return Response(HTTP_204, content="")
def handle(
resolver: DependencyResolver,
request: Request,
environ: Environ,
route: Optional[Route],
) -> Response:
if route is None or not getattr(route.handler, "supports_ws",
False):
return handler()
try:
connection = request.headers["connection"]
upgrade = request.headers["upgrade"]
websocket_key = request.headers["sec-websocket-key"]
websocket_version = request.headers["sec-websocket-version"]
except HeaderMissing as e:
raise HTTPError(
HTTP_400, {"errors": {
str(e): "this header is required"
}})
try:
origin = request.headers["origin"]
except HeaderMissing:
origin = ""
if self.origin_re and not self.origin_re.match(origin):
raise HTTPError(HTTP_400, {"error": "invalid origin"})
if "upgrade" not in connection.lower(
) or "websocket" not in upgrade.lower():
raise HTTPError(HTTP_400, {"error": "invalid upgrade request"})
if websocket_version not in SUPPORTED_VERSIONS:
return Response(
HTTP_426,
headers={"sec-websocket-version": SUPPORTED_VERSIONS_STR})
# TODO: Implement extension handling.
# TODO: Implement subprotocol handling.
stream = _BufferedStream(environ["gunicorn.socket"])
stream.write(
UPGRADE_RESPONSE_TEMPLATE % {
b"websocket_accept":
b64encode(sha1(f"{websocket_key}{PSK}".encode()).digest()),
})
websocket = Websocket(stream)
resolver.add_component(_WebsocketComponent(websocket))
try:
handler()
except Exception as e:
handle_exception = resolver.resolve(self.handle_exception)
handle_exception(exception=e)
finally:
websocket.close(CloseMessage())
raise RequestHandled("websocket request was upgraded")
def template_handler(mail_templates: MailTemplates) -> Response:
mail.send_message(
subject="Test email",
html=mail_templates.render("test_template.html", name="Molten"),
recipients=["*****@*****.**"],
)
return Response(HTTP_204, content="")
def test_responses_are_representable():
# Given that I have a Response instance
response = Response(HTTP_200)
# When I call repr on it
# Then I should get back a valid repr
assert repr(response)
def render(self, status: str, response_data: Any) -> Response:
content = packb(response_data, use_bin_type=True, default=self.default)
return Response(status,
stream=BytesIO(content),
headers={
"content-type": "application/x-msgpack",
})
def get_countries() -> Response:
return Response(HTTP_200,
stream=open(path_to("fixtures", "example.json"),
mode="rb"),
headers={
"content-type": "application/json",
})
def login(login: Login, auth: AuthProvider,
user_manager: UserProvider) -> Response:
user = auth.get_user_from_token(login.token)
if user is None:
return Response(HTTP_401, content='{}')
user = user_manager.get_user_from_external(user)
token = auth.get_user_token(user)
return Response(
HTTP_200,
content=json.dumps({'token': token}),
headers={
'Content-Type': 'application/json',
},
)
def middleware() -> Any:
try:
return handler()
except errors.ArtemisHTTPError as error:
return Response(
status=error.status,
content=json.dumps(error.response),
headers=error.headers)
def expose_metrics_multiprocess() -> Response: # pragma: no cover
"""Expose prometheus metrics from the current set of processes.
Use this instead of expose_metrics if you're using a multi-process
server.
"""
registry = CollectorRegistry()
multiprocess.MultiProcessCollector(registry)
return Response(HTTP_200,
headers=_HEADERS,
stream=BytesIO(generate_latest(registry)))
def sign_up(signup: Signup, mail: Mail, templates: MailTemplates):
"""Handler that simulates a basic async sending of an html templated welcome email"""
msg = Message(
subject="Welcome to Molten!",
body="This is a body that gets shown if html can't",
html=templates.render("welcome_mail.html", name=signup.first_name),
recipients=[signup.email],
)
Thread(target=send_async_email, args=(mail, msg)).start()
return Response(HTTP_204, content="")
def middleware(authorization: Optional[Header],
auth_provider: AuthProvider,
user_provider: UserProvider) -> Any:
if getattr(handler, 'exclude_auth', False):
return handler()
if not authorization:
return Response(HTTP_403, content='{}')
if not authorization.startswith('Bearer '):
return Response(HTTP_403, content='{}')
token = authorization.split(' ')[1]
if not token or not auth_provider.verify_user_token(token):
return Response(HTTP_403, content='{}')
user_provider.load_user(auth_provider.verify_user_token(token))
return handler()
def render(self, template_name: str, **context: Any) -> Response:
"""Find a template and render it.
Parameters:
template_name: The name of the template to render.
**context: Bindings passed to the template.
"""
template = self.environment.get_template(template_name)
rendered_template = template.render(**context)
return Response(HTTP_200, content=rendered_template, headers={
"content-type": "text/html",
})
def send_envelope(envelope: Envelope) -> Response:
if envelope.recipient != "*":
try:
MAILBOXES[envelope.recipient].put(envelope)
except KeyError:
raise HTTPError(HTTP_404,
{"error": f"user {envelope.recipient} not found"})
else:
for mailbox in MAILBOXES.values():
mailbox.put(envelope)
return Response(HTTP_204)
def render(self, status: str, response_data: Any) -> Response:
if response_data is not None:
try:
response_data = dump_schema(response_data)
except TypeError:
pass
# TODO - fix hack to prevent camel casing openAPI data
if type(response_data) == dict:
if not response_data.get('openapi'):
response_data = parse_keys(response_data, types='camel')
content = json.dumps(response_data, default=self.default)
return Response(status, content=content, headers={
"content-type": "application/json; charset=utf-8",
})
def index() -> Response:
return Response(HTTP_200)
def render(self, status: str, response_data: Any) -> Response:
content = json.dumps(response_data, default=self.default)
return Response(status,
content=content,
headers={"content-type": "text/plain"})
def index(request: Request) -> Response:
return Response(HTTP_200, content="Hello!")
def params(params: QueryParams) -> Response:
return Response(HTTP_200, content=repr(params))
def no_content() -> Response:
return Response(HTTP_204)
def named_headers(content_type: Header) -> Response:
return Response(HTTP_200, content=f"{content_type}")
def named_optional_headers(content_type: Optional[Header]) -> Response:
return Response(HTTP_200, content=f"{content_type}")
def get_paste(paste_id: str) -> Response:
try:
paste = open(relative_path("uploads", paste_id), "rb")
return Response(HTTP_200, stream=paste)
except FileNotFoundError:
return Response(HTTP_404, content="Paste not found.")
def index() -> Response:
return Response(HTTP_200,
content=__doc__,
headers={
"content-type": "text/plain",
})
def named_params(x: QueryParam, y: QueryParam) -> Response:
return Response(HTTP_200, content=f"x: {x}, y: {y}")
def named_optional_params(x: Optional[QueryParam]) -> Response:
return Response(HTTP_200, content=f"{x}")
def test_auth(jwt: JWT):
cookie_name = "molten_auth_cookie"
cookie_value = jwt.encode({"sub": 123456, "name": "spiderman"})
auth_response = Response(HTTP_200)
auth_response.set_cookie(Cookie(cookie_name, cookie_value))
return auth_response
def parser(data: RequestData) -> Response:
return Response(HTTP_200)
