@cachly-dev/mcp-server 0.10.55 → 0.10.57

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

@@ -0,0 +1,142 @@
+"""
+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

@@ -0,0 +1,32 @@
+"""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

@@ -0,0 +1,121 @@
+"""
+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

@@ -0,0 +1,48 @@
+"""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

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

@@ -0,0 +1,107 @@
+"""
+Tests for /api/v1/inbox
+
+Covers:
+  list_inbox   – empty, pending filter, other status filters
+  assign       – moves item to trip, updates status to 'assigned', migrates attachments
+  reject       – sets status to 'rejected', idempotent on 404
+
+Run: pytest tests/test_inbox.py -v
+"""
+
+import pytest
+from httpx import AsyncClient
+from tests.conftest import make_trip
+
+pytestmark = pytest.mark.asyncio
+
+
+async def _create_trip(client: AsyncClient) -> str:
+    r = await client.post("/api/v1/trips", json=make_trip())
+    assert r.status_code == 201
+    return r.json()["id"]
+
+
+async def _seed_inbox(client: AsyncClient) -> str:
+    """Parse some text so it lands in inbox (no trip_id → inbox)."""
+    r = await client.post(
+        "/api/v1/parse/text",
+        data={"raw_text": "Flight LH 400 Frankfurt to New York on Aug 15"},
+    )
+    assert r.status_code == 200
+    # fetch inbox to get the id
+    inbox = await client.get("/api/v1/inbox")
+    assert inbox.status_code == 200
+    items = inbox.json()
+    assert len(items) > 0
+    return items[0]["id"]
+
+
+# ── list ──────────────────────────────────────────────────────────────────────
+
+async def test_inbox_empty(client):
+    r = await client.get("/api/v1/inbox")
+    assert r.status_code == 200
+    assert r.json() == []
+
+
+async def test_inbox_default_status_is_pending(client, mock_ollama_flight):
+    await _seed_inbox(client)
+    r = await client.get("/api/v1/inbox")
+    assert r.status_code == 200
+    items = r.json()
+    assert all(i["status"] == "pending" for i in items)
+
+
+async def test_inbox_filter_by_status(client, mock_ollama_flight):
+    inbox_id = await _seed_inbox(client)
+    await client.delete(f"/api/v1/inbox/{inbox_id}")
+
+    r = await client.get("/api/v1/inbox?status_filter=rejected")
+    assert r.status_code == 200
+    assert any(i["id"] == inbox_id for i in r.json())
+
+
+# ── assign ────────────────────────────────────────────────────────────────────
+
+async def test_assign_creates_trip_item(client, mock_ollama_flight):
+    trip_id = await _create_trip(client)
+    inbox_id = await _seed_inbox(client)
+
+    r = await client.post(
+        f"/api/v1/inbox/{inbox_id}/assign",
+        json={"trip_id": trip_id, "type": "flight"},
+    )
+    assert r.status_code == 200
+    assert "trip_item_id" in r.json()
+
+
+async def test_assign_marks_inbox_as_assigned(client, mock_ollama_flight):
+    trip_id = await _create_trip(client)
+    inbox_id = await _seed_inbox(client)
+    await client.post(f"/api/v1/inbox/{inbox_id}/assign",
+                      json={"trip_id": trip_id, "type": "flight"})
+
+    r = await client.get("/api/v1/inbox?status_filter=assigned")
+    assert any(i["id"] == inbox_id for i in r.json())
+
+
+async def test_assign_not_found(client):
+    r = await client.post(
+        "/api/v1/inbox/00000000-0000-0000-0000-000000000000/assign",
+        json={"trip_id": "00000000-0000-0000-0000-000000000001", "type": "other"},
+    )
+    assert r.status_code == 404
+
+
+# ── reject ────────────────────────────────────────────────────────────────────
+
+async def test_reject_inbox_item(client, mock_ollama_flight):
+    inbox_id = await _seed_inbox(client)
+    r = await client.delete(f"/api/v1/inbox/{inbox_id}")
+    assert r.status_code == 204
+
+
+async def test_reject_not_found(client):
+    r = await client.delete("/api/v1/inbox/00000000-0000-0000-0000-000000000000")
+    assert r.status_code == 404

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

@@ -0,0 +1,138 @@
+"""
+Tests for /api/v1/trips/{trip_id}/items
+
+Covers:
+  list_items   – empty, sorted by event_at, trip isolation
+  create_item  – happy path, optional fields, missing title → 422
+  update_item  – partial patch, type change, 404 for wrong trip
+  delete_item  – removes item, 404 guard
+  timeline order – items sorted chronologically regardless of insert order
+
+Run: pytest tests/test_items.py -v
+"""
+import pytest
+from httpx import AsyncClient
+from tests.conftest import make_trip, make_item
+
+pytestmark = pytest.mark.asyncio
+
+
+async def _create_trip(client: AsyncClient) -> str:
+    r = await client.post("/api/v1/trips", json=make_trip())
+    assert r.status_code == 201
+    return r.json()["id"]
+
+
+async def _create_item(client: AsyncClient, trip_id: str, **kwargs) -> dict:
+    r = await client.post(f"/api/v1/trips/{trip_id}/items", json=make_item(**kwargs))
+    assert r.status_code == 201, r.text
+    return r.json()
+
+
+# ── list ──────────────────────────────────────────────────────────────────────
+
+async def test_list_items_empty(client):
+    trip_id = await _create_trip(client)
+    r = await client.get(f"/api/v1/trips/{trip_id}/items")
+    assert r.status_code == 200
+    assert r.json() == []
+
+
+async def test_list_items_wrong_trip_404(client):
+    r = await client.get("/api/v1/trips/00000000-0000-0000-0000-000000000000/items")
+    assert r.status_code == 404
+
+
+async def test_timeline_sorted_by_event_at(client):
+    trip_id = await _create_trip(client)
+    await _create_item(client, trip_id, title="Late flight", event_at="2024-08-20T18:00:00")
+    await _create_item(client, trip_id, title="Early flight", event_at="2024-08-15T06:00:00")
+    await _create_item(client, trip_id, title="Mid hotel",   event_at="2024-08-17T14:00:00")
+
+    r = await client.get(f"/api/v1/trips/{trip_id}/items")
+    titles = [i["title"] for i in r.json()]
+    assert titles == ["Early flight", "Mid hotel", "Late flight"]
+
+
+# ── create ────────────────────────────────────────────────────────────────────
+
+async def test_create_item_happy_path(client):
+    trip_id = await _create_trip(client)
+    r = await client.post(f"/api/v1/trips/{trip_id}/items", json=make_item(title="LH 400 FRA→JFK"))
+    assert r.status_code == 201
+    body = r.json()
+    assert body["title"] == "LH 400 FRA→JFK"
+    assert body["type"] == "flight"
+    assert body["trip_id"] == trip_id
+
+
+async def test_create_item_missing_title_rejected(client):
+    trip_id = await _create_trip(client)
+    r = await client.post(f"/api/v1/trips/{trip_id}/items", json={"type": "flight"})
+    assert r.status_code == 422
+
+
+async def test_create_item_optional_fields_nullable(client):
+    trip_id = await _create_trip(client)
+    r = await client.post(f"/api/v1/trips/{trip_id}/items",
+                          json={"title": "Minimal item", "type": "other"})
+    assert r.status_code == 201
+    body = r.json()
+    assert body["event_at"] is None
+    assert body["booking_ref"] is None
+
+
+async def test_create_item_with_parsed_data(client):
+    trip_id = await _create_trip(client)
+    parsed = {"origin": "FRA", "destination": "JFK", "confidence": 0.95}
+    r = await client.post(f"/api/v1/trips/{trip_id}/items",
+                          json={**make_item(), "parsed_data": parsed})
+    assert r.status_code == 201
+    assert r.json()["parsed_data"]["origin"] == "FRA"
+
+
+# ── update ────────────────────────────────────────────────────────────────────
+
+async def test_update_item_type(client):
+    trip_id = await _create_trip(client)
+    item = await _create_item(client, trip_id)
+    r = await client.patch(f"/api/v1/trips/{trip_id}/items/{item['id']}",
+                           json={"type": "hotel"})
+    assert r.status_code == 200
+    assert r.json()["type"] == "hotel"
+
+
+async def test_update_item_not_found(client):
+    trip_id = await _create_trip(client)
+    r = await client.patch(
+        f"/api/v1/trips/{trip_id}/items/00000000-0000-0000-0000-000000000000",
+        json={"title": "Ghost"},
+    )
+    assert r.status_code == 404
+
+
+async def test_update_item_empty_body_rejected(client):
+    trip_id = await _create_trip(client)
+    item = await _create_item(client, trip_id)
+    r = await client.patch(f"/api/v1/trips/{trip_id}/items/{item['id']}", json={})
+    assert r.status_code == 400
+
+
+# ── delete ────────────────────────────────────────────────────────────────────
+
+async def test_delete_item(client):
+    trip_id = await _create_trip(client)
+    item = await _create_item(client, trip_id)
+    r = await client.delete(f"/api/v1/trips/{trip_id}/items/{item['id']}")
+    assert r.status_code == 204
+
+    items = await client.get(f"/api/v1/trips/{trip_id}/items")
+    assert items.json() == []
+
+
+async def test_delete_item_not_found(client):
+    trip_id = await _create_trip(client)
+    r = await client.delete(
+        f"/api/v1/trips/{trip_id}/items/00000000-0000-0000-0000-000000000000"
+    )
+    assert r.status_code == 404