Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(wpt): support remote context executors and dispatcher queues
ldm06108e3eda52a
diff --git a/moli-benchmark/moli_benchmark/wpt_cross/case_set.py b/moli-benchmark/moli_benchmark/wpt_cross/case_set.pyindex 6214837c6..41d6e03b7 100644--- a/moli-benchmark/moli_benchmark/wpt_cross/case_set.py+++ b/moli-benchmark/moli_benchmark/wpt_cross/case_set.py@@ -815,6 +815,24 @@ def _empty_location_handler_reference_patterns(directory: str) -> tuple[re.Pattereturn tuple(patterns)+@lru_cache(maxsize=None)+def _remote_context_handler_reference_patterns(directory: str) -> tuple[re.Pattern[str], ...]:+ references = []+ for resource in (+ "common/dispatcher/dispatcher.py",+ "html/browsers/browsing-the-web/remote-context-helper/resources/executor-window.py",+ ):+ relative = posixpath.relpath(resource, directory)+ references.extend(("/" + resource, relative, "./" + relative))+ return tuple(+ re.compile(+ rf"(?<![A-Za-z0-9_./-]){re.escape(reference)}"+ rf"{WPTSERVE_HANDLER_TRAILING_BOUNDARY}"+ )+ for reference in references+ )++def _supported_wptserve_handler_references(rel: str | None,) -> tuple[re.Pattern[str], ...]:@@ -823,6 +841,7 @@ def _supported_wptserve_handler_references(supported += _empty_location_handler_reference_patterns(posixpath.dirname(rel))if rel is not None:supported += _common_echo_handler_reference_patterns(posixpath.dirname(rel) or ".")+ supported += _remote_context_handler_reference_patterns(posixpath.dirname(rel) or ".")supported += _navigation_handler_reference_patterns(posixpath.dirname(rel) or ".")supported += _json_module_handler_reference_patterns(posixpath.dirname(rel) or ".")if rel is not None:diff --git a/moli-benchmark/moli_benchmark/wpt_cross/server.py b/moli-benchmark/moli_benchmark/wpt_cross/server.pyindex 815d32d8c..0fe06f077 100644--- a/moli-benchmark/moli_benchmark/wpt_cross/server.py+++ b/moli-benchmark/moli_benchmark/wpt_cross/server.py@@ -98,6 +98,14 @@ XHR_RESPONSE_RESOURCE_PATHS = {"/xhr/resources/status.py","/xhr/resources/last-modified.py",}+DISPATCHER_PATH = "/common/dispatcher/dispatcher.py"++REMOTE_CONTEXT_EXECUTOR_PATH = (+ "/html/browsers/browsing-the-web/remote-context-helper/resources/executor-window.py"+)++REMOTE_CONTEXT_RESOURCE_PATHS = {DISPATCHER_PATH, REMOTE_CONTEXT_EXECUTOR_PATH}+COMMON_ECHO_PATH = "/common/echo.py"COMMON_REDIRECT_PATH = "/common/redirect.py"FETCH_EMPTY_LOCATION_PATH = "/fetch/api/resources/redirect-empty-location.py"@@ -1682,6 +1690,19 @@ class FetchStash:with self._lock:return self._values.pop(parsed_key, None)+ def exchange_queue(self, key: str, value: bytes | None = None, *, path: str) -> bytes | None:+ """Atomically append a message or take the oldest message in a stash queue."""+ parsed_key = (path, uuid.UUID(key))+ with self._lock:+ queue = self._values.pop(parsed_key, None) or []+ if value is not None:+ queue.append(value)+ result = None+ else:+ result = queue.pop(0) if queue else None+ self._values[parsed_key] = queue+ return result+def _directory_listing_body(directory: Path, path: str) -> bytes:items = [] if path == "/" else ['<li><a href="../">..</a></li>']@@ -1707,6 +1728,151 @@ def _make_handler(range_stash = FetchStash()class WptHandler(BaseHTTPRequestHandler):+ def _serve_remote_context_resource(self) -> bool:+ parsed = urlsplit(self.path)+ path = unquote(parsed.path)+ if path not in REMOTE_CONTEXT_RESOURCE_PATHS:+ return False+ # These handlers only read the upload for dispatcher POSTs that+ # do not request show-headers. Do not wait for any other upload.+ self.close_connection = True+ request_headers: dict[str, list[str]] = {}+ for name, value in self.headers.raw_items():+ request_headers.setdefault(name.lower(), []).append(value)+ params = parse_qs(parsed.query, keep_blank_values=True, encoding="latin-1")+ try:+ if path == DISPATCHER_PATH:+ origin = ", ".join(request_headers.get("origin", [])) or "*"+ headers = [+ ("Access-Control-Allow-Credentials", "true"),+ ("Access-Control-Allow-Methods", "OPTIONS, GET, POST"),+ ("Access-Control-Allow-Headers", "Content-Type"),+ ("Access-Control-Allow-Origin", origin),+ ("Cache-Control", "max-age=31536000" if "cacheable" in params+ else "no-cache, no-store, must-revalidate"),+ ]+ if self.command == "OPTIONS":+ body = b""+ else:+ # Upstream takes the queue (and validates the UUID)+ # before reading request.body, so bad keys fail promptly.+ key = str(uuid.UUID(params["uuid"][0]))+ if "show-headers" in params:+ message = json.dumps({+ name: ", ".join(values) for name, values in request_headers.items()+ }).encode("utf-8")+ fetch_stash.exchange_queue(key, message, path="/common/dispatcher")+ body = b""+ elif self.command == "POST":+ message = self._read_content_length_request_body(ignore_transfer_encoding=True)+ if message is None:+ return True+ fetch_stash.exchange_queue(key, message, path="/common/dispatcher")+ body = b"done"+ else:+ message = fetch_stash.exchange_queue(key, path="/common/dispatcher")+ body = b"not ready" if message is None else message+ status = 200+ else:+ # Request.GET keeps blank values; urllib.parse.parse_qs in+ # executor-window.py separately drops them and decodes UTF-8.+ status = int(params["status"][0]) if "status" in params else 200+ query = parse_qs(parsed.query)+ executor_uuid = query["uuid"][0]+ start_on = query.get("startOn")+ start_on_js = f"'{start_on[0]}'" if start_on else "null"+ scripts = "\n".join(+ f"<script src='{html.escape(script)}'></script>"+ for script in query.get("script", [])+ )+ initialize_headers = ""+ for name, values in request_headers.items():+ js_name = json.dumps(name.encode("latin-1").decode("utf-8"))+ for value in values:+ js_value = json.dumps(value.encode("latin-1").decode("utf-8"))+ initialize_headers += f"window.__requestHeaders.append({js_name}, {js_value});\n"+ request_url = self.path+ if not request_url.startswith("http://"):+ authority = self.headers.get("Host")+ if authority is None:+ authority = _url_host_literal(str(self.server.server_address[0]))+ if urlsplit("//" + authority).port is None:+ authority += ":" + str(self.server.server_address[1])+ request_url = f"http://{authority}{self.path}"+ body = f"""+<!DOCTYPE HTML>+<base href="{html.escape(request_url)}">+<script src="/common/dispatcher/dispatcher.js"></script>+<script src="./executor-common.js"></script>+<script src="./executor-window.js"></script>++{scripts}+<body>+<script>+window.__requestHeaders = new Headers();+{initialize_headers}+requestExecutor("{executor_uuid}", {start_on_js});+</script>+""".encode("utf-8")+ headers = [("Content-Type", "text/html")]+ except (KeyError, ValueError, TypeError, AttributeError):+ self.send_error(500)+ return True+ self._send_python_handler_response(+ path, parsed.query, body, headers=headers, status_code=status,+ )+ return True++ def _send_python_handler_response(+ self, path: str, query: str, body: bytes | None,+ *, headers: list[tuple[str, str]] | None = None,+ status_code: int = 200,+ ) -> None:+ # FunctionHandler only applies pipes when main() returns a value.+ # In particular, an empty stash (None) differs from stored b"".+ headers = list(headers or [])+ status, delay, auto_content_length = status_code, 0.0, body is not None+ try:+ for name, args in parse_pipe_commands(query) if body is not None else ():+ if name == "header":+ header_name, value = args[:2]+ value = value.replace("\r", " ").replace("\n", " ")+ if _valid_static_response_header(header_name, value):+ headers = _apply_header_operations(headers, [(+ header_name, value,+ len(args) == 3 and args[2].lower() in {"true", "1"},+ )])+ elif name == "status":+ status = int(args[0])+ elif name == "sub":+ body = self._substitute_response_template(+ body, path, query,+ escape_type=args[0] if args else "html",+ )+ elif name == "trickle":+ auto_content_length = False+ if not any(_headers_include(headers, name)+ for name in ("Cache-Control", "Pragma", "Expires")):+ headers.extend([+ ("Cache-Control", "no-cache, no-store, must-revalidate"),+ ("Pragma", "no-cache"),+ ("Expires", "0"),+ ])+ match = _TRICKLE_DELAY_RE.fullmatch(args[0])+ if match is not None:+ delay = max(delay, float(match.group(1)))+ except WptPipeError:+ self.send_error(500)+ return+ if delay:+ time.sleep(min(delay, _MAX_TRICKLE_DELAY_SECONDS))+ self._send_bytes(+ None, body if body is not None else b"", emit_body=self.command != "HEAD",+ extra_headers=[*headers, ("Connection", "close")],+ status_code=status, cache_control=None,+ auto_content_length=auto_content_length,+ )+def do_GET(self) -> None: # noqa: N802 (BaseHTTPRequestHandler API)if self.headers.get("Upgrade", "").lower() == "websocket":self._serve_websocket()@@ -1717,6 +1883,8 @@ def _make_handler(self._serve(emit_body=False)def do_OPTIONS(self) -> None: # noqa: N802+ if self._serve_remote_context_resource():+ returnif self._serve_common_echo_resource():returnif self._serve_common_redirect_resource():@@ -1753,6 +1921,8 @@ def _make_handler(self.send_error(404)def do_POST(self) -> None: # noqa: N802+ if self._serve_remote_context_resource():+ returnif self._serve_common_echo_resource():returnif self._serve_common_redirect_resource():@@ -1810,6 +1980,8 @@ def _make_handler(self.end_headers()def _serve_fetch_resource_method(self) -> None:+ if self._serve_remote_context_resource():+ returnif self._serve_common_echo_resource():returnif self._serve_common_redirect_resource():@@ -1845,6 +2017,8 @@ def _make_handler(do_DELETE = _serve_fetch_resource_methoddef do_YO(self) -> None: # noqa: N802 (WPT custom method)+ if self._serve_remote_context_resource():+ returnif self._serve_common_echo_resource():returnif self._serve_common_redirect_resource():@@ -2060,6 +2234,8 @@ def _make_handler(return Truedef _serve(self, *, emit_body: bool) -> None:+ if self._serve_remote_context_resource():+ returntry:self._serve_response(emit_body=emit_body)except WptPipeError:@@ -2604,6 +2780,8 @@ def _make_handler()def __getattr__(self, name: str):+ if name.startswith("do_") and unquote(urlsplit(self.path).path) in REMOTE_CONTEXT_RESOURCE_PATHS:+ return self._serve_remote_context_resourceif name.startswith("do_") and unquote(urlsplit(self.path).path) == COMMON_ECHO_PATH:return self._serve_common_echo_resourceif name.startswith("do_") and unquote(urlsplit(self.path).path) == COMMON_REDIRECT_PATH:@@ -2618,8 +2796,8 @@ def _make_handler(return self._serve_fetch_resource_methodraise AttributeError(name)- def _read_content_length_request_body(self) -> bytes | None:- if self.headers.get("Transfer-Encoding") is not None:+ def _read_content_length_request_body(self, *, ignore_transfer_encoding: bool = False) -> bytes | None:+ if not ignore_transfer_encoding and self.headers.get("Transfer-Encoding") is not None:self._reject_request_body(400)return Nonelength_str = self.headers.get("Content-Length")diff --git a/moli-benchmark/tests/test_wpt_remote_context_server.py b/moli-benchmark/tests/test_wpt_remote_context_server.pynew file mode 100644index 000000000..5b25a666f--- /dev/null+++ b/moli-benchmark/tests/test_wpt_remote_context_server.py@@ -0,0 +1,276 @@+from __future__ import annotations++import html+import json+import tempfile+import unittest+import uuid+from concurrent.futures import ThreadPoolExecutor+from contextlib import ExitStack+from http.client import HTTPConnection+from pathlib import Path+from unittest.mock import patch+from urllib.parse import urlencode++from moli_benchmark.wpt_cross.case_set import enumerate_cases+from moli_benchmark.wpt_cross.server import WptFixtureServer+++DISPATCHER = "/common/dispatcher/dispatcher.py"+EXECUTOR = "/html/browsers/browsing-the-web/remote-context-helper/resources/executor-window.py"+++class RemoteContextFixtureTests(unittest.TestCase):+ def setUp(self) -> None:+ self.stack = ExitStack()+ self.addCleanup(self.stack.close)+ self.root = Path(self.stack.enter_context(tempfile.TemporaryDirectory()))+ (self.root / "resources").mkdir()+ (self.root / "resources/testharness.js").write_text("// testharness")+ for name in (DISPATCHER, EXECUTOR):+ path = self.root / name.lstrip("/")+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_text("# Python source must not be served")+ self.stack.enter_context(patch(+ "moli_benchmark.wpt_cross.server._global_ipv6_address", return_value=None,+ ))+ self.server = self.stack.enter_context(WptFixtureServer(self.root))+ self.key = str(uuid.uuid4())+ self.query = "uuid=" + self.key++ def request(self, query=None, *, path=DISPATCHER, method="GET", body=None, headers=(), port=None):+ connection = HTTPConnection("127.0.0.1", port or self.server.port, timeout=3)+ try:+ connection.putrequest(+ method, path + "?" + (self.query if query is None else query),+ skip_host=True, skip_accept_encoding=True,+ )+ connection.putheader("Host", "fixture.test:8000")+ for name, value in headers:+ connection.putheader(name, value)+ if body is not None:+ connection.putheader("Content-Length", str(len(body)))+ connection.endheaders(body)+ response = connection.getresponse()+ return response.status, response.headers, response.read()+ finally:+ connection.close()++ def test_dispatcher_keeps_raw_messages_in_fifo_order(self) -> None:+ self.assertEqual(self.request()[2], b"not ready")+ values = (b"first", b"", bytes(range(256)), b'{"result":false}', b"last")+ for value in values:+ status, headers, body = self.request(method="POST", body=value)+ self.assertEqual((status, body), (200, b"done"))+ self.assertEqual(headers["Content-Length"], "4")+ for value in values:+ status, headers, body = self.request()+ self.assertEqual((status, body), (200, value))+ self.assertEqual(headers["Content-Length"], str(len(value)))+ self.assertIsNone(headers["Content-Type"])+ self.assertEqual(self.request()[2], b"not ready")++ def test_dispatcher_cors_and_cache_presence_flags(self) -> None:+ for origin in (None, "", "null", "https://caller.test"):+ for flag in ("", "&cacheable", "&cacheable=0", "&Cacheable=1"):+ with self.subTest(origin=origin, flag=flag):+ headers = [] if origin is None else [("Origin", origin)]+ status, response, body = self.request(self.query + flag, headers=headers)+ self.assertEqual((status, body), (200, b"not ready"))+ self.assertEqual(response["Access-Control-Allow-Origin"], origin or "*")+ self.assertEqual(response["Access-Control-Allow-Credentials"], "true")+ self.assertEqual(response["Access-Control-Allow-Methods"], "OPTIONS, GET, POST")+ self.assertEqual(response["Access-Control-Allow-Headers"], "Content-Type")+ expected = "max-age=31536000" if flag.startswith("&cacheable") else "no-cache, no-store, must-revalidate"+ self.assertEqual(response["Cache-Control"], expected)++ def test_options_does_not_require_uuid_or_touch_the_queue(self) -> None:+ self.request(method="POST", body=b"saved")+ for query in ("", "uuid=invalid", self.query + "&show-headers"):+ status, headers, body = self.request(query, method="OPTIONS")+ self.assertEqual((status, body), (200, b""))+ self.assertEqual(headers["Content-Length"], "0")+ self.assertEqual(self.request()[2], b"saved")+ self.assertEqual(self.request()[2], b"not ready")++ def test_show_headers_precedes_post_and_preserves_header_values(self) -> None:+ for method in ("GET", "HEAD", "POST", "PUT", "chicken"):+ with self.subTest(method=method):+ self.request(method="POST", body=b"first")+ status, _, body = self.request(+ self.query + "&show-headers=0", method=method, body=b"ignored",+ headers=[("Cookie", "one=1; two=2"), ("X-Value", "first"),+ ("x-value", "second"), ("X-Bytes", "\xff")],+ )+ self.assertEqual((status, body), (200, b""))+ self.assertEqual(self.request()[2], b"first")+ saved = json.loads(self.request()[2])+ self.assertEqual(saved, {+ "host": "fixture.test:8000", "cookie": "one=1; two=2",+ "x-value": "first, second", "x-bytes": "\xff", "content-length": "7",+ })+ self.assertEqual(self.request()[2], b"not ready")++ def test_other_methods_take_and_head_consumes_without_a_body(self) -> None:+ for method in ("HEAD", "PUT", "PATCH", "DELETE", "YO", "chicken", "post"):+ with self.subTest(method=method):+ self.request(method="POST", body=b"message")+ status, headers, body = self.request(method=method, body=b"unused")+ self.assertEqual(status, 200)+ self.assertEqual(headers["Content-Length"], "7")+ self.assertEqual(body, b"" if method == "HEAD" else b"message")+ self.assertEqual(self.request()[2], b"not ready")++ def test_uuid_normalization_first_value_and_invalid_keys(self) -> None:+ for query in (+ "uuid=" + self.key.upper(), "uuid=" + self.key.replace("-", ""),+ urlencode({"uuid": "{" + self.key + "}"}), "u%75id=" + self.key + "&uuid=bad",+ ):+ self.assertEqual(self.request(query, method="POST", body=b"message")[0], 200)+ self.assertEqual(self.request()[2], b"message")+ for query in ("", "uuid=", "uuid=bad", "uuid=%FF", "uuid=&" + self.query, "UUID=" + self.key):+ for method in ("GET", "POST"):+ self.assertEqual(self.request(query, method=method, body=b"unused")[0], 500)++ def test_queues_share_origins_and_explicit_namespace_but_not_servers(self) -> None:+ other = self.stack.enter_context(WptFixtureServer(self.root))+ self.server.fetch_stash.put(self.key, b"fetch")+ self.server.fetch_stash.put(self.key, b"other-path", path=DISPATCHER)+ self.request(method="POST", path=DISPATCHER.replace("dispatcher.py", "%64ispatcher.py"), body=b"shared")+ self.assertEqual(self.request(port=other.port)[2], b"not ready")+ self.assertEqual(self.request(port=self.server.alternate_port)[2], b"shared")+ self.assertEqual(self.server.fetch_stash.take(self.key), b"fetch")+ self.assertEqual(self.server.fetch_stash.take(self.key, path=DISPATCHER), b"other-path")+ self.assertEqual(self.server.fetch_stash.take(self.key, path="/common/dispatcher"), [])++ def test_concurrent_producers_and_consumers_do_not_lose_or_duplicate_messages(self) -> None:+ values = [str(index).encode("ascii") for index in range(16)]+ with ThreadPoolExecutor(max_workers=32) as pool:+ posted = list(pool.map(lambda value: self.request(method="POST", body=value), values))+ received = list(pool.map(+ lambda index: self.request(port=self.server.port if index % 2 else self.server.alternate_port),+ range(len(values)),+ ))+ self.assertTrue(all(status == 200 and body == b"done" for status, _, body in posted))+ self.assertTrue(all(status == 200 for status, _, _ in received))+ self.assertEqual(sorted(body for _, _, body in received), sorted(values))+ self.assertEqual(self.request()[2], b"not ready")++ def test_unused_uploads_do_not_block_either_handler(self) -> None:+ for path, method, query in (+ (DISPATCHER, "OPTIONS", ""), (DISPATCHER, "POST", self.query + "&show-headers"),+ (DISPATCHER, "PUT", self.query), (EXECUTOR, "POST", self.query),+ (DISPATCHER, "POST", "uuid=invalid"),+ ):+ connection = HTTPConnection("127.0.0.1", self.server.port, timeout=2)+ try:+ connection.putrequest(method, path + "?" + query)+ connection.putheader("Content-Length", "100")+ connection.endheaders()+ response = connection.getresponse()+ self.assertEqual(response.status, 500 if query == "uuid=invalid" else 200)+ response.read()+ finally:+ connection.close()++ def test_executor_generates_scripts_base_url_and_request_header_initialization(self) -> None:+ query = urlencode([+ ("uuid", "executor-id"), ("script", "/one.js?x='a'&y=<b>"),+ ("script", "/two.js"), ("startOn", "pageshow"),+ ])+ status, headers, body = self.request(+ query, path=EXECUTOR,+ headers=[("X-Value", 'first"'), ("x-value", "second"), ("X-Utf8", "caf\xc3\xa9")],+ )+ text = body.decode("utf-8")+ self.assertEqual(status, 200)+ self.assertEqual(headers["Content-Type"], "text/html")+ self.assertEqual(headers["Content-Length"], str(len(body)))+ self.assertIsNone(headers["Cache-Control"])+ self.assertIsNone(headers["Access-Control-Allow-Origin"])+ self.assertIn('<base href="' + html.escape("http://fixture.test:8000" + EXECUTOR + "?" + query) + '">', text)+ self.assertIn('<script src="/common/dispatcher/dispatcher.js"></script>', text)+ self.assertIn('<script src="./executor-common.js"></script>', text)+ self.assertIn('<script src="./executor-window.js"></script>', text)+ self.assertLess(text.index("/one.js"), text.index("/two.js"))+ self.assertIn("<script src='" + html.escape("/one.js?x='a'&y=<b>") + "'></script>", text)+ self.assertIn('window.__requestHeaders.append("x-value", "first\\\"");', text)+ self.assertIn('window.__requestHeaders.append("x-value", "second");', text)+ self.assertIn('window.__requestHeaders.append("x-utf8", "caf\\u00e9");', text)+ self.assertIn('requestExecutor("executor-id", \'pageshow\');', text)++ def test_executor_query_defaults_first_nonempty_values_and_errors(self) -> None:+ status, _, body = self.request(+ "uuid=&uuid=chosen&uuid=ignored&script=&startOn=&startOn=load", path=EXECUTOR,+ )+ self.assertEqual(status, 200)+ self.assertIn(b'requestExecutor("chosen", \'load\');', body)+ self.assertIn(b'requestExecutor("not-a-uuid", null);', self.request("uuid=not-a-uuid", path=EXECUTOR)[2])+ for query in ("", "uuid=", "UUID=wrong", self.query + "&status=", self.query + "&status=bad"):+ self.assertEqual(self.request(query, path=EXECUTOR)[0], 500)+ self.assertEqual(self.request(path=EXECUTOR, headers=[("X-Bytes", "\xff")])[0], 500)+ self.assertEqual(self.request(self.query + "&status=201&status=404", path=EXECUTOR)[0], 201)++ def test_executor_supports_all_methods_and_head_omits_the_generated_body(self) -> None:+ for method in ("GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "YO", "chicken"):+ with self.subTest(method=method):+ status, headers, body = self.request(path=EXECUTOR, method=method, body=b"unused")+ self.assertEqual(status, 200)+ self.assertEqual(headers["Content-Type"], "text/html")+ if method == "HEAD":+ self.assertEqual(body, b"")+ self.assertGreater(int(headers["Content-Length"]), 0)+ else:+ self.assertIn(b"requestExecutor(", body)++ def test_pipes_apply_after_queue_side_effects_and_executor_status(self) -> None:+ query = urlencode({"uuid": self.key, "pipe": "status(202)|header(Cache-Control,private)|header(X-Result,yes)"})+ status, headers, body = self.request(query, method="POST", body=b"{{host}}")+ self.assertEqual((status, body), (202, b"done"))+ self.assertEqual(headers["Cache-Control"], "private")+ self.assertEqual(headers["X-Result"], "yes")+ status, _, body = self.request(urlencode({"uuid": self.key, "pipe": "sub(none)"}))+ self.assertEqual((status, body), (200, b"localhost"))+ self.assertEqual(self.request()[2], b"not ready")+ status, headers, body = self.request(query + "&status=404", path=EXECUTOR)+ self.assertEqual(status, 202)+ self.assertEqual(headers["Cache-Control"], "private")+ self.assertIn(b"requestExecutor(", body)+ invalid = urlencode({"uuid": self.key, "pipe": "unknown()"})+ self.assertEqual(self.request(invalid, method="POST", body=b"retained")[0], 500)+ self.assertEqual(self.request()[2], b"retained")++ def test_discovery_and_routing_only_allow_the_two_supported_paths(self) -> None:+ directory = "fixture-tests"+ cases = {+ "dispatcher.html": (DISPATCHER, True),+ "executor.html": (EXECUTOR, True),+ "relative.html": ("../common/dispatcher/dispatcher.py", True),+ "dot-relative.html": ("./../common/dispatcher/dispatcher.py", True),+ "wrong-relative.html": ("dispatcher.py", False),+ "wrong-root.html": ("/dispatcher.py", False),+ "wrong-case.html": (DISPATCHER.replace("common", "COMMON"), False),+ "suffix.html": (EXECUTOR + ".extra", False),+ "unsupported.html": ("/common/dispatcher/other.py", False),+ }+ for name, (reference, allowed) in cases.items():+ path = self.root / directory / name+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_text(+ '<script src="/resources/testharness.js"></script>'+ f'<script>fetch("{reference}?uuid={self.key}")</script>'+ )+ if not allowed and reference.startswith("/"):+ self.assertEqual(self.request(path=reference)[0], 404)+ (self.root / directory / "unknown.html").write_text(+ '<script src="/resources/testharness.js"></script>'+ f'<script>fetch("{DISPATCHER}"); fetch("/unsupported.py")</script>'+ )+ self.assertEqual(+ sorted(case.case_path for case in enumerate_cases(self.root, dir_prefixes=(directory,))),+ sorted(directory + "/" + name for name, (_, allowed) in cases.items() if allowed),+ )+++if __name__ == "__main__":+ unittest.main()