def patch_wrong_content_type__required_args(self) -> None:
self.env["REQUEST_METHOD"] = "PATCH"
self.env["CONTENT_TYPE"] = "application/octet-stream"
self.env["CONTENT_LENGTH"] = "2"
self.env["wsgi.input"] = BytesIO(b"AB")
with assert_raises(BadRequest):
parse_args(self.env, [("foo", str, Multiplicity.REQUIRED)])
def required_any_argument_missing(self) -> None:
try:
parse_args(self.env, [("foo", int, Multiplicity.REQUIRED_ANY)])
except ArgumentsError as exc:
assert_equal({"foo": "mandatory argument missing"}, exc.arguments)
else:
fail("ArgumentsError not raised")
def exhaustive_check__succeeds(self) -> None:
self.add_path_argument("foo", "v")
with assert_succeeds(ArgumentsError):
parse_args(
self.env,
[("foo", str, Multiplicity.OPTIONAL)],
exhaustive=True,
)
def app(env: WSGIEnvironment, sr: StartResponse) -> Iterable[bytes]:
try:
parse_args(env, argument_template)
except ArgumentsError:
sr("400 Bad Request", [])
else:
sr("200 OK", [])
return []
def invalid_value_parser(self) -> None:
with assert_raises(TypeError):
parse_args(
self.env,
[(
"foo", # type: ignore
"INVALID",
Multiplicity.OPTIONAL,
)],
)
def empty_delete__required_not_supplied(self) -> None:
self.env["REQUEST_METHOD"] = "DELETE"
self.setup_empty_urlencoded_request()
with assert_raises(ArgumentsError):
parse_args(
self.env,
[
("req", str, Multiplicity.REQUIRED),
("once", str, Multiplicity.REQUIRED_ANY),
],
)
def parse_invalid_int_arg(self) -> None:
self.add_path_argument("foo", "bar")
try:
parse_args(self.env, [("foo", int, Multiplicity.REQUIRED)])
except ArgumentsError as exc:
assert_equal(
{"foo": "invalid literal for int() with base 10: 'bar'"},
exc.arguments,
)
else:
fail("ArgumentsError not raised")
def exhaustive_check__fails(self) -> None:
self.add_path_argument("foo", "v")
self.add_path_argument("unknown", "v")
try:
parse_args(
self.env,
[("foo", str, Multiplicity.OPTIONAL)],
exhaustive=True,
)
except ArgumentsError as exc:
assert_equal({"unknown": "unknown argument"}, exc.arguments)
else:
fail("ArgumentsError not raised")
def patch_wrong_content_type__optional_args(self) -> None:
self.env["REQUEST_METHOD"] = "PATCH"
self.env["CONTENT_TYPE"] = "application/octet-stream"
self.env["CONTENT_LENGTH"] = "2"
self.env["wsgi.input"] = BytesIO(b"AB")
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({}, args)
def multipart_post_request_with_empty_file(self) -> None:
self.env["REQUEST_METHOD"] = "POST"
self.setup_multipart_request("my-file", "test")
args = parse_args(self.env,
[("my-file", "file-or-str", Multiplicity.REQUIRED)])
assert_in("my-file", args)
assert_equal("test", args["my-file"])
def read_value_as_file_with_umlauts(self) -> None:
self.env["REQUEST_METHOD"] = "GET"
self.add_path_argument("foo", "bär")
args = parse_args(self.env, [("foo", "file", Multiplicity.REQUIRED)])
assert_in("foo", args)
f = args["foo"]
assert_equal("", f.filename)
assert_equal("application/octet-stream", f.content_type)
assert_equal("bär".encode("utf-8"), f.read())
def multipart_post_request_with_file_and_umlauts(self) -> None:
self.env["REQUEST_METHOD"] = "POST"
self.setup_multipart_file_request("föo", "my-filé.txt", "cöntent",
"text/plain; charset=utf-8")
args = parse_args(self.env, [("föo", "file", Multiplicity.REQUIRED)])
assert_in("föo", args)
f = args["föo"]
assert_equal("my-filé.txt", f.filename)
assert_equal("text/plain", f.content_type)
assert_equal("cöntent".encode("utf-8"), f.read())
def post_wrong_content_type__optional_args(self) -> None:
"""This exposes a bug in Python's cgi module that will raise a
TypeError when no request string was provided. See
<https://bugs.python.org/issue32029>.
"""
self.env["REQUEST_METHOD"] = "POST"
self.env["CONTENT_TYPE"] = "application/octet-stream"
self.env["CONTENT_LENGTH"] = "2"
self.env["wsgi.input"] = BytesIO(b"AB")
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({}, args)
def multipart_put_request_with_file(self) -> None:
self.env["REQUEST_METHOD"] = "PUT"
self.setup_multipart_file_request("my-file", "my-file.txt", "content",
"text/plain")
args = parse_args(self.env,
[("my-file", "file", Multiplicity.REQUIRED)])
assert_in("my-file", args)
f = args["my-file"]
assert_equal("my-file.txt", f.filename)
assert_equal("text/plain", f.content_type)
assert_equal(b"content", f.read())
def empty_delete__optional(self) -> None:
self.env["REQUEST_METHOD"] = "DELETE"
self.setup_empty_urlencoded_request()
args = parse_args(
self.env,
[
("opt", str, Multiplicity.OPTIONAL),
("any", str, Multiplicity.ANY),
],
)
assert_not_in("opt", args)
assert_equal([], args["any"])
def unsupported_method(self) -> None:
self.env["REQUEST_METHOD"] = "UNKNOWN"
with assert_raises(ValueError):
parse_args(self.env, [])
def required_any_argument(self) -> None:
self.add_path_argument("foo", "123")
self.add_path_argument("foo", "456")
self.add_path_argument("foo", "789")
args = parse_args(self.env, [("foo", int, Multiplicity.REQUIRED_ANY)])
assert_equal({"foo": [123, 456, 789]}, args)
def parse_int_arg(self) -> None:
self.add_path_argument("foo", "123")
args = parse_args(self.env, [("foo", int, Multiplicity.REQUIRED)])
assert_equal({"foo": 123}, args)
def no_exhaustive_check(self) -> None:
self.add_path_argument("foo", "v")
self.add_path_argument("unknown", "v")
with assert_succeeds(ArgumentsError):
parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
def optional_argument_missing(self) -> None:
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({}, args)
def urlencoded_put_request(self) -> None:
self.env["REQUEST_METHOD"] = "PUT"
self.setup_urlencoded_request("foo", "bar")
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({"foo": "bar"}, args)
def read_file_as_value(self) -> None:
self.env["REQUEST_METHOD"] = "POST"
self.setup_multipart_file_request("foo", "my-file.txt", "123",
"text/plain")
args = parse_args(self.env, [("foo", int, Multiplicity.REQUIRED)])
assert_equal(123, args["foo"])
def any_argument_empty(self) -> None:
args = parse_args(self.env, [("foo", int, Multiplicity.ANY)])
assert_equal({"foo": []}, args)
def parse_nothing(self) -> None:
args = parse_args(self.env, [])
assert_equal({}, args)
def parse_unicode_arg(self) -> None:
self.add_path_argument("föo", "bär")
args = parse_args(self.env, [("föo", str, Multiplicity.REQUIRED)])
assert_equal({"föo": "bär"}, args)
def multipart_multiple_arguments(self) -> None:
self.env["REQUEST_METHOD"] = "PUT"
self.setup_multipart_request("foo", ["bar", "baz"])
args = parse_args(self.env, [("foo", str, Multiplicity.ANY)])
assert_equal({"foo": ["bar", "baz"]}, args)
def multipart_put_request_with_umlauts(self) -> None:
self.env["REQUEST_METHOD"] = "PUT"
self.setup_multipart_request("föo", "bär")
args = parse_args(self.env, [("föo", str, Multiplicity.OPTIONAL)])
assert_equal({"föo": "bär"}, args)
def multipart_post_request(self) -> None:
self.env["REQUEST_METHOD"] = "POST"
self.setup_multipart_request("foo", "bar")
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({"foo": "bar"}, args)
def multipart__optional_argument_empty(self) -> None:
self.env["REQUEST_METHOD"] = "PUT"
self.setup_multipart_request("foo", "")
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({"foo": ""}, args)
def optional_argument_empty(self) -> None:
self.add_path_argument("foo", "")
args = parse_args(self.env, [("foo", str, Multiplicity.OPTIONAL)])
assert_equal({"foo": ""}, args)
