def clear_arguments(self) -> None:
request = create_request("GET", "/foo")
request.add_argument("foo", "bar")
request.clear_arguments()
environ = request.to_environment()
assert_not_in("QUERY_STRING", environ)
request = create_request("POST", "/foo")
request.add_argument("foo", "bar")
request.clear_arguments()
environ = request.to_environment()
content = environ["wsgi.input"].read()
assert_equal(b"", content)
def add_file_argument__content_type(self) -> None:
request = create_request("POST", "/foo/bar")
assert_is_none(request.content_type)
request.add_file_argument("foo", b"", "text/plain")
assert_is_none(request.content_type)
environ = request.to_environment()
content_type, boundary = environ["CONTENT_TYPE"].split(";")
assert_equal("multipart/form-data", content_type)
request = create_request("POST", "/foo/bar")
request.content_type = "image/png"
request.add_file_argument("abc", b"", "text/plain")
assert_equal("image/png", request.content_type)
environ = request.to_environment()
assert_dict_superset({"CONTENT_TYPE": "image/png"}, environ)
def set_body_when_argument_is_set(self) -> None:
request = create_request("POST", "/")
request.add_argument("foo", "bar")
with assert_raises(ValueError):
request.body = b""
with assert_raises(ValueError):
request.body = b"Body"
def to_environment__post(self) -> None:
request = create_request("POST", "/foo/bar")
environ = request.to_environment()
assert_dict_superset(
{
"REQUEST_METHOD": "POST",
"PATH_INFO": "/foo/bar",
"SERVER_NAME": "www.example.com",
"SERVER_PORT": "80",
"SERVER_PROTOCOL": "HTTP/1.1",
"REMOTE_ADDR": "127.0.0.1",
"wsgi.version": (1, 0),
"wsgi.url_scheme": "http",
"wsgi.multithread": False,
"wsgi.multiprocess": False,
"wsgi.run_once": True,
"wsgi.errors": request.error_stream,
},
environ,
)
assert_wsgi_input_stream(environ["wsgi.input"])
assert_equal(b"", environ["wsgi.input"].read())
assert_not_in("CONTENT_TYPE", environ)
assert_not_in("CONTENT_LENGTH", environ)
assert_not_in("QUERY_STRING", environ)
def start_response_not_called(self) -> None:
def app(_: WSGIEnvironment, __: StartResponse) -> Iterable[bytes]:
return []
request = create_request("GET", "/foo/bar")
with assert_raises(AssertionError):
run_wsgi_test(app, request)
def set_header__content_type(self) -> None:
request = create_request("GET", "/foo/bar")
request.set_header("Content-Type", "text/html")
assert_equal("text/html", request.content_type)
environ = request.to_environment()
assert_dict_superset({"CONTENT_TYPE": "text/html"}, environ)
assert_not_in("HTTP_CONTENT_TYPE", environ)
def body(self) -> None:
request = create_request("POST", "/")
assert_equal(b"", request.body)
request.body = b"Test Body"
assert_equal(b"Test Body", request.body)
environ = request.to_environment()
assert_equal("9", environ.get("CONTENT_LENGTH"))
assert_equal(b"Test Body", environ["wsgi.input"].read())
def arguments__get_request(self) -> None:
request = create_request("GET", "/foo")
request.add_argument("foo", "bar")
request.add_argument("abc", ["def", "ghi"])
environ = request.to_environment()
assert_dict_superset(
{"QUERY_STRING": "foo=bar&abc=def&abc=ghi"}, environ
)
def handle_other_errors(self) -> None:
def app(_: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
sr("500 Internal Server Error", [])
return []
request = create_request("POST", "/")
with assert_raises(AssertionError):
run_wsgi_arguments_test(app, request, [])
def set_env_var__priority(self) -> None:
request = create_request("GET", "/foo/bar")
request.set_env_var("SERVER_PORT", "8888")
request.set_env_var("HTTP_X_FOO", "Set by env var")
request.set_header("X-Foo", "Set by header")
environ = request.to_environment()
assert_dict_superset(
{"SERVER_PORT": "8888", "HTTP_X_FOO": "Set by env var"}, environ
)
def _failing_arg_test(
self,
app_args: Sequence[ArgumentTemplate],
expected_args: Iterable[ArgumentToTest],
) -> None:
app = self._create_app(app_args)
request = create_request("GET", "/")
with assert_raises(AssertionError):
run_wsgi_arguments_test(app, request, expected_args)
def response(self) -> None:
def app(_: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
sr("404 Not Found", [("X-Foo", "Bar")])
return []
request = create_request("GET", "/foo/bar")
response = run_wsgi_test(app, request)
response.assert_status(HTTPStatus.NOT_FOUND)
response.assert_header_equal("X-Foo", "Bar")
def response_body(self) -> None:
def app(_: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
writer = sr("200 OK", [])
writer(b"Abc")
writer(b"def")
return [b"Foo", b"bar"]
request = create_request("GET", "/foo/bar")
response = run_wsgi_test(app, request)
assert_equal(b"AbcdefFoobar", response.body)
def start_response_called_no_output_written(self) -> None:
def app(_: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
writer = sr("200 OK", [])
writer(b"")
sr("404 OK", [], _get_exc_info())
return []
request = create_request("GET", "/foo/bar")
response = run_wsgi_test(app, request)
response.assert_status(HTTPStatus.NOT_FOUND)
def start_response_called_after_output_written(self) -> None:
def app(_: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
writer = sr("200 OK", [])
writer(b"abc")
sr("404 OK", [], _get_exc_info())
return []
request = create_request("GET", "/foo/bar")
with assert_raises(ValueError):
run_wsgi_test(app, request)
def arguments__put_request(self) -> None:
request = create_request("PUT", "/foo")
request.add_argument("foo", "bar")
request.add_argument("abc", ["def", "ghi"])
environ = request.to_environment()
assert_not_in("QUERY_STRING", environ)
assert_equal(
"application/x-www-form-urlencoded", environ["CONTENT_TYPE"]
)
content = environ["wsgi.input"].read()
assert_equal(b"foo=bar&abc=def&abc=ghi", content)
def add_argument__content_type(self) -> None:
request = create_request("POST", "/foo/bar")
assert_is_none(request.content_type)
request.add_argument("foo", "bar")
assert_is_none(request.content_type)
environ = request.to_environment()
assert_dict_superset(
{"CONTENT_TYPE": "application/x-www-form-urlencoded"}, environ
)
request = create_request("POST", "/foo/bar")
request.content_type = "image/png"
request.add_argument("abc", "def")
assert_equal("image/png", request.content_type)
environ = request.to_environment()
assert_dict_superset({"CONTENT_TYPE": "image/png"}, environ)
request = create_request("GET", "/foo/bar")
assert_is_none(request.content_type)
request.add_argument("foo", "bar")
assert_is_none(request.content_type)
environ = request.to_environment()
assert_not_in("CONTENT_TYPE", environ)
def to_environment__post_urlencoded(self) -> None:
request = create_request("POST", "/foo/bar")
request.add_argument("arg", "value")
environ = request.to_environment()
assert_dict_superset(
{
"REQUEST_METHOD": "POST",
"CONTENT_TYPE": "application/x-www-form-urlencoded",
"CONTENT_LENGTH": "9",
},
environ,
)
assert_wsgi_input_stream(environ["wsgi.input"])
assert_equal(b"arg=value", environ["wsgi.input"].read())
assert_not_in("QUERY_STRING", environ)
def start_response_called_multiple_times_with_exc_info(self) -> None:
assert_raised = False
def app(_: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
nonlocal assert_raised
sr("200 OK", [])
try:
sr("404 Not Found", [], _get_exc_info())
except AssertionError:
assert_raised = True
return []
request = create_request("GET", "/foo/bar")
run_wsgi_test(app, request)
assert_false(assert_raised)
def file_arguments__umlauts(self) -> None:
request = create_request("PUT", "/foo")
request.add_argument('f"öo', "bär")
request.add_file_argument(
'f"öle', b"", "text/plain", filename="ä\"'bc"
)
environ = request.to_environment()
assert_not_in("QUERY_STRING", environ)
content_type, boundary = environ["CONTENT_TYPE"].split(";")
assert_equal("multipart/form-data", content_type)
_, args, files = parse_form_data(environ)
assert_equal(1, len(args))
assert_equal(args["f%22%C3%B6o"], "bär")
assert_equal(1, len(files))
file = files["f%22%C3%B6le"]
assert_equal("text/plain", file.mimetype)
assert_equal("ä\"'bc", file.filename)
assert_equal(b"", file.stream.read())
def run_app(self) -> None:
app_run = False
env: WSGIEnvironment | None = None
def app(
environ: WSGIEnvironment, sr: StartResponse
) -> Iterable[bytes]:
nonlocal app_run, env
app_run = True
env = environ
sr("200 OK", [])
return []
request = create_request("GET", "/foo/bar")
request.add_argument("foo", "bar")
run_wsgi_test(app, request)
assert_true(app_run, "app not run")
assert env is not None
assert_equal("foo=bar", env.get("QUERY_STRING"))
def file_arguments(self) -> None:
request = create_request("PUT", "/foo")
request.add_argument("foo", "bar")
request.add_file_argument("file1", b"content1", "text/plain")
request.add_file_argument(
"file2", b"content2", "image/png", filename="foobar"
)
environ = request.to_environment()
assert_not_in("QUERY_STRING", environ)
content_type, boundary = environ["CONTENT_TYPE"].split(";")
assert_equal("multipart/form-data", content_type)
_, args, files = parse_form_data(environ)
assert_equal(1, len(args))
assert_equal(args["foo"], "bar")
assert_equal(2, len(files))
file1 = files["file1"]
assert_equal("text/plain", file1.mimetype)
assert_equal("", file1.filename)
assert_equal(b"content1", file1.stream.read())
file2 = files["file2"]
assert_equal("image/png", file2.mimetype)
assert_equal("foobar", file2.filename)
assert_equal(b"content2", file2.stream.read())
def attributes(self) -> None:
request = create_request("GET", "/foo/bar")
assert_equal("GET", request.method)
assert_equal("/foo/bar", request.path)
assert_is_none(request.content_type)
assert_is_instance(request.error_stream, BytesIO)
def set_json_request__get_request(self) -> None:
request = create_request("GET", "/")
with assert_raises(ValueError):
request.set_json_request(b"{}")
def set_json_request__str(self) -> None:
request = create_request("POST", "/")
request.set_json_request('{"foo": "bär"}')
self._assert_json_request(request, '{"foo": "bär"}'.encode("utf-8"))
def set_json_request__dict(self) -> None:
request = create_request("POST", "/")
request.set_json_request({"foo": "bär"})
self._assert_json_request(request, b'{"foo": "b\\u00e4r"}')
def set_json_request__list(self) -> None:
request = create_request("POST", "/")
request.set_json_request(["foo", "bär"])
self._assert_json_request(request, b'["foo", "b\\u00e4r"]')
def set_body_in_get_request(self) -> None:
request = create_request("GET", "/")
with assert_succeeds(ValueError):
request.body = b""
with assert_raises(ValueError):
request.body = b"Test Body"
def set_json_request__bytes(self) -> None:
request = create_request("POST", "/")
request.set_json_request(b"{}")
self._assert_json_request(request, b"{}")
def capitalize_method(self) -> None:
request = create_request("pOst", "/foo/bar")
assert_equal("POST", request.method)
