workers-runtime-sdk 1.6.12__tar.gz → 1.6.14__tar.gz

{workers_runtime_sdk-1.6.12 → workers_runtime_sdk-1.6.14}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 <!-- version list -->
 
+## v1.6.14 (2026-08-19)
+
+### Bug Fixes
+
+- Fixes fastapi lifespan state not persisting
+  ([`fadd19b`](https://github.com/cloudflare/workers-py/commit/fadd19bcb6ca47518d5e42562879164dd62ab404))
+
+
+## v1.6.13 (2026-08-12)
+
+### Bug Fixes
+
+- **runtime-sdk**: Preserve repeated response headers (multiple `Set-Cookie`)
+  ([#167](https://github.com/cloudflare/workers-py/pull/167),
+  [`f68bf6d`](https://github.com/cloudflare/workers-py/commit/f68bf6d622c896b6c61fe3c615d43d6e9b05d19b))
+
+
 ## v1.6.12 (2026-08-11)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.12 → workers_runtime_sdk-1.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: workers-runtime-sdk
-Version: 1.6.12
+Version: 1.6.14
 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.6.12 → workers_runtime_sdk-1.6.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.6.12"
+version = "1.6.14"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -64,6 +64,9 @@ lint.per-file-ignores."tests/web-frameworks-test/**" = ["C901", "PLR0911", "PLR0
 
 [tool.pytest.ini_options]
 addopts = ["--ignore=tests/workerd-test", "--ignore=tests/bindings-test", "--ignore=tests/web-frameworks-test"]
+markers = [
+  "hyperdrive: needs MySQL and PostgreSQL on localhost; skipped unless run with -m hyperdrive",
+]
 
 [tool.mypy]
 packages = ["workers_runtime_sdk"]

workers_runtime_sdk-1.6.14/src/asgi.py

@@ -0,0 +1,6 @@
+# Compatibility module for existing code that imports `asgi` directly.
+import sys
+
+from workers import asgi as _asgi
+
+sys.modules[__name__] = _asgi

{workers_runtime_sdk-1.6.12/src → workers_runtime_sdk-1.6.14/src/workers}/asgi.py

@@ -8,6 +8,7 @@ from urllib.parse import unquote
 import js
 
 from workers import Context, Request
+from workers.utils import _to_js_headers
 
 ASGI = {"spec_version": "2.0", "version": "3.0"}
 NULL_BODY_STATUSES = frozenset({101, 103, 204, 205, 304})
@@ -48,7 +49,7 @@ def acquire_js_buffer(pybuffer):
         buf.release()
 
 
-def request_to_scope(req, env, ws=False):
+def request_to_scope(req, env, ws=False, state=None):
     from js import URL
 
     # @app.get("/example")
@@ -73,7 +74,7 @@ def request_to_scope(req, env, ws=False):
         ty = "websocket"
     else:
         ty = "http"
-    return {
+    scope = {
         "asgi": ASGI,
         "headers": headers,
         "http_version": "1.1",
@@ -85,6 +86,10 @@ def request_to_scope(req, env, ws=False):
         "type": ty,
         "env": env,
     }
+    if state is not None:
+        # ASGI requires a shallow copy of lifespan state for each request.
+        scope["state"] = dict(state)
+    return scope
 
 
 async def start_application(app):
@@ -93,6 +98,7 @@ async def start_application(app):
     # don't implement it and fall back to serving requests without lifespan.
     # https://asgi.readthedocs.io/en/latest/specs/lifespan.html
     receive_queue = Queue()
+    state = {}
     await receive_queue.put({"type": "lifespan.startup"})
 
     # `startup` resolves True on `lifespan.startup.complete`, False when the app
@@ -140,7 +146,7 @@ async def start_application(app):
             await app(
                 {
                     "asgi": ASGI,
-                    "state": {},
+                    "state": state,
                     "type": "lifespan",
                 },
                 receive,
@@ -167,19 +173,20 @@ async def start_application(app):
     run_in_background(run_lifespan())
     supported = await startup
     if not supported:
-        return no_lifespan_shutdown
-    return shutdown
+        return no_lifespan_shutdown, state
+    return shutdown, state
 
 
-async def process_request(
+async def process_request(  # noqa: PLR0913
     app: Any,
     req: "Request | js.Request",
     env: Any,
     # added for waitUntil, but not used anymore
     # TODO(later): remove this parameter after unvendoring Python SDK from workerd
     ctx: Context | None,
+    state: dict[str, Any] | None = None,
 ) -> js.Response:
-    from js import Object, Response, TransformStream
+    from js import Response, TransformStream
     from pyodide.ffi import create_proxy
 
     status = None
@@ -221,6 +228,8 @@ async def process_request(
         if got["type"] == "http.response.start":
             status = got["status"]
             # Like above, we need to convert byte-pairs into string explicitly.
+            # A response header name may repeat (multiple Set-Cookie), so this
+            # must stay a sequence of pairs, not a name-keyed mapping.
             headers = [(k.decode(), v.decode()) for k, v in got.get("headers", [])]
 
         elif got["type"] == "http.response.body":
@@ -243,7 +252,7 @@ async def process_request(
                 readable = transform_stream.readable
                 writer = transform_stream.writable.getWriter()
                 resp = Response.new(
-                    readable, headers=Object.fromEntries(headers), status=status
+                    readable, headers=_to_js_headers(headers), status=status
                 )
                 result.set_result(resp)
                 with acquire_js_buffer(body) as jsbytes:
@@ -252,7 +261,7 @@ async def process_request(
                 # 101/103/204/205/304 must not carry a body per the Fetch spec.
                 # https://fetch.spec.whatwg.org/#null-body-status
                 resp = Response.new(
-                    None, headers=Object.fromEntries(headers), status=status
+                    None, headers=_to_js_headers(headers), status=status
                 )
                 result.set_result(resp)
                 finished_response.set()
@@ -262,7 +271,7 @@ async def process_request(
                 buf = px.getBuffer()
                 px.destroy()
                 resp = Response.new(
-                    buf.data, headers=Object.fromEntries(headers), status=status
+                    buf.data, headers=_to_js_headers(headers), status=status
                 )
                 result.set_result(resp)
                 finished_response.set()
@@ -270,7 +279,7 @@ async def process_request(
     # Run the application in the background
     async def run_app():
         try:
-            await app(request_to_scope(req, env), receive, send)
+            await app(request_to_scope(req, env, state=state), receive, send)
 
             # If we get here and no response has been set yet, the app didn't generate a response
             if not result.done():
@@ -377,9 +386,9 @@ async def fetch(
     app: Any, req: "Request | js.Request", env: Any, ctx: Context | None = None
 ) -> js.Response:
     logger.debug("ASGI request: %s %s", req.method, req.url)
-    shutdown = await start_application(app)
+    shutdown, state = await start_application(app)
     try:
-        result = await process_request(app, req, env, ctx)
+        result = await process_request(app, req, env, ctx, state=state)
     except Exception:
         logger.exception("ASGI request failed")
         raise

workers_runtime_sdk-1.6.14/tests/bindings-test/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "bindings-test"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0", "pg8000", "pymysql", "cryptography"]

{workers_runtime_sdk-1.6.12/tests/web-frameworks-test/fastapi-tests → workers_runtime_sdk-1.6.14/tests/bindings-test}/src/conftest.py

@@ -1,4 +1,5 @@
 # pyright: reportMissingImports=false
+import uuid
 
 import pytest
 
@@ -8,3 +9,8 @@ from workers import env as _env
 @pytest.fixture
 def env():
     return _env
+
+
+def unique_table_name() -> str:
+    """Unique per call"""
+    return f"test_{uuid.uuid4().hex[:10]}"

workers_runtime_sdk-1.6.14/tests/bindings-test/src/test_hyperdrive_mysql.py

@@ -0,0 +1,208 @@
+# pyright: reportMissingImports=false
+
+"""
+This test requires a MySQL server to be running on localhost.
+
+Run mysql with docker:
+
+docker run -d --name mysql \
+    -e MYSQL_ROOT_PASSWORD=rootpass \
+    -e MYSQL_USER=testuser \
+    -e MYSQL_PASSWORD=testpass \
+    -e MYSQL_DATABASE=testdb \
+    -p 3306:3306 \
+    --health-cmd="mysqladmin ping -h 127.0.0.1" \
+    --health-interval=10s \
+    --health-timeout=5s \
+    --health-retries=5 \
+    mysql:8.4
+
+Then run the test:
+
+uv run pytest tests/test_bindings.py -m hyperdrive -k mysql
+"""
+
+import sys
+
+import pymysql
+import pytest
+from conftest import unique_table_name
+
+
+@pytest.fixture(autouse=True)
+def skip_if_no_socket_support():
+    if sys.version_info.minor < 14:
+        pytest.skip("Socket support requires Python 3.14+")
+
+
+def _connect(env):
+    hd = env.HYPERDRIVE_MYSQL
+    return pymysql.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        database=hd.database,
+        unix_socket=False,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl_disabled=True,
+    )
+
+
+@pytest.mark.asyncio
+async def test_connect(env):
+    conn = _connect(env)
+    cur = conn.cursor()
+    cur.execute("SELECT 1")
+    assert cur.fetchone() == (1,)
+    conn.close()
+
+
+@pytest.mark.asyncio
+async def test_create_insert_select(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} "
+            "(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100), value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("beta", 2))
+        conn.commit()
+
+        cur.execute(f"SELECT name, value FROM {table} ORDER BY name")
+        assert cur.fetchall() == (("alpha", 1), ("beta", 2))
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_update(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} "
+            "(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100), value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        conn.commit()
+
+        cur.execute(
+            f"UPDATE {table} SET value = value + 10 WHERE name = %s", ("alpha",)
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT value FROM {table} WHERE name = %s", ("alpha",))
+        assert cur.fetchone() == (11,)
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_delete(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100))"
+        )
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("alpha",))
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("beta",))
+        conn.commit()
+
+        cur.execute(f"DELETE FROM {table} WHERE name = %s", ("alpha",))
+        conn.commit()
+
+        cur.execute(f"SELECT name FROM {table}")
+        assert cur.fetchall() == (("beta",),)
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_transaction_rollback(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} "
+            "(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100)) ENGINE=InnoDB"
+        )
+        conn.commit()
+
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("should_disappear",))
+        conn.rollback()
+
+        cur.execute(f"SELECT COUNT(*) FROM {table}")
+        assert cur.fetchone() == (0,)
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_multiple_data_types(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} ("
+            "id INT AUTO_INCREMENT PRIMARY KEY, "
+            "text_col VARCHAR(255), "
+            "int_col INT, "
+            "float_col DOUBLE, "
+            "bool_col BOOLEAN)"
+        )
+        cur.execute(
+            f"INSERT INTO {table} (text_col, int_col, float_col, bool_col) "
+            "VALUES (%s, %s, %s, %s)",
+            ("hello", 42, 3.14, True),
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT text_col, int_col, float_col, bool_col FROM {table}")
+        row = cur.fetchone()
+        assert row[0] == "hello"
+        assert row[1] == 42
+        assert abs(row[2] - 3.14) < 0.001
+        assert row[3] == 1
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_executemany(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100))"
+        )
+        cur.executemany(
+            f"INSERT INTO {table} (name) VALUES (%s)", [("a",), ("b",), ("c",)]
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT name FROM {table} ORDER BY name")
+        assert cur.fetchall() == (("a",), ("b",), ("c",))
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()

workers_runtime_sdk-1.6.14/tests/bindings-test/src/test_hyperdrive_postgresql.py

@@ -0,0 +1,182 @@
+# pyright: reportMissingImports=false
+
+"""
+This test requires a PostgreSQL server to be running on localhost.
+
+Run postgresql with docker:
+
+docker run -d --name postgres \
+    -e POSTGRES_USER=testuser \
+    -e POSTGRES_PASSWORD=testpass \
+    -e POSTGRES_DB=testdb \
+    -e POSTGRES_HOST_AUTH_METHOD=md5 \
+    -e POSTGRES_INITDB_ARGS="--auth-host=md5" \
+    -p 5432:5432 \
+    --health-cmd="pg_isready -U testuser -d testdb" \
+    --health-interval=10s \
+    --health-timeout=5s \
+    --health-retries=5 \
+    postgres:16
+
+Then run the test:
+
+uv run pytest tests/test_bindings.py -m hyperdrive -k postgresql
+
+Note: "POSTGRES_HOST_AUTH_METHOD=md5" is required for PostgreSQL to work with pg8000, since the
+      default `scram-sha-256` is not available in the pg8000 with Python workers (missing openssl)
+"""
+
+import sys
+
+import pg8000
+import pytest
+from conftest import unique_table_name
+
+
+@pytest.fixture(autouse=True)
+def skip_if_no_socket_support():
+    if sys.version_info.minor < 14:
+        pytest.skip("Socket support requires Python 3.14+")
+
+
+def _connect(env):
+    hd = env.HYPERDRIVE_PG
+    return pg8000.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        database=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl_context=False,
+    )
+
+
+@pytest.mark.asyncio
+async def test_connect(env):
+    conn = _connect(env)
+    cur = conn.cursor()
+    cur.execute("SELECT 1")
+    assert cur.fetchone() == [1]
+    conn.close()
+
+
+@pytest.mark.asyncio
+async def test_create_insert_select(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT, value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("beta", 2))
+        conn.commit()
+
+        cur.execute(f"SELECT name, value FROM {table} ORDER BY name")
+        assert list(cur.fetchall()) == [["alpha", 1], ["beta", 2]]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_update(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT, value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        conn.commit()
+
+        cur.execute(
+            f"UPDATE {table} SET value = value + 10 WHERE name = %s", ("alpha",)
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT value FROM {table} WHERE name = %s", ("alpha",))
+        assert cur.fetchone() == [11]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_delete(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT)")
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("alpha",))
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("beta",))
+        conn.commit()
+
+        cur.execute(f"DELETE FROM {table} WHERE name = %s", ("alpha",))
+        conn.commit()
+
+        cur.execute(f"SELECT name FROM {table}")
+        assert list(cur.fetchall()) == [["beta"]]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_transaction_rollback(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT)")
+        conn.commit()
+
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("should_disappear",))
+        conn.rollback()
+
+        cur.execute(f"SELECT COUNT(*) FROM {table}")
+        assert cur.fetchone() == [0]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_multiple_data_types(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} ("
+            "id SERIAL PRIMARY KEY, "
+            "text_col TEXT, "
+            "int_col INT, "
+            "float_col DOUBLE PRECISION, "
+            "bool_col BOOLEAN)"
+        )
+        cur.execute(
+            f"INSERT INTO {table} (text_col, int_col, float_col, bool_col) "
+            "VALUES (%s, %s, %s, %s)",
+            ("hello", 42, 3.14, True),
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT text_col, int_col, float_col, bool_col FROM {table}")
+        row = cur.fetchone()
+        assert row[0] == "hello"
+        assert row[1] == 42
+        assert abs(row[2] - 3.14) < 0.001
+        assert row[3] is True
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()

{workers_runtime_sdk-1.6.12 → workers_runtime_sdk-1.6.14}/tests/bindings-test/wrangler.jsonc

@@ -49,6 +49,18 @@
     "analytics_engine_datasets": [
         { "binding": "ANALYTICS", "dataset": "test-dataset" }
     ],
+    "hyperdrive": [
+        {
+            "binding": "HYPERDRIVE_PG",
+            "id": "00000000-0000-0000-0000-000000000001",
+            "localConnectionString": "postgres://testuser:testpass@127.0.0.1:5432/testdb"
+        },
+        {
+            "binding": "HYPERDRIVE_MYSQL",
+            "id": "00000000-0000-0000-0000-000000000002",
+            "localConnectionString": "mysql://testuser:testpass@127.0.0.1:3306/testdb"
+        }
+    ],
     "images": { "binding": "IMAGES" },
     "ratelimits": [
         { "name": "RATE_LIMITER", "namespace_id": "1001", "simple": { "period": 60, "limit": 100 } }

{workers_runtime_sdk-1.6.12 → workers_runtime_sdk-1.6.14}/tests/conftest.py

@@ -24,6 +24,22 @@ DEV_POLL_INTERVAL: float = 0.5
 SUITE_CONNECT_TIMEOUT: int = 10
 SUITE_READ_TIMEOUT: int = 300
 
+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)
+
 
 @dataclass(frozen=True)
 class CompatConfig:
@@ -256,12 +272,19 @@ def discover_suites(src_dir: Path) -> dict[str, list[str]]:
     }
 
 
-def register_in_worker_suites(namespace: dict[str, Any], src_dir: Path) -> None:
+def register_in_worker_suites(
+    namespace: dict[str, Any],
+    src_dir: Path,
+    marks: dict[str, pytest.MarkDecorator] | None = None,
+) -> None:
     """Define a ``TestXxx`` class in `namespace` for every suite found in `src_dir`.
 
     Call with ``globals()`` from a test module so each in-worker test surfaces as
-    its own pytest case without manual registration.
+    its own pytest case without manual registration. `marks` applies a marker to
+    the class generated for the suite of the same name.
     """
     for suite, test_names in discover_suites(src_dir).items():
         suite_cls = make_suite_class(suite, test_names)
+        if marks and suite in marks:
+            suite_cls = marks[suite](suite_cls)
         namespace[suite_cls.__name__] = suite_cls

{workers_runtime_sdk-1.6.12 → workers_runtime_sdk-1.6.14}/tests/test_bindings.py

@@ -18,10 +18,18 @@ from conftest import register_in_worker_suites
 BINDINGS_TEST_DIR: Path = Path(__file__).parent / "bindings-test"
 BINDINGS_SRC_DIR: Path = BINDINGS_TEST_DIR / "src"
 
+SUITE_MARKS: dict[str, pytest.MarkDecorator] = {
+    # hyperdrive tests require external databases to be running
+    # so it is skipped by default.
+    # See each test file for details on how to run them.
+    "hyperdrive_postgresql": pytest.mark.hyperdrive,
+    "hyperdrive_mysql": pytest.mark.hyperdrive,
+}
+
 
 @pytest.fixture(scope="module")
 def worker_project_dir() -> Path:
     return BINDINGS_TEST_DIR
 
 
-register_in_worker_suites(globals(), BINDINGS_SRC_DIR)
+register_in_worker_suites(globals(), BINDINGS_SRC_DIR, marks=SUITE_MARKS)