Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(SKY-11008): stop sending pooler-incompatible startup params to the DB (#6785)
Aaron Perez94038ebf0340
diff --git a/skyvern/forge/sdk/db/agent_db.py b/skyvern/forge/sdk/db/agent_db.pyindex 33bea4a8c..d623d82d3 100644--- a/skyvern/forge/sdk/db/agent_db.py+++ b/skyvern/forge/sdk/db/agent_db.py@@ -1,11 +1,15 @@import asyncio+import shlex+from collections.abc import Mappingfrom typing import Any+from uuid import uuid4import structlogfrom sqlalchemy import (event,pool,)+from sqlalchemy.engine import make_urlfrom sqlalchemy.exc import (SQLAlchemyError,)@@ -39,6 +43,253 @@ from skyvern.forge.sdk.trace import tracedLOG = structlog.get_logger()+# Transaction-pooler compatibility is intentionally scoped to standard :6543 deployments.+TRANSACTION_POOLER_PORT = 6543+_ENFORCING_SSL_MODES = frozenset({"require", "verify-ca", "verify-full"})+++def _query_values(query: Mapping[str, "str | tuple[str, ...]"], key: str) -> tuple[str, ...]:+ value = query.get(key)+ if value is None:+ return ()+ values = value if isinstance(value, tuple) else (value,)+ return tuple(part for item in values for part in item.split(",") if part)+++def _parse_port(port: str) -> int | None:+ try:+ return int(port)+ except ValueError:+ return None+++def _query_host_port(host: str) -> int | None:+ if host.startswith("["):+ _, separator, port = host.rpartition("]:")+ if not separator:+ return None+ return _parse_port(port)++ _, separator, port = host.rpartition(":")+ if not separator:+ return None+ return _parse_port(port)+++def _query_targets_transaction_pooler(query: Mapping[str, "str | tuple[str, ...]"]) -> bool:+ # Startup args cannot vary by fallback target, so use pooler-safe args if any+ # query-level fallback host may connect through the transaction pooler.+ host_ports = (_query_host_port(host) for host in _query_values(query, "host"))+ query_ports = (_parse_port(port) for port in _query_values(query, "port"))+ return TRANSACTION_POOLER_PORT in host_ports or TRANSACTION_POOLER_PORT in query_ports+++def _query_pins_every_host_port(query: Mapping[str, "str | tuple[str, ...]"]) -> bool:+ # A query host without its own port inherits the authority port, so the authority+ # port only stops being a target when every query host names a port itself.+ hosts = _query_values(query, "host")+ if not hosts:+ return False+ if _query_values(query, "port"):+ return True+ return all(_query_host_port(host) is not None for host in hosts)+++def _is_transaction_pooler(database_string: str) -> bool:+ try:+ database_url = make_url(database_string)+ except Exception:+ return False+ if _query_targets_transaction_pooler(database_url.query):+ return True+ if _query_pins_every_host_port(database_url.query):+ return False+ return database_url.port == TRANSACTION_POOLER_PORT+++def _query_last_value(query: Mapping[str, "str | tuple[str, ...]"], key: str) -> str | None:+ value = query.get(key)+ if isinstance(value, tuple):+ value = value[-1] if value else None+ return value+++def _has_enforcing_ssl(query: Mapping[str, "str | tuple[str, ...]"], key: str) -> bool:+ value = _query_last_value(query, key)+ return value in _ENFORCING_SSL_MODES+++def _require_pooler_ssl(+ connect_args: dict[str, Any],+ query: Mapping[str, "str | tuple[str, ...]"],+ key: str,+ query_keys: tuple[str, ...] | None = None,+) -> None:+ query_keys = query_keys or (key,)+ if any(_has_enforcing_ssl(query, query_key) for query_key in query_keys):+ return++ connect_args[key] = "require"+ overridden_key = None+ overridden_value = None+ for query_key in query_keys:+ overridden_value = _query_last_value(query, query_key)+ if overridden_value is not None:+ overridden_key = query_key+ break++ if overridden_key is not None and overridden_value is not None:+ LOG.debug(+ "Overriding non-enforcing Postgres pooler SSL mode",+ ssl_key=overridden_key,+ ssl_mode=overridden_value,+ required_ssl_mode="require",+ )+++def _postgres_options(query: Mapping[str, "str | tuple[str, ...]"]) -> str | None:+ existing_options = query.get("options")+ if isinstance(existing_options, tuple):+ existing_options = " ".join(existing_options)+ return existing_options+++def _direct_psycopg_options(query: Mapping[str, "str | tuple[str, ...]"]) -> str:+ timeout_option = f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"+ existing_options = _postgres_options(query)+ if existing_options:+ return f"{existing_options} {timeout_option}"+ return timeout_option+++def _postgres_options_server_settings(query: Mapping[str, "str | tuple[str, ...]"]) -> dict[str, str]:+ options = _postgres_options(query)+ if not options:+ return {}++ try:+ option_parts = shlex.split(options)+ except ValueError:+ return {}++ server_settings: dict[str, str] = {}+ index = 0+ while index < len(option_parts):+ option = option_parts[index]+ setting = None+ if option == "-c" and index + 1 < len(option_parts):+ index += 1+ setting = option_parts[index]+ elif option.startswith("-c") and len(option) > 2:+ setting = option[2:]++ if setting and "=" in setting:+ key, value = setting.split("=", 1)+ if key:+ server_settings[key] = value+ index += 1++ return server_settings+++def _direct_asyncpg_server_settings(query: Mapping[str, "str | tuple[str, ...]"]) -> dict[str, str]:+ server_settings = _postgres_options_server_settings(query)+ server_settings["statement_timeout"] = str(settings.DATABASE_STATEMENT_TIMEOUT_MS)+ return server_settings+++def _asyncpg_prepared_statement_name() -> str:+ return f"__asyncpg_{uuid4()}__"+++def _postgres_connect_args(database_string: str) -> dict[str, Any]:+ connect_args: dict[str, Any] = {}+ try:+ database_url = make_url(database_string)+ except Exception:+ database_url = None++ drivername = database_url.drivername if database_url else ""+ is_psycopg = drivername in {"postgresql+psycopg", "postgresql+psycopg_async"}+ is_asyncpg = drivername == "postgresql+asyncpg"++ if not _is_transaction_pooler(database_string):+ if is_psycopg:+ connect_args["options"] = _direct_psycopg_options(database_url.query if database_url else {})+ if is_asyncpg:+ connect_args["server_settings"] = _direct_asyncpg_server_settings(+ database_url.query if database_url else {}+ )+ return connect_args++ existing_query = database_url.query if database_url else {}+ if is_psycopg:+ connect_args["prepare_threshold"] = None+ _require_pooler_ssl(connect_args, existing_query, "sslmode")+ if is_asyncpg:+ # Disable both asyncpg's native prepared-statement cache and SQLAlchemy's+ # own per-connection cache; either one reuses prepared statements across+ # pooled server connections, which the transaction pooler can't honor.+ connect_args["statement_cache_size"] = 0+ connect_args["prepared_statement_cache_size"] = 0+ # SQLAlchemy/asyncpg call this zero-arg hook for each prepared statement.+ connect_args["prepared_statement_name_func"] = _asyncpg_prepared_statement_name+ _require_pooler_ssl(connect_args, existing_query, "ssl", query_keys=("ssl", "sslmode"))+ return connect_args+++def _normalize_asyncpg_ssl_query(database_string: str, connect_args: dict[str, Any]) -> str:+ try:+ database_url = make_url(database_string)+ except Exception:+ return database_string++ if database_url.drivername != "postgresql+asyncpg":+ return database_string++ query = dict(database_url.query)+ sslmode = _query_last_value(query, "sslmode")+ if sslmode is None and "ssl" not in query:+ return database_string++ if sslmode is not None:+ query.pop("sslmode", None)++ if "ssl" in connect_args:+ query.pop("ssl", None)+ elif sslmode in _ENFORCING_SSL_MODES:+ connect_args["ssl"] = sslmode+ query.pop("ssl", None)+ elif sslmode is not None and "ssl" not in query:+ connect_args["ssl"] = sslmode++ return database_url.set(query=query).render_as_string(hide_password=False)+++def _strip_postgres_options_query(database_string: str) -> str:+ try:+ database_url = make_url(database_string)+ except Exception:+ return database_string++ if "options" not in database_url.query:+ return database_string++ is_psycopg = database_url.drivername in {"postgresql+psycopg", "postgresql+psycopg_async"}+ is_asyncpg = database_url.drivername == "postgresql+asyncpg"+ if not _is_transaction_pooler(database_string) and not (is_psycopg or is_asyncpg):+ return database_string++ query = dict(database_url.query)+ query.pop("options", None)+ return database_url.set(query=query).render_as_string(hide_password=False)+++def _postgres_engine_config(database_string: str) -> tuple[str, dict[str, Any]]:+ connect_args = _postgres_connect_args(database_string)+ database_string = _strip_postgres_options_query(database_string)+ return _normalize_asyncpg_ssl_query(database_string, connect_args), connect_args+def _build_engine(database_string: str) -> AsyncEngine:"""@@ -47,11 +298,10 @@ def _build_engine(database_string: str) -> AsyncEngine:Supports both PostgreSQL and SQLite (via aiosqlite) dialects.PostgreSQL behaviour:- When DISABLE_CONNECTION_POOL=True (NullPool): enforce statement_timeout- and allow prepared statements.- When DISABLE_CONNECTION_POOL=False (QueuePool): disable prepared statements- and do not set statement_timeout - set at role level in the database,- since the transaction pooler does not maintain session-level settings.+ Connect args are chosen by the connection target (see _postgres_connect_args):+ transaction poolers get SSL + no prepared statements + no startup options,+ direct connections get a session statement_timeout. DISABLE_CONNECTION_POOL+ independently selects NullPool (True) vs QueuePool (False).SQLite behaviour:For :memory: databases, uses StaticPool to keep the single connection alive.@@ -81,12 +331,8 @@ def _build_engine(database_string: str) -> AsyncEngine:return engine- connect_args: dict[str, Any] = {}+ database_string, connect_args = _postgres_engine_config(database_string)if settings.DISABLE_CONNECTION_POOL:- if "postgresql+psycopg" in database_string:- connect_args["options"] = f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"- if "postgresql+asyncpg" in database_string:- connect_args["server_settings"] = {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}return create_async_engine(database_string,json_serializer=_custom_json_serializer,@@ -94,19 +340,14 @@ def _build_engine(database_string: str) -> AsyncEngine:poolclass=pool.NullPool,)- else:- if "postgresql+psycopg" in database_string:- connect_args["prepare_threshold"] = None- if "postgresql+asyncpg" in database_string:- connect_args["statement_cache_size"] = 0- return create_async_engine(- database_string,- json_serializer=_custom_json_serializer,- connect_args=connect_args,- pool_pre_ping=True,- pool_size=settings.DATABASE_POOL_SIZE,- max_overflow=settings.DATABASE_POOL_MAX_OVERFLOW,- )+ return create_async_engine(+ database_string,+ json_serializer=_custom_json_serializer,+ connect_args=connect_args,+ pool_pre_ping=True,+ pool_size=settings.DATABASE_POOL_SIZE,+ max_overflow=settings.DATABASE_POOL_MAX_OVERFLOW,+ )__all__ = ["AgentDB", "ScheduleLimitExceededError"]diff --git a/tests/unit/test_db_engine_connect_args.py b/tests/unit/test_db_engine_connect_args.pynew file mode 100644index 000000000..02f2af3ae--- /dev/null+++ b/tests/unit/test_db_engine_connect_args.py@@ -0,0 +1,429 @@+"""Postgres engine connect-arg selection.++The args that a Postgres transaction pooler on :6543 tolerates are determined+by the connection *target*, not by SQLAlchemy's pool class. Regression cover for+the pooler `unsupported startup parameter: options` and `SSL required` failures.+"""++from collections.abc import Callable+from typing import Any, cast++import pytest+from sqlalchemy import pool+from sqlalchemy.engine import make_url++from skyvern.config import settings+from skyvern.forge.sdk.db import agent_db+from skyvern.forge.sdk.db.agent_db import _is_transaction_pooler, _postgres_connect_args++POOLER_PSYCOPG = "postgresql+psycopg://user:[email protected]:6543/postgres"+DIRECT_PSYCOPG = "postgresql+psycopg://user:[email protected]:5432/postgres"+POOLER_ASYNCPG = "postgresql+asyncpg://user:[email protected]:6543/postgres"+DIRECT_ASYNCPG = "postgresql+asyncpg://user:[email protected]:5432/postgres"+POOLER_PSYCOPG2 = "postgresql+psycopg2://user:[email protected]:6543/postgres"+MULTI_HOST_POOLER_PSYCOPG = "postgresql+psycopg://user:pass@/postgres?host=pooler-a:6543&host=pooler-b:6543"+MULTI_HOST_POOLER_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=pooler-a:6543&host=pooler-b:6543"+MULTI_HOST_DIRECT_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=db-a:5432&host=db-b:5432"+COMMA_MULTI_HOST_POOLER_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=pooler-a,pooler-b&port=6543,6543"+COMMA_MULTI_HOST_DIRECT_ASYNCPG = "postgresql+asyncpg://user:pass@/postgres?host=db-a,db-b&port=5432,5432"+AUTHORITY_POOLER_QUERY_DIRECT_PSYCOPG = (+ "postgresql+psycopg://user:[email protected]:6543/postgres?host=db-a:5432&host=db-b:5432"+)+AUTHORITY_POOLER_QUERY_DIRECT_ASYNCPG = (+ "postgresql+asyncpg://user:[email protected]:6543/postgres?host=db-a:5432&host=db-b:5432"+)+POOLER_PSYCOPG_ASYNC = "postgresql+psycopg_async://user:[email protected]:6543/postgres"+DIRECT_PSYCOPG_ASYNC = "postgresql+psycopg_async://user:[email protected]:5432/postgres"+++ "url, expected",+ [+ (POOLER_PSYCOPG, True),+ (POOLER_ASYNCPG, True),+ (MULTI_HOST_POOLER_PSYCOPG, True),+ (MULTI_HOST_POOLER_ASYNCPG, True),+ ("postgresql+asyncpg://user:pass@/postgres?host=pooler-a&host=pooler-b&port=6543", True),+ (COMMA_MULTI_HOST_POOLER_ASYNCPG, True),+ (POOLER_PSYCOPG_ASYNC, True),+ (DIRECT_PSYCOPG, False),+ (DIRECT_ASYNCPG, False),+ (MULTI_HOST_DIRECT_ASYNCPG, False),+ (COMMA_MULTI_HOST_DIRECT_ASYNCPG, False),+ (AUTHORITY_POOLER_QUERY_DIRECT_PSYCOPG, False),+ (AUTHORITY_POOLER_QUERY_DIRECT_ASYNCPG, False),+ ("postgresql+psycopg://user:pass@h:6543/postgres?host=pooler", True),+ ("postgresql+asyncpg://user:pass@h:6543/postgres?host=pooler", True),+ ("postgresql+asyncpg://user:pass@h:6543/postgres?host=db-a:5432&host=pooler-b", True),+ ("postgresql+asyncpg://user:pass@h:5432/postgres?host=pooler", False),+ (DIRECT_PSYCOPG_ASYNC, False),+ ("postgresql+psycopg://user:pass@host/postgres", False),+ ("sqlite+aiosqlite:///:memory:", False),+ ("not a url", False),+ ],+)+def test_is_transaction_pooler(url: str, expected: bool) -> None:+ assert _is_transaction_pooler(url) is expected+++def test_pooler_psycopg_never_sends_options() -> None:+ """The pooler rejects the `options` startup parameter."""+ args = _postgres_connect_args(POOLER_PSYCOPG)+ assert "options" not in args+ assert args["prepare_threshold"] is None+ assert args["sslmode"] == "require"+++def test_multi_host_pooler_psycopg_never_sends_options() -> None:+ args = _postgres_connect_args(MULTI_HOST_POOLER_PSYCOPG)+ assert "options" not in args+ assert args["prepare_threshold"] is None+ assert args["sslmode"] == "require"+++def test_pooler_psycopg_async_never_sends_options() -> None:+ args = _postgres_connect_args(POOLER_PSYCOPG_ASYNC)+ assert "options" not in args+ assert args["prepare_threshold"] is None+ assert args["sslmode"] == "require"+++def test_direct_psycopg_sets_statement_timeout() -> None:+ args = _postgres_connect_args(DIRECT_PSYCOPG)+ assert args["options"] == f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"+ assert "sslmode" not in args+ assert "prepare_threshold" not in args+++def test_query_host_direct_psycopg_sets_statement_timeout_when_authority_port_is_pooler() -> None:+ args = _postgres_connect_args(AUTHORITY_POOLER_QUERY_DIRECT_PSYCOPG)+ assert args["options"] == f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"+ assert "sslmode" not in args+ assert "prepare_threshold" not in args+++def test_query_host_pooler_psycopg_never_sends_options_when_authority_port_is_pooler() -> None:+ args = _postgres_connect_args("postgresql+psycopg://user:pass@h:6543/postgres?host=pooler")+ assert "options" not in args+ assert args["prepare_threshold"] is None+ assert args["sslmode"] == "require"+++def test_direct_psycopg_preserves_existing_options() -> None:+ args = _postgres_connect_args(f"{DIRECT_PSYCOPG}?options=-c%20search_path%3Dtenant")+ assert args["options"] == f"-c search_path=tenant -c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"+ assert "sslmode" not in args+ assert "prepare_threshold" not in args+++def test_direct_psycopg_async_sets_statement_timeout() -> None:+ args = _postgres_connect_args(DIRECT_PSYCOPG_ASYNC)+ assert args["options"] == f"-c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"+ assert "sslmode" not in args+ assert "prepare_threshold" not in args+++def test_psycopg2_url_does_not_receive_psycopg_v3_connect_args() -> None:+ args = _postgres_connect_args(POOLER_PSYCOPG2)+ assert args == {}+++def test_pooler_asyncpg_disables_prepared_statements_and_requires_ssl() -> None:+ args = _postgres_connect_args(POOLER_ASYNCPG)+ assert "server_settings" not in args+ assert args["statement_cache_size"] == 0+ assert args["prepared_statement_cache_size"] == 0+ name_func = cast(Callable[[], str], args["prepared_statement_name_func"])+ first_name = name_func()+ second_name = name_func()+ assert first_name != second_name+ assert first_name.startswith("__asyncpg_")+ assert first_name.endswith("__")+ assert args["ssl"] == "require"+++def test_multi_host_pooler_asyncpg_uses_pooler_safe_args() -> None:+ args = _postgres_connect_args(MULTI_HOST_POOLER_ASYNCPG)+ assert "server_settings" not in args+ assert args["statement_cache_size"] == 0+ assert args["prepared_statement_cache_size"] == 0+ assert "prepared_statement_name_func" in args+ assert args["ssl"] == "require"+++def test_comma_multi_host_pooler_asyncpg_uses_pooler_safe_args() -> None:+ args = _postgres_connect_args(COMMA_MULTI_HOST_POOLER_ASYNCPG)+ assert "server_settings" not in args+ assert args["statement_cache_size"] == 0+ assert args["prepared_statement_cache_size"] == 0+ assert "prepared_statement_name_func" in args+ assert args["ssl"] == "require"+++def test_direct_asyncpg_sets_statement_timeout() -> None:+ args = _postgres_connect_args(DIRECT_ASYNCPG)+ assert args["server_settings"] == {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}+ assert "ssl" not in args+ assert "prepared_statement_name_func" not in args+++def test_query_host_direct_asyncpg_sets_statement_timeout_when_authority_port_is_pooler() -> None:+ args = _postgres_connect_args(AUTHORITY_POOLER_QUERY_DIRECT_ASYNCPG)+ assert args["server_settings"] == {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}+ assert "ssl" not in args+ assert "prepared_statement_name_func" not in args+++def test_build_engine_keeps_pool_class_selection_independent_of_connect_args(monkeypatch: pytest.MonkeyPatch) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)++ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", True)+ agent_db._build_engine(POOLER_ASYNCPG)+ disabled_kwargs = calls[-1]["kwargs"]++ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)+ agent_db._build_engine(POOLER_ASYNCPG)+ enabled_kwargs = calls[-1]["kwargs"]++ assert disabled_kwargs["poolclass"] is pool.NullPool+ assert "poolclass" not in enabled_kwargs+ assert disabled_kwargs["connect_args"] == enabled_kwargs["connect_args"]+ assert disabled_kwargs["connect_args"]["prepared_statement_name_func"] is agent_db._asyncpg_prepared_statement_name+++def test_build_engine_strips_asyncpg_weak_sslmode_when_requiring_pooler_ssl(monkeypatch: pytest.MonkeyPatch) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{POOLER_ASYNCPG}?sslmode=prefer")++ assert "sslmode" not in calls[-1]["database_string"]+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == "require"+++def test_build_engine_converts_asyncpg_enforcing_sslmode_to_ssl_connect_arg(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{POOLER_ASYNCPG}?sslmode=verify-full")++ assert "sslmode" not in calls[-1]["database_string"]+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == "verify-full"+++def test_build_engine_removes_pooler_asyncpg_weak_ssl_and_sslmode(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{POOLER_ASYNCPG}?ssl=prefer&sslmode=prefer")++ engine_query = make_url(calls[-1]["database_string"]).query+ assert "ssl" not in engine_query+ assert "sslmode" not in engine_query+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == "require"++[email protected]("database_string", [POOLER_ASYNCPG, DIRECT_ASYNCPG])[email protected]("strong_mode", ["require", "verify-full"])+def test_build_engine_prefers_enforcing_asyncpg_sslmode_over_weak_ssl(+ monkeypatch: pytest.MonkeyPatch,+ database_string: str,+ strong_mode: str,+) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{database_string}?ssl=prefer&sslmode={strong_mode}")++ engine_query = make_url(calls[-1]["database_string"]).query+ connect_args = calls[-1]["kwargs"]["connect_args"]+ assert "ssl" not in engine_query+ assert "sslmode" not in engine_query+ assert connect_args["ssl"] == strong_mode+ if database_string == DIRECT_ASYNCPG:+ assert connect_args["server_settings"] == {"statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)}+ else:+ assert "server_settings" not in connect_args+ assert connect_args["statement_cache_size"] == 0++[email protected]("sslmode", ["prefer", "verify-full"])+def test_build_engine_converts_direct_asyncpg_sslmode_to_ssl_connect_arg(+ monkeypatch: pytest.MonkeyPatch,+ sslmode: str,+) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{DIRECT_ASYNCPG}?sslmode={sslmode}")++ assert "sslmode" not in make_url(calls[-1]["database_string"]).query+ assert calls[-1]["kwargs"]["connect_args"]["ssl"] == sslmode+ assert calls[-1]["kwargs"]["connect_args"]["server_settings"] == {+ "statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS)+ }+++def test_build_engine_strips_pooler_psycopg_options_from_url(monkeypatch: pytest.MonkeyPatch) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{POOLER_PSYCOPG}?options=-c%20search_path%3Dtenant")++ assert "options" not in make_url(calls[-1]["database_string"]).query+ assert "options" not in calls[-1]["kwargs"]["connect_args"]+ assert calls[-1]["kwargs"]["connect_args"]["sslmode"] == "require"+++def test_build_engine_moves_direct_psycopg_options_to_connect_args(monkeypatch: pytest.MonkeyPatch) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{DIRECT_PSYCOPG}?options=-c%20search_path%3Dtenant")++ assert "options" not in make_url(calls[-1]["database_string"]).query+ assert (+ calls[-1]["kwargs"]["connect_args"]["options"]+ == f"-c search_path=tenant -c statement_timeout={settings.DATABASE_STATEMENT_TIMEOUT_MS}"+ )+++def test_build_engine_moves_direct_asyncpg_options_to_server_settings(monkeypatch: pytest.MonkeyPatch) -> None:+ calls: list[dict[str, Any]] = []++ def fake_create_async_engine(database_string: str, **kwargs: Any) -> object:+ calls.append({"database_string": database_string, "kwargs": kwargs})+ return object()++ monkeypatch.setattr(agent_db, "create_async_engine", fake_create_async_engine)+ monkeypatch.setattr(settings, "DISABLE_CONNECTION_POOL", False)++ agent_db._build_engine(f"{DIRECT_ASYNCPG}?options=-c%20search_path%3Dtenant")++ assert "options" not in make_url(calls[-1]["database_string"]).query+ assert calls[-1]["kwargs"]["connect_args"]["server_settings"] == {+ "search_path": "tenant",+ "statement_timeout": str(settings.DATABASE_STATEMENT_TIMEOUT_MS),+ }++[email protected]("strong_mode", ["require", "verify-ca", "verify-full"])+def test_pooler_psycopg_preserves_enforcing_sslmode(strong_mode: str) -> None:+ args = _postgres_connect_args(f"{POOLER_PSYCOPG}?sslmode={strong_mode}")+ assert "sslmode" not in args+ assert args["prepare_threshold"] is None++[email protected]("ssl_query_key", ["ssl", "sslmode"])[email protected]("strong_mode", ["require", "verify-ca", "verify-full"])+def test_pooler_asyncpg_preserves_enforcing_ssl_modes(ssl_query_key: str, strong_mode: str) -> None:+ args = _postgres_connect_args(f"{POOLER_ASYNCPG}?{ssl_query_key}={strong_mode}")+ assert "ssl" not in args+ assert args["statement_cache_size"] == 0+ assert args["prepared_statement_cache_size"] == 0++[email protected]("weak_mode", ["disable", "allow", "prefer"])+def test_pooler_psycopg_overrides_non_enforcing_sslmode(weak_mode: str) -> None:+ """A non-enforcing sslmode in the URL must still be forced to require."""+ args = _postgres_connect_args(f"{POOLER_PSYCOPG}?sslmode={weak_mode}")+ assert args["sslmode"] == "require"++[email protected]("weak_mode", ["disable", "allow", "prefer"])+def test_pooler_asyncpg_overrides_non_enforcing_sslmode(weak_mode: str) -> None:+ args = _postgres_connect_args(f"{POOLER_ASYNCPG}?sslmode={weak_mode}")+ assert args["ssl"] == "require"++[email protected]("weak_mode", ["disable", "allow", "prefer"])+def test_pooler_asyncpg_overrides_non_enforcing_ssl(weak_mode: str) -> None:+ args = _postgres_connect_args(f"{POOLER_ASYNCPG}?ssl={weak_mode}")+ assert args["ssl"] == "require"+++ "url, connect_arg_key, log_ssl_key",+ [+ (f"{POOLER_PSYCOPG}?sslmode=prefer", "sslmode", "sslmode"),+ (f"{POOLER_ASYNCPG}?ssl=prefer", "ssl", "ssl"),+ (f"{POOLER_ASYNCPG}?sslmode=prefer", "ssl", "sslmode"),+ ],+)+def test_pooler_logs_when_overriding_non_enforcing_ssl(+ monkeypatch: pytest.MonkeyPatch,+ url: str,+ connect_arg_key: str,+ log_ssl_key: str,+) -> None:+ logs: list[dict[str, Any]] = []++ class FakeLogger:+ def debug(self, message: str, **kwargs: Any) -> None:+ logs.append({"message": message, **kwargs})++ monkeypatch.setattr(agent_db, "LOG", FakeLogger())++ args = _postgres_connect_args(url)++ assert args[connect_arg_key] == "require"+ assert logs == [+ {+ "message": "Overriding non-enforcing Postgres pooler SSL mode",+ "ssl_key": log_ssl_key,+ "ssl_mode": "prefer",+ "required_ssl_mode": "require",+ }+ ]