957 lines
27 KiB
Python
957 lines
27 KiB
Python
import pytest
|
|
|
|
from sanic.testing import SanicASGITestClient
|
|
from sanic.response import text
|
|
|
|
|
|
def asgi_client_instantiation(app):
|
|
assert isinstance(app.asgi_client, SanicASGITestClient)
|
|
|
|
|
|
# import logging
|
|
# import os
|
|
# import ssl
|
|
|
|
# from json import dumps as json_dumps
|
|
# from json import loads as json_loads
|
|
# from urllib.parse import urlparse
|
|
|
|
# import pytest
|
|
|
|
# from sanic import Blueprint, Sanic
|
|
# from sanic.exceptions import ServerError
|
|
# from sanic.request import DEFAULT_HTTP_CONTENT_TYPE, RequestParameters
|
|
# from sanic.response import json, text
|
|
# from sanic.testing import HOST, PORT
|
|
|
|
|
|
# ------------------------------------------------------------ #
|
|
# GET - Adapted from test_requests.py
|
|
# ------------------------------------------------------------ #
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_basic_request(app):
|
|
@app.route("/")
|
|
def handler(request):
|
|
return text("Hello")
|
|
|
|
_, response = await app.asgi_client.get("/")
|
|
assert response.text == "Hello"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_ip(app):
|
|
@app.route("/")
|
|
def handler(request):
|
|
return text("{}".format(request.ip))
|
|
|
|
request, response = await app.asgi_client.get("/")
|
|
|
|
assert response.text == "mockserver"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
def test_text(app):
|
|
@app.route("/")
|
|
async def handler(request):
|
|
return text("Hello")
|
|
|
|
request, response = await app.asgi_client.get("/")
|
|
|
|
assert response.text == "Hello"
|
|
|
|
|
|
# def test_headers(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# headers = {"spam": "great"}
|
|
# return text("Hello", headers=headers)
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert response.headers.get("spam") == "great"
|
|
|
|
|
|
# def test_non_str_headers(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# headers = {"answer": 42}
|
|
# return text("Hello", headers=headers)
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert response.headers.get("answer") == "42"
|
|
|
|
|
|
# def test_invalid_response(app):
|
|
# @app.exception(ServerError)
|
|
# def handler_exception(request, exception):
|
|
# return text("Internal Server Error.", 500)
|
|
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return "This should fail"
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
# assert response.status == 500
|
|
# assert response.text == "Internal Server Error."
|
|
|
|
|
|
# def test_json(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return json({"test": True})
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# results = json_loads(response.text)
|
|
|
|
# assert results.get("test") is True
|
|
|
|
|
|
# def test_empty_json(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# assert request.json is None
|
|
# return json(request.json)
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
# assert response.status == 200
|
|
# assert response.text == "null"
|
|
|
|
|
|
# def test_invalid_json(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return json(request.json)
|
|
|
|
# data = "I am not json"
|
|
# request, response = app.asgi_client.get("/", data=data)
|
|
|
|
# assert response.status == 400
|
|
|
|
|
|
# def test_query_string(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.get(
|
|
# "/", params=[("test1", "1"), ("test2", "false"), ("test2", "true")]
|
|
# )
|
|
|
|
# assert request.args.get("test1") == "1"
|
|
# assert request.args.get("test2") == "false"
|
|
# assert request.args.getlist("test2") == ["false", "true"]
|
|
# assert request.args.getlist("test1") == ["1"]
|
|
# assert request.args.get("test3", default="My value") == "My value"
|
|
|
|
|
|
# def test_uri_template(app):
|
|
# @app.route("/foo/<id:int>/bar/<name:[A-z]+>")
|
|
# async def handler(request, id, name):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.get("/foo/123/bar/baz")
|
|
# assert request.uri_template == "/foo/<id:int>/bar/<name:[A-z]+>"
|
|
|
|
|
|
# def test_token(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# # uuid4 generated token.
|
|
# token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
|
|
# headers = {
|
|
# "content-type": "application/json",
|
|
# "Authorization": "{}".format(token),
|
|
# }
|
|
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
|
|
# assert request.token == token
|
|
|
|
# token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
|
|
# headers = {
|
|
# "content-type": "application/json",
|
|
# "Authorization": "Token {}".format(token),
|
|
# }
|
|
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
|
|
# assert request.token == token
|
|
|
|
# token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
|
|
# headers = {
|
|
# "content-type": "application/json",
|
|
# "Authorization": "Bearer {}".format(token),
|
|
# }
|
|
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
|
|
# assert request.token == token
|
|
|
|
# # no Authorization headers
|
|
# headers = {"content-type": "application/json"}
|
|
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
|
|
# assert request.token is None
|
|
|
|
|
|
# def test_content_type(app):
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text(request.content_type)
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
# assert request.content_type == DEFAULT_HTTP_CONTENT_TYPE
|
|
# assert response.text == DEFAULT_HTTP_CONTENT_TYPE
|
|
|
|
# headers = {"content-type": "application/json"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.content_type == "application/json"
|
|
# assert response.text == "application/json"
|
|
|
|
|
|
# def test_remote_addr_with_two_proxies(app):
|
|
# app.config.PROXIES_COUNT = 2
|
|
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text(request.remote_addr)
|
|
|
|
# headers = {"X-Real-IP": "127.0.0.2", "X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.2"
|
|
# assert response.text == "127.0.0.2"
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == ""
|
|
# assert response.text == ""
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.0.1, 127.0.1.2"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.1"
|
|
# assert response.text == "127.0.0.1"
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
# assert request.remote_addr == ""
|
|
# assert response.text == ""
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.0.1, , ,,127.0.1.2"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.1"
|
|
# assert response.text == "127.0.0.1"
|
|
|
|
# headers = {
|
|
# "X-Forwarded-For": ", 127.0.2.2, , ,127.0.0.1, , ,,127.0.1.2"
|
|
# }
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.1"
|
|
# assert response.text == "127.0.0.1"
|
|
|
|
|
|
# def test_remote_addr_with_infinite_number_of_proxies(app):
|
|
# app.config.PROXIES_COUNT = -1
|
|
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text(request.remote_addr)
|
|
|
|
# headers = {"X-Real-IP": "127.0.0.2", "X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.2"
|
|
# assert response.text == "127.0.0.2"
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.1.1"
|
|
# assert response.text == "127.0.1.1"
|
|
|
|
# headers = {
|
|
# "X-Forwarded-For": "127.0.0.5, 127.0.0.4, 127.0.0.3, 127.0.0.2, 127.0.0.1"
|
|
# }
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.5"
|
|
# assert response.text == "127.0.0.5"
|
|
|
|
|
|
# def test_remote_addr_without_proxy(app):
|
|
# app.config.PROXIES_COUNT = 0
|
|
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text(request.remote_addr)
|
|
|
|
# headers = {"X-Real-IP": "127.0.0.2", "X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == ""
|
|
# assert response.text == ""
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == ""
|
|
# assert response.text == ""
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.0.1, 127.0.1.2"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == ""
|
|
# assert response.text == ""
|
|
|
|
|
|
# def test_remote_addr_custom_headers(app):
|
|
# app.config.PROXIES_COUNT = 1
|
|
# app.config.REAL_IP_HEADER = "Client-IP"
|
|
# app.config.FORWARDED_FOR_HEADER = "Forwarded"
|
|
|
|
# @app.route("/")
|
|
# async def handler(request):
|
|
# return text(request.remote_addr)
|
|
|
|
# headers = {"X-Real-IP": "127.0.0.2", "Forwarded": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.1.1"
|
|
# assert response.text == "127.0.1.1"
|
|
|
|
# headers = {"X-Forwarded-For": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == ""
|
|
# assert response.text == ""
|
|
|
|
# headers = {"Client-IP": "127.0.0.2", "Forwarded": "127.0.1.1"}
|
|
# request, response = app.asgi_client.get("/", headers=headers)
|
|
# assert request.remote_addr == "127.0.0.2"
|
|
# assert response.text == "127.0.0.2"
|
|
|
|
|
|
# def test_match_info(app):
|
|
# @app.route("/api/v1/user/<user_id>/")
|
|
# async def handler(request, user_id):
|
|
# return json(request.match_info)
|
|
|
|
# request, response = app.asgi_client.get("/api/v1/user/sanic_user/")
|
|
|
|
# assert request.match_info == {"user_id": "sanic_user"}
|
|
# assert json_loads(response.text) == {"user_id": "sanic_user"}
|
|
|
|
|
|
# # ------------------------------------------------------------ #
|
|
# # POST
|
|
# # ------------------------------------------------------------ #
|
|
|
|
|
|
# def test_post_json(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# payload = {"test": "OK"}
|
|
# headers = {"content-type": "application/json"}
|
|
|
|
# request, response = app.asgi_client.post(
|
|
# "/", data=json_dumps(payload), headers=headers
|
|
# )
|
|
|
|
# assert request.json.get("test") == "OK"
|
|
# assert request.json.get("test") == "OK" # for request.parsed_json
|
|
# assert response.text == "OK"
|
|
|
|
|
|
# def test_post_form_urlencoded(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# payload = "test=OK"
|
|
# headers = {"content-type": "application/x-www-form-urlencoded"}
|
|
|
|
# request, response = app.asgi_client.post(
|
|
# "/", data=payload, headers=headers
|
|
# )
|
|
|
|
# assert request.form.get("test") == "OK"
|
|
# assert request.form.get("test") == "OK" # For request.parsed_form
|
|
|
|
|
|
# @pytest.mark.parametrize(
|
|
# "payload",
|
|
# [
|
|
# "------sanic\r\n"
|
|
# 'Content-Disposition: form-data; name="test"\r\n'
|
|
# "\r\n"
|
|
# "OK\r\n"
|
|
# "------sanic--\r\n",
|
|
# "------sanic\r\n"
|
|
# 'content-disposition: form-data; name="test"\r\n'
|
|
# "\r\n"
|
|
# "OK\r\n"
|
|
# "------sanic--\r\n",
|
|
# ],
|
|
# )
|
|
# def test_post_form_multipart_form_data(app, payload):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# headers = {"content-type": "multipart/form-data; boundary=----sanic"}
|
|
|
|
# request, response = app.asgi_client.post(data=payload, headers=headers)
|
|
|
|
# assert request.form.get("test") == "OK"
|
|
|
|
|
|
# @pytest.mark.parametrize(
|
|
# "path,query,expected_url",
|
|
# [
|
|
# ("/foo", "", "http://{}:{}/foo"),
|
|
# ("/bar/baz", "", "http://{}:{}/bar/baz"),
|
|
# ("/moo/boo", "arg1=val1", "http://{}:{}/moo/boo?arg1=val1"),
|
|
# ],
|
|
# )
|
|
# def test_url_attributes_no_ssl(app, path, query, expected_url):
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# app.add_route(handler, path)
|
|
|
|
# request, response = app.asgi_client.get(path + "?{}".format(query))
|
|
# assert request.url == expected_url.format(HOST, PORT)
|
|
|
|
# parsed = urlparse(request.url)
|
|
|
|
# assert parsed.scheme == request.scheme
|
|
# assert parsed.path == request.path
|
|
# assert parsed.query == request.query_string
|
|
# assert parsed.netloc == request.host
|
|
|
|
|
|
# @pytest.mark.parametrize(
|
|
# "path,query,expected_url",
|
|
# [
|
|
# ("/foo", "", "https://{}:{}/foo"),
|
|
# ("/bar/baz", "", "https://{}:{}/bar/baz"),
|
|
# ("/moo/boo", "arg1=val1", "https://{}:{}/moo/boo?arg1=val1"),
|
|
# ],
|
|
# )
|
|
# def test_url_attributes_with_ssl_context(app, path, query, expected_url):
|
|
# current_dir = os.path.dirname(os.path.realpath(__file__))
|
|
# context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
|
|
# context.load_cert_chain(
|
|
# os.path.join(current_dir, "certs/selfsigned.cert"),
|
|
# keyfile=os.path.join(current_dir, "certs/selfsigned.key"),
|
|
# )
|
|
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# app.add_route(handler, path)
|
|
|
|
# request, response = app.asgi_client.get(
|
|
# "https://{}:{}".format(HOST, PORT) + path + "?{}".format(query),
|
|
# server_kwargs={"ssl": context},
|
|
# )
|
|
# assert request.url == expected_url.format(HOST, PORT)
|
|
|
|
# parsed = urlparse(request.url)
|
|
|
|
# assert parsed.scheme == request.scheme
|
|
# assert parsed.path == request.path
|
|
# assert parsed.query == request.query_string
|
|
# assert parsed.netloc == request.host
|
|
|
|
|
|
# @pytest.mark.parametrize(
|
|
# "path,query,expected_url",
|
|
# [
|
|
# ("/foo", "", "https://{}:{}/foo"),
|
|
# ("/bar/baz", "", "https://{}:{}/bar/baz"),
|
|
# ("/moo/boo", "arg1=val1", "https://{}:{}/moo/boo?arg1=val1"),
|
|
# ],
|
|
# )
|
|
# def test_url_attributes_with_ssl_dict(app, path, query, expected_url):
|
|
|
|
# current_dir = os.path.dirname(os.path.realpath(__file__))
|
|
# ssl_cert = os.path.join(current_dir, "certs/selfsigned.cert")
|
|
# ssl_key = os.path.join(current_dir, "certs/selfsigned.key")
|
|
|
|
# ssl_dict = {"cert": ssl_cert, "key": ssl_key}
|
|
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# app.add_route(handler, path)
|
|
|
|
# request, response = app.asgi_client.get(
|
|
# "https://{}:{}".format(HOST, PORT) + path + "?{}".format(query),
|
|
# server_kwargs={"ssl": ssl_dict},
|
|
# )
|
|
# assert request.url == expected_url.format(HOST, PORT)
|
|
|
|
# parsed = urlparse(request.url)
|
|
|
|
# assert parsed.scheme == request.scheme
|
|
# assert parsed.path == request.path
|
|
# assert parsed.query == request.query_string
|
|
# assert parsed.netloc == request.host
|
|
|
|
|
|
# def test_invalid_ssl_dict(app):
|
|
# @app.get("/test")
|
|
# async def handler(request):
|
|
# return text("ssl test")
|
|
|
|
# ssl_dict = {"cert": None, "key": None}
|
|
|
|
# with pytest.raises(ValueError) as excinfo:
|
|
# request, response = app.asgi_client.get(
|
|
# "/test", server_kwargs={"ssl": ssl_dict}
|
|
# )
|
|
|
|
# assert str(excinfo.value) == "SSLContext or certificate and key required."
|
|
|
|
|
|
# def test_form_with_multiple_values(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# payload = "selectedItems=v1&selectedItems=v2&selectedItems=v3"
|
|
|
|
# headers = {"content-type": "application/x-www-form-urlencoded"}
|
|
|
|
# request, response = app.asgi_client.post(
|
|
# "/", data=payload, headers=headers
|
|
# )
|
|
|
|
# assert request.form.getlist("selectedItems") == ["v1", "v2", "v3"]
|
|
|
|
|
|
# def test_request_string_representation(app):
|
|
# @app.route("/", methods=["GET"])
|
|
# async def get(request):
|
|
# return text("OK")
|
|
|
|
# request, _ = app.asgi_client.get("/")
|
|
# assert repr(request) == "<Request: GET />"
|
|
|
|
|
|
# @pytest.mark.parametrize(
|
|
# "payload,filename",
|
|
# [
|
|
# (
|
|
# "------sanic\r\n"
|
|
# 'Content-Disposition: form-data; filename="filename"; name="test"\r\n'
|
|
# "\r\n"
|
|
# "OK\r\n"
|
|
# "------sanic--\r\n",
|
|
# "filename",
|
|
# ),
|
|
# (
|
|
# "------sanic\r\n"
|
|
# 'content-disposition: form-data; filename="filename"; name="test"\r\n'
|
|
# "\r\n"
|
|
# 'content-type: application/json; {"field": "value"}\r\n'
|
|
# "------sanic--\r\n",
|
|
# "filename",
|
|
# ),
|
|
# (
|
|
# "------sanic\r\n"
|
|
# 'Content-Disposition: form-data; filename=""; name="test"\r\n'
|
|
# "\r\n"
|
|
# "OK\r\n"
|
|
# "------sanic--\r\n",
|
|
# "",
|
|
# ),
|
|
# (
|
|
# "------sanic\r\n"
|
|
# 'content-disposition: form-data; filename=""; name="test"\r\n'
|
|
# "\r\n"
|
|
# 'content-type: application/json; {"field": "value"}\r\n'
|
|
# "------sanic--\r\n",
|
|
# "",
|
|
# ),
|
|
# (
|
|
# "------sanic\r\n"
|
|
# 'Content-Disposition: form-data; filename*="utf-8\'\'filename_%C2%A0_test"; name="test"\r\n'
|
|
# "\r\n"
|
|
# "OK\r\n"
|
|
# "------sanic--\r\n",
|
|
# "filename_\u00A0_test",
|
|
# ),
|
|
# (
|
|
# "------sanic\r\n"
|
|
# 'content-disposition: form-data; filename*="utf-8\'\'filename_%C2%A0_test"; name="test"\r\n'
|
|
# "\r\n"
|
|
# 'content-type: application/json; {"field": "value"}\r\n'
|
|
# "------sanic--\r\n",
|
|
# "filename_\u00A0_test",
|
|
# ),
|
|
# ],
|
|
# )
|
|
# def test_request_multipart_files(app, payload, filename):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def post(request):
|
|
# return text("OK")
|
|
|
|
# headers = {"content-type": "multipart/form-data; boundary=----sanic"}
|
|
|
|
# request, _ = app.asgi_client.post(data=payload, headers=headers)
|
|
# assert request.files.get("test").name == filename
|
|
|
|
|
|
# def test_request_multipart_file_with_json_content_type(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def post(request):
|
|
# return text("OK")
|
|
|
|
# payload = (
|
|
# "------sanic\r\n"
|
|
# 'Content-Disposition: form-data; name="file"; filename="test.json"\r\n'
|
|
# "Content-Type: application/json\r\n"
|
|
# "Content-Length: 0"
|
|
# "\r\n"
|
|
# "\r\n"
|
|
# "------sanic--"
|
|
# )
|
|
|
|
# headers = {"content-type": "multipart/form-data; boundary=------sanic"}
|
|
|
|
# request, _ = app.asgi_client.post(data=payload, headers=headers)
|
|
# assert request.files.get("file").type == "application/json"
|
|
|
|
|
|
# def test_request_multipart_file_without_field_name(app, caplog):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def post(request):
|
|
# return text("OK")
|
|
|
|
# payload = (
|
|
# '------sanic\r\nContent-Disposition: form-data; filename="test.json"'
|
|
# "\r\nContent-Type: application/json\r\n\r\n\r\n------sanic--"
|
|
# )
|
|
|
|
# headers = {"content-type": "multipart/form-data; boundary=------sanic"}
|
|
|
|
# request, _ = app.asgi_client.post(
|
|
# data=payload, headers=headers, debug=True
|
|
# )
|
|
# with caplog.at_level(logging.DEBUG):
|
|
# request.form
|
|
|
|
# assert caplog.record_tuples[-1] == (
|
|
# "sanic.root",
|
|
# logging.DEBUG,
|
|
# "Form-data field does not have a 'name' parameter "
|
|
# "in the Content-Disposition header",
|
|
# )
|
|
|
|
|
|
# def test_request_multipart_file_duplicate_filed_name(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def post(request):
|
|
# return text("OK")
|
|
|
|
# payload = (
|
|
# "--e73ffaa8b1b2472b8ec848de833cb05b\r\n"
|
|
# 'Content-Disposition: form-data; name="file"\r\n'
|
|
# "Content-Type: application/octet-stream\r\n"
|
|
# "Content-Length: 15\r\n"
|
|
# "\r\n"
|
|
# '{"test":"json"}\r\n'
|
|
# "--e73ffaa8b1b2472b8ec848de833cb05b\r\n"
|
|
# 'Content-Disposition: form-data; name="file"\r\n'
|
|
# "Content-Type: application/octet-stream\r\n"
|
|
# "Content-Length: 15\r\n"
|
|
# "\r\n"
|
|
# '{"test":"json2"}\r\n'
|
|
# "--e73ffaa8b1b2472b8ec848de833cb05b--\r\n"
|
|
# )
|
|
|
|
# headers = {
|
|
# "Content-Type": "multipart/form-data; boundary=e73ffaa8b1b2472b8ec848de833cb05b"
|
|
# }
|
|
|
|
# request, _ = app.asgi_client.post(
|
|
# data=payload, headers=headers, debug=True
|
|
# )
|
|
# assert request.form.getlist("file") == [
|
|
# '{"test":"json"}',
|
|
# '{"test":"json2"}',
|
|
# ]
|
|
|
|
|
|
# def test_request_multipart_with_multiple_files_and_type(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def post(request):
|
|
# return text("OK")
|
|
|
|
# payload = (
|
|
# '------sanic\r\nContent-Disposition: form-data; name="file"; filename="test.json"'
|
|
# "\r\nContent-Type: application/json\r\n\r\n\r\n"
|
|
# '------sanic\r\nContent-Disposition: form-data; name="file"; filename="some_file.pdf"\r\n'
|
|
# "Content-Type: application/pdf\r\n\r\n\r\n------sanic--"
|
|
# )
|
|
# headers = {"content-type": "multipart/form-data; boundary=------sanic"}
|
|
|
|
# request, _ = app.asgi_client.post(data=payload, headers=headers)
|
|
# assert len(request.files.getlist("file")) == 2
|
|
# assert request.files.getlist("file")[0].type == "application/json"
|
|
# assert request.files.getlist("file")[1].type == "application/pdf"
|
|
|
|
|
|
# def test_request_repr(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("pass")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
# assert repr(request) == "<Request: GET />"
|
|
|
|
# request.method = None
|
|
# assert repr(request) == "<Request: None />"
|
|
|
|
|
|
# def test_request_bool(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("pass")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
# assert bool(request)
|
|
|
|
# request.transport = False
|
|
# assert not bool(request)
|
|
|
|
|
|
# def test_request_parsing_form_failed(app, caplog):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def handler(request):
|
|
# return text("OK")
|
|
|
|
# payload = "test=OK"
|
|
# headers = {"content-type": "multipart/form-data"}
|
|
|
|
# request, response = app.asgi_client.post(
|
|
# "/", data=payload, headers=headers
|
|
# )
|
|
|
|
# with caplog.at_level(logging.ERROR):
|
|
# request.form
|
|
|
|
# assert caplog.record_tuples[-1] == (
|
|
# "sanic.error",
|
|
# logging.ERROR,
|
|
# "Failed when parsing form",
|
|
# )
|
|
|
|
|
|
# def test_request_args_no_query_string(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("pass")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert request.args == {}
|
|
|
|
|
|
# def test_request_raw_args(app):
|
|
|
|
# params = {"test": "OK"}
|
|
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("pass")
|
|
|
|
# request, response = app.asgi_client.get("/", params=params)
|
|
|
|
# assert request.raw_args == params
|
|
|
|
|
|
# def test_request_query_args(app):
|
|
# # test multiple params with the same key
|
|
# params = [("test", "value1"), ("test", "value2")]
|
|
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("pass")
|
|
|
|
# request, response = app.asgi_client.get("/", params=params)
|
|
|
|
# assert request.query_args == params
|
|
|
|
# # test cached value
|
|
# assert (
|
|
# request.parsed_not_grouped_args[(False, False, "utf-8", "replace")]
|
|
# == request.query_args
|
|
# )
|
|
|
|
# # test params directly in the url
|
|
# request, response = app.asgi_client.get("/?test=value1&test=value2")
|
|
|
|
# assert request.query_args == params
|
|
|
|
# # test unique params
|
|
# params = [("test1", "value1"), ("test2", "value2")]
|
|
|
|
# request, response = app.asgi_client.get("/", params=params)
|
|
|
|
# assert request.query_args == params
|
|
|
|
# # test no params
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert not request.query_args
|
|
|
|
|
|
# def test_request_query_args_custom_parsing(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("pass")
|
|
|
|
# request, response = app.asgi_client.get(
|
|
# "/?test1=value1&test2=&test3=value3"
|
|
# )
|
|
|
|
# assert request.get_query_args(keep_blank_values=True) == [
|
|
# ("test1", "value1"),
|
|
# ("test2", ""),
|
|
# ("test3", "value3"),
|
|
# ]
|
|
# assert request.query_args == [("test1", "value1"), ("test3", "value3")]
|
|
# assert request.get_query_args(keep_blank_values=False) == [
|
|
# ("test1", "value1"),
|
|
# ("test3", "value3"),
|
|
# ]
|
|
|
|
# assert request.get_args(keep_blank_values=True) == RequestParameters(
|
|
# {"test1": ["value1"], "test2": [""], "test3": ["value3"]}
|
|
# )
|
|
|
|
# assert request.args == RequestParameters(
|
|
# {"test1": ["value1"], "test3": ["value3"]}
|
|
# )
|
|
|
|
# assert request.get_args(keep_blank_values=False) == RequestParameters(
|
|
# {"test1": ["value1"], "test3": ["value3"]}
|
|
# )
|
|
|
|
|
|
# def test_request_cookies(app):
|
|
|
|
# cookies = {"test": "OK"}
|
|
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.get("/", cookies=cookies)
|
|
|
|
# assert request.cookies == cookies
|
|
# assert request.cookies == cookies # For request._cookies
|
|
|
|
|
|
# def test_request_cookies_without_cookies(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert request.cookies == {}
|
|
|
|
|
|
# def test_request_port(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# port = request.port
|
|
# assert isinstance(port, int)
|
|
|
|
# delattr(request, "_socket")
|
|
# delattr(request, "_port")
|
|
|
|
# port = request.port
|
|
# assert isinstance(port, int)
|
|
# assert hasattr(request, "_socket")
|
|
# assert hasattr(request, "_port")
|
|
|
|
|
|
# def test_request_socket(app):
|
|
# @app.get("/")
|
|
# def handler(request):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# socket = request.socket
|
|
# assert isinstance(socket, tuple)
|
|
|
|
# ip = socket[0]
|
|
# port = socket[1]
|
|
|
|
# assert ip == request.ip
|
|
# assert port == request.port
|
|
|
|
# delattr(request, "_socket")
|
|
|
|
# socket = request.socket
|
|
# assert isinstance(socket, tuple)
|
|
# assert hasattr(request, "_socket")
|
|
|
|
|
|
# def test_request_form_invalid_content_type(app):
|
|
# @app.route("/", methods=["POST"])
|
|
# async def post(request):
|
|
# return text("OK")
|
|
|
|
# request, response = app.asgi_client.post("/", json={"test": "OK"})
|
|
|
|
# assert request.form == {}
|
|
|
|
|
|
# def test_endpoint_basic():
|
|
# app = Sanic()
|
|
|
|
# @app.route("/")
|
|
# def my_unique_handler(request):
|
|
# return text("Hello")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert request.endpoint == "test_requests.my_unique_handler"
|
|
|
|
|
|
# def test_endpoint_named_app():
|
|
# app = Sanic("named")
|
|
|
|
# @app.route("/")
|
|
# def my_unique_handler(request):
|
|
# return text("Hello")
|
|
|
|
# request, response = app.asgi_client.get("/")
|
|
|
|
# assert request.endpoint == "named.my_unique_handler"
|
|
|
|
|
|
# def test_endpoint_blueprint():
|
|
# bp = Blueprint("my_blueprint", url_prefix="/bp")
|
|
|
|
# @bp.route("/")
|
|
# async def bp_root(request):
|
|
# return text("Hello")
|
|
|
|
# app = Sanic("named")
|
|
# app.blueprint(bp)
|
|
|
|
# request, response = app.asgi_client.get("/bp")
|
|
|
|
# assert request.endpoint == "named.my_blueprint.bp_root"
|