Accept header parsing (#2200)

* Add some tests

* docstring

* Add accept matching

* Add some more tests on matching

* Add matching flags for wildcards

* Add mathing controls to accept

* Limit uvicorn 14 in testing

tests/test_headers.py

@@ -3,7 +3,7 @@ from unittest.mock import Mock
 import pytest
 
 from sanic import headers, text
-from sanic.exceptions import PayloadTooLarge
+from sanic.exceptions import InvalidHeader, PayloadTooLarge
 from sanic.http import Http
 
 
@@ -182,3 +182,159 @@ def test_request_line(app):
     )
 
     assert request.request_line == b"GET / HTTP/1.1"
+
+
+@pytest.mark.parametrize(
+    "raw",
+    (
+        "show/first, show/second",
+        "show/*, show/first",
+        "*/*, show/first",
+        "*/*, show/*",
+        "other/*; q=0.1, show/*; q=0.2",
+        "show/first; q=0.5, show/second; q=0.5",
+        "show/first; foo=bar, show/second; foo=bar",
+        "show/second, show/first; foo=bar",
+        "show/second; q=0.5, show/first; foo=bar; q=0.5",
+        "show/second; q=0.5, show/first; q=1.0",
+        "show/first, show/second; q=1.0",
+    ),
+)
+def test_parse_accept_ordered_okay(raw):
+    ordered = headers.parse_accept(raw)
+    expected_subtype = (
+        "*" if all(q.subtype.is_wildcard for q in ordered) else "first"
+    )
+    assert ordered[0].type_ == "show"
+    assert ordered[0].subtype == expected_subtype
+
+
+@pytest.mark.parametrize(
+    "raw",
+    (
+        "missing",
+        "missing/",
+        "/missing",
+    ),
+)
+def test_bad_accept(raw):
+    with pytest.raises(InvalidHeader):
+        headers.parse_accept(raw)
+
+
+def test_empty_accept():
+    assert headers.parse_accept("") == []
+
+
+def test_wildcard_accept_set_ok():
+    accept = headers.parse_accept("*/*")[0]
+    assert accept.type_.is_wildcard
+    assert accept.subtype.is_wildcard
+
+    accept = headers.parse_accept("foo/bar")[0]
+    assert not accept.type_.is_wildcard
+    assert not accept.subtype.is_wildcard
+
+
+def test_accept_parsed_against_str():
+    accept = headers.Accept.parse("foo/bar")
+    assert accept > "foo/bar; q=0.1"
+
+
+def test_media_type_equality():
+    assert headers.MediaType("foo") == headers.MediaType("foo") == "foo"
+    assert headers.MediaType("foo") == headers.MediaType("*") == "*"
+    assert headers.MediaType("foo") != headers.MediaType("bar")
+    assert headers.MediaType("foo") != "bar"
+
+
+def test_media_type_matching():
+    assert headers.MediaType("foo").match(headers.MediaType("foo"))
+    assert headers.MediaType("foo").match("foo")
+
+    assert not headers.MediaType("foo").match(headers.MediaType("*"))
+    assert not headers.MediaType("foo").match("*")
+
+    assert not headers.MediaType("foo").match(headers.MediaType("bar"))
+    assert not headers.MediaType("foo").match("bar")
+
+
+@pytest.mark.parametrize(
+    "value,other,outcome,allow_type,allow_subtype",
+    (
+        # ALLOW BOTH
+        ("foo/bar", "foo/bar", True, True, True),
+        ("foo/bar", headers.Accept.parse("foo/bar"), True, True, True),
+        ("foo/bar", "foo/*", True, True, True),
+        ("foo/bar", headers.Accept.parse("foo/*"), True, True, True),
+        ("foo/bar", "*/*", True, True, True),
+        ("foo/bar", headers.Accept.parse("*/*"), True, True, True),
+        ("foo/*", "foo/bar", True, True, True),
+        ("foo/*", headers.Accept.parse("foo/bar"), True, True, True),
+        ("foo/*", "foo/*", True, True, True),
+        ("foo/*", headers.Accept.parse("foo/*"), True, True, True),
+        ("foo/*", "*/*", True, True, True),
+        ("foo/*", headers.Accept.parse("*/*"), True, True, True),
+        ("*/*", "foo/bar", True, True, True),
+        ("*/*", headers.Accept.parse("foo/bar"), True, True, True),
+        ("*/*", "foo/*", True, True, True),
+        ("*/*", headers.Accept.parse("foo/*"), True, True, True),
+        ("*/*", "*/*", True, True, True),
+        ("*/*", headers.Accept.parse("*/*"), True, True, True),
+        # ALLOW TYPE
+        ("foo/bar", "foo/bar", True, True, False),
+        ("foo/bar", headers.Accept.parse("foo/bar"), True, True, False),
+        ("foo/bar", "foo/*", False, True, False),
+        ("foo/bar", headers.Accept.parse("foo/*"), False, True, False),
+        ("foo/bar", "*/*", False, True, False),
+        ("foo/bar", headers.Accept.parse("*/*"), False, True, False),
+        ("foo/*", "foo/bar", False, True, False),
+        ("foo/*", headers.Accept.parse("foo/bar"), False, True, False),
+        ("foo/*", "foo/*", False, True, False),
+        ("foo/*", headers.Accept.parse("foo/*"), False, True, False),
+        ("foo/*", "*/*", False, True, False),
+        ("foo/*", headers.Accept.parse("*/*"), False, True, False),
+        ("*/*", "foo/bar", False, True, False),
+        ("*/*", headers.Accept.parse("foo/bar"), False, True, False),
+        ("*/*", "foo/*", False, True, False),
+        ("*/*", headers.Accept.parse("foo/*"), False, True, False),
+        ("*/*", "*/*", False, True, False),
+        ("*/*", headers.Accept.parse("*/*"), False, True, False),
+        # ALLOW SUBTYPE
+        ("foo/bar", "foo/bar", True, False, True),
+        ("foo/bar", headers.Accept.parse("foo/bar"), True, False, True),
+        ("foo/bar", "foo/*", True, False, True),
+        ("foo/bar", headers.Accept.parse("foo/*"), True, False, True),
+        ("foo/bar", "*/*", False, False, True),
+        ("foo/bar", headers.Accept.parse("*/*"), False, False, True),
+        ("foo/*", "foo/bar", True, False, True),
+        ("foo/*", headers.Accept.parse("foo/bar"), True, False, True),
+        ("foo/*", "foo/*", True, False, True),
+        ("foo/*", headers.Accept.parse("foo/*"), True, False, True),
+        ("foo/*", "*/*", False, False, True),
+        ("foo/*", headers.Accept.parse("*/*"), False, False, True),
+        ("*/*", "foo/bar", False, False, True),
+        ("*/*", headers.Accept.parse("foo/bar"), False, False, True),
+        ("*/*", "foo/*", False, False, True),
+        ("*/*", headers.Accept.parse("foo/*"), False, False, True),
+        ("*/*", "*/*", False, False, True),
+        ("*/*", headers.Accept.parse("*/*"), False, False, True),
+    ),
+)
+def test_accept_matching(value, other, outcome, allow_type, allow_subtype):
+    assert (
+        headers.Accept.parse(value).match(
+            other,
+            allow_type_wildcard=allow_type,
+            allow_subtype_wildcard=allow_subtype,
+        )
+        is outcome
+    )
+
+
+@pytest.mark.parametrize("value", ("foo/bar", "foo/*", "*/*"))
+def test_value_in_accept(value):
+    acceptable = headers.parse_accept(value)
+    assert "foo/bar" in acceptable
+    assert "foo/*" in acceptable
+    assert "*/*" in acceptable

tests/test_request.py

@@ -140,3 +140,39 @@ def test_ipv6_address_is_not_wrapped(app):
     assert resp.json["client"] == "[::1]"
     assert resp.json["client_ip"] == "::1"
     assert request.ip == "::1"
+
+
+def test_request_accept():
+    app = Sanic("req-generator")
+
+    @app.get("/")
+    async def get(request):
+        return response.empty()
+
+    request, _ = app.test_client.get(
+        "/",
+        headers={
+            "Accept": "text/*, text/plain, text/plain;format=flowed, */*"
+        },
+    )
+    assert request.accept == [
+        "text/plain;format=flowed",
+        "text/plain",
+        "text/*",
+        "*/*",
+    ]
+
+    request, _ = app.test_client.get(
+        "/",
+        headers={
+            "Accept": (
+                "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"
+            )
+        },
+    )
+    assert request.accept == [
+        "text/html",
+        "text/x-c",
+        "text/x-dvi; q=0.8",
+        "text/plain; q=0.5",
+    ]