workers-runtime-sdk 1.8.2__tar.gz → 1.8.4__tar.gz

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 <!-- version list -->
 
+## v1.8.4 (2026-09-08)
+
+### Bug Fixes
+
+- **runtime-sdk**: Fix top-level entropy call for litestar and fix entropy tests
+  ([#241](https://github.com/cloudflare/workers-py/pull/241),
+  [`99b77c7`](https://github.com/cloudflare/workers-py/commit/99b77c7658d1e4b0591233b8ce6cc179719751e3))
+
+
+## v1.8.3 (2026-08-31)
+
+### Bug Fixes
+
+- **runtime-sdk**: Stop losing details of ASGI lifespan failures
+  ([#172](https://github.com/cloudflare/workers-py/pull/172),
+  [`c6d1f69`](https://github.com/cloudflare/workers-py/commit/c6d1f69e96fd13b5b9e41f48e70aebb7469310c8))
+
+
 ## v1.8.2 (2026-08-31)
 
 ### Bug Fixes

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: workers-runtime-sdk
-Version: 1.8.2
+Version: 1.8.4
 Summary: Python SDK for Cloudflare Workers
 Project-URL: Homepage, https://github.com/cloudflare/workers-py
 Project-URL: Bug Tracker, https://github.com/cloudflare/workers-py/issues

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.8.2"
+version = "1.8.4"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -21,42 +21,18 @@ dev = [
   "ruff>=0.1.0",
   "mypy>=1.0.0",
   "requests>=2.28.0",
+  "testlib[host]",
 ]
 
+[tool.uv.sources]
+testlib = { path = "../testlib", editable = true }
+
 [project.urls]
 "Homepage" = "https://github.com/cloudflare/workers-py"
 "Bug Tracker" = "https://github.com/cloudflare/workers-py/issues"
 
 [tool.ruff]
-target-version = "py311"
-lint.select = [
-  "B0",     # bugbear (all B0* checks enabled by default)
-  "B904",   # bugbear (Within an except clause, raise exceptions with raise ... from err)
-  "B905",   # bugbear (zip() without an explicit strict= parameter set.)
-  "C4",     # flake8-comprehensions
-  "C9",     # mccabe complexity
-  "E",      # pycodestyles
-  "F",      # pyflakes
-  "I",      # isort
-  "PERF",   # Perflint
-  "PGH",    # pygrep-hooks
-  "PL",     # Pylint
-  "UP",     # pyupgrade
-  "W",      # pycodestyles
-]
-lint.ignore = [
-  "C901", # Too complex
-  "E402",
-  "E501",
-  "E731",
-  "E741",
-  "PLR0911", # Too many return statements
-  "PLR0915", # Too many statements
-  "PLW2901",
-  "UP031",
-  "UP038", # Use X | Y instead of (X, Y)
-]
-lint.flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
+extend = "../../ruff.toml"
 lint.per-file-ignores."tests/**" = ["PLR2004", "PLR0913"]
 lint.per-file-ignores."tests/workerd-test/**" = ["C901", "PLR0911", "PLR0912", "PLR2004", "PLW0603"]
 lint.per-file-ignores."tests/bindings-test/**" = ["C901", "PLR0911", "PLR0912", "PLR2004", "PLW0603"]

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/src/_workers_sdk_entropy_import_context.py

@@ -178,3 +178,14 @@ def langsmith__internal__constants_context(module):
 def langchain_openai_chat_models_base_context(module):
     with allow_bad_entropy_calls(1):
         yield
+
+
+@register_exec_patch("litestar.openapi.controller")
+@register_exec_patch("litestar.constants")
+@contextmanager
+def litestar_context(module):
+    # Uses os.urandom() to generate a OPENAPI_JSON_HANDLER_NAME
+    # https://github.com/litestar-org/litestar/blob/e3b6a1d103a9160a575dce01ae34839e6e9bf990/litestar/constants.py#L19
+    # https://github.com/litestar-org/litestar/blob/v2.24.0/litestar/openapi/controller.py#L27
+    with allow_bad_entropy_calls(1):
+        yield

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/src/workers/asgi.py

@@ -127,7 +127,9 @@ async def start_application(app):
                 startup.set_result(True)
             return
         if got["type"] == "lifespan.startup.failed":
-            message = got.get("message", "ASGI lifespan startup failed")
+            # `or`, not a .get default: an empty message field is legal and
+            # would otherwise produce RuntimeError('').
+            message = got.get("message") or "ASGI lifespan startup failed"
             if not startup.done():
                 startup.set_exception(RuntimeError(message))
             return
@@ -136,7 +138,7 @@ async def start_application(app):
                 shutdown_complete.set_result(None)
             return
         if got["type"] == "lifespan.shutdown.failed":
-            message = got.get("message", "ASGI lifespan shutdown failed")
+            message = got.get("message") or "ASGI lifespan shutdown failed"
             if not shutdown_complete.done():
                 shutdown_complete.set_exception(RuntimeError(message))
             return
@@ -161,8 +163,15 @@ async def start_application(app):
                 shutdown_complete.set_result(None)
         except Exception as exc:
             # Spec: an exception raised before startup is acked signals that the
-            # app doesn't support lifespan; swallow it and serve requests anyway.
+            # app doesn't support lifespan; serve requests anyway. Log it, or an
+            # app that crashed mid-startup looks like one with no lifespan
+            # handler at all.
             if not startup.done():
+                logger.debug(
+                    "ASGI lifespan task raised before reporting startup; "
+                    "treating the app as not supporting lifespan",
+                    exc_info=exc,
+                )
                 startup.set_result(False)
                 return
             # After a successful startup, a shutdown-phase error can't affect the

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/bindings-test/pyproject.toml

@@ -2,4 +2,7 @@
 name = "bindings-test"
 version = "0.1.0"
 requires-python = ">=3.12"
-dependencies = ["pytest", "pytest-asyncio<1.2.0", "pg8000", "pymysql", "cryptography"]
+dependencies = ["pytest", "pytest-asyncio<1.2.0", "pg8000", "pymysql", "cryptography", "testlib"]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }

workers_runtime_sdk-1.8.4/tests/bindings-test/src/worker.py

@@ -0,0 +1,32 @@
+"""Bindings test worker.
+
+Each binding suite lives in a `test_<suite>.py` module written as ordinary pytest
+tests (see test_kv.py). The `/run-tests/<suite>` endpoint runs pytest against that
+module inside workerd and returns per-test results as JSON, which the host-side
+test_bindings.py maps onto individual pytest cases.
+
+To add a new binding: create `src/test_<binding>.py` with pytest tests.
+"""
+
+from testlib.entrypoint import TestRunnerEntrypoint
+from worker_durable_object import (
+    TestDurableObject,  # noqa: F401 - import to trigger side effect of registering the Durable Object
+)
+from worker_workflow import (
+    TestWorkflow,  # noqa: F401 - import to trigger side effect of registering the Workflow
+)
+
+RECEIVED_MESSAGES = []
+
+
+class Default(TestRunnerEntrypoint):
+    async def queue(self, batch, env, ctx):
+        for message in batch.messages:
+            RECEIVED_MESSAGES.append(
+                {
+                    "id": message.id,
+                    "body": message.body,
+                    "attempts": message.attempts,
+                }
+            )
+            message.ack()

workers_runtime_sdk-1.8.4/tests/conftest.py

@@ -0,0 +1,116 @@
+"""Shared fixtures and helpers for the host-side test suite."""
+
+import os
+import shutil
+import subprocess
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any
+
+import pytest
+from testlib.host import (
+    COMPAT_CONFIGS,
+    CompatConfig,
+    configure_compatibility,
+)
+from testlib.host import (
+    dev_server as run_dev_server,
+)
+from testlib.host import (
+    register_in_worker_suites as register_testlib_suites,
+)
+
+TEST_DIR: Path = Path(__file__).parent
+WORKERS_PY: Path = TEST_DIR.parent.parent / "cli"
+WORKERS_RUNTIME_SDK: Path = TEST_DIR.parent / "src"
+TESTLIB: Path = TEST_DIR.parent.parent / "testlib"
+
+DEV_STARTUP_TIMEOUT: int = 120
+OPT_IN_MARKERS: tuple[str, ...] = ("hyperdrive",)
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: list[pytest.Item]
+) -> None:
+    """Skip opt-in suites unless the run explicitly asks for them via ``-m``."""
+    markexpr: str = config.getoption("markexpr")
+    for marker in OPT_IN_MARKERS:
+        if marker in markexpr:
+            continue
+        skip = pytest.mark.skip(reason=f"needs local services; run with -m {marker}")
+        for item in items:
+            if marker in item.keywords:
+                item.add_marker(skip)
+
+
+@pytest.fixture(scope="session", autouse=True)
+def build_testlib():
+    subprocess.run(["uv", "build"], cwd=TESTLIB, check=True)
+
+
+@pytest.fixture(
+    scope="module",
+    params=COMPAT_CONFIGS,
+    ids=[c.python_version for c in COMPAT_CONFIGS],
+)
+def compat_config(request: pytest.FixtureRequest) -> CompatConfig:
+    return request.param
+
+
+@pytest.fixture(scope="module")
+def worker_project_dir() -> Path:
+    """Worker project the `dev_server` fixture should serve.
+
+    Test modules using `dev_server` must override this fixture.
+    """
+    raise NotImplementedError(
+        "override the `worker_project_dir` fixture in your test module"
+    )
+
+
+@pytest.fixture(scope="module")
+def dev_server(
+    tmp_path_factory: pytest.TempPathFactory,
+    worker_project_dir: Path,
+    compat_config: CompatConfig,
+) -> Generator[str]:
+    """Start a pywrangler dev server on a free port and yield its base URL."""
+    tmp_path = tmp_path_factory.mktemp(f"{worker_project_dir.name}_dev")
+    target = tmp_path / worker_project_dir.name
+    shutil.copytree(worker_project_dir, target, ignore=shutil.ignore_patterns(".venv"))
+    shutil.copytree(TESTLIB, tmp_path / "testlib")
+    env = os.environ | {"_PYODIDE_EXTRA_MOUNTS": str(tmp_path)}
+
+    wrangler_jsonc = target / "wrangler.jsonc"
+    configure_compatibility(wrangler_jsonc, compat_config)
+
+    pywrangler_cmd = ["uv", "run", "--no-project", "--with", WORKERS_PY, "pywrangler"]
+
+    subprocess.run(
+        [*pywrangler_cmd, "sync"],
+        cwd=target,
+        check=True,
+        env=env,
+    )
+
+    shutil.copytree(WORKERS_RUNTIME_SDK, target / "python_modules", dirs_exist_ok=True)
+
+    with run_dev_server(
+        target,
+        tmp_path,
+        env,
+        pywrangler_cmd,
+        startup_timeout=DEV_STARTUP_TIMEOUT,
+        readiness_path="/health",
+        require_success=True,
+        log_name="dev.log",
+    ) as (base_url, _):
+        yield base_url
+
+
+def register_in_worker_suites(
+    namespace: dict[str, Any],
+    src_dir: Path,
+    marks: dict[str, pytest.MarkDecorator] | None = None,
+) -> None:
+    register_testlib_suites(namespace, src_dir, marks=marks, class_name=str.upper)

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/test_fastapi.py

@@ -4,9 +4,6 @@ Python 3.12 (Pyodide 0.26.0a2) is excluded. The in-worker pytest suite drives
 async tests via ``loop.run_until_complete``, which is a no-op on Pyodide 0.26.0a2
 (no ``run_sync``/JSPI): async tests return unawaited futures and report false
 passes.
-
-Python 3.14 is excluded because pydantic_core has a circular import error on
-the 3.14 Pyodide runtime (``validate_core_schema`` not found during module init).
 """
 
 from pathlib import Path
@@ -26,9 +23,8 @@ def worker_project_dir() -> Path:
 
 
 # Exclude Python 3.12 (Pyodide 0.26.0a2) for async tests.
-# Exclude Python 3.14 due to pydantic_core circular import error on Pyodide.
 FASTAPI_COMPAT_CONFIGS = [
-    c for c in COMPAT_CONFIGS if c.python_version not in ("3.12", "3.14")
+    c for c in COMPAT_CONFIGS if c.python_version not in ("3.12",)
 ]
 
 

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/test_in_workerd.py

@@ -7,8 +7,7 @@ import pytest
 from conftest import (
     COMPAT_CONFIGS,
     CompatConfig,
-    inject_compat_flags,
-    replace_compat_date,
+    configure_compatibility,
 )
 
 TEST_DIR = Path(__file__).parent
@@ -62,7 +61,7 @@ def bundle_cache_dir(tmp_path_factory):
     ids=[c.python_version for c in COMPAT_CONFIGS],
 )
 @pytest.mark.parametrize("test_dir, wd_test_file", discover_workerd_tests())
-def test_in_workerd(  # noqa: PLR0913  (too-many-arguments)
+def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
     tmp_path,
     test_dir,
     wd_test_file,
@@ -71,22 +70,27 @@ def test_in_workerd(  # noqa: PLR0913  (too-many-arguments)
     bundle_cache_dir,
 ):
     compat_date = compat_config.compat_date
+    python_version = compat_config.python_version
 
     # `wsgi` streams the request body via `pyodide.ffi.run_sync` (JSPI), which
     # is only available in newer Pyodide runtimes.
-    if test_dir.name == "wsgi" and compat_date < "2026-01-01":
+    if test_dir.name == "wsgi" and python_version == "3.12":
         pytest.skip(
             "wsgi requires pyodide.ffi.run_sync (JSPI), unavailable before 2026-01-01"
         )
 
+    if test_dir.name == "entropy-patches" and python_version == "3.14":
+        pytest.skip(
+            "TODO: enable me after https://github.com/cloudflare/workerd/pull/7200 lands in wrangler"
+        )
+
     color = pytestconfig.get_terminal_writer().hasmarkup
     target = tmp_path / test_dir.name
     disk_service_dir = target / DISK_SERVICE_NAME
     shutil.copytree(test_dir, target, ignore=shutil.ignore_patterns(".venv"))
     disk_service_dir.mkdir(exist_ok=True)
 
-    replace_compat_date(target / "wrangler.jsonc", compat_date)
-    inject_compat_flags(target / "wrangler.jsonc", compat_config.extra_compat_flags)
+    configure_compatibility(target / "wrangler.jsonc", compat_config)
 
     pywrangler_cmd = ["uv", "run", "--no-project", "--with", WORKERS_PY, "pywrangler"]
 
@@ -114,7 +118,7 @@ def test_in_workerd(  # noqa: PLR0913  (too-many-arguments)
         .replace("%COLOR", str(color).lower())
         .replace("%COMPAT_DATE", compat_date)
     )
-    inject_compat_flags(wd_config, compat_config.extra_compat_flags)
+    configure_compatibility(wd_config, compat_config)
 
     subprocess.run(
         ["npm", "i", "workerd"],

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/web-frameworks-test/django-async/pyproject.toml

@@ -10,4 +10,8 @@ dependencies = [
     "django-cors-headers",
     "pytest",
     "pytest-asyncio<1.2.0",
+    "testlib",
 ]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }

workers_runtime_sdk-1.8.4/tests/web-frameworks-test/django-async/src/worker.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+
+import pytest
+from testlib.entrypoint import TestRunnerEntrypoint
+
+import asgi
+
+BASE_DIR = Path(__file__).parent
+TEMPLATES_DIR = str(BASE_DIR / "templates")
+
+
+import django.conf  # noqa: E402
+
+django.conf.settings.configure(
+    DEBUG=False,
+    SECRET_KEY="test-secret-key-for-workers-py",
+    ROOT_URLCONF="django_app.urls",
+    ALLOWED_HOSTS=["*"],
+    INSTALLED_APPS=[
+        "django.contrib.contenttypes",
+        "django.contrib.sessions",
+        "django.contrib.auth",
+        "rest_framework",
+        "corsheaders",
+    ],
+    MIDDLEWARE=[
+        "corsheaders.middleware.CorsMiddleware",
+        "django.middleware.security.SecurityMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.common.CommonMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.middleware.clickjacking.XFrameOptionsMiddleware",
+        "django_app.middleware.CustomAsyncMiddleware",
+    ],
+    TEMPLATES=[
+        {
+            "BACKEND": "django.template.backends.django.DjangoTemplates",
+            "DIRS": [TEMPLATES_DIR],
+            "APP_DIRS": False,
+            "OPTIONS": {
+                "context_processors": [
+                    "django.template.context_processors.request",
+                ],
+                "builtins": ["django_app.templatetags.custom_tags"],
+            },
+        }
+    ],
+    CACHES={
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        }
+    },
+    SESSION_ENGINE="django.contrib.sessions.backends.signed_cookies",
+    AUTHENTICATION_BACKENDS=["django_app.auth_backend.InMemoryBackend"],
+    DATABASES={},
+    TIME_ZONE="UTC",
+    USE_TZ=True,
+    DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
+    CORS_ALLOWED_ORIGINS=[
+        "http://localhost:3000",
+        "https://example.com",
+    ],
+    CORS_ALLOW_CREDENTIALS=True,
+    CORS_ALLOWED_ORIGIN_REGEXES=[r"^https://.*\.example\.com$"],
+    REST_FRAMEWORK={
+        "DEFAULT_RENDERER_CLASSES": ["rest_framework.renderers.JSONRenderer"],
+        "DEFAULT_PARSER_CLASSES": [
+            "rest_framework.parsers.JSONParser",
+            "rest_framework.parsers.FormParser",
+            "rest_framework.parsers.MultiPartParser",
+        ],
+        "DEFAULT_THROTTLE_RATES": {
+            "anon": "10/min",
+            "user": "100/min",
+        },
+    },
+)
+
+import django  # noqa: E402
+
+django.setup()
+
+from django.core.handlers.asgi import ASGIHandler  # noqa: E402
+
+django_asgi_app = ASGIHandler()
+
+
+class DjangoAppPlugin:
+    @pytest.fixture
+    def django_asgi_app(self):
+        return django_asgi_app
+
+
+class Default(TestRunnerEntrypoint):
+    app = django_asgi_app
+
+    async def fetch(self, request):
+        result = await super().fetch(request)
+        if result.status == 404:
+            result = await asgi.fetch(django_asgi_app, request, self.env, self.ctx)
+        return result
+
+    def plugins(self):
+        return super().plugins() + [DjangoAppPlugin()]

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/web-frameworks-test/fastapi-tests/pyproject.toml

@@ -7,4 +7,8 @@ dependencies = [
     "python-multipart",
     "pytest",
     "pytest-asyncio<1.2.0",
+    "testlib",
 ]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -1,7 +1,6 @@
 import asyncio
 import enum
 import hashlib
-import importlib.util
 import json
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -34,6 +33,7 @@ from pydantic import BaseModel
 from pyodide.webloop import WebLoop
 from starlette.background import BackgroundTask
 from starlette.middleware.gzip import GZipMiddleware
+from testlib.entrypoint import TestRunner
 
 import asgi
 
@@ -585,57 +585,6 @@ async def native_file():
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
 
-class ResultCollector:
-    def __init__(self):
-        self.results = {}
-
-    @staticmethod
-    def _key(item):
-        name = item.name
-        return name[len("test_") :] if name.startswith("test_") else name
-
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_runtest_makereport(self, item, call):
-        outcome = yield
-        report = outcome.get_result()
-        key = self._key(item)
-
-        if report.when == "call":
-            if report.passed:
-                self.results[key] = {"status": "passed"}
-            elif report.skipped:
-                self.results[key] = {
-                    "status": "skipped",
-                    "reason": str(report.longrepr),
-                }
-            elif report.failed:
-                excinfo = call.excinfo
-                if excinfo is not None and excinfo.errisinstance(AssertionError):
-                    self.results[key] = {
-                        "status": "failed",
-                        "error": str(excinfo.value),
-                    }
-                else:
-                    self.results[key] = {
-                        "status": "error",
-                        "error": f"{excinfo.typename}: {excinfo.value}"
-                        if excinfo is not None
-                        else "unknown error",
-                        "traceback": report.longreprtext,
-                    }
-        elif report.when in ("setup", "teardown") and report.skipped:
-            self.results[key] = {
-                "status": "skipped",
-                "reason": str(report.longrepr),
-            }
-        elif report.when in ("setup", "teardown") and report.failed:
-            self.results[key] = {
-                "status": "error",
-                "error": report.longreprtext,
-                "traceback": report.longreprtext,
-            }
-
-
 class EnvPlugin:
     def __init__(self, env):
         self._env = env
@@ -653,27 +602,9 @@ class FastAPIAppPlugin:
 
 @app.get("/run-tests/{suite_name:path}")
 async def run_suite(suite_name: str, request: Request):
-    module = f"test_{suite_name}"
-    if importlib.util.find_spec(module) is None:
-        return JSONResponse(
-            {"error": f"Unknown suite '{suite_name}' (no module '{module}')"},
-            status_code=404,
-        )
-
-    collector = ResultCollector()
-    saved_loop = asyncio.events._get_running_loop()
-    try:
-        pytest.main(
-            ["--pyargs", module, "-p", "no:cacheprovider"],
-            plugins=[
-                collector,
-                EnvPlugin(request.scope["env"]),
-                FastAPIAppPlugin(),
-            ],
-        )
-    finally:
-        asyncio.events._set_running_loop(saved_loop)
-    return collector.results
+    runner = TestRunner(request.scope["env"])
+    result = runner.run_suite(suite_name)
+    return JSONResponse(result.payload, status_code=result.status)
 
 
 @app.get("/{path:path}")

workers_runtime_sdk-1.8.4/tests/web-frameworks-test/flask-tests/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "flask-tests"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = ["flask", "pytest", "testlib"]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }

workers_runtime_sdk-1.8.4/tests/web-frameworks-test/flask-tests/src/worker.py

@@ -0,0 +1,5 @@
+from testlib.entrypoint import TestRunnerEntrypoint
+
+
+class Default(TestRunnerEntrypoint):
+    pass

{workers_runtime_sdk-1.8.2 → workers_runtime_sdk-1.8.4}/tests/workerd-test/asgi/tests/test_asgi.py

@@ -428,3 +428,49 @@ async def test_multiple_set_cookie_headers_survive():
         "first=1; Path=/",
         "second=2; Path=/",
     ]
+
+
+class _StartupFailEmptyMessageApp:
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "lifespan":
+            message = await receive()
+            if message["type"] == "lifespan.startup":
+                await send({"type": "lifespan.startup.failed", "message": ""})
+            return
+
+
+@pytest.mark.asyncio
+async def test_lifespan_startup_failure_with_empty_message():
+    req = js.Request.new("http://example.com/startup-fail-empty")
+    with pytest.raises(RuntimeError, match="ASGI lifespan startup failed"):
+        await asyncio.wait_for(
+            asgi.fetch(_StartupFailEmptyMessageApp(), req, env), timeout=5
+        )
+
+
+class _PreAckCrashApp:
+    """Raises on the lifespan scope before any ack; HTTP must still serve."""
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "lifespan":
+            raise RuntimeError("crashed before ack")
+        await receive()
+        await send({"type": "http.response.start", "status": 200, "headers": []})
+        await send({"type": "http.response.body", "body": b"ok"})
+
+
+@pytest.mark.asyncio
+async def test_lifespan_preack_crash_is_logged_and_treated_as_unsupported():
+    handler = _install_handler()
+    try:
+        req = js.Request.new("http://example.com/preack-crash")
+        response = await asyncio.wait_for(
+            asgi.fetch(_PreAckCrashApp(), req, env), timeout=5
+        )
+        assert await response.text() == "ok"
+        assert any(
+            "before reporting startup" in record.getMessage()
+            for record in handler.records
+        )
+    finally:
+        _remove_handler(handler)