code-coordinator 0.5.275__tar.gz → 0.5.276__tar.gz

{code_coordinator-0.5.275 → code_coordinator-0.5.276}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.275
+Version: 0.5.276
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.275 → code_coordinator-0.5.276}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.275
+Version: 0.5.276
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

code_coordinator-0.5.276/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.276",
+  "distance": 0,
+  "node": "gf933f3cbf3912a33e93783fcaece9a9d6aac054b",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-29"
+}

{code_coordinator-0.5.275 → code_coordinator-0.5.276}/coord/serve_app.py

@@ -3831,6 +3831,73 @@ def openapi_spec() -> dict:
                 },
             }
         },
+        "/issue-upsert": {
+            "post": {
+                "summary": "Upsert ONE issue row into the shared issue cache (#2895)",
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "repo_name": {"type": "string"},
+                                    "issue": {"type": "object"},
+                                },
+                                "required": ["repo_name", "issue"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {"application/json": {"schema": ok_response}},
+                    },
+                    "400": {"description": "Missing field"},
+                },
+            }
+        },
+        "/purge": {
+            "post": {
+                "summary": (
+                    "Count (dry_run) or delete old done/failed assignments and "
+                    "old closed issues (#2895)"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "older_than_secs": {"type": "number"},
+                                    "dry_run": {"type": "boolean"},
+                                },
+                                "required": ["older_than_secs"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": "Rows deleted (or, with dry_run, matched)",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "assignments": {"type": "integer"},
+                                        "issues": {"type": "integer"},
+                                    },
+                                }
+                            }
+                        },
+                    },
+                    "400": {"description": "Bad older_than_secs"},
+                },
+            }
+        },
         "/issue-edit": {
             "post": {
                 "summary": "Edit an issue's title/body through the tracker seam",
@@ -6761,6 +6828,70 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
             )
         return JSONResponse({"ok": True})
 
+    async def post_issue_upsert(request: Request) -> Response:
+        # #2895: upsert ONE issue row into the shared issue cache. The TUI's
+        # `gh issue view` refresh used to write this straight into coord.db
+        # over its own rusqlite connection; now that coord-tui is
+        # daemon-required, it POSTs here. Unlike /issues-sync this does not
+        # mark the repo's other issues closed — it refreshes one row.
+        from coord import state  # noqa: PLC0415
+
+        body = await _read_json(request)
+        if body is None:
+            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+        issue = body.get("issue")
+        if not isinstance(issue, dict) or "number" not in issue:
+            return JSONResponse(
+                {"error": "missing field: issue.number"}, status_code=400
+            )
+        try:
+            state._upsert_issue_local(body["repo_name"], issue)
+        except (KeyError, TypeError, ValueError) as e:
+            return JSONResponse({"error": f"missing field: {e}"}, status_code=400)
+        except Exception as e:  # noqa: BLE001
+            return JSONResponse(
+                {"error": "issue-upsert write failed", "detail": str(e)},
+                status_code=503,
+            )
+        _bust_board_cache()
+        return JSONResponse({"ok": True})
+
+    async def post_purge(request: Request) -> Response:
+        # #2895: count (dry_run) or delete old done/failed assignments and old
+        # closed issues. The TUI's Settings purge action drove this through a
+        # read-write rusqlite connection to coord.db, behind the daemon's back
+        # while `coord serve` held the same file open; it is a daemon call now.
+        from coord import state  # noqa: PLC0415
+
+        body = await _read_json(request)
+        if body is None:
+            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+        try:
+            older_than_secs = float(body["older_than_secs"])
+        except (KeyError, TypeError, ValueError) as e:
+            return JSONResponse(
+                {"error": f"bad older_than_secs: {e}"}, status_code=400
+            )
+        if older_than_secs < 0:
+            return JSONResponse(
+                {"error": "older_than_secs must be >= 0"}, status_code=400
+            )
+        dry_run = bool(body.get("dry_run", False))
+        try:
+            if dry_run:
+                assignments, issues = state._count_purgeable_local(older_than_secs)
+            else:
+                assignments, issues = state._purge_done_assignments_local(
+                    older_than_secs
+                )
+        except Exception as e:  # noqa: BLE001
+            return JSONResponse(
+                {"error": "purge failed", "detail": str(e)}, status_code=503
+            )
+        if not dry_run:
+            _bust_board_cache()
+        return JSONResponse({"assignments": assignments, "issues": issues})
+
     async def post_issue_edit(request: Request) -> Response:
         # Edit an issue's title/body through the tracker seam (the backend write
         # — GitHub via gh today — runs HERE on the daemon, not the client, so the
@@ -9377,6 +9508,10 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
         Route("/issue-label", post_issue_label, methods=["POST"]),
         Route("/issue-create", post_issue_create, methods=["POST"]),
         Route("/issues-sync", post_issues_sync, methods=["POST"]),
+        # #2895: single-row issue upsert + purge, the two write paths coord-tui
+        # used to perform against coord.db directly.
+        Route("/issue-upsert", post_issue_upsert, methods=["POST"]),
+        Route("/purge", post_purge, methods=["POST"]),
         Route("/issue-edit", post_issue_edit, methods=["POST"]),
         Route("/issue-milestone", post_issue_milestone, methods=["POST"]),
         Route(

{code_coordinator-0.5.275 → code_coordinator-0.5.276}/coord/state.py

@@ -5315,6 +5315,65 @@ def upsert_open_issues(repo_name: str, issues: list[dict]) -> None:
     _upsert_open_issues_local(repo_name, issues)
 
 
+def upsert_issue(repo_name: str, issue: dict) -> None:
+    """Upsert ONE issue row — routes to the daemon when ``board_service`` is set.
+
+    #2895: the single-row sibling of :func:`upsert_open_issues`.  The TUI
+    fetches one issue at a time (``gh issue view``) when the operator opens an
+    issue that isn't in the cache yet, and used to write it into ``coord.db``
+    through its own rusqlite connection.  It now POSTs here instead, so the
+    row lands in whichever engine the daemon owns.
+
+    Unlike :func:`upsert_open_issues` this does **not** mark the repo's other
+    issues closed — it is a targeted refresh of one row, not a sync.
+    ``issue`` needs ``number``; ``title``/``body``/``state``/``labels``/
+    ``milestone_number``/``milestone_title`` are optional.  ``labels`` accepts
+    either GitHub's ``[{"name": ...}]`` shape or a plain list of strings (what
+    the TUI sends).
+    """
+    svc = _board_service()
+    resp = _route_write(svc, "/issue-upsert", {"repo_name": repo_name, "issue": issue})
+    if resp is not None:
+        return
+    _upsert_issue_local(repo_name, issue)
+
+
+def _upsert_issue_local(repo_name: str, issue: dict) -> None:
+    """Backend adapter for :func:`upsert_issue` — writes the local DB."""
+    raw_labels = issue.get("labels") or []
+    labels = json.dumps(
+        [lbl["name"] if isinstance(lbl, dict) else str(lbl) for lbl in raw_labels]
+    )
+    conn = get_connection()
+    sql.execute(conn,
+        """
+        INSERT INTO issues (repo_name, number, title, body, state, labels, synced_at,
+                            milestone_number, milestone_title)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT (repo_name, number) DO UPDATE SET
+            title            = excluded.title,
+            body             = excluded.body,
+            state            = excluded.state,
+            labels           = excluded.labels,
+            synced_at        = excluded.synced_at,
+            milestone_number = excluded.milestone_number,
+            milestone_title  = excluded.milestone_title
+        """,
+        (
+            repo_name,
+            int(issue["number"]),
+            issue.get("title", "") or "",
+            issue.get("body", "") or "",
+            (issue.get("state") or "open").lower(),
+            labels,
+            time.time(),
+            issue.get("milestone_number"),
+            issue.get("milestone_title"),
+        ),
+    )
+    conn.commit()
+
+
 def _upsert_open_issues_local(repo_name: str, issues: list[dict]) -> None:
     """Persist open issues for a repo into the local issues table.
 
@@ -6769,24 +6828,74 @@ def issue_context_block(repo_name: str, issue_number: int) -> str:
 
 # ── Purge ──────────────────────────────────────────────────────────────────────
 
-def purge_done_assignments(older_than_days: float = 7.0) -> int:
-    """Delete old done/failed assignments and closed issues from the database.
+def count_purgeable(older_than_secs: float) -> tuple[int, int]:
+    """``(assignments, closed_issues)`` :func:`purge_done_assignments_split` would delete.
+
+    Routes to the daemon's ``POST /purge`` (``dry_run=True``) when
+    ``board_service`` is set, else counts against the local DB.  #2895: the
+    TUI's purge confirmation prompt reads this over HTTP — it no longer opens
+    ``coord.db`` itself — so the number it shows and the number it deletes
+    come from the same engine.
+    """
+    svc = _board_service()
+    resp = _route_write(
+        svc, "/purge", {"older_than_secs": older_than_secs, "dry_run": True}
+    )
+    if resp is not None:
+        return int(resp.get("assignments", 0)), int(resp.get("issues", 0))
+    return _count_purgeable_local(older_than_secs)
+
+
+def _count_purgeable_local(older_than_secs: float) -> tuple[int, int]:
+    """Backend adapter for :func:`count_purgeable` — counts, deletes nothing."""
+    cutoff = time.time() - older_than_secs
+    conn = get_connection()
+    assignments = sql.execute(conn,
+        "SELECT COUNT(*) FROM assignments "
+        "WHERE status IN ('done', 'failed') "
+        "AND finished_at IS NOT NULL "
+        "AND finished_at < ?",
+        (cutoff,),
+    ).fetchone()[0]
+    issues = sql.execute(conn,
+        "SELECT COUNT(*) FROM issues "
+        "WHERE state = 'closed' "
+        "AND synced_at IS NOT NULL "
+        "AND synced_at < ?",
+        (cutoff,),
+    ).fetchone()[0]
+    return int(assignments), int(issues)
+
+
+def purge_done_assignments_split(older_than_secs: float) -> tuple[int, int]:
+    """Delete old done/failed assignments + closed issues; return per-table counts.
+
+    Routes to the daemon's ``POST /purge`` when ``board_service`` is set, else
+    deletes from the local DB.  The per-table split (rather than
+    :func:`purge_done_assignments`'s single total) is what the TUI's purge
+    toast reports, so it matches the confirmation prompt fed by
+    :func:`count_purgeable`.
+    """
+    svc = _board_service()
+    resp = _route_write(
+        svc, "/purge", {"older_than_secs": older_than_secs, "dry_run": False}
+    )
+    if resp is not None:
+        return int(resp.get("assignments", 0)), int(resp.get("issues", 0))
+    return _purge_done_assignments_local(older_than_secs)
+
+
+def _purge_done_assignments_local(older_than_secs: float) -> tuple[int, int]:
+    """Backend adapter for :func:`purge_done_assignments_split`.
 
     Removes from two tables:
 
     * ``assignments`` — rows where ``status IN ('done', 'failed')`` and
-      ``finished_at < now - older_than_days * 86400``.
+      ``finished_at < now - older_than_secs``.
     * ``issues`` — rows where ``state = 'closed'`` and
-      ``synced_at < now - older_than_days * 86400``.
-
-    Returns the total number of rows deleted across both tables.
-
-    This is the Python-side equivalent of the TUI's 'P' purge action, which
-    performs the same DELETE directly via a short-lived Rust rusqlite
-    connection.  Exposed here so a future ``coord purge`` CLI command or
-    maintenance hook can call it without duplicating the SQL.
+      ``synced_at < now - older_than_secs``.
     """
-    cutoff = time.time() - older_than_days * 86_400
+    cutoff = time.time() - older_than_secs
     conn = get_connection()
     deleted_assignments = sql.execute(conn,
         "DELETE FROM assignments "
@@ -6809,4 +6918,16 @@ def purge_done_assignments(older_than_days: float = 7.0) -> int:
         "(SELECT repo_name, number FROM issues WHERE state = 'open')"
     )
     conn.commit()
-    return deleted_assignments + deleted_issues
+    return int(deleted_assignments), int(deleted_issues)
+
+
+def purge_done_assignments(older_than_days: float = 7.0) -> int:
+    """Total rows deleted by a purge older than *older_than_days* days.
+
+    Thin day-denominated wrapper over :func:`purge_done_assignments_split`
+    (which is seconds-denominated because that is the unit the TUI's Settings
+    retention field uses).  Kept so a future ``coord purge`` CLI command or
+    maintenance hook has the simple "how many rows went away" shape.
+    """
+    assignments, issues = purge_done_assignments_split(older_than_days * 86_400)
+    return assignments + issues

{code_coordinator-0.5.275 → code_coordinator-0.5.276}/tests/test_serve.py

@@ -8079,3 +8079,231 @@ def test_auto_drain_leaves_a_clean_sibling_alone(
     rows = {x.assignment_id: x for x in mq.load_queue()}
     assert rows["work-sib"].state == mq.PENDING
     assert rows["work-sib"].error is None
+
+
+# ── #2895: coord-tui's ex-SQLite writers as daemon routes ─────────────────────
+#
+# `POST /purge` and `POST /issue-upsert` replace the read-write rusqlite
+# connection coord-tui used to open against ~/.coord/coord.db (Settings →
+# purge, and the `gh issue view` cache refresh). The SQL predicates asserted
+# here were previously asserted in Rust, in `tui/src/app/tests.rs`, against an
+# in-memory SQLite fixture — they now live on this side of the seam, where
+# `coord/sql.py`'s dialect layer can carry them onto Postgres (#2894 Phase D).
+
+def _seed_purge_rows(conn) -> None:
+    """Two purgeable assignments, one too fresh, one running; plus issues."""
+    for aid, status, finished_at in [
+        ("old-done", "done", 100.0),
+        ("old-failed", "failed", 100.0),
+        ("fresh-done", "done", 500.0),
+        ("running", "running", 100.0),
+        ("no-finish", "done", None),
+    ]:
+        conn.execute(
+            "INSERT INTO assignments (assignment_id, machine_name, repo_name, "
+            "issue_number, issue_title, status, finished_at) VALUES (?,?,?,?,?,?,?)",
+            (aid, "laptop", "api", 1, "t", status, finished_at),
+        )
+    for number, state_, synced_at in [
+        (1, "closed", 100.0),
+        (2, "closed", 200.0),
+        (3, "closed", 500.0),   # too fresh
+        (4, "open", 100.0),     # open: never purged
+        (5, "closed", None),    # no synced_at: never purged
+    ]:
+        conn.execute(
+            "INSERT INTO issues (repo_name, number, title, state, labels, synced_at) "
+            "VALUES (?,?,?,?,?,?)",
+            ("api", number, "t", state_, "[]", synced_at),
+        )
+    conn.commit()
+
+
+def _purge(cli, *, older_than_secs: float, dry_run: bool):
+    return cli.post(
+        "/purge", json={"older_than_secs": older_than_secs, "dry_run": dry_run}
+    )
+
+
+def test_serve_purge_dry_run_counts_without_deleting(
+    file_db: Path, valid_config_path: Path, rw_db, monkeypatch
+):
+    _seed_purge_rows(rw_db)
+    # Freeze "now" so the cutoff lands at 300.0 with older_than_secs=200.
+    monkeypatch.setattr("coord.state.time.time", lambda: 500.0)
+    app = build_app(SqliteStore(file_db), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        resp = _purge(cli, older_than_secs=200.0, dry_run=True)
+    assert resp.status_code == 200
+    # done+failed older than the cutoff only: running excluded, fresh excluded,
+    # NULL finished_at excluded.  Issues: closed and old only.
+    assert resp.json() == {"assignments": 2, "issues": 2}
+    # Nothing actually deleted.
+    assert rw_db.execute("SELECT COUNT(*) c FROM assignments").fetchone()["c"] == 5
+    assert rw_db.execute("SELECT COUNT(*) c FROM issues").fetchone()["c"] == 5
+
+
+def test_serve_purge_deletes_exactly_what_the_dry_run_counted(
+    file_db: Path, valid_config_path: Path, rw_db, monkeypatch
+):
+    """The prompt and the toast must never disagree.
+
+    The TUI shows the dry-run number in its confirmation prompt and the delete
+    number in the completion toast; a drift between the two predicates is the
+    "confirmed Purge 3 rows, got 47 removed" bug this guards.
+    """
+    _seed_purge_rows(rw_db)
+    monkeypatch.setattr("coord.state.time.time", lambda: 500.0)
+    app = build_app(SqliteStore(file_db), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        counted = _purge(cli, older_than_secs=200.0, dry_run=True).json()
+        deleted = _purge(cli, older_than_secs=200.0, dry_run=False).json()
+    assert counted == deleted == {"assignments": 2, "issues": 2}
+    remaining = {
+        r["assignment_id"]
+        for r in rw_db.execute("SELECT assignment_id FROM assignments").fetchall()
+    }
+    assert remaining == {"fresh-done", "running", "no-finish"}
+    remaining_issues = {
+        r["number"] for r in rw_db.execute("SELECT number FROM issues").fetchall()
+    }
+    assert remaining_issues == {3, 4, 5}
+
+
+def test_serve_purge_rejects_bad_older_than_secs(
+    file_db: Path, valid_config_path: Path, rw_db
+):
+    app = build_app(SqliteStore(file_db), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        assert cli.post("/purge", json={}).status_code == 400
+        assert cli.post("/purge", json={"older_than_secs": "soon"}).status_code == 400
+        assert cli.post("/purge", json={"older_than_secs": -1}).status_code == 400
+
+
+def test_serve_issue_upsert_inserts_then_updates_one_row(
+    file_db: Path, valid_config_path: Path, rw_db
+):
+    app = build_app(SqliteStore(file_db), load_config(valid_config_path))
+    issue = {
+        "number": 42,
+        "title": "first title",
+        "body": "first body",
+        "state": "open",
+        "labels": ["coord"],
+        "milestone_number": 3,
+        "milestone_title": "ms-3",
+    }
+    with TestClient(app) as cli:
+        assert cli.post(
+            "/issue-upsert", json={"repo_name": "api", "issue": issue}
+        ).status_code == 200
+        row = rw_db.execute(
+            "SELECT title, body, state, labels, milestone_title FROM issues "
+            "WHERE repo_name='api' AND number=42"
+        ).fetchone()
+        assert row["title"] == "first title"
+        assert row["state"] == "open"
+        assert json.loads(row["labels"]) == ["coord"]
+        assert row["milestone_title"] == "ms-3"
+
+        # Second POST for the same (repo, number) updates in place.
+        issue["title"] = "second title"
+        issue["state"] = "closed"
+        assert cli.post(
+            "/issue-upsert", json={"repo_name": "api", "issue": issue}
+        ).status_code == 200
+    rows = rw_db.execute(
+        "SELECT title, state FROM issues WHERE repo_name='api' AND number=42"
+    ).fetchall()
+    assert len(rows) == 1, "upsert must not duplicate the row"
+    assert rows[0]["title"] == "second title" and rows[0]["state"] == "closed"
+
+
+def test_serve_issue_upsert_does_not_close_sibling_issues(
+    file_db: Path, valid_config_path: Path, rw_db
+):
+    """Unlike /issues-sync, a single-row upsert is a refresh, not a sync.
+
+    /issues-sync marks every other issue in the repo closed before upserting
+    the fetched set.  The TUI's `gh issue view` refresh fetches exactly ONE
+    issue, so routing it through that endpoint would have closed the entire
+    rest of the board's backlog.
+    """
+    rw_db.execute(
+        "INSERT INTO issues (repo_name, number, title, state, labels, synced_at) "
+        "VALUES ('api', 7, 'sibling', 'open', '[]', 1.0)"
+    )
+    rw_db.commit()
+    app = build_app(SqliteStore(file_db), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        assert cli.post(
+            "/issue-upsert",
+            json={"repo_name": "api", "issue": {"number": 42, "title": "new"}},
+        ).status_code == 200
+    sibling = rw_db.execute("SELECT state FROM issues WHERE number=7").fetchone()
+    assert sibling["state"] == "open", "the sibling must be untouched"
+
+
+def test_serve_issue_upsert_rejects_missing_number(
+    file_db: Path, valid_config_path: Path, rw_db
+):
+    app = build_app(SqliteStore(file_db), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        assert cli.post("/issue-upsert", json={"repo_name": "api"}).status_code == 400
+        assert cli.post(
+            "/issue-upsert", json={"repo_name": "api", "issue": {"title": "x"}}
+        ).status_code == 400
+
+
+def test_purge_routes_to_daemon_when_service_set(coord_db, monkeypatch):
+    from coord import client as cc
+    from coord import state
+
+    _seed_purge_rows(coord_db)
+    monkeypatch.setattr(
+        cc, "resolve_board_service", lambda *a, **k: cc.ServiceConfig("http://d:7435")
+    )
+    captured: list = []
+    monkeypatch.setattr(
+        cc, "post_record",
+        lambda svc, path, payload, **kw: captured.append((path, payload))
+        or {"assignments": 9, "issues": 4},
+    )
+    assert state.count_purgeable(600.0) == (9, 4)
+    assert state.purge_done_assignments_split(600.0) == (9, 4)
+    assert [p for p, _ in captured] == ["/purge", "/purge"]
+    assert captured[0][1]["dry_run"] is True
+    assert captured[1][1]["dry_run"] is False
+    # Routed → the thin client's own (wrong) DB is left completely alone.
+    assert coord_db.execute("SELECT COUNT(*) c FROM assignments").fetchone()["c"] == 5
+
+
+def test_upsert_issue_routes_to_daemon_when_service_set(coord_db, monkeypatch):
+    from coord import client as cc
+    from coord import state
+
+    monkeypatch.setattr(
+        cc, "resolve_board_service", lambda *a, **k: cc.ServiceConfig("http://d:7435")
+    )
+    captured: dict = {}
+    monkeypatch.setattr(
+        cc, "post_record",
+        lambda svc, path, payload, **kw: captured.update(path=path, payload=payload)
+        or {"ok": True},
+    )
+    state.upsert_issue("api", {"number": 42, "title": "t"})
+    assert captured["path"] == "/issue-upsert"
+    assert captured["payload"]["issue"]["number"] == 42
+    assert coord_db.execute("SELECT COUNT(*) c FROM issues").fetchone()["c"] == 0
+
+
+def test_upsert_issue_local_accepts_github_and_plain_label_shapes(coord_db):
+    from coord import state
+
+    state._upsert_issue_local("api", {"number": 1, "labels": [{"name": "coord"}]})
+    state._upsert_issue_local("api", {"number": 2, "labels": ["coord"]})
+    rows = {
+        r["number"]: json.loads(r["labels"])
+        for r in coord_db.execute("SELECT number, labels FROM issues").fetchall()
+    }
+    assert rows == {1: ["coord"], 2: ["coord"]}