business-stack 0.1.0

package/backend/tests/test_post_ingest_hooks.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from alembic.config import Config
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from alembic import command
+from app.config import Settings, clear_settings_cache, get_settings
+from app.services.hooks.post_ingest import (
+    _apply_template,
+    _truncate,
+    dispatch_post_ingest_hooks,
+)
+
+
+def test_apply_template_missing_key_preserved() -> None:
+    s = _apply_template("Hi {name} {missing}", {"name": "x"})
+    assert "x" in s
+    assert "{missing}" in s
+
+
+def test_truncate() -> None:
+    assert _truncate("abc", 2) == "a…"
+
+
+async def _seed_ok_doc(session: AsyncSession) -> str:
+    await session.execute(
+        text("INSERT INTO sources (name, connector_type) VALUES ('src1', 't')"),
+    )
+    sid = int(
+        (await session.execute(text("SELECT id FROM sources LIMIT 1"))).scalar_one(),
+    )
+    doc_id = "hook-doc-1"
+    await session.execute(
+        text(
+            "INSERT INTO documents "
+            "(id, source_id, timestamp, content_type, raw_content, summary, status, "
+            "canonical_url, external_id, dedupe_content_hash, normalization_error) "
+            "VALUES (:id, :sid, :ts, 'text', '{}', :sum, 'ok', :cu, NULL, NULL, NULL)",
+        ),
+        {
+            "id": doc_id,
+            "sid": sid,
+            "ts": datetime.now(UTC).isoformat(),
+            "sum": "hello " * 50,
+            "cu": "https://example.com/page",
+        },
+    )
+    await session.execute(
+        text(
+            "INSERT INTO document_links (document_id, url, ordinal) "
+            "VALUES (:d, 'https://fallback.test/', 0)",
+        ),
+        {"d": doc_id},
+    )
+    await session.commit()
+    return doc_id
+
+
+def test_dispatch_slack_and_discord_no_secret_logs(
+    tmp_path,
+    monkeypatch,
+    caplog,
+) -> None:
+    monkeypatch.setenv("DATA_DIR", str(tmp_path))
+    monkeypatch.setenv(
+        "POST_INGEST_SLACK_WEBHOOK_URL",
+        "https://hooks.slack.com/services/SECRET/SHOULD/NOTLOG",
+    )
+    monkeypatch.setenv(
+        "POST_INGEST_DISCORD_WEBHOOK_URL",
+        "https://discord.com/api/webhooks/SECRET/NOTLOG",
+    )
+    clear_settings_cache()
+
+    backend = Path(__file__).resolve().parents[1]
+    prev = os.getcwd()
+    os.chdir(str(backend))
+    try:
+        command.upgrade(Config(str(backend / "alembic.ini")), "head")
+    finally:
+        os.chdir(prev)
+    clear_settings_cache()
+
+    settings = Settings()
+    engine = create_async_engine(settings.sqlalchemy_database_url)
+    factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+    async def _setup() -> str:
+        async with factory() as session:
+            return await _seed_ok_doc(session)
+
+    doc_id = asyncio.run(_setup())
+
+    caplog.set_level(logging.INFO, logger="app.services.hooks.post_ingest")
+
+    mock_resp = MagicMock()
+    mock_resp.raise_for_status = MagicMock()
+    client_inst = MagicMock()
+    client_inst.post = AsyncMock(return_value=mock_resp)
+    client_inst.__aenter__ = AsyncMock(return_value=client_inst)
+    client_inst.__aexit__ = AsyncMock(return_value=False)
+
+    with patch(
+        "app.services.hooks.post_ingest.httpx.AsyncClient",
+        return_value=client_inst,
+    ):
+        asyncio.run(
+            dispatch_post_ingest_hooks(
+                factory,
+                document_id=doc_id,
+                settings=get_settings(),
+            ),
+        )
+
+    assert client_inst.post.await_count == 2
+
+    def _call_url(c: object) -> str:
+        args, kwargs = c.args, c.kwargs
+        if args:
+            return str(args[0])
+        return str(kwargs.get("url", ""))
+
+    calls = list(client_inst.post.await_args_list)
+    urls = [_call_url(c) for c in calls]
+    assert any("hooks.slack.com" in u for u in urls)
+    assert any("discord.com" in u for u in urls)
+    slack_call = next(c for c in calls if "slack" in _call_url(c))
+    slack_json = slack_call.kwargs["json"]
+    assert "hello" in slack_json["text"]
+    assert "example.com/page" in slack_json["text"]
+
+    log_text = caplog.text
+    assert "SECRET" not in log_text
+    assert "NOTLOG" not in log_text
+    assert "hooks.slack.com" not in log_text.lower()
+
+    asyncio.run(engine.dispose())
+
+
+def test_dispatch_no_webhooks_is_noop(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("DATA_DIR", str(tmp_path))
+    monkeypatch.delenv("POST_INGEST_SLACK_WEBHOOK_URL", raising=False)
+    monkeypatch.delenv("POST_INGEST_DISCORD_WEBHOOK_URL", raising=False)
+    clear_settings_cache()
+
+    with patch("app.services.hooks.post_ingest.httpx.AsyncClient") as ac:
+        asyncio.run(
+            dispatch_post_ingest_hooks(
+                MagicMock(),
+                document_id="x",
+                settings=get_settings(),
+            ),
+        )
+    ac.assert_not_called()

package/backend/tests/test_query.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, patch
+
+from fastapi.testclient import TestClient
+
+from app.config import clear_settings_cache, get_settings
+from app.schemas.query import QueryFiltersPayload
+from app.services.retrieval_service import (
+    blended_retrieval_score,
+    recency_score_from_ingested_at,
+    semantic_score_from_distance,
+    source_weight_for_connector,
+)
+
+_DIM = 1536
+
+
+def _vec(first: float = 1.0) -> list[float]:
+    v = [0.0] * _DIM
+    v[0] = first
+    return v
+
+
+def test_query_requires_gateway(migrated_client: TestClient) -> None:
+    r = migrated_client.post("/query", json={"query": "hi", "k": 5})
+    assert r.status_code == 401
+
+
+def test_semantic_score_decreases_with_distance() -> None:
+    assert semantic_score_from_distance(0.0) > semantic_score_from_distance(2.0)
+
+
+def test_recency_newer_higher() -> None:
+    now = datetime(2026, 6, 15, tzinfo=UTC)
+    old = recency_score_from_ingested_at(
+        "2020-01-01T00:00:00Z",
+        now=now,
+        half_life_days=30.0,
+    )
+    new = recency_score_from_ingested_at(
+        "2026-06-10T00:00:00Z",
+        now=now,
+        half_life_days=30.0,
+    )
+    assert new > old
+
+
+def test_source_weight_default() -> None:
+    w = {"default": 0.5, "web": 0.9}
+    assert source_weight_for_connector("missing", w) == 0.5
+    assert source_weight_for_connector("web", w) == 0.9
+
+
+def test_blended_score() -> None:
+    from app.config import Settings
+
+    s = Settings()
+    score = blended_retrieval_score(
+        semantic=1.0,
+        recency=1.0,
+        source_w=1.0,
+        settings=s,
+    )
+    assert abs(score - 1.0) < 1e-6
+
+
+def test_filters_newer_than_days_sets_timestamp_min() -> None:
+    now = datetime(2026, 1, 20, 12, 0, 0, tzinfo=UTC)
+    f = QueryFiltersPayload(newer_than_days=10.0)
+    vf = f.to_vector_filters(now=now)
+    assert vf is not None
+    assert vf.timestamp_min is not None
+    assert vf.timestamp_max is None
+
+
+def test_vector_filters_merge_timestamp_min() -> None:
+    now = datetime(2026, 1, 20, tzinfo=UTC)
+    f = QueryFiltersPayload(
+        timestamp_min="2026-01-01T00:00:00Z",
+        newer_than_days=30.0,
+    )
+    vf = f.to_vector_filters(now=now)
+    assert vf is not None
+    # Later (stricter) bound should win
+    assert vf.timestamp_min == "2026-01-01T00:00:00Z"
+
+
+def test_query_retrieves_chunk(migrated_client: TestClient, monkeypatch) -> None:
+    monkeypatch.setenv("GEMINI_API_KEY", "test-key")
+    clear_settings_cache()
+
+    h = {"x-user-id": "u1"}
+    settings = get_settings()
+    db_path = settings.data_dir / settings.sqlite_filename
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    cur.execute(
+        "INSERT INTO sources (name, connector_type) VALUES ('n', 'web')",
+    )
+    sid = int(cur.lastrowid)
+    cur.execute(
+        "INSERT INTO documents (id, source_id, timestamp, content_type, raw_content, "
+        "summary, status) VALUES ('d1', ?, '2024-01-01T00:00:00Z', 'text', '{}', "
+        "'summary one', 'ok')",
+        (sid,),
+    )
+    cur.execute(
+        "INSERT INTO document_chunks (document_id, ordinal, text, start_block_ordinal, "
+        "end_block_ordinal, meta) VALUES ('d1', 0, 'alpha beta gamma', 0, 0, NULL)",
+    )
+    cid = int(cur.lastrowid)
+    conn.commit()
+    conn.close()
+
+    ts = "2026-01-10T12:00:00Z"
+    up = migrated_client.post(
+        "/vectors/upsert",
+        headers=h,
+        json={
+            "embeddings": [_vec(1.0)],
+            "metas": [
+                {
+                    "document_id": "d1",
+                    "chunk_id": cid,
+                    "source_id": sid,
+                    "modality": "text",
+                    "ingested_at": ts,
+                },
+            ],
+        },
+    )
+    assert up.status_code == 200
+
+    async def _fake_batch(*args, **kwargs):
+        return [_vec(1.0)]
+
+    with patch(
+        "app.services.retrieval_service.batch_embed_contents",
+        new=AsyncMock(side_effect=_fake_batch),
+    ):
+        q = migrated_client.post(
+            "/query",
+            headers=h,
+            json={"query": "alpha beta", "k": 5},
+        )
+    assert q.status_code == 200
+    data = q.json()
+    assert len(data["candidates"]) == 1
+    c0 = data["candidates"][0]
+    assert c0["chunk"]["text"] == "alpha beta gamma"
+    assert c0["document"]["summary"] == "summary one"
+    assert c0["attribution"]["document_id"] == "d1"
+    assert "combined_text" in data["context"]
+    assert "d1" in data["context"]["combined_text"]
+
+
+def test_query_503_without_gemini_key(migrated_client: TestClient, monkeypatch) -> None:
+    monkeypatch.delenv("GEMINI_API_KEY", raising=False)
+    clear_settings_cache()
+    h = {"x-user-id": "u1"}
+    r = migrated_client.post("/query", headers=h, json={"query": "x", "k": 1})
+    assert r.status_code == 503

package/backend/tests/test_thread_expansion.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import UTC, datetime
+
+import pytest
+
+from app.connectors.thread_expansion import (
+    FakeRedditThreadExpansionFetcher,
+    FakeTwitterThreadExpansionFetcher,
+    ThreadExpansionResult,
+    ThreadRelationshipEdge,
+)
+from app.connectors.thread_expansion.models import ThreadDocumentNode
+
+
+def test_thread_edge_rejects_self_loop() -> None:
+    with pytest.raises(ValueError, match="must differ"):
+        ThreadRelationshipEdge(
+            parent_document_id="a",
+            child_document_id="a",
+            relation_type="reply",
+        )
+
+
+def test_expansion_result_requires_root_in_nodes() -> None:
+    with pytest.raises(ValueError, match="root_document_id"):
+        ThreadExpansionResult(
+            platform="twitter",
+            thread_key="k",
+            root_document_id="missing",
+            nodes=[
+                ThreadDocumentNode(
+                    document_id="x",
+                    external_id="1",
+                    text="t",
+                    created_at=datetime.now(UTC),
+                ),
+            ],
+            edges=[],
+        )
+
+
+def test_fake_twitter_linear_reply_chain() -> None:
+    f = FakeTwitterThreadExpansionFetcher()
+    r = asyncio.run(f.fetch_full_thread("1999", config={}))
+    assert r.platform == "twitter"
+    assert r.root_document_id == "twitter:tw_root"
+    reply_edges = [e for e in r.edges if e.relation_type == "reply"]
+    assert len(reply_edges) == 2
+    parents = {e.child_document_id: e.parent_document_id for e in reply_edges}
+    assert parents["twitter:tw_r1"] == "twitter:tw_root"
+    assert parents["twitter:tw_r2"] == "twitter:tw_r1"
+
+
+def test_fake_reddit_post_and_nested_comment() -> None:
+    f = FakeRedditThreadExpansionFetcher()
+    r = asyncio.run(f.fetch_post_and_comments("t3_abc123", config={}))
+    assert r.platform == "reddit"
+    assert len(r.nodes) == 3
+    assert any(
+        e.parent_document_id == "reddit:t3_abc123"
+        and e.child_document_id == "reddit:t1_cmnt1"
+        for e in r.edges
+    )
+
+
+def test_fakes_run_sync_helper() -> None:
+    """Ensure asyncio.run works for quick local scripts."""
+    f = FakeTwitterThreadExpansionFetcher()
+    r = asyncio.run(f.fetch_full_thread("1", config={}))
+    assert isinstance(r, ThreadExpansionResult)

package/backend/tests/test_vectors.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+
+_DIM = 1536
+
+
+def _vec(first: float = 1.0) -> list[float]:
+    v = [0.0] * _DIM
+    v[0] = first
+    return v
+
+
+def test_vectors_require_gateway(migrated_client: TestClient) -> None:
+    r = migrated_client.post(
+        "/vectors/search",
+        json={"query_vector": _vec(), "k": 1},
+    )
+    assert r.status_code == 401
+
+
+def test_vectors_upsert_search_delete(migrated_client: TestClient) -> None:
+    h = {"x-user-id": "u1"}
+    ts = "2024-06-01T12:00:00Z"
+
+    r = migrated_client.post(
+        "/vectors/upsert",
+        json={
+            "embeddings": [_vec(1.0), _vec(0.2)],
+            "metas": [
+                {
+                    "document_id": "doc-a",
+                    "chunk_id": 0,
+                    "source_id": 10,
+                    "modality": "text",
+                    "ingested_at": ts,
+                },
+                {
+                    "document_id": "doc-b",
+                    "chunk_id": 1,
+                    "source_id": 10,
+                    "modality": "text",
+                    "ingested_at": ts,
+                },
+            ],
+        },
+        headers=h,
+    )
+    assert r.status_code == 200
+
+    q = migrated_client.post(
+        "/vectors/search",
+        json={"query_vector": _vec(1.0), "k": 2},
+        headers=h,
+    )
+    assert q.status_code == 200
+    data = q.json()["results"]
+    assert len(data) == 2
+    assert data[0]["document_id"] == "doc-a"
+    assert data[0]["distance"] < data[1]["distance"]
+
+    f = migrated_client.post(
+        "/vectors/search",
+        json={
+            "query_vector": _vec(1.0),
+            "k": 5,
+            "filters": {"source_id": 10, "modality": "text"},
+        },
+        headers=h,
+    )
+    assert f.status_code == 200
+    assert len(f.json()["results"]) == 2
+
+    d = migrated_client.delete("/vectors/documents/doc-a", headers=h)
+    assert d.status_code == 200
+    assert d.json()["deleted"] >= 1
+
+    q2 = migrated_client.post(
+        "/vectors/search",
+        json={"query_vector": _vec(1.0), "k": 5},
+        headers=h,
+    )
+    ids = {row["document_id"] for row in q2.json()["results"]}
+    assert "doc-a" not in ids
+    assert "doc-b" in ids