Release 0.5.0: PR-less per-RFC discussion (contribution still requires PR)
Roadmap item #3. An RFC's main view now carries a discussion surface distinct from PR comments and from branch chat. The substrate is the existing threads/thread_messages tables — rows with branch_name IS NULL scope to the RFC's main view; the schema already permitted that shape, v0.5.0 is the first build to write it. Five new endpoints under /api/rfcs/<slug>/discussion/..., a new RFCDiscussionPanel right-column component used when branchParam === main, SPEC §10.10 settling discussion-vs-contribution, and §17 listing the new routes. Notification routing reuses the existing chat_message_in_participated_thread / chat_reply_to_my_message event kinds with branch_name=null on the fan-out row; a distinct event_kind is a §19.2 candidate. Anonymous viewers can read; writes require contributor — v0.6.0's item #4 will harden adjacent gates. No schema migration; minor bump, no operator action required beyond rebuild and restart. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ben Stull
@@ -20,6 +20,7 @@ from pydantic import BaseModel, Field
|
||||
from . import (
|
||||
api_admin,
|
||||
api_branches,
|
||||
api_discussion,
|
||||
api_graduation,
|
||||
api_notifications,
|
||||
api_prs,
|
||||
@@ -81,6 +82,12 @@ def make_router(
|
||||
# the §15.8 mute typeahead) and the §6/§17 admin surfaces
|
||||
# (role, write-mute, audit-log, graduation-readiness queue).
|
||||
router.include_router(api_admin.make_router(config))
|
||||
# v0.5.0: §5 / §7 / §10 — PR-less per-RFC discussion endpoints.
|
||||
# The substrate is the existing threads/thread_messages tables;
|
||||
# rows whose branch_name IS NULL scope to the RFC's main view.
|
||||
# Contribution still requires a PR (api_prs above); this surface
|
||||
# is for discussion that does not yet warrant a branch.
|
||||
router.include_router(api_discussion.make_router())
|
||||
|
||||
# ---------------------------------------------------------------
|
||||
# §17: /api/health — unauthenticated post-flight probe.
|
||||
|
||||
@@ -0,0 +1,330 @@
|
||||
"""§5 / §7 / §10 — PR-less per-RFC discussion endpoints (v0.5.0).
|
||||
|
||||
This module surfaces the discussion-without-PR shape committed by the
|
||||
roadmap's item #3. The substrate is the existing `threads` /
|
||||
`thread_messages` pair from §5: rows whose `branch_name` is NULL are
|
||||
scoped to the RFC's main view (the schema comment on the column says
|
||||
exactly this; until now no write path produced such rows). This module
|
||||
is the read+write surface for those rows.
|
||||
|
||||
Contribution still requires a PR: the §10 PR flow is unchanged, the
|
||||
branch-scoped chat in `api_branches.py` is unchanged, and accept /
|
||||
decline of AI `<change>` blocks still lives on a branch. What this
|
||||
module adds is the "discuss freely about the RFC, no branch yet" surface
|
||||
— a place to drop a question, a flag-style observation, or a multi-turn
|
||||
conversation that does not yet warrant cutting a branch.
|
||||
|
||||
Auth shape mirrors the v0.3.0 anonymous-read contract: reads are open,
|
||||
writes require `auth.require_contributor`. Item #4 ("anon discuss/
|
||||
contribute off-limits") tightens the read gate in v0.6.0; v0.5.0's
|
||||
write gate already holds the line.
|
||||
|
||||
Notification routing reuses the existing `fan_out_chat_message` path
|
||||
with `branch_name=None`; the `notifications.branch_name` column is
|
||||
nullable, and the inbox row prose ("@alice posted a chat message on
|
||||
<RFC title>") renders identically whether the chat lives on a branch
|
||||
or on the RFC's discussion surface. The existing
|
||||
`chat_message_in_participated_thread` / `chat_reply_to_my_message`
|
||||
event kinds carry both shapes; introducing a parallel
|
||||
`open_rfc_discussion_thread` / `post_rfc_discussion_message` enum pair
|
||||
would split routing without adding signal. The §15 §19.2 candidate
|
||||
"distinct event_kinds for PR-less discussion" notes the option for a
|
||||
future session if evidence demands the split.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from . import auth, chat as chat_layer, db
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Request bodies
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class DiscussionThreadCreateBody(BaseModel):
|
||||
"""A discussion thread is a `thread_kind='chat'`, `anchor_kind='whole-doc'`,
|
||||
`branch_name=NULL` row. Anchored-range / per-paragraph threads on the
|
||||
RFC discussion surface are a §19.2 candidate — the schema supports
|
||||
them; the UI work to surface a range-anchor on a non-branch view is
|
||||
the deferred part. v0.5.0 keeps the shape narrow."""
|
||||
label: str | None = Field(default=None, max_length=400)
|
||||
message: str | None = Field(default=None, max_length=20_000)
|
||||
|
||||
|
||||
class DiscussionMessageBody(BaseModel):
|
||||
text: str = Field(min_length=1, max_length=20_000)
|
||||
quote: str | None = Field(default=None, max_length=2000)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Router
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def make_router() -> APIRouter:
|
||||
router = APIRouter()
|
||||
|
||||
# -------------------------------------------------------------------
|
||||
# GET /api/rfcs/<slug>/discussion/threads
|
||||
# Lists every PR-less thread on the RFC. The default whole-doc thread
|
||||
# is materialized lazily on first list (mirroring the §8.12 branch-
|
||||
# chat default-thread treatment) so the UI always has a target for
|
||||
# the compose-message affordance.
|
||||
# -------------------------------------------------------------------
|
||||
|
||||
@router.get("/api/rfcs/{slug}/discussion/threads")
|
||||
async def list_discussion_threads(slug: str, request: Request) -> dict[str, Any]:
|
||||
viewer = auth.current_user(request)
|
||||
_require_rfc_readable(slug)
|
||||
# Ensure the default whole-doc discussion thread exists. We mint
|
||||
# it on first read regardless of viewer (anonymous viewers can
|
||||
# trigger the creation — the row's `created_by` is null in that
|
||||
# case, mirroring `_ensure_branch_chat_thread`).
|
||||
_ensure_discussion_thread(slug, viewer)
|
||||
rows = db.conn().execute(
|
||||
"""
|
||||
SELECT id, anchor_kind, anchor_payload, thread_kind, label, state,
|
||||
created_by, created_at, resolved_at, resolved_by
|
||||
FROM threads
|
||||
WHERE rfc_slug = ? AND branch_name IS NULL
|
||||
ORDER BY id
|
||||
""",
|
||||
(slug,),
|
||||
).fetchall()
|
||||
return {"items": [_serialize_thread(r) for r in rows]}
|
||||
|
||||
# -------------------------------------------------------------------
|
||||
# POST /api/rfcs/<slug>/discussion/threads
|
||||
# Open a fresh discussion thread. Writes require require_contributor
|
||||
# — anonymous viewers can read but cannot open a thread, per item
|
||||
# #4's hardening anticipated in v0.6.0 (we already enforce it here
|
||||
# to avoid the open window).
|
||||
# -------------------------------------------------------------------
|
||||
|
||||
@router.post("/api/rfcs/{slug}/discussion/threads")
|
||||
async def create_discussion_thread(
|
||||
slug: str, body: DiscussionThreadCreateBody, request: Request
|
||||
) -> dict[str, Any]:
|
||||
viewer = auth.require_contributor(request)
|
||||
_require_rfc_readable(slug)
|
||||
cur = db.conn().execute(
|
||||
"""
|
||||
INSERT INTO threads
|
||||
(rfc_slug, branch_name, anchor_kind, anchor_payload,
|
||||
thread_kind, label, created_by)
|
||||
VALUES (?, NULL, 'whole-doc', NULL, 'chat', ?, ?)
|
||||
""",
|
||||
(slug, body.label, viewer.user_id),
|
||||
)
|
||||
thread_id = cur.lastrowid
|
||||
message_id = None
|
||||
if body.message:
|
||||
message_id = chat_layer.append_user_message(
|
||||
thread_id=thread_id,
|
||||
author_user_id=viewer.user_id,
|
||||
text=body.message,
|
||||
quote=None,
|
||||
)
|
||||
return {"thread_id": thread_id, "message_id": message_id}
|
||||
|
||||
# -------------------------------------------------------------------
|
||||
# GET /api/rfcs/<slug>/discussion/threads/<thread_id>/messages
|
||||
# -------------------------------------------------------------------
|
||||
|
||||
@router.get("/api/rfcs/{slug}/discussion/threads/{thread_id}/messages")
|
||||
async def get_discussion_thread_messages(
|
||||
slug: str, thread_id: int, request: Request
|
||||
) -> dict[str, Any]:
|
||||
_viewer = auth.current_user(request)
|
||||
_require_rfc_readable(slug)
|
||||
thread = _require_discussion_thread(slug, thread_id)
|
||||
rows = db.conn().execute(
|
||||
"""
|
||||
SELECT m.id, m.role, m.author_user_id,
|
||||
u.gitea_login AS author_login,
|
||||
u.display_name AS author_display,
|
||||
m.model_id, m.text, m.quote, m.created_at
|
||||
FROM thread_messages m
|
||||
LEFT JOIN users u ON u.id = m.author_user_id
|
||||
WHERE m.thread_id = ?
|
||||
ORDER BY m.id
|
||||
""",
|
||||
(thread_id,),
|
||||
).fetchall()
|
||||
return {
|
||||
"thread": _serialize_thread(thread),
|
||||
"messages": [_serialize_message(r) for r in rows],
|
||||
}
|
||||
|
||||
# -------------------------------------------------------------------
|
||||
# POST /api/rfcs/<slug>/discussion/threads/<thread_id>/messages
|
||||
# -------------------------------------------------------------------
|
||||
|
||||
@router.post("/api/rfcs/{slug}/discussion/threads/{thread_id}/messages")
|
||||
async def post_discussion_message(
|
||||
slug: str, thread_id: int, body: DiscussionMessageBody, request: Request
|
||||
) -> dict[str, Any]:
|
||||
viewer = auth.require_contributor(request)
|
||||
_require_rfc_readable(slug)
|
||||
_require_discussion_thread(slug, thread_id)
|
||||
message_id = chat_layer.append_user_message(
|
||||
thread_id=thread_id,
|
||||
author_user_id=viewer.user_id,
|
||||
text=body.text,
|
||||
quote=body.quote,
|
||||
)
|
||||
return {"ok": True, "message_id": message_id}
|
||||
|
||||
# -------------------------------------------------------------------
|
||||
# POST /api/rfcs/<slug>/discussion/threads/<thread_id>/resolve
|
||||
# -------------------------------------------------------------------
|
||||
|
||||
@router.post("/api/rfcs/{slug}/discussion/threads/{thread_id}/resolve")
|
||||
async def resolve_discussion_thread(
|
||||
slug: str, thread_id: int, request: Request
|
||||
) -> dict[str, Any]:
|
||||
viewer = auth.require_contributor(request)
|
||||
rfc = _require_rfc_readable(slug)
|
||||
thread = _require_discussion_thread(slug, thread_id)
|
||||
if not _can_resolve(rfc, thread, viewer):
|
||||
raise HTTPException(
|
||||
403,
|
||||
"Only the thread creator, an RFC owner/arbiter, or an app admin/owner may resolve",
|
||||
)
|
||||
db.conn().execute(
|
||||
"""
|
||||
UPDATE threads
|
||||
SET state = 'resolved',
|
||||
resolved_by = ?,
|
||||
resolved_at = datetime('now')
|
||||
WHERE id = ?
|
||||
""",
|
||||
(viewer.user_id, thread_id),
|
||||
)
|
||||
return {"ok": True, "thread_id": thread_id}
|
||||
|
||||
return router
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _require_rfc_readable(slug: str):
|
||||
"""Per the v0.3.0 anonymous-read contract: any cached RFC is readable
|
||||
by anyone. Withdrawn entries refuse reads of every shape — same rule
|
||||
`_require_rfc_with_repo` in `api_branches.py` follows."""
|
||||
row = db.conn().execute(
|
||||
"SELECT * FROM cached_rfcs WHERE slug = ?", (slug,)
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise HTTPException(404, "RFC not found")
|
||||
if row["state"] == "withdrawn":
|
||||
raise HTTPException(409, "RFC is withdrawn")
|
||||
return row
|
||||
|
||||
|
||||
def _require_discussion_thread(slug: str, thread_id: int):
|
||||
"""A discussion thread is one whose (rfc_slug, branch_name) = (slug,
|
||||
NULL). Refuse cleanly if the thread id resolves to a branch-scoped
|
||||
thread instead — that lookup belongs on the branch endpoints."""
|
||||
row = db.conn().execute(
|
||||
"""
|
||||
SELECT * FROM threads
|
||||
WHERE id = ? AND rfc_slug = ? AND branch_name IS NULL
|
||||
""",
|
||||
(thread_id, slug),
|
||||
).fetchone()
|
||||
if not row:
|
||||
raise HTTPException(404, "Discussion thread not found")
|
||||
return row
|
||||
|
||||
|
||||
def _ensure_discussion_thread(slug: str, viewer) -> int:
|
||||
"""Per the §8.12 lazy-create pattern, materialize a default whole-doc
|
||||
chat thread on the RFC's discussion surface on first read. Created_by
|
||||
is null when an anonymous viewer triggers creation — the thread is
|
||||
structurally owned by the RFC, not by whoever opened the view."""
|
||||
row = db.conn().execute(
|
||||
"""
|
||||
SELECT id FROM threads
|
||||
WHERE rfc_slug = ? AND branch_name IS NULL
|
||||
AND anchor_kind = 'whole-doc' AND thread_kind = 'chat'
|
||||
ORDER BY id LIMIT 1
|
||||
""",
|
||||
(slug,),
|
||||
).fetchone()
|
||||
if row:
|
||||
return row["id"]
|
||||
cur = db.conn().execute(
|
||||
"""
|
||||
INSERT INTO threads
|
||||
(rfc_slug, branch_name, anchor_kind, thread_kind, label, created_by)
|
||||
VALUES (?, NULL, 'whole-doc', 'chat', NULL, ?)
|
||||
""",
|
||||
(slug, viewer.user_id if viewer else None),
|
||||
)
|
||||
return cur.lastrowid
|
||||
|
||||
|
||||
def _can_resolve(rfc, thread, viewer) -> bool:
|
||||
if viewer is None:
|
||||
return False
|
||||
if viewer.role in ("owner", "admin"):
|
||||
return True
|
||||
owners = json.loads(rfc["owners_json"] or "[]")
|
||||
arbiters = json.loads(rfc["arbiters_json"] or "[]")
|
||||
if viewer.gitea_login in owners or viewer.gitea_login in arbiters:
|
||||
return True
|
||||
if thread["created_by"] == viewer.user_id:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Serializers — mirror api_branches.py's shape
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _serialize_thread(row) -> dict[str, Any]:
|
||||
payload = row["anchor_payload"]
|
||||
try:
|
||||
anchor = json.loads(payload) if payload else None
|
||||
except Exception:
|
||||
anchor = None
|
||||
return {
|
||||
"id": row["id"],
|
||||
"anchor_kind": row["anchor_kind"],
|
||||
"anchor_payload": anchor,
|
||||
"thread_kind": row["thread_kind"],
|
||||
"label": row["label"],
|
||||
"state": row["state"],
|
||||
"created_by": row["created_by"],
|
||||
"created_at": row["created_at"],
|
||||
"resolved_at": row["resolved_at"] if "resolved_at" in row.keys() else None,
|
||||
"resolved_by": row["resolved_by"] if "resolved_by" in row.keys() else None,
|
||||
}
|
||||
|
||||
|
||||
def _serialize_message(row) -> dict[str, Any]:
|
||||
return {
|
||||
"id": row["id"],
|
||||
"role": row["role"],
|
||||
"author_user_id": row["author_user_id"],
|
||||
"author_login": row["author_login"],
|
||||
"author_display": row["author_display"],
|
||||
"model_id": row["model_id"],
|
||||
"text": row["text"],
|
||||
"quote": row["quote"],
|
||||
"created_at": row["created_at"],
|
||||
}
|
||||
+6
-1
@@ -168,10 +168,15 @@ def _fan_out_chat(thread_id: int, author_user_id: int, message_id: int) -> None:
|
||||
).fetchone()
|
||||
if pr_row:
|
||||
pr_number = pr_row["pr_number"]
|
||||
# v0.5.0 (§5 / §10 — PR-less discussion): a thread with
|
||||
# branch_name IS NULL is scoped to the RFC's main view. Pass None
|
||||
# through to the notify chokepoint so the notifications row keeps
|
||||
# `branch_name` null — coercing it to "main" would misroute the
|
||||
# §15.7 chat-seen reconciler (which keys on branch_name).
|
||||
notify.fan_out_chat_message(
|
||||
actor_user_id=author_user_id,
|
||||
rfc_slug=row["rfc_slug"],
|
||||
branch_name=row["branch_name"] or "main",
|
||||
branch_name=row["branch_name"],
|
||||
thread_id=thread_id,
|
||||
message_id=message_id,
|
||||
is_review_thread=(row["thread_kind"] == "review"),
|
||||
|
||||
@@ -212,7 +212,7 @@ def fan_out_chat_message(
|
||||
*,
|
||||
actor_user_id: int,
|
||||
rfc_slug: str,
|
||||
branch_name: str,
|
||||
branch_name: str | None,
|
||||
thread_id: int,
|
||||
message_id: int,
|
||||
is_review_thread: bool = False,
|
||||
@@ -227,6 +227,14 @@ def fan_out_chat_message(
|
||||
(state='watching', i.e. full stream) get a churn-class
|
||||
`chat_message_in_participated_thread`. The two are union'd so a user
|
||||
who is both gets only the personal-direct row.
|
||||
|
||||
v0.5.0: `branch_name` may be None — that is the PR-less per-RFC
|
||||
discussion shape (`threads.branch_name IS NULL`, §5). The
|
||||
notifications row carries the null through; the inbox prose renders
|
||||
identically whether the chat lives on a branch or on the RFC's
|
||||
discussion surface, and the §15.7 reconciler keys on
|
||||
(rfc_slug, branch_name) so a null branch correctly matches the
|
||||
PR-less discussion's eventual chat-seen-equivalent advance.
|
||||
"""
|
||||
_bump_auto_watch(actor_user_id, rfc_slug)
|
||||
|
||||
|
||||
@@ -0,0 +1,237 @@
|
||||
"""End-to-end integration tests for the v0.5.0 PR-less discussion
|
||||
surface — roadmap item #3, "discussion without PR; contribution requires
|
||||
PR."
|
||||
|
||||
The vertical: an active RFC exists; the discussion endpoints under
|
||||
`/api/rfcs/<slug>/discussion/...` open threads with
|
||||
`threads.branch_name IS NULL`, post messages into them, and surface
|
||||
them on subsequent reads. Branch-scoped threads (the §8.12 surface)
|
||||
remain segregated. Anonymous viewers can read; only signed-in
|
||||
contributors can write.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
# Reuse the harness from Slice 1 / Slice 2.
|
||||
from test_propose_vertical import ( # noqa: F401 — fixtures land via import
|
||||
FakeGitea,
|
||||
app_with_fake_gitea,
|
||||
provision_user_row,
|
||||
sign_in_as,
|
||||
tmp_env,
|
||||
)
|
||||
from test_rfc_view_vertical import seed_active_rfc, SEED_BODY
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_create_and_post_to_pr_less_discussion_thread(app_with_fake_gitea):
|
||||
"""The vertical: signed-in contributor opens a thread on the RFC's
|
||||
discussion surface, posts a message, and the thread + message
|
||||
surface on subsequent reads with branch_name IS NULL."""
|
||||
from fastapi.testclient import TestClient
|
||||
from app import db
|
||||
|
||||
app, fake = app_with_fake_gitea
|
||||
with TestClient(app) as client:
|
||||
provision_user_row(user_id=1, login="alice", role="contributor")
|
||||
seed_active_rfc(fake, slug="ohm", title="OHM", body=SEED_BODY)
|
||||
sign_in_as(client, user_id=1, gitea_login="alice", display_name="Alice", role="contributor")
|
||||
|
||||
# Listing materializes the default whole-doc thread.
|
||||
r = client.get("/api/rfcs/ohm/discussion/threads")
|
||||
assert r.status_code == 200, r.text
|
||||
items = r.json()["items"]
|
||||
assert len(items) == 1
|
||||
default_thread_id = items[0]["id"]
|
||||
assert items[0]["anchor_kind"] == "whole-doc"
|
||||
assert items[0]["thread_kind"] == "chat"
|
||||
|
||||
# Open an additional discussion thread with a first message.
|
||||
r = client.post(
|
||||
"/api/rfcs/ohm/discussion/threads",
|
||||
json={"label": "Question about §3", "message": "Is consent baked into the trait model?"},
|
||||
)
|
||||
assert r.status_code == 200, r.text
|
||||
payload = r.json()
|
||||
thread_id = payload["thread_id"]
|
||||
message_id = payload["message_id"]
|
||||
assert thread_id is not None and message_id is not None
|
||||
|
||||
# Confirm the row carries branch_name IS NULL (the PR-less shape).
|
||||
row = db.conn().execute(
|
||||
"SELECT rfc_slug, branch_name, thread_kind, anchor_kind, created_by FROM threads WHERE id = ?",
|
||||
(thread_id,),
|
||||
).fetchone()
|
||||
assert row["rfc_slug"] == "ohm"
|
||||
assert row["branch_name"] is None
|
||||
assert row["thread_kind"] == "chat"
|
||||
assert row["anchor_kind"] == "whole-doc"
|
||||
assert row["created_by"] == 1
|
||||
|
||||
# The thread surfaces on the list endpoint alongside the default.
|
||||
r = client.get("/api/rfcs/ohm/discussion/threads")
|
||||
ids = [t["id"] for t in r.json()["items"]]
|
||||
assert default_thread_id in ids
|
||||
assert thread_id in ids
|
||||
|
||||
# Posting a reply on the new thread persists and returns the id.
|
||||
r = client.post(
|
||||
f"/api/rfcs/ohm/discussion/threads/{thread_id}/messages",
|
||||
json={"text": "Following up — see §3.2."},
|
||||
)
|
||||
assert r.status_code == 200, r.text
|
||||
reply_id = r.json()["message_id"]
|
||||
|
||||
# The messages read endpoint returns both messages in order.
|
||||
r = client.get(f"/api/rfcs/ohm/discussion/threads/{thread_id}/messages")
|
||||
assert r.status_code == 200
|
||||
messages = r.json()["messages"]
|
||||
assert [m["id"] for m in messages] == [message_id, reply_id]
|
||||
assert messages[0]["author_login"] == "alice"
|
||||
assert messages[0]["text"].startswith("Is consent")
|
||||
|
||||
|
||||
def test_anonymous_can_read_but_cannot_post_discussion(app_with_fake_gitea):
|
||||
"""Per the v0.3.0 anonymous-read contract: reads on the discussion
|
||||
surface are open; write attempts return 401. v0.6.0 (item #4) will
|
||||
tighten the read gate — v0.5.0 holds the write line so there is no
|
||||
open window between releases."""
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
app, fake = app_with_fake_gitea
|
||||
with TestClient(app) as client:
|
||||
provision_user_row(user_id=2, login="alice", role="contributor")
|
||||
seed_active_rfc(fake, slug="ohm", title="OHM", body=SEED_BODY)
|
||||
|
||||
# Seed the discussion thread + first message as Alice.
|
||||
sign_in_as(client, user_id=2, gitea_login="alice", display_name="Alice", role="contributor")
|
||||
r = client.post(
|
||||
"/api/rfcs/ohm/discussion/threads",
|
||||
json={"message": "First."},
|
||||
)
|
||||
assert r.status_code == 200
|
||||
thread_id = r.json()["thread_id"]
|
||||
|
||||
# Drop the session — viewer is anonymous now.
|
||||
client.cookies.clear()
|
||||
|
||||
# Reads are open.
|
||||
r = client.get("/api/rfcs/ohm/discussion/threads")
|
||||
assert r.status_code == 200
|
||||
assert any(t["id"] == thread_id for t in r.json()["items"])
|
||||
|
||||
r = client.get(f"/api/rfcs/ohm/discussion/threads/{thread_id}/messages")
|
||||
assert r.status_code == 200
|
||||
assert len(r.json()["messages"]) >= 1
|
||||
|
||||
# Writes refuse 401.
|
||||
r = client.post(
|
||||
"/api/rfcs/ohm/discussion/threads",
|
||||
json={"message": "Drive-by."},
|
||||
)
|
||||
assert r.status_code == 401
|
||||
|
||||
r = client.post(
|
||||
f"/api/rfcs/ohm/discussion/threads/{thread_id}/messages",
|
||||
json={"text": "Drive-by reply."},
|
||||
)
|
||||
assert r.status_code == 401
|
||||
|
||||
|
||||
def test_discussion_threads_and_branch_threads_are_segregated(app_with_fake_gitea):
|
||||
"""A branch-scoped thread (the §8.12 surface, branch_name='main' or a
|
||||
feature branch) MUST NOT surface on the discussion endpoint, which
|
||||
is keyed on branch_name IS NULL. The two surfaces share a table; the
|
||||
null-filter is what segregates them."""
|
||||
from fastapi.testclient import TestClient
|
||||
from app import db
|
||||
|
||||
app, fake = app_with_fake_gitea
|
||||
with TestClient(app) as client:
|
||||
provision_user_row(user_id=3, login="alice", role="contributor")
|
||||
seed_active_rfc(fake, slug="ohm", title="OHM", body=SEED_BODY)
|
||||
sign_in_as(client, user_id=3, gitea_login="alice", display_name="Alice", role="contributor")
|
||||
|
||||
# Manually materialize a branch-scoped thread on a feature branch.
|
||||
db.conn().execute(
|
||||
"""
|
||||
INSERT INTO threads
|
||||
(rfc_slug, branch_name, anchor_kind, thread_kind, label, created_by)
|
||||
VALUES ('ohm', 'alice-draft-aa00', 'whole-doc', 'chat', NULL, 3)
|
||||
"""
|
||||
)
|
||||
# And one on the discussion surface.
|
||||
r = client.post(
|
||||
"/api/rfcs/ohm/discussion/threads",
|
||||
json={"message": "Discussion-surface message."},
|
||||
)
|
||||
assert r.status_code == 200
|
||||
discussion_thread_id = r.json()["thread_id"]
|
||||
|
||||
# The discussion list contains the null-branch thread (plus the
|
||||
# default whole-doc) and excludes the feature-branch thread.
|
||||
r = client.get("/api/rfcs/ohm/discussion/threads")
|
||||
assert r.status_code == 200
|
||||
ids = [t["id"] for t in r.json()["items"]]
|
||||
assert discussion_thread_id in ids
|
||||
# Feature-branch thread MUST NOT surface.
|
||||
branch_thread_row = db.conn().execute(
|
||||
"SELECT id FROM threads WHERE branch_name = 'alice-draft-aa00'"
|
||||
).fetchone()
|
||||
assert branch_thread_row is not None
|
||||
assert branch_thread_row["id"] not in ids
|
||||
|
||||
|
||||
def test_discussion_thread_resolve_permissions(app_with_fake_gitea):
|
||||
"""A thread's creator can resolve it; an unrelated contributor cannot;
|
||||
an admin / owner / RFC-owner can. Mirrors §8.12's resolution rule for
|
||||
branch-scoped threads."""
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
app, fake = app_with_fake_gitea
|
||||
with TestClient(app) as client:
|
||||
provision_user_row(user_id=4, login="alice", role="contributor")
|
||||
provision_user_row(user_id=5, login="bob", role="contributor")
|
||||
provision_user_row(user_id=6, login="ben", role="owner")
|
||||
seed_active_rfc(fake, slug="ohm", title="OHM", body=SEED_BODY)
|
||||
|
||||
sign_in_as(client, user_id=4, gitea_login="alice", display_name="Alice", role="contributor")
|
||||
r = client.post(
|
||||
"/api/rfcs/ohm/discussion/threads",
|
||||
json={"label": "Alice's thread", "message": "..."},
|
||||
)
|
||||
thread_id = r.json()["thread_id"]
|
||||
|
||||
# Unrelated contributor refused.
|
||||
sign_in_as(client, user_id=5, gitea_login="bob", display_name="Bob", role="contributor")
|
||||
r = client.post(f"/api/rfcs/ohm/discussion/threads/{thread_id}/resolve")
|
||||
assert r.status_code == 403
|
||||
|
||||
# Creator allowed.
|
||||
sign_in_as(client, user_id=4, gitea_login="alice", display_name="Alice", role="contributor")
|
||||
r = client.post(f"/api/rfcs/ohm/discussion/threads/{thread_id}/resolve")
|
||||
assert r.status_code == 200
|
||||
|
||||
# Open another thread, resolve it as the owner.
|
||||
r = client.post(
|
||||
"/api/rfcs/ohm/discussion/threads",
|
||||
json={"label": "Another thread", "message": "..."},
|
||||
)
|
||||
thread_id2 = r.json()["thread_id"]
|
||||
sign_in_as(client, user_id=6, gitea_login="ben", display_name="Ben", role="owner")
|
||||
r = client.post(f"/api/rfcs/ohm/discussion/threads/{thread_id2}/resolve")
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_discussion_404_on_unknown_rfc(app_with_fake_gitea):
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
app, _fake = app_with_fake_gitea
|
||||
with TestClient(app) as client:
|
||||
r = client.get("/api/rfcs/nonexistent/discussion/threads")
|
||||
assert r.status_code == 404
|
||||
Reference in New Issue
Block a user