Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.py
index 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.Patte
return 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.py
index 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():
+ return
if self._serve_common_echo_resource():
return
if 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():
+ return
if self._serve_common_echo_resource():
return
if 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():
+ return
if self._serve_common_echo_resource():
return
if self._serve_common_redirect_resource():
@@ -1845,6 +2017,8 @@ def _make_handler(
do_DELETE = _serve_fetch_resource_method
def do_YO(self) -> None: # noqa: N802 (WPT custom method)
+ if self._serve_remote_context_resource():
+ return
if self._serve_common_echo_resource():
return
if self._serve_common_redirect_resource():
@@ -2060,6 +2234,8 @@ def _make_handler(
return True
def _serve(self, *, emit_body: bool) -> None:
+ if self._serve_remote_context_resource():
+ return
try:
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_resource
if name.startswith("do_") and unquote(urlsplit(self.path).path) == COMMON_ECHO_PATH:
return self._serve_common_echo_resource
if name.startswith("do_") and unquote(urlsplit(self.path).path) == COMMON_REDIRECT_PATH:
@@ -2618,8 +2796,8 @@ def _make_handler(
return self._serve_fetch_resource_method
raise 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 None
length_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.py
new file mode 100644
index 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()