@cachly-dev/mcp-server 0.10.47 → 0.10.49

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

@@ -0,0 +1,113 @@
+"""
+Tests for /api/v1/mail/import
+
+Covers:
+  strip_email_headers – removes From/To/Subject/X-* lines, preserves body
+  import_mail         – text body → inbox when no trip_id
+  import_mail         – text body → trip item when trip_id provided
+  import_mail         – stripped headers don't leak into parsed_data
+
+Run: pytest tests/test_mail.py -v
+"""
+import pytest
+from httpx import AsyncClient
+
+from app.routers.mail import strip_email_headers
+from tests.conftest import make_trip, mock_ollama_flight
+
+RAW_EMAIL = """\
+From: booking@lufthansa.com
+To: max@example.com
+Subject: Ihre Buchungsbestätigung LH 400
+Date: Mon, 12 Aug 2024 09:00:00 +0200
+Content-Type: text/plain; charset=utf-8
+
+Sehr geehrter Herr Mustermann,
+
+Ihre Buchung wurde bestätigt.
+Flug LH 400 Frankfurt (FRA) → New York (JFK)
+Abflug: 15. August 2024, 10:30 Uhr
+Buchungsreferenz: ABC123
+"""
+
+
+# ── strip_email_headers (pure, synchronous) ───────────────────────────────────
+
+def test_strip_removes_from_header():
+    result = strip_email_headers(RAW_EMAIL)
+    assert "From:" not in result
+    assert "To:" not in result
+
+
+def test_strip_removes_subject():
+    result = strip_email_headers(RAW_EMAIL)
+    assert "Subject:" not in result
+
+
+def test_strip_preserves_body():
+    result = strip_email_headers(RAW_EMAIL)
+    assert "LH 400" in result
+    assert "ABC123" in result
+    assert "Mustermann" in result
+
+
+def test_strip_x_headers():
+    raw = "X-Mailer: Outlook\nX-Spam-Status: No\n\nBody content here."
+    result = strip_email_headers(raw)
+    assert "X-Mailer" not in result
+    assert "Body content here" in result
+
+
+def test_strip_collapses_blank_lines():
+    raw = "From: a@b.com\n\n\n\n\nBody text."
+    result = strip_email_headers(raw)
+    assert "\n\n\n" not in result
+
+
+# ── import_mail endpoint ──────────────────────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_import_mail_goes_to_inbox_without_trip(client: AsyncClient, mock_ollama_flight):
+    r = await client.post(
+        "/api/v1/mail/import",
+        content=RAW_EMAIL,
+        headers={"Content-Type": "text/plain"},
+    )
+    assert r.status_code == 200
+    body = r.json()
+    assert body["parsed"]["type"] == "flight"
+    assert body["parsed"]["booking_ref"] == "ABC123"
+
+    inbox = await client.get("/api/v1/inbox")
+    assert inbox.status_code == 200
+    assert len(inbox.json()) == 1
+
+
+@pytest.mark.asyncio
+async def test_import_mail_assigned_to_trip(client: AsyncClient, mock_ollama_flight):
+    trip_r = await client.post("/api/v1/trips", json=make_trip())
+    trip_id = trip_r.json()["id"]
+
+    r = await client.post(
+        f"/api/v1/mail/import?trip_id={trip_id}",
+        content=RAW_EMAIL,
+        headers={"Content-Type": "text/plain"},
+    )
+    assert r.status_code == 200
+
+    items_r = await client.get(f"/api/v1/trips/{trip_id}/items")
+    assert len(items_r.json()) == 1
+
+    inbox = await client.get("/api/v1/inbox")
+    assert inbox.json() == []
+
+
+@pytest.mark.asyncio
+async def test_import_mail_low_confidence_still_saves(client: AsyncClient, mock_ollama_low_confidence):
+    r = await client.post(
+        "/api/v1/mail/import",
+        content="Some random text that isn't a booking",
+        headers={"Content-Type": "text/plain"},
+    )
+    assert r.status_code == 200
+    assert r.json()["parsed"]["confidence"] == 0.1

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

@@ -0,0 +1,145 @@
+"""
+Unit tests for the Ollama service layer.
+
+Covers:
+  parse_text    – valid JSON response, malformed JSON fallback, empty response
+  parse_image   – base64 encoding, correct payload shape
+  _safe_parse   – markdown fence stripping, JSON decode errors → fallback dict
+  confidence    – low-confidence items still return a dict (never raise)
+
+Run: pytest tests/test_ollama.py -v
+"""
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from app.services.ollama import _safe_parse, parse_image, parse_text
+
+# ── _safe_parse (pure, synchronous) ──────────────────────────────────────────
+
+def test_safe_parse_valid_json():
+    raw = '{"type": "flight", "title": "LH 400", "confidence": 0.9}'
+    result = _safe_parse(raw)
+    assert result["type"] == "flight"
+    assert result["confidence"] == 0.9
+
+
+def test_safe_parse_strips_markdown_fences():
+    raw = "```json\n{\"type\": \"hotel\", \"title\": \"Marriott\"}\n```"
+    result = _safe_parse(raw)
+    assert result["type"] == "hotel"
+
+
+def test_safe_parse_strips_plain_fences():
+    raw = "```\n{\"type\": \"train\"}\n```"
+    assert _safe_parse(raw)["type"] == "train"
+
+
+def test_safe_parse_malformed_returns_fallback():
+    result = _safe_parse("this is not json at all")
+    assert result["type"] == "other"
+    assert result["confidence"] == 0.0
+    assert "Unrecognized" in result["title"]
+
+
+def test_safe_parse_empty_string_returns_fallback():
+    result = _safe_parse("")
+    assert result["type"] == "other"
+
+
+def test_safe_parse_truncates_long_summary():
+    long_text = "x" * 1000
+    result = _safe_parse(long_text)
+    assert len(result.get("raw_summary", "")) <= 300
+
+
+# ── parse_text ────────────────────────────────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_parse_text_happy_path():
+    expected = {"type": "flight", "title": "LH 400 FRA→JFK", "confidence": 0.9}
+    mock_response = MagicMock()
+    mock_response.json.return_value = {"response": json.dumps(expected)}
+
+    with patch("httpx.AsyncClient") as mock_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.post = AsyncMock(return_value=mock_response)
+        mock_cls.return_value = mock_client
+
+        result, was_cached = await parse_text("Flight LH 400 from Frankfurt to New York")
+
+    assert result["type"] == "flight"
+    assert result["confidence"] == 0.9
+    assert was_cached is False
+
+
+@pytest.mark.asyncio
+async def test_parse_text_ollama_returns_garbage():
+    mock_response = MagicMock()
+    mock_response.json.return_value = {"response": "I cannot parse this."}
+
+    with patch("httpx.AsyncClient") as mock_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.post = AsyncMock(return_value=mock_response)
+        mock_cls.return_value = mock_client
+
+        result, was_cached = await parse_text("some text")
+
+    assert result["type"] == "other"
+    assert result["confidence"] == 0.0
+    assert was_cached is False
+
+
+@pytest.mark.asyncio
+async def test_parse_text_ollama_empty_response():
+    mock_response = MagicMock()
+    mock_response.json.return_value = {}
+
+    with patch("httpx.AsyncClient") as mock_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.post = AsyncMock(return_value=mock_response)
+        mock_cls.return_value = mock_client
+
+        result, was_cached = await parse_text("anything")
+
+    assert isinstance(result, dict)
+    assert was_cached is False
+
+
+# ── parse_image ───────────────────────────────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_parse_image_sends_base64():
+    payload_sent = {}
+    expected = {"type": "hotel", "title": "Marriott Berlin", "confidence": 0.85}
+
+    async def fake_post(url, json=None, **kwargs):
+        payload_sent.update(json or {})
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"response": json_str(expected)}
+        return mock_resp
+
+    def json_str(d): return __import__("json").dumps(d)
+
+    with patch("httpx.AsyncClient") as mock_cls:
+        mock_client = AsyncMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=False)
+        mock_client.post = AsyncMock(side_effect=fake_post)
+        mock_cls.return_value = mock_client
+
+        result, raw, was_cached = await parse_image(b"\xff\xd8\xff", "image/jpeg")
+
+    assert "images" in payload_sent
+    assert len(payload_sent["images"]) == 1
+    assert isinstance(payload_sent["images"][0], str)
+    assert result["type"] == "hotel"
+    assert was_cached is False

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

@@ -0,0 +1,98 @@
+"""
+Tests for POST /parse/url endpoint.
+httpx is mocked — no real network calls.
+"""
+import json
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+
+
+FAKE_HTML = """
+<html><head><title>Booking Confirmation</title></head>
+<body>
+<h1>Booking Confirmed</h1>
+<p>Flight LH 400 Frankfurt to New York</p>
+<p>Booking Reference: XYZ789</p>
+<p>Date: 2025-08-15</p>
+</body></html>
+"""
+
+
+@pytest.fixture
+def mock_ollama_parse():
+    with patch("app.services.ollama.parse_text", new_callable=AsyncMock) as m:
+        m.return_value = (
+            {
+                "type": "flight",
+                "title": "LH 400 Frankfurt → New York",
+                "booking_ref": "XYZ789",
+                "provider": "Lufthansa",
+                "event_at": "2025-08-15T10:30:00",
+                "confidence": 0.88,
+            },
+            False,
+        )
+        yield m
+
+
+@pytest.fixture
+def mock_http_response():
+    mock_resp = MagicMock()
+    mock_resp.headers = {"content-type": "text/html; charset=utf-8"}
+    mock_resp.text = FAKE_HTML
+    mock_resp.raise_for_status = MagicMock()
+    return mock_resp
+
+
+@pytest.mark.asyncio
+async def test_parse_url_to_inbox(client, mock_ollama_parse, mock_http_response):
+    with patch("httpx.AsyncClient") as mock_client_cls:
+        mock_client_instance = AsyncMock()
+        mock_client_instance.get = AsyncMock(return_value=mock_http_response)
+        mock_client_cls.return_value.__aenter__ = AsyncMock(return_value=mock_client_instance)
+        mock_client_cls.return_value.__aexit__ = AsyncMock(return_value=False)
+
+        resp = await client.post("/api/v1/parse/url", json={"url": "https://example.com/booking"})
+
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["parsed"]["type"] == "flight"
+    assert data["parsed"]["booking_ref"] == "XYZ789"
+
+
+@pytest.mark.asyncio
+async def test_parse_url_to_trip(client, mock_ollama_parse, mock_http_response):
+    # Create a trip first
+    trip_resp = await client.post("/api/v1/trips", json={"name": "Test Trip"})
+    assert trip_resp.status_code == 201
+    trip_id = trip_resp.json()["id"]
+
+    with patch("httpx.AsyncClient") as mock_client_cls:
+        mock_client_instance = AsyncMock()
+        mock_client_instance.get = AsyncMock(return_value=mock_http_response)
+        mock_client_cls.return_value.__aenter__ = AsyncMock(return_value=mock_client_instance)
+        mock_client_cls.return_value.__aexit__ = AsyncMock(return_value=False)
+
+        resp = await client.post(
+            "/api/v1/parse/url",
+            json={"url": "https://example.com/booking", "trip_id": trip_id},
+        )
+
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["parsed"]["type"] == "flight"
+
+
+@pytest.mark.asyncio
+async def test_parse_url_unreachable_returns_422(client):
+    import httpx
+    with patch("httpx.AsyncClient") as mock_client_cls:
+        mock_client_instance = AsyncMock()
+        mock_client_instance.get = AsyncMock(side_effect=httpx.ConnectError("refused"))
+        mock_client_cls.return_value.__aenter__ = AsyncMock(return_value=mock_client_instance)
+        mock_client_cls.return_value.__aexit__ = AsyncMock(return_value=False)
+
+        resp = await client.post("/api/v1/parse/url", json={"url": "https://unreachable.invalid"})
+
+    assert resp.status_code == 422
+    assert "Could not fetch URL" in resp.json()["detail"]

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

@@ -0,0 +1,72 @@
+"""
+Unit tests for app/services/parser.py
+
+Covers:
+  extract_text_from_pdf – real minimal PDF bytes, multi-page join
+  is_image / is_pdf / is_text – mime type routing guards
+
+Run: pytest tests/test_parser.py -v
+"""
+
+import pytest
+from app.services.parser import extract_text_from_pdf, is_image, is_pdf, is_text
+
+
+# ── MIME type guards ───────────────────────────────────────────────────────────
+
+def test_is_pdf():
+    assert is_pdf("application/pdf") is True
+    assert is_pdf("application/octet-stream") is False
+    assert is_pdf("image/png") is False
+
+
+def test_is_image():
+    assert is_image("image/jpeg") is True
+    assert is_image("image/png") is True
+    assert is_image("image/webp") is True
+    assert is_image("application/pdf") is False
+    assert is_image("text/plain") is False
+
+
+def test_is_text():
+    assert is_text("text/plain") is True
+    assert is_text("text/html") is True
+    assert is_text("text/csv") is True
+    assert is_text("application/pdf") is False
+    assert is_text("image/jpeg") is False
+
+
+# ── PDF extraction ─────────────────────────────────────────────────────────────
+
+def _minimal_pdf(text: str) -> bytes:
+    """Creates a minimal valid 1-page PDF containing `text`."""
+    import fitz
+    doc = fitz.open()
+    page = doc.new_page()
+    page.insert_text((72, 72), text)
+    return doc.tobytes()
+
+
+def test_extract_text_from_pdf_single_page():
+    content = _minimal_pdf("Booking confirmation LH400")
+    result = extract_text_from_pdf(content)
+    assert "LH400" in result
+    assert "Booking" in result
+
+
+def test_extract_text_from_pdf_strips_whitespace():
+    content = _minimal_pdf("   some text   ")
+    result = extract_text_from_pdf(content)
+    assert result == result.strip()
+
+
+def test_extract_text_from_pdf_multi_page():
+    import fitz
+    doc = fitz.open()
+    doc.new_page().insert_text((72, 72), "Page one content")
+    doc.new_page().insert_text((72, 72), "Page two content")
+    content = doc.tobytes()
+
+    result = extract_text_from_pdf(content)
+    assert "Page one" in result
+    assert "Page two" in result

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

@@ -0,0 +1,163 @@
+"""Tests for Stripe webhook handling (signature bypassed, event structure tested)."""
+import json
+from unittest.mock import patch, MagicMock
+import pytest
+from httpx import AsyncClient
+
+# All webhook tests use client fixture from conftest
+# Stripe signature verification is mocked
+
+CHECKOUT_EVENT = {
+    "type": "checkout.session.completed",
+    "data": {"object": {
+        "metadata": {"user_id": "user-test-123"},
+        "client_reference_id": "user-test-123",
+        "customer": "cus_test123",
+        "amount_total": 999,
+        "currency": "eur",
+    }},
+}
+
+SUBSCRIPTION_DELETED_EVENT = {
+    "type": "customer.subscription.deleted",
+    "data": {"object": {"customer": "cus_test123"}},
+}
+
+PAYMENT_SUCCEEDED_EVENT = {
+    "type": "invoice.payment_succeeded",
+    "data": {"object": {"subscription": "sub_123", "customer": "cus_test123"}},
+}
+
+PAYMENT_FAILED_EVENT_ATTEMPT1 = {
+    "type": "invoice.payment_failed",
+    "data": {"object": {"customer": "cus_test123", "attempt_count": 1}},
+}
+
+PAYMENT_FAILED_EVENT_ATTEMPT3 = {
+    "type": "invoice.payment_failed",
+    "data": {"object": {"customer": "cus_test123", "attempt_count": 3}},
+}
+
+
+def mock_stripe_webhook(event_dict):
+    """Patch stripe to bypass signature verification and return our event dict."""
+    mock_event = MagicMock()
+    mock_event.__getitem__ = lambda self, key: event_dict[key]
+    mock_event.get = lambda key, default=None: event_dict.get(key, default)
+    mock_event["type"] = event_dict["type"]
+    mock_event["data"] = event_dict["data"]
+    return mock_event
+
+
+@pytest.mark.asyncio
+async def test_webhook_no_stripe_configured_returns_ok(client: AsyncClient):
+    """When stripe not configured, webhook returns 200 immediately."""
+    with patch("app.routers.payments.get_settings") as mock_settings:
+        mock_settings.return_value.stripe_secret_key = ""
+        r = await client.post("/api/v1/payments/webhook",
+                              content=b"{}",
+                              headers={"stripe-signature": "test"})
+    assert r.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_webhook_missing_signature_returns_400(client: AsyncClient):
+    """Missing Stripe-Signature header returns 400."""
+    with patch("app.routers.payments.get_settings") as mock_settings:
+        mock_settings.return_value.stripe_secret_key = "sk_test_123"
+        mock_settings.return_value.stripe_webhook_secret = "whsec_test"
+        r = await client.post("/api/v1/payments/webhook", content=b"{}")
+    assert r.status_code == 400
+    assert "Stripe-Signature" in r.json()["detail"]
+
+
+@pytest.mark.asyncio
+async def test_checkout_completed_upgrades_user(client: AsyncClient):
+    """checkout.session.completed sets user to pro and stores customer_id."""
+    from unittest.mock import AsyncMock
+    import stripe as stripe_mod
+    mock_event = {
+        "type": "checkout.session.completed",
+        "data": {"object": {
+            "metadata": {"user_id": "user-test-123"},
+            "client_reference_id": "user-test-123",
+            "customer": "cus_test123",
+            "amount_total": 999,
+            "currency": "eur",
+        }},
+    }
+    with patch("app.config.get_settings") as ms, \
+         patch("stripe.Webhook.construct_event") as mock_construct, \
+         patch("app.services.telemetry.track", new_callable=AsyncMock), \
+         patch("app.services.notifier.notify", new_callable=AsyncMock):
+        ms.return_value.stripe_secret_key = "sk_test"
+        ms.return_value.stripe_webhook_secret = "whsec_test"
+        mock_construct.return_value = mock_event
+        r = await client.post("/api/v1/payments/webhook",
+                               content=b"{}",
+                               headers={"stripe-signature": "t=1,v1=abc"})
+    assert r.status_code == 200
+    assert r.json() == {"ok": True}
+
+
+@pytest.mark.asyncio
+async def test_subscription_deleted_downgrades_user(client: AsyncClient):
+    """customer.subscription.deleted downgrades user to free."""
+    from sqlalchemy import text
+    from unittest.mock import AsyncMock
+    mock_event = {
+        "type": "customer.subscription.deleted",
+        "data": {"object": {"customer": "cus_test999"}},
+    }
+    with patch("app.config.get_settings") as ms, \
+         patch("stripe.Webhook.construct_event") as mock_construct, \
+         patch("app.services.telemetry.track", new_callable=AsyncMock), \
+         patch("app.services.notifier.notify", new_callable=AsyncMock):
+        ms.return_value.stripe_secret_key = "sk_test"
+        ms.return_value.stripe_webhook_secret = "whsec_test"
+        mock_construct.return_value = mock_event
+        r = await client.post("/api/v1/payments/webhook",
+                               content=b"{}",
+                               headers={"stripe-signature": "t=1,v1=abc"})
+    assert r.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_invoice_payment_failed_attempt1_no_downgrade(client: AsyncClient):
+    """invoice.payment_failed attempt 1: grace period, no downgrade."""
+    from unittest.mock import AsyncMock
+    mock_event = {
+        "type": "invoice.payment_failed",
+        "data": {"object": {"customer": "cus_test123", "attempt_count": 1}},
+    }
+    with patch("app.config.get_settings") as ms, \
+         patch("stripe.Webhook.construct_event") as mock_construct, \
+         patch("app.services.telemetry.track", new_callable=AsyncMock), \
+         patch("app.services.notifier.notify", new_callable=AsyncMock):
+        ms.return_value.stripe_secret_key = "sk_test"
+        ms.return_value.stripe_webhook_secret = "whsec_test"
+        mock_construct.return_value = mock_event
+        r = await client.post("/api/v1/payments/webhook",
+                               content=b"{}",
+                               headers={"stripe-signature": "t=1,v1=abc"})
+    assert r.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_unknown_event_type_returns_ok(client: AsyncClient):
+    """Unknown event type is ignored and returns 200."""
+    from unittest.mock import AsyncMock
+    mock_event = {
+        "type": "customer.created",
+        "data": {"object": {}},
+    }
+    with patch("app.config.get_settings") as ms, \
+         patch("stripe.Webhook.construct_event") as mock_construct:
+        ms.return_value.stripe_secret_key = "sk_test"
+        ms.return_value.stripe_webhook_secret = "whsec_test"
+        mock_construct.return_value = mock_event
+        r = await client.post("/api/v1/payments/webhook",
+                               content=b"{}",
+                               headers={"stripe-signature": "t=1,v1=abc"})
+    assert r.status_code == 200
+    assert r.json() == {"ok": True}

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

@@ -0,0 +1,46 @@
+"""Tests for freemium quota enforcement."""
+import pytest
+from httpx import AsyncClient
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_free_trip_limit_enforced(client: AsyncClient):
+    """Free plan blocks trip creation after 3 trips."""
+    # Create 3 trips (should succeed)
+    for i in range(3):
+        r = await client.post(
+            "/api/v1/trips",
+            json={"name": f"Trip {i}", "description": None, "start_date": None, "end_date": None},
+        )
+        assert r.status_code == 201, f"Trip {i} creation failed: {r.text}"
+
+    # 4th trip should be blocked (402)
+    r = await client.post(
+        "/api/v1/trips",
+        json={"name": "Trip 4", "description": None, "start_date": None, "end_date": None},
+    )
+    assert r.status_code == 402
+    assert "Free plan" in r.json()["detail"]
+
+
+async def test_pro_plan_bypasses_trip_limit(client: AsyncClient, db_session):
+    """Pro users can create more than 3 trips."""
+    from sqlalchemy import text
+
+    # Upgrade user to pro
+    await db_session.execute(
+        text(
+            "INSERT INTO users (id, plan) VALUES (:uid, 'pro')"
+            " ON CONFLICT (id) DO UPDATE SET plan='pro'"
+        ),
+        {"uid": "user-test-123"},
+    )
+    await db_session.commit()
+
+    for i in range(5):
+        r = await client.post(
+            "/api/v1/trips",
+            json={"name": f"Pro Trip {i}", "description": None, "start_date": None, "end_date": None},
+        )
+        assert r.status_code == 201