@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/memory_orchestrator/tests/test_promotion_service.py

@@ -1,322 +0,0 @@
-"""Tests for promotion_service: get_promotion_status + repush_by_status.
-
-Phase 177 Gap-2. All external dependencies (DB, Celery) are mocked.
-"""
-
-from __future__ import annotations
-
-from contextlib import asynccontextmanager
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-pytestmark = [pytest.mark.asyncio]
-
-
-# ---------------------------------------------------------------------------
-# Mock helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_connect_mock(rows: list[dict]) -> MagicMock:
-    """Mock database_service with engine.connect() returning grouped rows."""
-    mock_result = MagicMock()
-    mock_result.mappings.return_value.all.return_value = rows
-
-    mock_conn = AsyncMock()
-    mock_conn.execute = AsyncMock(return_value=mock_result)
-
-    @asynccontextmanager
-    async def _connect():
-        yield mock_conn
-
-    @asynccontextmanager
-    async def _begin():
-        yield mock_conn
-
-    mock_engine = MagicMock()
-    mock_engine.connect = _connect
-    mock_engine.begin = _begin
-
-    mock_pg = MagicMock()
-    mock_pg._initialized = True
-    mock_pg.engine = mock_engine
-
-    mock_db = MagicMock()
-    mock_db.postgres = mock_pg
-    mock_db.update_memory = AsyncMock()
-    return mock_db
-
-
-def _make_celery_mock() -> MagicMock:
-    mock_celery = MagicMock()
-    mock_celery.send_task = MagicMock()
-    return mock_celery
-
-
-# ---------------------------------------------------------------------------
-# get_promotion_status
-# ---------------------------------------------------------------------------
-
-
-async def test_get_promotion_status_returns_grouped_counts() -> None:
-    """get_promotion_status should return counts keyed by status plus total."""
-    rows = [
-        {"status": "synced", "cnt": 980},
-        {"status": "local-only", "cnt": 12},
-        {"status": "stalled", "cnt": 5},
-        {"status": "pending", "cnt": 3},
-    ]
-    mock_db = _make_connect_mock(rows)
-
-    with patch(
-        "vds_memory_orchestrator.service.services.promotion_service.database_service",
-        mock_db,
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import get_promotion_status
-
-        result = await get_promotion_status()
-
-    assert result["counts"]["synced"] == 980
-    assert result["counts"]["local-only"] == 12
-    assert result["counts"]["stalled"] == 5
-    assert result["counts"]["pending"] == 3
-    assert result["total"] == 1000
-    assert "queried_at" in result
-
-
-async def test_get_promotion_status_fills_missing_known_statuses() -> None:
-    """Statuses not present in DB should appear as 0 in the result."""
-    rows = [{"status": "synced", "cnt": 50}]
-    mock_db = _make_connect_mock(rows)
-
-    with patch(
-        "vds_memory_orchestrator.service.services.promotion_service.database_service",
-        mock_db,
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import get_promotion_status
-
-        result = await get_promotion_status()
-
-    assert result["counts"]["local-only"] == 0
-    assert result["counts"]["pending"] == 0
-    assert result["counts"]["stalled"] == 0
-    assert result["counts"]["skipped"] == 0
-    assert result["total"] == 50
-
-
-async def test_get_promotion_status_empty_table() -> None:
-    """Empty memories table should return total=0 and all known statuses at 0."""
-    mock_db = _make_connect_mock([])
-
-    with patch(
-        "vds_memory_orchestrator.service.services.promotion_service.database_service",
-        mock_db,
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import get_promotion_status
-
-        result = await get_promotion_status()
-
-    assert result["total"] == 0
-    assert all(v == 0 for v in result["counts"].values())
-
-
-# ---------------------------------------------------------------------------
-# repush_by_status — dry run
-# ---------------------------------------------------------------------------
-
-
-async def test_repush_by_status_dry_run_returns_candidate_count() -> None:
-    """dry_run=True should return candidates without writing or queueing."""
-    rows = [
-        {"memory_id": "mem-001", "metadata": {"mem0_status": "local-only"}},
-        {"memory_id": "mem-002", "metadata": {"mem0_status": "local-only"}},
-    ]
-    mock_db = _make_connect_mock(rows)
-    mock_celery = _make_celery_mock()
-
-    with (
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.database_service",
-            mock_db,
-        ),
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.celery_app",
-            mock_celery,
-        ),
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import repush_by_status
-
-        result = await repush_by_status("local-only", limit=10, dry_run=True)
-
-    assert result["dry_run"] is True
-    assert result["candidates"] == 2
-    assert result["queued"] == 0
-    assert result["errors"] == 0
-    mock_celery.send_task.assert_not_called()
-    mock_db.update_memory.assert_not_called()
-
-
-# ---------------------------------------------------------------------------
-# repush_by_status — live run (success)
-# ---------------------------------------------------------------------------
-
-
-async def test_repush_by_status_queues_push_tasks_and_sets_pending() -> None:
-    """repush_by_status live run should update metadata and queue mem0.push_memory."""
-    rows = [
-        {"memory_id": "mem-001", "metadata": {"mem0_status": "local-only"}},
-        {"memory_id": "mem-002", "metadata": {"mem0_status": "local-only"}},
-    ]
-    mock_db = _make_connect_mock(rows)
-    mock_celery = _make_celery_mock()
-
-    with (
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.database_service",
-            mock_db,
-        ),
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.celery_app",
-            mock_celery,
-        ),
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import repush_by_status
-
-        result = await repush_by_status("local-only", limit=10, dry_run=False)
-
-    assert result["queued"] == 2
-    assert result["errors"] == 0
-    assert result["candidates"] == 2
-    assert mock_celery.send_task.call_count == 2
-    # Verify metadata was updated to 'pending' for each row
-    calls = mock_db.update_memory.call_args_list
-    assert len(calls) == 2
-    for call in calls:
-        _conn, mem_id, payload = call.args
-        assert payload["metadata"]["mem0_status"] == "pending"
-        assert "mem0_repush_requested_at" in payload["metadata"]
-
-
-async def test_repush_by_status_counts_errors_on_queue_failure() -> None:
-    """repush_by_status should count errors when send_task raises."""
-    rows = [
-        {"memory_id": "mem-001", "metadata": {"mem0_status": "local-only"}},
-        {"memory_id": "mem-002", "metadata": {"mem0_status": "local-only"}},
-    ]
-    mock_db = _make_connect_mock(rows)
-    mock_celery = _make_celery_mock()
-    mock_celery.send_task.side_effect = [None, RuntimeError("broker down")]
-
-    with (
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.database_service",
-            mock_db,
-        ),
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.celery_app",
-            mock_celery,
-        ),
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import repush_by_status
-
-        result = await repush_by_status("local-only", limit=10, dry_run=False)
-
-    assert result["queued"] == 1
-    assert result["errors"] == 1
-
-
-async def test_repush_by_status_empty_cohort() -> None:
-    """repush_by_status with no matching rows returns zeros."""
-    mock_db = _make_connect_mock([])
-    mock_celery = _make_celery_mock()
-
-    with (
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.database_service",
-            mock_db,
-        ),
-        patch(
-            "vds_memory_orchestrator.service.services.promotion_service.celery_app",
-            mock_celery,
-        ),
-    ):
-        from vds_memory_orchestrator.service.services.promotion_service import repush_by_status
-
-        result = await repush_by_status("local-only", limit=100, dry_run=False)
-
-    assert result["candidates"] == 0
-    assert result["queued"] == 0
-    assert result["errors"] == 0
-    mock_celery.send_task.assert_not_called()
-
-
-# ---------------------------------------------------------------------------
-# Celery beat schedule — fully retired per ADR-14 (commit a0ba4179, 2026-04-24)
-# ---------------------------------------------------------------------------
-
-
-def test_celery_beat_schedule_empty_after_retirement() -> None:
-    """ADR-14 retirement: beat_schedule MUST be empty post-2026-04-24.
-
-    The 6 mem0-repush-* / memory-evolution-* periodic tasks moved to DBOS
-    schedules in scheduler_orchestrator. Celery worker plumbing is retained
-    for ad-hoc task dispatch (see RETIREMENT-EXECUTED.md §Scope Clarification),
-    but Celery Beat no longer registers any periodic tasks.
-
-    Mirror of scheduler_orchestrator/tests/unit/test_celery_migration_workflows.py
-    ::TestCeleryBeatRetired::test_beat_schedule_always_empty_after_retirement.
-    """
-    pytest.importorskip("celery")
-    from vds_memory_orchestrator.service.services.memory_evolution.celery_app import celery_app
-
-    assert celery_app.conf.beat_schedule == {}, (
-        "Post-retirement beat_schedule must be empty; if non-empty, the "
-        "retirement was reversed without spec-version bump (see "
-        "RETIREMENT-EXECUTED.md §A.1)."
-    )
-
-
-def test_celery_task_route_repush_local_only_registered() -> None:
-    """Task route for mem0.repush_local_only must be in celery_app task_routes."""
-    pytest.importorskip("celery")
-    from vds_memory_orchestrator.service.services.memory_evolution.celery_app import (
-        DEFAULT_QUEUE_NAME,
-        celery_app,
-    )
-
-    routes = celery_app.conf.task_routes
-    assert "mem0.repush_local_only" in routes, (
-        "Task route mem0.repush_local_only must be registered"
-    )
-    assert routes["mem0.repush_local_only"]["queue"] == DEFAULT_QUEUE_NAME
-
-
-# ---------------------------------------------------------------------------
-# Celery task — repush_local_only delegates to repush_by_status
-# ---------------------------------------------------------------------------
-
-
-async def test_repush_local_only_celery_task_delegates_to_service() -> None:
-    """_repush_local_only async helper must call repush_by_status with status='local-only'."""
-    pytest.importorskip("celery")
-    mock_result = {
-        "status": "local-only",
-        "limit": 100,
-        "dry_run": False,
-        "candidates": 5,
-        "queued": 5,
-        "errors": 0,
-    }
-    with patch(
-        "vds_memory_orchestrator.service.services.promotion_service.repush_by_status",
-        new=AsyncMock(return_value=mock_result),
-    ) as mock_repush:
-        from vds_memory_orchestrator.service.services.memory_evolution.worker import (
-            _repush_local_only,
-        )
-
-        result = await _repush_local_only(limit=50)
-
-    mock_repush.assert_called_once_with(status="local-only", limit=50, dry_run=False)
-    assert result["queued"] == 5

package/tools/vds-scripts/memory_orchestrator/tests/test_status_endpoint.py

@@ -1,193 +0,0 @@
-"""Unit tests for the /memories/{id}/status response mapping (VAMI-018 T-F1-1).
-
-Covers the F-1 root cause: the endpoint recognised only ``"success"`` (which
-no writer emits), so terminal ``"synced"``/``"stalled"`` values fell through
-to a perpetual ``"processing"`` response. VAMI-018 aligns the mapping to
-canonical writer vocabulary (ADR-17) and adds an explicit unknown-value
-terminal (ADR-18).
-
-Tests target the dep-free ``service.api.status_mapping`` module so the
-mapping is unit-testable without the full FastAPI dependency graph.
-"""
-
-from __future__ import annotations
-
-from vds_memory_orchestrator.service.api.status_mapping import (
-    resolve_status_response,
-)
-
-
-class TestStatusEndpointMapping:
-    """Endpoint response mapping aligns to canonical writer vocabulary."""
-
-    def test_synced_with_mem0_id_returns_complete(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "synced", "mem0_id": "m_abc"}, "mem0_id": None},
-            "pg_1",
-        )
-        assert result == {"memory_id": "pg_1", "status": "complete", "mem0_id": "m_abc"}
-
-    def test_synced_without_mem0_id_still_complete(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "synced"}, "mem0_id": None}, "pg_1"
-        )
-        assert result["status"] == "complete"
-
-    # VAMI-021 (ADR-37): test_legacy_success_still_returns_complete deleted
-    # — the "success" writer alias is retired; only canonical "synced" is
-    # recognised. See the docstring in status_mapping.py.
-
-    def test_mem0_id_present_wins_over_unknown_status(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_id": "m_abc"}, "mem0_id": None}, "pg_1"
-        )
-        assert result["status"] == "complete"
-        assert result["mem0_id"] == "m_abc"
-
-    def test_stalled_returns_failed_with_reason(self) -> None:
-        result = resolve_status_response(
-            {
-                "metadata": {
-                    "mem0_status": "stalled",
-                    "mem0_stalled_reason": "mem0_event_succeeded_but_missing_in_list",
-                },
-                "mem0_id": None,
-            },
-            "pg_1",
-        )
-        assert result["status"] == "failed"
-        assert "succeeded_but_missing" in result["error"]
-
-    def test_stalled_without_reason_uses_default_error(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "stalled"}, "mem0_id": None}, "pg_1"
-        )
-        assert result["status"] == "failed"
-        assert result["error"] == "mem0 add stalled"
-
-    def test_failed_returns_failed(self) -> None:
-        result = resolve_status_response(
-            {
-                "metadata": {"mem0_status": "failed", "mem0_reason": "api timeout"},
-                "mem0_id": None,
-            },
-            "pg_1",
-        )
-        assert result == {
-            "memory_id": "pg_1",
-            "status": "failed",
-            "error": "api timeout",
-        }
-
-    def test_error_alias_returns_failed(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "error"}, "mem0_id": None}, "pg_1"
-        )
-        assert result["status"] == "failed"
-
-    def test_pending_returns_queued(self) -> None:
-        result = resolve_status_response(
-            {
-                "metadata": {"mem0_status": "pending", "mem0_reason": "async_mode_queued"},
-                "mem0_id": None,
-            },
-            "pg_1",
-        )
-        assert result == {"memory_id": "pg_1", "status": "queued"}
-
-    def test_processing_returns_processing(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "processing"}, "mem0_id": None}, "pg_1"
-        )
-        assert result == {"memory_id": "pg_1", "status": "processing"}
-
-    def test_unknown_status_returns_failed_with_explicit_error(self) -> None:
-        # ADR-18: previously returned "processing" forever for any value the
-        # endpoint didn't recognise, masking enum drift.
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "rate_limited"}, "mem0_id": None}, "pg_1"
-        )
-        assert result["status"] == "failed"
-        assert "rate_limited" in result["error"]
-
-    def test_no_metadata_returns_complete(self) -> None:
-        result = resolve_status_response({"metadata": {}, "mem0_id": None}, "pg_1")
-        assert result["status"] == "complete"
-
-    def test_object_shape_handled(self) -> None:
-        class _MemoryObj:
-            def __init__(self) -> None:
-                self.metadata = {"mem0_status": "synced", "mem0_id": "m_xyz"}
-                self.mem0_id = None
-
-        result = resolve_status_response(_MemoryObj(), "pg_1")
-        assert result["status"] == "complete"
-        assert result["mem0_id"] == "m_xyz"
-
-
-class TestLocalOnlyOkMapping:
-    """VAMI-019 T-S2: local-only-ok terminal maps to complete+source=local."""
-
-    def test_local_only_ok_returns_complete_with_source_local(self) -> None:
-        result = resolve_status_response(
-            {
-                "metadata": {
-                    "mem0_status": "local-only-ok",
-                    "mem0_id_local": "qdrant-uuid-7",
-                },
-                "mem0_id": None,
-            },
-            "pg_v19",
-        )
-        assert result["status"] == "complete"
-        assert result["source"] == "local"
-        assert result["mem0_id"] == "qdrant-uuid-7"
-
-    def test_local_only_ok_falls_back_to_mem0_id_when_no_local_specific(self) -> None:
-        # Some writers may populate mem0_id but leave mem0_id_local unset —
-        # the `mem0_id_local or mem0_id` chain should still work.
-        result = resolve_status_response(
-            {
-                "metadata": {
-                    "mem0_status": "local-only-ok",
-                    "mem0_id": "fallback-id",
-                },
-                "mem0_id": None,
-            },
-            "pg_v19",
-        )
-        # mem0_id hit by the FIRST complete branch (mem0_id present wins)
-        # — so status is "complete" without source:"local". That's the
-        # correct behaviour: if mem0_id is populated, we consider cloud
-        # resolved regardless of mem0_status string.
-        assert result["status"] == "complete"
-        assert result["mem0_id"] == "fallback-id"
-
-    def test_local_only_ok_without_any_id_returns_complete_with_source(self) -> None:
-        result = resolve_status_response(
-            {"metadata": {"mem0_status": "local-only-ok"}, "mem0_id": None},
-            "pg_v19",
-        )
-        assert result["status"] == "complete"
-        assert result["source"] == "local"
-        # No id available at all — mem0_id is None; caller must handle
-        assert result["mem0_id"] is None
-
-    def test_local_only_ok_distinguishable_from_synced(self) -> None:
-        """A consumer looking at `source` can tell local from cloud-confirmed."""
-        synced = resolve_status_response(
-            {"metadata": {"mem0_status": "synced", "mem0_id": "cloud-1"}, "mem0_id": None},
-            "pg_a",
-        )
-        local_only = resolve_status_response(
-            {
-                "metadata": {
-                    "mem0_status": "local-only-ok",
-                    "mem0_id_local": "local-1",
-                },
-                "mem0_id": None,
-            },
-            "pg_b",
-        )
-        assert synced.get("source") is None  # cloud-confirmed doesn't add source
-        assert local_only["source"] == "local"

package/tools/vds-scripts/memory_orchestrator/tests/test_worker_status_emission.py

@@ -1,150 +0,0 @@
-"""Unit tests for VAMI-020 T-W1 status-emission pivot.
-
-Locks in the 3-branch decision contract for
-``memory_evolution.worker._push_memory_to_mem0``:
-
-  - cloud ``mem0_id`` resolved              -> ``status == "synced"``
-  - cloud unresolved + ``source == "local-primary"``
-                                            -> ``status == "local-only-ok"``
-  - neither                                  -> ``status == "stalled"``
-
-VAMI-020 pivots this from the prior ``elif local_id`` branch to
-``elif local_write_ok`` (where ``local_write_ok`` is the
-adapter-deterministic ``result.get("source") == "local-primary"`` flag).
-The pivot makes the ``local-only-ok`` bucket fire reliably even when
-mem0 OSS does not return a synchronous local id (the VAMI-019 backfill
-showed only 1.3% of cases populated ``local_id``).
-
-The decision tree is reproduced here as a pure helper so it can be
-exercised in isolation, without dragging in asyncpg / Celery / mem0
-adapter import chains. The helper mirrors worker.py:399-404 exactly;
-any future drift between the helper and the worker should be caught by
-T-V3's live integration test.
-"""
-
-from __future__ import annotations
-
-import sys
-import types
-from typing import Any
-
-
-def _stub_missing_deps() -> None:
-    """Inject stubs for modules absent from the unit-test venv.
-
-    Mirrors the pattern in ``test_mem0_event_resolver.py``. The worker
-    module pulls ``asyncpg`` (via ``postgres_manager``) and ``jose`` at
-    import time; the unit-test venv doesn't install them. We stub the
-    minimal attribute surface the imports actually read so that
-    ``import vds_memory_orchestrator.service.services.memory_evolution.worker``
-    succeeds without side effects.
-    """
-    if "jose" not in sys.modules:
-        jose = types.ModuleType("jose")
-        jose.JWTError = type("JWTError", (Exception,), {})  # type: ignore[attr-defined]
-        jose.jwt = types.SimpleNamespace(
-            decode=lambda *a, **k: {},
-            encode=lambda *a, **k: "",
-        )
-        sys.modules["jose"] = jose
-
-    if "asyncpg" not in sys.modules:
-        asyncpg = types.ModuleType("asyncpg")
-        asyncpg.exceptions = types.SimpleNamespace(
-            TooManyConnectionsError=type("TooManyConnectionsError", (Exception,), {}),
-            ConnectionFailureError=type("ConnectionFailureError", (Exception,), {}),
-        )
-        sys.modules["asyncpg"] = asyncpg
-        sys.modules["asyncpg.exceptions"] = asyncpg.exceptions
-
-
-def _decide_status(mem0_id: str | None, result: Any) -> str:
-    """Pure reproduction of worker.py:_push_memory_to_mem0 status logic.
-
-    Kept in lock-step with worker.py:380-404 (VAMI-020 T-W1 pivot). If
-    you change the worker decision tree, update this helper too — both
-    encode the same contract.
-    """
-    local_write_ok = isinstance(result, dict) and result.get("source") == "local-primary"
-    if mem0_id:
-        return "synced"
-    if local_write_ok:
-        return "local-only-ok"
-    return "stalled"
-
-
-# ---------------------------------------------------------------------------
-# Required cases (T-V2, FR-20.7)
-# ---------------------------------------------------------------------------
-
-
-def test_status_synced_when_cloud_mem0_id_resolved() -> None:
-    """Cloud-resolved path: mem0_id present wins over any local signal."""
-    result = {"source": "local-primary", "local_id": "local-uuid-1"}
-    assert _decide_status(mem0_id="m0_cloud_123", result=result) == "synced"
-
-
-def test_status_local_only_ok_when_source_flag_set_and_no_cloud() -> None:
-    """VAMI-020 T-W1 pivot: source-flag drives the bucket, not local_id.
-
-    Crucially, this case asserts ``local-only-ok`` even when ``local_id``
-    is None — that was the gap VAMI-020 closed (mem0 OSS under
-    ``infer=True`` returned a None id 98.7% of the time).
-    """
-    result = {"source": "local-primary", "local_id": None}
-    assert _decide_status(mem0_id=None, result=result) == "local-only-ok"
-
-
-def test_status_stalled_when_no_cloud_and_no_source_flag() -> None:
-    """No cloud id and no local-primary source flag = genuine failure."""
-    result: dict = {}  # adapter returned an empty dict — no source key
-    assert _decide_status(mem0_id=None, result=result) == "stalled"
-
-
-# ---------------------------------------------------------------------------
-# Defensive coverage — pre-pivot regressions and shape-edge cases
-# ---------------------------------------------------------------------------
-
-
-def test_status_stalled_when_local_id_present_but_source_flag_missing() -> None:
-    """Pre-pivot regression: ``local_id`` alone must NOT produce local-only-ok.
-
-    Before VAMI-020 the worker keyed on ``local_id``; after the pivot,
-    a stray ``local_id`` without the deterministic ``source`` flag falls
-    through to ``stalled``. This guards against accidentally re-introducing
-    the old branch.
-    """
-    result = {"local_id": "stale-uuid", "source": None}
-    assert _decide_status(mem0_id=None, result=result) == "stalled"
-
-
-def test_status_stalled_when_result_is_not_a_dict() -> None:
-    """Adapter occasionally returns a list/None — must not crash and must stall."""
-    assert _decide_status(mem0_id=None, result=None) == "stalled"
-    assert _decide_status(mem0_id=None, result=[]) == "stalled"
-    assert _decide_status(mem0_id=None, result="unexpected") == "stalled"
-
-
-def test_status_synced_even_when_result_shape_is_unexpected() -> None:
-    """A resolved cloud id always wins, regardless of result shape."""
-    assert _decide_status(mem0_id="m0_x", result=None) == "synced"
-    assert _decide_status(mem0_id="m0_x", result=[]) == "synced"
-
-
-# ---------------------------------------------------------------------------
-# Stub-helper smoke
-# ---------------------------------------------------------------------------
-
-
-def test_stub_helper_idempotent() -> None:
-    """``_stub_missing_deps`` is safe to call multiple times.
-
-    The unit-test venv does not install ``asyncpg`` or ``jose``; the
-    helper installs minimal stubs so future tests in this file can
-    import the worker without dragging in heavy deps. Calling it twice
-    must be a no-op (mirrors ``test_mem0_event_resolver.py`` pattern).
-    """
-    _stub_missing_deps()
-    _stub_missing_deps()
-    assert "jose" in sys.modules
-    assert "asyncpg" in sys.modules