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)