queryview 0.0.2__py3-none-any.whl

queryview/test_dashboards.py

@@ -0,0 +1,216 @@
+"""Tests for the dashboard store and its REST surface. These don't need a real
+ClickHouse: the store is pure SQLite, and route tests exercise validation plus
+the persist/push path (the runner's happy/bad ClickHouse paths live in e2e)."""
+
+from __future__ import annotations
+
+import asyncio
+
+from fastapi.testclient import TestClient
+
+from queryview import remote
+from queryview.dashboards import (
+    _upsert_and_push,
+    get_dashboard,
+    list_dashboards,
+    upsert_dashboard,
+)
+from queryview.main import app
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_upsert_creates_then_updates_by_name(default_ws_id):
+    _run(upsert_dashboard("d1", "conn-a", "<h1>v1</h1>", {"q": "SELECT 1"}, workspace_id=default_ws_id))
+    got = _run(get_dashboard("d1", default_ws_id))
+    assert got is not None
+    assert got["connection"] == "conn-a"
+    assert got["html"] == "<h1>v1</h1>"
+    assert got["queries"] == {"q": "SELECT 1"}
+
+    _run(upsert_dashboard("d1", "conn-b", "<h1>v2</h1>", {"q": "SELECT 2"}, workspace_id=default_ws_id))
+    got = _run(get_dashboard("d1", default_ws_id))
+    assert got is not None
+    assert got["connection"] == "conn-b"
+    assert got["html"] == "<h1>v2</h1>"
+    assert got["queries"] == {"q": "SELECT 2"}
+
+
+def test_get_dashboard_round_trips_queries_dict(default_ws_id):
+    queries = {"sales": "SELECT * FROM sales", "users": "SELECT count() FROM users"}
+    _run(upsert_dashboard("multi", "c", "<div></div>", queries, workspace_id=default_ws_id))
+    got = _run(get_dashboard("multi", default_ws_id))
+    assert got is not None
+    assert got["queries"] == queries
+
+
+def test_get_missing_dashboard_is_none(default_ws_id):
+    assert _run(get_dashboard("does-not-exist", default_ws_id)) is None
+
+
+def test_list_dashboards_orders_by_name_and_omits_payload(default_ws_id):
+    _run(upsert_dashboard("zeta", "c", "<i></i>", {"q": "SELECT 1"}, workspace_id=default_ws_id))
+    _run(upsert_dashboard("alpha", "c", "<i></i>", {"q": "SELECT 1"}, workspace_id=default_ws_id))
+    names = [d["name"] for d in _run(list_dashboards(default_ws_id))]
+    assert names.index("alpha") < names.index("zeta")
+    row = next(d for d in _run(list_dashboards(default_ws_id)) if d["name"] == "alpha")
+    assert set(row) == {"name", "connection", "updated_at"}
+
+
+def test_upsert_and_push_persists_without_session(default_ws_id):
+    persisted, pushed, _ = _run(
+        _upsert_and_push("np", "c", "<p></p>", {"q": "SELECT 1"}, None, workspace_id=default_ws_id)
+    )
+    assert persisted is True and pushed is False
+    assert _run(get_dashboard("np", default_ws_id)) is not None
+
+
+def test_upsert_and_push_delivers_to_registered_session(default_ws_id):
+    rid = remote.register()
+    try:
+        persisted, pushed, _ = _run(
+            _upsert_and_push("pushed", "c", "<p>x</p>", {"q": "SELECT 1"}, rid, workspace_id=default_ws_id)
+        )
+        assert persisted is True and pushed is True
+        msg = _run(remote.next_message(rid, 1.0))
+        assert msg is not None
+        assert msg["type"] == "dashboard"
+        assert msg["name"] == "pushed"
+        assert msg["connection"] == "c"
+        assert msg["html"] == "<p>x</p>"
+        assert msg["queries"] == {"q": "SELECT 1"}
+    finally:
+        remote.unregister(rid)
+
+
+# --- REST surface ---------------------------------------------------------
+
+
+def test_runqueries_requires_connection_and_queries():
+    client = TestClient(app)
+    assert client.post("/api/runqueries", json={"queries": {"q": "SELECT 1"}}).status_code == 400
+    assert client.post("/api/runqueries", json={"connection": "c"}).status_code == 400
+    assert client.post("/api/runqueries", json={"connection": "c", "queries": {}}).status_code == 400
+
+
+def test_runqueries_unknown_connection_returns_404():
+    client = TestClient(app)
+    r = client.post(
+        "/api/runqueries",
+        json={"connection": "no-such-connection", "queries": {"q": "SELECT 1"}},
+    )
+    assert r.status_code == 404
+    assert r.json()["ok"] is False
+    assert "no connection" in r.json()["message"].lower()
+
+
+def test_dashboards_upsert_requires_fields():
+    client = TestClient(app)
+    r = client.post("/api/dashboards", json={"name": "x", "connection": "c"})
+    assert r.status_code == 400
+
+
+def test_dashboards_upsert_persists_and_lists_and_gets():
+    client = TestClient(app)
+    r = client.post(
+        "/api/dashboards",
+        json={
+            "name": "rest-dash",
+            "connection": "c",
+            "html": "<h1>hi</h1>",
+            "queries": {"q": "SELECT 1"},
+        },
+    )
+    assert r.status_code == 200
+    body = r.json()
+    assert body["persisted"] is True and body["pushed"] is False
+
+    listed = client.get("/api/dashboards").json()["dashboards"]
+    assert any(d["name"] == "rest-dash" for d in listed)
+
+    got = client.get("/api/dashboards/rest-dash").json()
+    assert got["html"] == "<h1>hi</h1>"
+    assert got["queries"] == {"q": "SELECT 1"}
+
+
+def test_dashboards_get_missing_returns_404():
+    client = TestClient(app)
+    assert client.get("/api/dashboards/missing-one").status_code == 404
+
+
+def test_dashboards_upsert_pushes_to_registered_session():
+    rid = remote.register()
+    try:
+        client = TestClient(app)
+        r = client.post(
+            "/api/dashboards",
+            json={
+                "session_id": rid,
+                "name": "live-dash",
+                "connection": "c",
+                "html": "<p></p>",
+                "queries": {"q": "SELECT 1"},
+            },
+        )
+        assert r.json()["pushed"] is True
+        msg = _run(remote.next_message(rid, 1.0))
+        assert msg is not None
+        assert msg["type"] == "dashboard" and msg["name"] == "live-dash"
+    finally:
+        remote.unregister(rid)
+
+
+def test_mcp_upsert_dashboard_pushes_draft_without_persisting(default_ws_id):
+    from queryview.mcp_server import push_dashboard as mcp_push
+
+    rid = remote.register()
+    try:
+        out = _run(mcp_push(rid, "draftdash", "c", "<p>d</p>", {"q": "SELECT 1"}))
+        assert out["pushed"] is True
+        # Draft: the agent push must NOT persist — only the user's Save does.
+        assert _run(get_dashboard("draftdash", default_ws_id)) is None
+        msg = _run(remote.next_message(rid, 1.0))
+        assert msg is not None
+        assert msg["type"] == "dashboard" and msg["name"] == "draftdash"
+    finally:
+        remote.unregister(rid)
+
+
+def test_dashboard_names_distinct_per_workspace(default_ws_id):
+    from queryview.workspaces import create_workspace, resolve
+
+    _run(create_workspace("t4-iso"))
+    other = _run(resolve("t4-iso")).id
+    _run(upsert_dashboard("iso d", "prod", "<html>1</html>", {"q": "SELECT 1"}, workspace_id=default_ws_id))
+    _run(upsert_dashboard("iso d", "prod", "<html>2</html>", {"q": "SELECT 2"}, workspace_id=other))
+
+    d_default = _run(get_dashboard("iso d", default_ws_id))
+    d_other = _run(get_dashboard("iso d", other))
+    assert d_default is not None and d_default["html"] == "<html>1</html>"
+    assert d_other is not None and d_other["html"] == "<html>2</html>"
+    assert "iso d" in [d["name"] for d in _run(list_dashboards(default_ws_id))]
+    assert "iso d" in [d["name"] for d in _run(list_dashboards(other))]
+
+
+def test_mcp_list_dashboards_scopes_by_session_workspace(default_ws_id):
+    from queryview.mcp_server import list_dashboards as mcp_list
+    from queryview.workspaces import create_workspace, resolve
+
+    _run(create_workspace("t-mcp-ld"))
+    other = _run(resolve("t-mcp-ld")).id
+    _run(upsert_dashboard("mcp ld", "c", "<i></i>", {}, workspace_id=other))
+
+    # No session_id -> default workspace: the other workspace's dashboard is absent.
+    names = [d["name"] for d in _run(mcp_list())["dashboards"]]
+    assert "mcp ld" not in names
+
+    # A session reporting the other workspace sees it.
+    rid = remote.register()
+    try:
+        remote.set_session_workspace(rid, "t-mcp-ld")
+        names = [d["name"] for d in _run(mcp_list(session_id=rid))["dashboards"]]
+        assert names == ["mcp ld"]
+    finally:
+        remote.unregister(rid)

queryview/test_gitsync.py

@@ -0,0 +1,346 @@
+"""Git sync: serializer round-trips (queries/dashboards <-> repo files) and,
+in later tests, store/history/restore against a local bare repo (no network)."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+
+import pytest
+
+from queryview import gitsync
+from queryview.gitsync import (
+    GitSyncError,
+    dashboard_from_files,
+    dashboard_reldir,
+    dashboard_to_files,
+    query_from_yaml,
+    query_relpath,
+    query_to_yaml,
+)
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_relpaths():
+    assert query_relpath("clickhouse", "top errors") == "queries/clickhouse/top errors.yaml"
+    assert dashboard_reldir("sales/eu") == "dashboards/sales%2Feu"
+
+
+def test_query_yaml_round_trip():
+    row = {
+        "query_name": "top errors",
+        "query": "SELECT *\nFROM errors\nORDER BY n DESC",
+        "cell_view": "cve_id:\n  type: link\n  value: https://x/{cell}\n",
+        "order_by": '[{"name": "n", "dir": "DESC"}]',
+        "fields": '["cve_id", "n"]',
+    }
+    text = query_to_yaml(row)
+    assert "SELECT *" in text  # multiline SQL is a readable block, not \n escapes
+    assert query_from_yaml(text) == row
+
+
+def test_query_yaml_omits_and_restores_none_fields():
+    row = {
+        "query_name": "plain",
+        "query": "SELECT 1",
+        "cell_view": None,
+        "order_by": None,
+        "fields": None,
+    }
+    text = query_to_yaml(row)
+    assert "cell_view" not in text
+    assert query_from_yaml(text) == row
+
+
+def test_query_from_yaml_rejects_malformed():
+    with pytest.raises(GitSyncError):
+        query_from_yaml("just a scalar")
+    with pytest.raises(GitSyncError):
+        query_from_yaml("query_name: x\n")  # no query
+
+
+def test_dashboard_files_round_trip():
+    d = {
+        "name": "sales",
+        "connection": "prod",
+        "html": "<html>\n<body>hi — ünicode</body>\n</html>",
+        "queries": {"revenue": "SELECT 1", "multi": "SELECT a\nFROM b"},
+    }
+    files = dashboard_to_files(d)
+    assert set(files) == {"meta.yaml", "dashboard.html", "queries.yaml"}
+    assert files["dashboard.html"] == d["html"]  # verbatim
+    assert dashboard_from_files(files) == d
+
+
+def test_dashboard_from_files_rejects_malformed_meta():
+    with pytest.raises(GitSyncError):
+        dashboard_from_files({"meta.yaml": "connection: x", "dashboard.html": "", "queries.yaml": ""})
+
+
+# The git_env fixture (bare repo + GIT_SYNC_* env vars) lives in conftest.py.
+
+
+def _default_ws_id() -> int:
+    from queryview.workspaces import DEFAULT_WORKSPACE, resolve
+
+    return _run(resolve(DEFAULT_WORKSPACE)).id
+
+
+def _default_ws():
+    """The default workspace, re-resolved so per-test remote changes are seen."""
+    from queryview.workspaces import DEFAULT_WORKSPACE, resolve
+
+    return _run(resolve(DEFAULT_WORKSPACE))
+
+
+def _remote_log(remote) -> str:
+    return subprocess.run(
+        ["git", "log", "--format=%H %s", "main"],
+        cwd=remote,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+
+
+def test_store_unconfigured_is_409():
+    # Outside git_env the default workspace has no remote configured.
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.store(_default_ws(), "query", "anything", "clickhouse"))
+    assert e.value.status == 409
+    assert "no git remote" in str(e.value)
+
+
+def test_unknown_kind_is_400():
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.store(_default_ws(), "quert", "x", "clickhouse"))
+    assert e.value.status == 400
+    assert "kind" in str(e.value)
+
+
+def test_query_without_conn_type_is_400():
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.history(_default_ws(), "query", "x"))
+    assert e.value.status == 400
+    assert "conn_type" in str(e.value)
+
+
+def test_store_missing_entity_is_404(git_env):
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.store(_default_ws(), "query", "no such query xyz", "clickhouse"))
+    assert e.value.status == 404
+
+
+def test_store_query_commits_and_pushes(git_env):
+    from queryview.queries import save_predefined_query
+
+    _run(save_predefined_query("gs top", "clickhouse", "SELECT 1", workspace_id=_default_ws_id()))
+    r = _run(gitsync.store(_default_ws(), "query", "gs top", "clickhouse"))
+    assert r["committed"] is True and r["sha"]
+    log = _remote_log(git_env)
+    assert r["sha"] in log
+    assert "store query clickhouse/gs top" in log
+
+
+def test_store_no_change_makes_no_commit(git_env):
+    from queryview.queries import save_predefined_query
+
+    _run(save_predefined_query("gs same", "clickhouse", "SELECT 2", workspace_id=_default_ws_id()))
+    r1 = _run(gitsync.store(_default_ws(), "query", "gs same", "clickhouse"))
+    r2 = _run(gitsync.store(_default_ws(), "query", "gs same", "clickhouse"))
+    assert r1["committed"] is True
+    assert r2 == {"committed": False, "sha": None, "message": "no changes"}
+    assert _remote_log(git_env).count("\n") == 1  # exactly one commit
+
+
+def test_store_dashboard_touches_only_its_dir(git_env):
+    from queryview.dashboards import upsert_dashboard
+
+    _run(upsert_dashboard("gs dash", "prod", "<html>v1</html>", {"q": "SELECT 1"}, workspace_id=_default_ws_id()))
+    r = _run(gitsync.store(_default_ws(), "dashboard", "gs dash"))
+    assert r["committed"] is True
+    out = subprocess.run(
+        ["git", "show", "--name-only", "--format=", r["sha"]],
+        cwd=git_env,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+    files = [line for line in out.splitlines() if line.strip()]
+    assert files and all(f.startswith("dashboards/gs dash/") for f in files)
+    assert set(files) == {
+        "dashboards/gs dash/meta.yaml",
+        "dashboards/gs dash/dashboard.html",
+        "dashboards/gs dash/queries.yaml",
+    }
+
+
+def test_store_custom_message(git_env):
+    from queryview.queries import save_predefined_query
+
+    _run(save_predefined_query("gs msg", "clickhouse", "SELECT 3", workspace_id=_default_ws_id()))
+    _run(gitsync.store(_default_ws(), "query", "gs msg", "clickhouse", message="before migration"))
+    assert "before migration" in _remote_log(git_env)
+
+
+def test_store_unreachable_remote_raises_without_init(tmp_path, monkeypatch):
+    from queryview.queries import save_predefined_query
+    from queryview.workspaces import DEFAULT_WORKSPACE, update_workspace
+
+    monkeypatch.setenv("GIT_SYNC_DIR", str(tmp_path / "clones"))
+    _run(update_workspace(DEFAULT_WORKSPACE, remote=str(tmp_path / "does-not-exist.git")))
+    try:
+        _run(save_predefined_query("gs unreachable", "clickhouse", "SELECT 1", workspace_id=_default_ws_id()))
+        ws = _default_ws()
+        with pytest.raises(GitSyncError) as e:
+            _run(gitsync.store(ws, "query", "gs unreachable", "clickhouse"))
+        assert e.value.status == 502
+        # No spurious local repo in this workspace's clone dir.
+        assert not (tmp_path / "clones" / str(ws.id) / ".git").exists()
+    finally:
+        _run(update_workspace(DEFAULT_WORKSPACE, remote=None))
+
+
+def _clone_head() -> str:
+    import os
+
+    wd = os.path.join(os.environ["GIT_SYNC_DIR"], str(_default_ws_id()))
+    return subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=wd,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def _store_query_versions(name: str, sqls: list[str]) -> list[str]:
+    """Save+store the query once per SQL; returns the commit shas in order."""
+    from queryview.queries import save_predefined_query
+
+    shas = []
+    for sql in sqls:
+        _run(save_predefined_query(name, "clickhouse", sql, workspace_id=_default_ws_id()))
+        shas.append(_run(gitsync.store(_default_ws(), "query", name, "clickhouse"))["sha"])
+    return shas
+
+
+def test_history_pages_newest_first(git_env):
+    shas = _store_query_versions("gs hist", ["SELECT 1", "SELECT 2", "SELECT 3"])
+    page1 = _run(gitsync.history(_default_ws(), "query", "gs hist", "clickhouse", limit=2))
+    assert [r["sha"] for r in page1["revisions"]] == [shas[2], shas[1]]
+    assert page1["has_more"] is True
+    assert all(isinstance(r["date"], int) and r["message"] for r in page1["revisions"])
+    page2 = _run(gitsync.history(_default_ws(), "query", "gs hist", "clickhouse", before=shas[1], limit=2))
+    assert [r["sha"] for r in page2["revisions"]] == [shas[0]]
+    assert page2["has_more"] is False
+    # Paging past the oldest commit yields an empty page, not an error.
+    page3 = _run(gitsync.history(_default_ws(), "query", "gs hist", "clickhouse", before=shas[0], limit=2))
+    assert page3 == {"revisions": [], "has_more": False}
+
+
+def test_history_garbage_before_is_404(git_env):
+    _store_query_versions("gs badbefore", ["SELECT 1"])
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.history(_default_ws(), "query", "gs badbefore", "clickhouse", before="not-a-sha"))
+    assert e.value.status == 404
+
+
+def test_history_only_sees_own_entity(git_env):
+    _store_query_versions("gs mine", ["SELECT 1"])
+    _store_query_versions("gs other", ["SELECT 9"])
+    h = _run(gitsync.history(_default_ws(), "query", "gs mine", "clickhouse"))
+    assert len(h["revisions"]) == 1
+
+
+def test_restore_old_version_overwrites_db_without_moving_head(git_env):
+    from queryview.queries import list_predefined_queries
+
+    shas = _store_query_versions("gs restore", ["SELECT 1", "SELECT 2"])
+    head_before = _clone_head()
+    r = _run(gitsync.restore(_default_ws(), "query", "gs restore", "clickhouse", ref=shas[0]))
+    assert r["restored"] is True
+    rows = _run(list_predefined_queries("clickhouse", _default_ws_id()))
+    row = next(x for x in rows if x["query_name"] == "gs restore")
+    assert row["query"] == "SELECT 1"
+    assert _clone_head() == head_before  # HEAD never moves
+
+
+def test_restore_default_ref_is_remote_head(git_env):
+    from queryview.queries import list_predefined_queries, save_predefined_query
+
+    _store_query_versions("gs latest", ["SELECT 1", "SELECT 2"])
+    _run(save_predefined_query("gs latest", "clickhouse", "SELECT 999", workspace_id=_default_ws_id()))  # local drift
+    _run(gitsync.restore(_default_ws(), "query", "gs latest", "clickhouse"))
+    rows = _run(list_predefined_queries("clickhouse", _default_ws_id()))
+    row = next(x for x in rows if x["query_name"] == "gs latest")
+    assert row["query"] == "SELECT 2"
+
+
+def test_restore_dashboard_round_trip(git_env):
+    from queryview.dashboards import get_dashboard, upsert_dashboard
+
+    _run(upsert_dashboard("gs rdash", "prod", "<html>v1</html>", {"q": "SELECT 1"}, workspace_id=_default_ws_id()))
+    _run(gitsync.store(_default_ws(), "dashboard", "gs rdash"))
+    _run(upsert_dashboard("gs rdash", "other", "<html>v2</html>", {"q": "SELECT 2"}, workspace_id=_default_ws_id()))
+    _run(gitsync.restore(_default_ws(), "dashboard", "gs rdash"))
+    d = _run(get_dashboard("gs rdash", _default_ws_id()))
+    assert d == {
+        "name": "gs rdash",
+        "connection": "prod",
+        "html": "<html>v1</html>",
+        "queries": {"q": "SELECT 1"},
+    }
+
+
+def test_restore_missing_at_ref_is_404(git_env):
+    _store_query_versions("gs exists", ["SELECT 1"])
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.restore(_default_ws(), "query", "never stored", "clickhouse"))
+    assert e.value.status == 404
+
+
+def _bare(tmp_path, name):
+    remote = tmp_path / name
+    subprocess.run(
+        ["git", "init", "--bare", "-b", "main", str(remote)],
+        check=True,
+        capture_output=True,
+    )
+    return remote
+
+
+def test_store_is_isolated_per_workspace(tmp_path, monkeypatch):
+    """A commit in workspace A lands only in A's remote; B's stays empty; a
+    workspace without a remote is 409."""
+    from queryview.queries import save_predefined_query
+    from queryview.workspaces import create_workspace, resolve
+
+    monkeypatch.setenv("GIT_SYNC_DIR", str(tmp_path / "clones"))
+    ra, rb = _bare(tmp_path, "a.git"), _bare(tmp_path, "b.git")
+    _run(create_workspace("t5-a", remote=str(ra)))
+    _run(create_workspace("t5-b", remote=str(rb)))
+    _run(create_workspace("t5-none"))
+    wa, wb = _run(resolve("t5-a")), _run(resolve("t5-b"))
+
+    _run(save_predefined_query("iso", "clickhouse", "SELECT 1", workspace_id=wa.id))
+    r = _run(gitsync.store(wa, "query", "iso", "clickhouse"))
+    assert r["committed"] is True
+    assert "store query clickhouse/iso" in _remote_log(ra)
+    # B's remote has no commits at all (git log fails on an empty bare repo).
+    p = subprocess.run(["git", "log", "--format=%H", "main"], cwd=rb, capture_output=True, text=True)
+    assert p.returncode != 0
+
+    # And B's history for the same entity name is empty, not A's history.
+    _run(save_predefined_query("iso", "clickhouse", "SELECT 2", workspace_id=wb.id))
+    h = _run(gitsync.history(wb, "query", "iso", "clickhouse"))
+    assert h["revisions"] == []
+
+    wn = _run(resolve("t5-none"))
+    with pytest.raises(GitSyncError) as e:
+        _run(gitsync.store(wn, "query", "iso", "clickhouse"))
+    assert e.value.status == 409
+    assert "no git remote" in str(e.value)

queryview/test_main.py

@@ -0,0 +1,18 @@
+"""Tests for the console-script entry point (port resolution)."""
+
+from queryview import main
+
+
+def test_port_flag_beats_env(monkeypatch):
+    monkeypatch.setenv("PORT", "7777")
+    assert main._resolve_port(["--port", "9000"]) == 9000
+
+
+def test_port_env_used_without_flag(monkeypatch):
+    monkeypatch.setenv("PORT", "7777")
+    assert main._resolve_port([]) == 7777
+
+
+def test_port_defaults_to_8000(monkeypatch):
+    monkeypatch.delenv("PORT", raising=False)
+    assert main._resolve_port([]) == 8000

queryview/test_mcp_gitsync.py

@@ -0,0 +1,72 @@
+"""The git-sync MCP tools: registration and delegation to gitsync (errors come
+back as {ok: False} rather than raising, matching the other tools)."""
+
+from __future__ import annotations
+
+import asyncio
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_git_tools_are_registered():
+    from queryview.mcp_server import mcp
+
+    names = {t.name for t in _run(mcp.list_tools())}
+    assert {"git_store", "git_history", "git_restore"} <= names
+
+
+def test_git_restore_tool_reports_unconfigured(monkeypatch):
+    monkeypatch.delenv("GIT_SYNC_REMOTE", raising=False)
+    from queryview.mcp_server import git_restore
+
+    r = _run(git_restore("dashboard", "x"))
+    assert r["ok"] is False
+
+
+def test_git_store_resolves_workspace_from_session(tmp_path, monkeypatch):
+    """An armed session on workspace B routes git_store to B's remote; no
+    session_id falls back to the default workspace."""
+    import subprocess
+
+    from queryview import remote
+    from queryview.mcp_server import git_store
+    from queryview.queries import save_predefined_query
+    from queryview.workspaces import create_workspace, resolve
+
+    monkeypatch.setenv("GIT_SYNC_DIR", str(tmp_path / "clones"))
+    rb = tmp_path / "b.git"
+    subprocess.run(
+        ["git", "init", "--bare", "-b", "main", str(rb)],
+        check=True,
+        capture_output=True,
+    )
+    _run(create_workspace("t7-b", remote=str(rb)))
+    wid = _run(resolve("t7-b")).id
+    _run(save_predefined_query("sess q", "clickhouse", "SELECT 1", workspace_id=wid))
+
+    rid = remote.register()
+    try:
+        remote.set_session_workspace(rid, "t7-b")
+        r = _run(git_store("query", "sess q", "clickhouse", session_id=rid))
+        assert r["ok"] is True and r["committed"] is True
+        log = subprocess.run(
+            ["git", "log", "--format=%s", "main"],
+            cwd=rb,
+            check=True,
+            capture_output=True,
+            text=True,
+        ).stdout
+        assert "sess q" in log
+    finally:
+        remote.unregister(rid)
+
+
+def test_git_store_without_session_uses_default_workspace():
+    from queryview.mcp_server import git_store
+
+    # Outside git_env the default workspace has no remote -> unconfigured.
+    r = _run(git_store("query", "anything", "clickhouse"))
+    assert r["ok"] is False
+    assert "no git remote" in r["message"]