Support subdomains when testing

Subdomains are supported in the Flask API and required if a user wants
to test routes that have a defined subdomain.

Author: pgjones

src/quart/app.py

@@ -1485,6 +1485,7 @@ def test_request_context(
         http_version: str = "1.1",
         scope_base: Optional[dict] = None,
         auth: Optional[Union[Authorization, Tuple[str, str]]] = None,
+        subdomain: Optional[str] = None,
     ) -> RequestContext:
         """Create a request context for testing purposes.
 
@@ -1511,6 +1512,7 @@ def test_request_context(
             headers,
             query_string,
             auth,
+            subdomain,
         )
         request_body, body_headers = make_test_body_with_headers(data=data, form=form, json=json)
         headers.update(**body_headers)

src/quart/testing/client.py

@@ -93,6 +93,7 @@ async def open(
         http_version: str = "1.1",
         scope_base: Optional[dict] = None,
         auth: Optional[Union[Authorization, Tuple[str, str]]] = None,
+        subdomain: Optional[str] = None,
     ) -> Response:
         self.push_promises = []
         response = await self._make_request(
@@ -109,6 +110,7 @@ async def open(
             http_version,
             scope_base,
             auth,
+            subdomain,
         )
         if follow_redirects:
             while response.status_code >= 300 and response.status_code <= 399:
@@ -131,6 +133,7 @@ async def open(
                     http_version,
                     scope_base,
                     auth,
+                    subdomain,
                 )
         if self.preserve_context:
             _cv_request.set(self.app._preserved_context)  # type: ignore
@@ -148,13 +151,15 @@ def request(
         http_version: str = "1.1",
         scope_base: Optional[dict] = None,
         auth: Optional[Union[Authorization, Tuple[str, str]]] = None,
+        subdomain: Optional[str] = None,
     ) -> TestHTTPConnectionProtocol:
         headers, path, query_string_bytes = make_test_headers_path_and_query_string(
             self.app,
             path,
             headers,
             query_string,
             auth,
+            subdomain,
         )
         if self.cookie_jar is not None:
             for cookie in self.cookie_jar:
@@ -185,13 +190,15 @@ def websocket(
         http_version: str = "1.1",
         scope_base: Optional[dict] = None,
         auth: Optional[Union[Authorization, Tuple[str, str]]] = None,
+        subdomain: Optional[str] = None,
     ) -> TestWebsocketConnectionProtocol:
         headers, path, query_string_bytes = make_test_headers_path_and_query_string(
             self.app,
             path,
             headers,
             query_string,
             auth,
+            subdomain,
         )
         if self.cookie_jar is not None:
             for cookie in self.cookie_jar:
@@ -409,9 +416,10 @@ async def _make_request(
         http_version: str,
         scope_base: Optional[dict],
         auth: Optional[Union[Authorization, Tuple[str, str]]] = None,
+        subdomain: Optional[str] = None,
     ) -> Response:
         headers, path, query_string_bytes = make_test_headers_path_and_query_string(
-            self.app, path, headers, query_string, auth
+            self.app, path, headers, query_string, auth, subdomain
         )
         request_data, body_headers = make_test_body_with_headers(
             data=data, form=form, files=files, json=json, app=self.app

src/quart/testing/utils.py

@@ -29,6 +29,7 @@ def make_test_headers_path_and_query_string(
     headers: Optional[Union[dict, Headers]] = None,
     query_string: Optional[dict] = None,
     auth: Optional[Union[Authorization, Tuple[str, str]]] = None,
+    subdomain: Optional[str] = None,
 ) -> Tuple[Headers, str, bytes]:
     """Make the headers and path with defaults for testing.
 
@@ -54,7 +55,10 @@ def make_test_headers_path_and_query_string(
         headers.setdefault("Authorization", auth.to_header())
 
     headers.setdefault("User-Agent", "Quart")
-    headers.setdefault("host", app.config["SERVER_NAME"] or "localhost")
+    host = app.config["SERVER_NAME"] or "localhost"
+    if subdomain is not None:
+        host = f"{subdomain}.{host}"
+    headers.setdefault("host", host)
     if "?" in path and query_string is not None:
         raise ValueError("Query string is defined in the path and as an argument")
     if query_string is None:

tests/test_testing.py

@@ -36,23 +36,29 @@ async def echo() -> str:
 
 
 @pytest.mark.parametrize(
-    "path, query_string, expected_path, expected_query_string",
+    "path, query_string, subdomain, expected_path, expected_query_string, expected_host",
     [
-        ("/path", {"a": "b"}, "/path", b"a=b"),
-        ("/path", {"a": ["b", "c"]}, "/path", b"a=b&a=c"),
-        ("/path?b=c", None, "/path", b"b=c"),
-        ("/path%20", None, "/path ", b""),
+        ("/path", {"a": "b"}, None, "/path", b"a=b", "localhost"),
+        ("/path", {"a": ["b", "c"]}, None, "/path", b"a=b&a=c", "localhost"),
+        ("/path?b=c", None, None, "/path", b"b=c", "localhost"),
+        ("/path%20", None, None, "/path ", b"", "localhost"),
+        ("/path", None, "api", "/path", b"", "api.localhost"),
     ],
 )
 def test_build_headers_path_and_query_string(
-    path: str, query_string: Optional[dict], expected_path: str, expected_query_string: bytes
+    path: str,
+    query_string: Optional[dict],
+    subdomain: Optional[str],
+    expected_path: str,
+    expected_query_string: bytes,
+    expected_host: str,
 ) -> None:
     headers, result_path, result_qs = make_test_headers_path_and_query_string(
-        Quart(__name__), path, None, query_string
+        Quart(__name__), path, None, query_string, None, subdomain
     )
     assert result_path == expected_path
     assert headers["User-Agent"] == "Quart"
-    assert headers["host"] == "localhost"
+    assert headers["host"] == expected_host
     assert result_qs == expected_query_string