feat: initialize resume agent with OfferPai sync

backend/tests/test_session_identity_lookup.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+import os
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import create_engine, text, update
+
+from app.database import Database
+from app.postgres_database import PostgresDatabase
+
+
+_INITIAL_TURN = {
+    "role": "assistant",
+    "content": None,
+    "composer_mode": "ui_only",
+    "blocks": [],
+}
+_TARGET_USER_ID = "2081575100391407617"
+
+
+def _profile(
+    user_id: str | None = _TARGET_USER_ID, *, provider: str = "offerpai"
+) -> dict[str, Any]:
+    if user_id is None:
+        return {}
+    return {
+        "external_account": {
+            "provider": provider,
+            "user_id": user_id,
+        }
+    }
+
+
+def _session_cases() -> list[tuple[str, dict[str, Any], datetime, datetime]]:
+    first = datetime(2026, 1, 1, tzinfo=UTC)
+    second = datetime(2026, 1, 2, tzinfo=UTC)
+    latest = datetime(2026, 1, 3, tzinfo=UTC)
+    excluded_latest = datetime(2026, 1, 4, tzinfo=UTC)
+    return [
+        ("session-old", _profile(), first, first),
+        # updated_at wins first; created_at then beats this lexically larger id.
+        ("session-z-created-old", _profile(), first, latest),
+        ("session-a", _profile(), second, latest),
+        # Same timestamps as session-a: id is the final deterministic tie-breaker.
+        ("session-c", _profile(), second, latest),
+        (
+            "session-other-provider",
+            _profile(provider="another-provider"),
+            excluded_latest,
+            excluded_latest,
+        ),
+        (
+            "session-other-user",
+            _profile("another-user"),
+            excluded_latest,
+            excluded_latest,
+        ),
+        ("session-anonymous", _profile(None), excluded_latest, excluded_latest),
+    ]
+
+
+def _create_sessions(database: Any) -> None:
+    for session_id, profile, _created_at, _updated_at in _session_cases():
+        database.create_session(
+            session_id,
+            "PRIVACY_CONSENT",
+            profile,
+            _INITIAL_TURN,
+        )
+
+
+def test_sqlite_finds_latest_offerpai_session_with_deterministic_order(
+    tmp_path: Path,
+) -> None:
+    database = Database(tmp_path / "identity-lookup.db")
+    database.initialize()
+    _create_sessions(database)
+    with database.transaction(immediate=True) as connection:
+        for session_id, _profile_value, created_at, updated_at in _session_cases():
+            connection.execute(
+                "UPDATE sessions SET created_at = ?, updated_at = ? WHERE id = ?",
+                (created_at.isoformat(), updated_at.isoformat(), session_id),
+            )
+
+    found = database.find_latest_session_by_external_user_id(
+        f"  {_TARGET_USER_ID}\t"
+    )
+
+    assert found is not None
+    assert found["id"] == "session-c"
+    assert database.find_latest_session_by_external_user_id("missing-user") is None
+
+
+def test_sqlite_ignores_blank_external_user_id(tmp_path: Path) -> None:
+    database = Database(tmp_path / "identity-lookup-blank.db")
+    database.initialize()
+
+    for external_user_id in ("", " ", "\t\r\n"):
+        assert database.find_latest_session_by_external_user_id(external_user_id) is None
+
+
+@pytest.fixture
+def postgres_database() -> Any:
+    database_url = os.environ["RESUME_AGENT_TEST_DATABASE_URL"]
+    schema = f"test_session_identity_{uuid4().hex}"
+    database = PostgresDatabase(database_url, schema=schema)
+    database.initialize()
+    try:
+        yield database
+    finally:
+        database.engine.dispose()
+        cleanup_engine = create_engine(database_url)
+        try:
+            with cleanup_engine.begin() as connection:
+                connection.execute(text(f'DROP SCHEMA IF EXISTS "{schema}" CASCADE'))
+        finally:
+            cleanup_engine.dispose()
+
+
+def test_postgres_finds_latest_offerpai_session_with_deterministic_order(
+    postgres_database: PostgresDatabase,
+) -> None:
+    _create_sessions(postgres_database)
+    sessions = postgres_database.tables["sessions"]
+    with postgres_database.transaction() as connection:
+        for session_id, _profile_value, created_at, updated_at in _session_cases():
+            connection.execute(
+                update(sessions)
+                .where(sessions.c.id == session_id)
+                .values(created_at=created_at, updated_at=updated_at)
+            )
+
+    found = postgres_database.find_latest_session_by_external_user_id(
+        f"  {_TARGET_USER_ID}\t"
+    )
+
+    assert found is not None
+    assert found["id"] == "session-c"
+    assert (
+        postgres_database.find_latest_session_by_external_user_id("missing-user")
+        is None
+    )
+
+
+def test_postgres_ignores_blank_external_user_id(
+    postgres_database: PostgresDatabase,
+) -> None:
+    for external_user_id in ("", " ", "\t\r\n"):
+        assert (
+            postgres_database.find_latest_session_by_external_user_id(
+                external_user_id
+            )
+            is None
+        )