@cachly-dev/mcp-server 0.10.64 → 0.10.66

package/apps/travel-chaos-organizer/backend/tests/conftest.py

@@ -1,223 +0,0 @@
-"""
-Shared fixtures for Travel Chaos Organizer backend tests.
-
-Patterns from cachly-mcp:
-- In-memory mocks instead of real services (no Docker required for unit tests)
-- Deterministic fake data via factory helpers
-- Auth always injectable / bypassable in unit scope
-"""
-
-import json
-import uuid
-from collections.abc import AsyncGenerator
-from datetime import date
-from typing import Any
-from unittest.mock import AsyncMock, patch
-
-import pytest
-import pytest_asyncio
-from fastapi import FastAPI
-from httpx import ASGITransport, AsyncClient
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-
-from app.db.database import Base, get_db
-from app.main import app
-from app.models.schemas import ParsedTravelData
-
-# ── In-memory SQLite DB (mirrors cachly MockRedis pattern) ────────────────────
-
-TEST_DB_URL = "sqlite+aiosqlite:///:memory:"
-
-
-@pytest_asyncio.fixture(scope="function")
-async def db_engine():
-    import sqlalchemy
-    engine = create_async_engine(TEST_DB_URL, echo=False)
-    async with engine.begin() as conn:
-        # Execute each DDL statement separately — SQLite doesn't support
-        # multi-statement execute() calls.
-        for stmt in SQLITE_SCHEMA.strip().split(";"):
-            stmt = stmt.strip()
-            if stmt:
-                await conn.execute(sqlalchemy.text(stmt))
-    yield engine
-    await engine.dispose()
-
-
-@pytest_asyncio.fixture
-async def db_session(db_engine) -> AsyncGenerator[AsyncSession, None]:
-    SessionLocal = async_sessionmaker(db_engine, expire_on_commit=False)
-    async with SessionLocal() as session:
-        yield session
-        await session.rollback()
-
-
-# ── Auth bypass (like cachly's checkJwt mock) ─────────────────────────────────
-
-FAKE_USER_ID = "user-test-123"
-FAKE_USER_PAYLOAD = {"sub": FAKE_USER_ID, "email": "test@example.com"}
-
-
-@pytest_asyncio.fixture
-async def client(db_session: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
-    """HTTP client with auth bypassed and real in-memory DB."""
-    from app.auth.keycloak import get_current_user
-    from app.db.database import get_db
-
-    from app.auth.keycloak import user_id_or_bot
-
-    async def override_auth():
-        return FAKE_USER_PAYLOAD
-
-    async def override_user_id_or_bot():
-        return FAKE_USER_ID
-
-    async def override_db():
-        yield db_session
-
-    app.dependency_overrides[get_current_user] = override_auth
-    app.dependency_overrides[user_id_or_bot] = override_user_id_or_bot
-    app.dependency_overrides[get_db] = override_db
-
-    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c:
-        yield c
-
-    app.dependency_overrides.clear()
-
-
-# ── Ollama mock (no real LLM needed) ──────────────────────────────────────────
-
-PARSED_FLIGHT = ParsedTravelData(
-    type="flight",
-    title="LH 400 Frankfurt → New York",
-    booking_ref="ABC123",
-    provider="Lufthansa",
-    event_at="2024-08-15T10:30:00",
-    origin="FRA",
-    destination="JFK",
-    passengers=["Max Mustermann"],
-    price="€ 850",
-    confidence=0.92,
-)
-
-
-@pytest.fixture
-def mock_ollama_flight():
-    with patch("app.services.ollama.parse_text", new_callable=AsyncMock) as m:
-        m.return_value = (PARSED_FLIGHT.model_dump(), False)
-        yield m
-
-
-@pytest.fixture
-def mock_ollama_low_confidence():
-    with patch("app.services.ollama.parse_text", new_callable=AsyncMock) as m:
-        m.return_value = (
-            {"type": "other", "title": "Unrecognized document", "confidence": 0.1},
-            False,
-        )
-        yield m
-
-
-# ── Factory helpers ────────────────────────────────────────────────────────────
-
-def make_trip(name: str = "Sommerurlaub 2024", **kwargs) -> dict[str, Any]:
-    return {"name": name, "description": "Test trip", "start_date": "2024-08-01",
-            "end_date": "2024-08-15", **kwargs}
-
-
-def make_item(**kwargs) -> dict[str, Any]:
-    return {"type": "flight", "title": "LH 400 FRA→JFK", "event_at": "2024-08-15T10:30:00",
-            "booking_ref": "ABC123", "provider": "Lufthansa", **kwargs}
-
-
-# ── SQLite-compatible schema (no PostgreSQL ENUMs / pgcrypto) ─────────────────
-
-def _uuid_default() -> str:
-    """SQLite UUID expression: generates xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format."""
-    return (
-        "lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-' || "
-        "lower(hex(randomblob(2))) || '-' || lower(hex(randomblob(2))) || '-' || "
-        "lower(hex(randomblob(6)))"
-    )
-
-_UD = _uuid_default()
-
-SQLITE_SCHEMA = f"""
-CREATE TABLE IF NOT EXISTS trips (
-    id          TEXT PRIMARY KEY DEFAULT ({_UD}),
-    user_id     TEXT NOT NULL,
-    name        TEXT NOT NULL,
-    description TEXT,
-    start_date  TEXT,
-    end_date    TEXT,
-    created_at  TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS trip_items (
-    id            TEXT PRIMARY KEY DEFAULT ({_UD}),
-    trip_id       TEXT NOT NULL,
-    user_id       TEXT NOT NULL,
-    type          TEXT NOT NULL DEFAULT 'other',
-    title         TEXT NOT NULL,
-    raw_text      TEXT,
-    parsed_data   TEXT,
-    event_at      TEXT,
-    event_end_at  TEXT,
-    booking_ref   TEXT,
-    provider      TEXT,
-    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS attachments (
-    id            TEXT PRIMARY KEY DEFAULT ({_UD}),
-    trip_item_id  TEXT,
-    inbox_id      TEXT,
-    user_id       TEXT NOT NULL,
-    file_path     TEXT NOT NULL,
-    file_name     TEXT NOT NULL,
-    mime_type     TEXT NOT NULL,
-    size_bytes    INTEGER,
-    created_at    TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS chaos_inbox (
-    id           TEXT PRIMARY KEY DEFAULT ({_UD}),
-    user_id      TEXT NOT NULL,
-    raw_content  TEXT,
-    source       TEXT,
-    status       TEXT NOT NULL DEFAULT 'pending',
-    parsed_data  TEXT,
-    created_at   TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS users (
-    id                 TEXT PRIMARY KEY,
-    email              TEXT,
-    plan               TEXT NOT NULL DEFAULT 'free',
-    plan_expires_at    TEXT,
-    stripe_customer_id TEXT,
-    telegram_chat_id   TEXT UNIQUE,
-    created_at         TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at         TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS events (
-    id          TEXT PRIMARY KEY DEFAULT ({_UD}),
-    user_id     TEXT,
-    event_name  TEXT NOT NULL,
-    properties  TEXT,
-    platform    TEXT,
-    app_version TEXT,
-    created_at  TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS waitlist (
-    id         TEXT PRIMARY KEY DEFAULT ({_UD}),
-    email      TEXT NOT NULL UNIQUE,
-    source     TEXT DEFAULT 'landing',
-    created_at TEXT NOT NULL DEFAULT (datetime('now'))
-);
-"""

package/apps/travel-chaos-organizer/backend/tests/test_admin.py

@@ -1,99 +0,0 @@
-"""Tests for admin endpoints."""
-import base64
-
-import pytest
-from httpx import AsyncClient
-
-pytestmark = pytest.mark.asyncio
-
-
-def admin_headers(user: str = "admin", password: str = "changeme") -> dict:
-    token = base64.b64encode(f"{user}:{password}".encode()).decode()
-    return {"Authorization": f"Basic {token}"}
-
-
-async def test_admin_health_requires_auth(client: AsyncClient):
-    r = await client.get("/admin/health")
-    assert r.status_code == 401
-
-
-async def test_admin_health_ok(client: AsyncClient):
-    r = await client.get("/admin/health", headers=admin_headers())
-    assert r.status_code == 200
-    data = r.json()
-    assert "events_total" in data
-    assert "waitlist_total" in data
-
-
-async def test_admin_dashboard_requires_auth(client: AsyncClient):
-    r = await client.get("/admin")
-    assert r.status_code == 401
-
-
-async def test_admin_dashboard_returns_html(client: AsyncClient):
-    r = await client.get("/admin", headers=admin_headers())
-    assert r.status_code == 200
-    assert "text/html" in r.headers["content-type"]
-    assert "TCO Admin" in r.text
-
-
-async def test_admin_wrong_password(client: AsyncClient):
-    r = await client.get("/admin/health", headers=admin_headers(password="wrongpassword"))
-    assert r.status_code == 401
-
-
-async def test_admin_events_summary(client: AsyncClient):
-    r = await client.get("/admin/events/summary", headers=admin_headers())
-    assert r.status_code == 200
-    assert "events" in r.json()
-
-
-async def test_admin_waitlist(client: AsyncClient):
-    r = await client.get("/admin/waitlist", headers=admin_headers())
-    assert r.status_code == 200
-    assert "signups" in r.json()
-
-
-async def test_admin_set_user_plan(client: AsyncClient, db_session):
-    from sqlalchemy import text
-
-    # First create the user by calling /me
-    await client.get("/api/v1/users/me")
-
-    r = await client.patch(
-        "/admin/users/user-test-123/plan?plan=pro", headers=admin_headers()
-    )
-    assert r.status_code == 200
-    assert r.json()["plan"] == "pro"
-
-    # Verify in DB
-    row = await db_session.execute(
-        text("SELECT plan FROM users WHERE id = 'user-test-123'")
-    )
-    assert row.fetchone()[0] == "pro"
-
-
-async def test_admin_set_invalid_plan(client: AsyncClient):
-    """Setting an invalid plan returns 400."""
-    # Create user first
-    await client.get("/api/v1/users/me")
-
-    r = await client.patch(
-        "/admin/users/user-test-123/plan?plan=enterprise", headers=admin_headers()
-    )
-    assert r.status_code == 400
-
-
-async def test_admin_users_list(client: AsyncClient):
-    r = await client.get("/admin/users", headers=admin_headers())
-    assert r.status_code == 200
-    assert "users" in r.json()
-
-
-async def test_admin_health_counts(client: AsyncClient):
-    """Health endpoint returns all expected count fields."""
-    r = await client.get("/admin/health", headers=admin_headers())
-    assert r.status_code == 200
-    data = r.json()
-    assert "users_total" in data
-    assert "pro_users" in data

package/apps/travel-chaos-organizer/backend/tests/test_cache.py

@@ -1,142 +0,0 @@
-"""
-Tests for Cachly Redis cache layer (services/cache.py).
-Uses unittest.mock — no real Redis required.
-"""
-import json
-import pytest
-from unittest.mock import AsyncMock, MagicMock, patch
-
-
-# ── No-Redis path ─────────────────────────────────────────────────────────────
-
-def test_cachly_configured_false_when_no_env(monkeypatch):
-    monkeypatch.delenv("CACHLY_REDIS_URL", raising=False)
-    from app.services import cache as c
-    assert c.cachly_configured() is False
-
-
-def test_cachly_configured_true_when_env_set(monkeypatch):
-    monkeypatch.setenv("CACHLY_REDIS_URL", "redis://:pw@host:6380/0")
-    from app.services import cache as c
-    assert c.cachly_configured() is True
-
-
-@pytest.mark.asyncio
-async def test_cache_get_returns_none_when_no_redis(monkeypatch):
-    monkeypatch.delenv("CACHLY_REDIS_URL", raising=False)
-    import importlib
-    from app.services import cache as c
-    # Reset module-level state
-    c._redis_client = None
-    c._redis_available = False
-
-    result = await c.cache_get("some content")
-    assert result is None
-
-
-@pytest.mark.asyncio
-async def test_cache_set_no_ops_when_no_redis(monkeypatch):
-    monkeypatch.delenv("CACHLY_REDIS_URL", raising=False)
-    from app.services import cache as c
-    c._redis_client = None
-    c._redis_available = False
-
-    # Should not raise
-    await c.cache_set("some content", {"type": "flight"})
-
-
-# ── With mocked Redis ─────────────────────────────────────────────────────────
-
-@pytest.mark.asyncio
-async def test_cache_get_returns_dict_on_hit():
-    from app.services import cache as c
-
-    mock_redis = AsyncMock()
-    mock_redis.get = AsyncMock(return_value=json.dumps({"type": "flight", "title": "LH 400"}))
-
-    c._redis_client = mock_redis
-    c._redis_available = True
-
-    result = await c.cache_get("flight booking text")
-    assert result == {"type": "flight", "title": "LH 400"}
-
-
-@pytest.mark.asyncio
-async def test_cache_get_returns_none_on_miss():
-    from app.services import cache as c
-
-    mock_redis = AsyncMock()
-    mock_redis.get = AsyncMock(return_value=None)
-
-    c._redis_client = mock_redis
-    c._redis_available = True
-
-    result = await c.cache_get("unknown content")
-    assert result is None
-
-
-@pytest.mark.asyncio
-async def test_cache_set_stores_json():
-    from app.services import cache as c
-
-    mock_redis = AsyncMock()
-    mock_redis.set = AsyncMock()
-
-    c._redis_client = mock_redis
-    c._redis_available = True
-
-    parsed = {"type": "hotel", "title": "Hilton Berlin"}
-    await c.cache_set("hotel email text", parsed)
-
-    mock_redis.set.assert_called_once()
-    call_args = mock_redis.set.call_args
-    assert call_args[1]["ex"] == c.CACHE_TTL
-    stored = json.loads(call_args[0][1])
-    assert stored["type"] == "hotel"
-
-
-@pytest.mark.asyncio
-async def test_cache_get_survives_redis_error():
-    from app.services import cache as c
-
-    mock_redis = AsyncMock()
-    mock_redis.get = AsyncMock(side_effect=Exception("connection refused"))
-
-    c._redis_client = mock_redis
-    c._redis_available = True
-
-    result = await c.cache_get("any content")
-    assert result is None  # never raises
-
-
-@pytest.mark.asyncio
-async def test_cache_set_survives_redis_error():
-    from app.services import cache as c
-
-    mock_redis = AsyncMock()
-    mock_redis.set = AsyncMock(side_effect=Exception("timeout"))
-
-    c._redis_client = mock_redis
-    c._redis_available = True
-
-    await c.cache_set("any content", {"type": "other"})  # never raises
-
-
-def test_cache_key_is_deterministic():
-    from app.services import cache as c
-
-    k1 = c._cache_key("same text")
-    k2 = c._cache_key("same text")
-    k3 = c._cache_key("different text")
-
-    assert k1 == k2
-    assert k1 != k3
-    assert k1.startswith("tco:parse:")
-
-
-def test_cache_key_works_for_bytes():
-    from app.services import cache as c
-
-    kb = c._cache_key(b"\x89PNG binary")
-    assert kb.startswith("tco:parse:")
-    assert len(kb) == len("tco:parse:") + 16

package/apps/travel-chaos-organizer/backend/tests/test_drip.py

@@ -1,32 +0,0 @@
-"""Tests for email drip sequence logic."""
-import pytest
-from unittest.mock import patch, AsyncMock
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-from datetime import datetime, timedelta, timezone
-
-
-@pytest.mark.asyncio
-async def test_drip_dry_run_returns_plan(client, db_session):
-    """Dry run returns what would be sent without sending."""
-    r = await client.post("/admin/drip/run?dry_run=true",
-                          headers={"Authorization": "Basic YWRtaW46Y2hhbmdlbWU="})  # admin:changeme
-    # Either 200 (admin auth works in test) or 401 (expected in test env)
-    assert r.status_code in (200, 401)
-
-
-@pytest.mark.asyncio
-async def test_drip_run_admin_required(client):
-    """Drip run without auth returns 401."""
-    r = await client.post("/admin/drip/run")
-    assert r.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_drip_no_users_no_emails(db_session: AsyncSession):
-    """run_drip with no users sends nothing."""
-    from app.services.drip import run_drip
-    with patch("app.services.email._send", new_callable=AsyncMock) as mock_send:
-        result = await run_drip(db_session, dry_run=True)
-        mock_send.assert_not_called()
-    assert isinstance(result, dict)

package/apps/travel-chaos-organizer/backend/tests/test_e2e_chain.py

@@ -1,121 +0,0 @@
-"""
-E2E chain test: parse text → inbox → assign to trip.
-Covers the full happy path a user would take.
-"""
-import json
-import uuid
-import pytest
-from unittest.mock import patch, AsyncMock
-from httpx import AsyncClient
-from sqlalchemy import text
-from tests.conftest import FAKE_USER_ID
-
-# A fixed UUID for the "other user's trip" in cross-user tests
-OTHER_TRIP_ID = "c3d4e5f6-a7b8-9012-cdef-123456789012"
-
-
-@pytest.mark.asyncio
-async def test_full_parse_to_assign_chain(client: AsyncClient, db_session, mock_ollama_flight):
-    """Parse text → lands in inbox → assign to trip → trip has item."""
-    # 1. Create a trip
-    r = await client.post("/api/v1/trips", json={
-        "name": "E2E Test Trip", "description": "Chain test",
-        "start_date": "2025-08-01", "end_date": "2025-08-10"
-    })
-    assert r.status_code == 201
-    trip_id = r.json()["id"]
-
-    # 2. Parse text → inbox (no trip_id)
-    with patch("app.services.telemetry.track", new_callable=AsyncMock):
-        r = await client.post("/api/v1/parse/text", data={"raw_text": "Lufthansa Buchungsbestaetigung LH400 FRA-JFK"})
-    assert r.status_code == 200
-    assert r.json()["parsed"]["type"] == "flight"
-
-    # 3. Fetch inbox
-    r = await client.get("/api/v1/inbox?status_filter=pending")
-    assert r.status_code == 200
-    inbox = r.json()
-    assert len(inbox) >= 1
-    inbox_id = inbox[0]["id"]
-
-    # 4. Assign inbox item to trip
-    r = await client.post(f"/api/v1/inbox/{inbox_id}/assign",
-                          json={"trip_id": trip_id, "type": "flight"})
-    assert r.status_code == 200
-    trip_item_id = r.json()["trip_item_id"]
-    assert trip_item_id
-
-    # 5. Verify item appears in trip timeline
-    r = await client.get(f"/api/v1/trips/{trip_id}/items")
-    assert r.status_code == 200
-    items = r.json()
-    assert any(i["id"] == trip_item_id for i in items)
-
-    # 6. Inbox item is now "assigned"
-    r = await client.get("/api/v1/inbox?status_filter=assigned")
-    assert r.status_code == 200
-    assigned = [i for i in r.json() if i["id"] == inbox_id]
-    assert len(assigned) == 1
-
-
-@pytest.mark.asyncio
-async def test_cross_user_inbox_assign_blocked(client: AsyncClient, db_session, mock_ollama_flight):
-    """Cannot assign inbox item to another user's trip."""
-    # Create a trip owned by a DIFFERENT user with a valid UUID
-    await db_session.execute(
-        text("INSERT INTO trips (id, user_id, name) VALUES (:id, :uid, :name)"),
-        {"id": OTHER_TRIP_ID, "uid": "other-user", "name": "Other Trip"}
-    )
-    await db_session.commit()
-
-    # Parse something into inbox
-    with patch("app.services.telemetry.track", new_callable=AsyncMock):
-        r = await client.post("/api/v1/parse/text", data={"raw_text": "Booking confirmation XYZ123"})
-    assert r.status_code == 200
-
-    r = await client.get("/api/v1/inbox?status_filter=pending")
-    inbox_id = r.json()[0]["id"]
-
-    # Try to assign to other user's trip — must be 403
-    r = await client.post(f"/api/v1/inbox/{inbox_id}/assign",
-                          json={"trip_id": OTHER_TRIP_ID, "type": "other"})
-    assert r.status_code == 403
-
-
-@pytest.mark.asyncio
-async def test_trip_search_returns_correct_results(client: AsyncClient, db_session):
-    """Search finds trips by name and description."""
-    # Create two trips
-    await client.post("/api/v1/trips", json={"name": "Barcelona Sommer", "description": "Strand"})
-    await client.post("/api/v1/trips", json={"name": "Winter Wien", "description": "Kultur"})
-
-    r = await client.get("/api/v1/trips/search?q=Barcelona")
-    assert r.status_code == 200
-    results = r.json()
-    assert any("Barcelona" in t["name"] for t in results)
-    assert all("Wien" not in t["name"] for t in results)
-
-
-@pytest.mark.asyncio
-async def test_delete_trip_cascades_cleanup(client: AsyncClient, db_session):
-    """Deleting a trip removes it from the list."""
-    r = await client.post("/api/v1/trips", json={"name": "Delete Me Trip"})
-    trip_id = r.json()["id"]
-
-    r = await client.delete(f"/api/v1/trips/{trip_id}")
-    assert r.status_code == 204
-
-    r = await client.get("/api/v1/trips")
-    assert all(t["id"] != trip_id for t in r.json())
-
-
-@pytest.mark.asyncio
-async def test_waitlist_signup_deduplication(client: AsyncClient):
-    """Same email can't sign up twice."""
-    email = "e2e-dedup@test.com"
-    r1 = await client.post("/api/v1/waitlist", json={"email": email})
-    assert r1.status_code in (200, 201)
-
-    r2 = await client.post("/api/v1/waitlist", json={"email": email})
-    # Should succeed (409 or 200 with "already registered") — not 500
-    assert r2.status_code < 500

package/apps/travel-chaos-organizer/backend/tests/test_export.py

@@ -1,48 +0,0 @@
-"""Tests for PDF export endpoint."""
-import uuid
-import pytest
-from unittest.mock import patch, AsyncMock
-from httpx import AsyncClient
-from sqlalchemy import text
-from tests.conftest import FAKE_USER_ID
-
-EXPORT_TRIP_ID = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
-
-
-@pytest.mark.asyncio
-async def test_pdf_export_trip_not_found(client: AsyncClient):
-    """Returns 404 for non-existent trip."""
-    r = await client.get(f"/api/v1/trips/{uuid.uuid4()}/export/pdf")
-    assert r.status_code == 404
-
-
-@pytest.mark.asyncio
-async def test_pdf_export_returns_pdf(client: AsyncClient, db_session):
-    """Creates a trip and exports it as PDF — verifies content-type."""
-    # Create a trip directly in DB using a valid UUID
-    await db_session.execute(
-        text("INSERT INTO trips (id, user_id, name, start_date, end_date) VALUES (:id, :uid, :name, :sd, :ed)"),
-        {"id": EXPORT_TRIP_ID, "uid": FAKE_USER_ID, "name": "Export Test Trip",
-         "sd": "2025-06-01", "ed": "2025-06-07"}
-    )
-    await db_session.commit()
-    fake_pdf = b"%PDF-1.4 fake content for test"
-    with patch("app.routers.export._build_pdf", return_value=fake_pdf), \
-         patch("app.services.telemetry.track", new_callable=AsyncMock):
-        r = await client.get(f"/api/v1/trips/{EXPORT_TRIP_ID}/export/pdf")
-    assert r.status_code == 200
-    assert r.headers["content-type"] == "application/pdf"
-    assert len(r.content) > 0
-
-
-@pytest.mark.asyncio
-async def test_pdf_export_other_users_trip_returns_404(client: AsyncClient, db_session):
-    """Cannot export another user's trip."""
-    other_trip_id = "b2c3d4e5-f6a7-8901-bcde-f12345678901"
-    await db_session.execute(
-        text("INSERT INTO trips (id, user_id, name) VALUES (:id, :uid, :name)"),
-        {"id": other_trip_id, "uid": "other-user-999", "name": "Secret Trip"}
-    )
-    await db_session.commit()
-    r = await client.get(f"/api/v1/trips/{other_trip_id}/export/pdf")
-    assert r.status_code == 404