gabriel / musehub public
test_rest_strict_inputs_311.py python
302 lines 14.4 KB
Raw
sha256:8142f1f2556a271f60c48e1e5c43f8d47fa28e6ac888651ce5cbc48211628ce8 fix(rest): strict REST inputs — unknown body fields and lis… Opus 5.5 minor ⚠ breaking 1 day ago
1 """musehub#311: REST inputs are strict — nothing a caller sends is silently ignored.
2
3 Owner decision (2026-11-15):
4
5 1. An unknown body field on a REST request model is a ``422`` whose error names the field
6 (``extra="forbid"``; ``loc`` is ``["body", <field>]``). Both the camelCase wire name and the
7 snake_case Python name of a real field are still accepted.
8 2. An unknown query parameter on ``GET …/issues`` and ``GET …/releases`` is a ``422`` naming it
9 (``loc`` is ``["query", <name>]``); ``cursor``, ``limit`` and the ``_`` cache-buster still work.
10 The documented filters are real: ``?assignee=<handle>`` on issues, ``?channel=`` and ``?draft=``
11 on releases (draft releases are listed only to writers).
12 3. ``visibility`` is ``public`` or ``private`` on create and on the settings update.
13 4. A release ``tag`` must be SemVer (Muse's own ``vMAJOR.MINOR.PATCH[-pre][+build]`` rule).
14 5. Label names are unique per repository ignoring case: a case-only duplicate is ``409``.
15 """
16 from __future__ import annotations
17
18 import pytest
19 from httpx import AsyncClient
20 from sqlalchemy.ext.asyncio import AsyncSession
21
22 from tests.factories import create_issue, create_proposal, create_repo
23
24
25 def _extra(r_json: dict, where: str, name: str) -> bool:
26 return any(
27 e.get("type") == "extra_forbidden" and list(e.get("loc", [])) == [where, name]
28 for e in r_json.get("detail", [])
29 )
30
31
32 async def _repo(client: AsyncClient, headers: dict[str, str], name: str = "strict-311") -> str:
33 r = await client.post(
34 "/api/repos", json={"name": name, "owner": "testuser", "initialize": False}, headers=headers
35 )
36 assert r.status_code == 201, r.text
37 return str(r.json()["repoId"])
38
39
40 # ── 1. Unknown body fields ──────────────────────────────────────────────────
41
42
43 _STRICT_REQUEST_MODELS = [
44 ("musehub.models.musehub", name)
45 for name in (
46 "CreateRepoRequest", "RepoSettingsPatch", "ForkRepoRequest", "TransferOwnershipRequest",
47 "IssueCreate", "IssueUpdate", "IssueCommentCreate", "IssueAssignRequest", "IssueLabelAssignRequest",
48 "ProposalCreate", "ProposalUpdate", "ProposalMergeRequest", "ProposalCommentCreate",
49 "ProposalReviewCreate", "ProposalReviewerRequest", "ReleaseCreate", "ReleaseAssetCreate",
50 )
51 ] + [
52 ("musehub.api.routes.musehub.labels", n) for n in ("LabelCreate", "LabelUpdate", "AssignLabelsRequest")
53 ] + [
54 ("musehub.api.routes.musehub.collaborators", n) for n in ("CollaboratorInviteRequest", "CollaboratorPermissionUpdate")
55 ] + [("musehub.api.routes.musehub.topics", "SetTopicsRequest")]
56
57
58 @pytest.mark.parametrize("module,name", _STRICT_REQUEST_MODELS)
59 def test_rest_request_models_forbid_unknown_fields(module: str, name: str) -> None:
60 import importlib
61
62 model = getattr(importlib.import_module(module), name)
63 assert model.model_config.get("extra") == "forbid", name
64
65
66 def test_response_models_stay_lenient() -> None:
67 from musehub.models.musehub import IssueResponse, ReleaseResponse, RepoResponse
68
69 for m in (IssueResponse, ReleaseResponse, RepoResponse):
70 assert m.model_config.get("extra") != "forbid", m.__name__
71
72
73 def test_camel_and_snake_names_are_both_still_accepted() -> None:
74 from musehub.models.musehub import IssueCreate
75
76 a = IssueCreate.model_validate({"title": "t", "symbolAnchors": ["a.py::f"], "agentId": "x"})
77 b = IssueCreate.model_validate({"title": "t", "symbol_anchors": ["a.py::f"], "agent_id": "x"})
78 assert a == b
79
80
81 @pytest.mark.asyncio
82 @pytest.mark.parametrize("field", ["status", "state"])
83 async def test_issue_patch_with_a_state_field_is_422_and_the_issue_stays_open(
84 client: AsyncClient, auth_headers: dict[str, str], field: str
85 ) -> None:
86 rid = await _repo(client, auth_headers)
87 r = await client.post(f"/api/repos/{rid}/issues", json={"title": "x"}, headers=auth_headers)
88 assert r.status_code == 201, r.text
89 n = r.json()["number"]
90 r = await client.patch(f"/api/repos/{rid}/issues/{n}", json={field: "closed"}, headers=auth_headers)
91 assert r.status_code == 422, r.text
92 assert _extra(r.json(), "body", field), r.json()
93 assert (await client.get(f"/api/repos/{rid}/issues/{n}")).json()["state"] == "open"
94
95
96 @pytest.mark.asyncio
97 async def test_issue_create_with_assignees_is_422(client: AsyncClient, auth_headers: dict[str, str]) -> None:
98 rid = await _repo(client, auth_headers)
99 r = await client.post(
100 f"/api/repos/{rid}/issues", json={"title": "x", "assignees": ["testuser"]}, headers=auth_headers
101 )
102 assert r.status_code == 422, r.text
103 assert _extra(r.json(), "body", "assignees"), r.json()
104 assert (await client.get(f"/api/repos/{rid}/issues", params={"state": "all"})).json()["total"] == 0
105
106
107 @pytest.mark.asyncio
108 async def test_proposal_merge_with_strategy_is_422(
109 client: AsyncClient, auth_headers: dict[str, str], db_session: AsyncSession
110 ) -> None:
111 rid = await _repo(client, auth_headers)
112 proposal = await create_proposal(db_session, rid)
113 r = await client.post(
114 f"/api/repos/{rid}/proposals/{proposal.proposal_id}/merge", json={"strategy": "weave"}, headers=auth_headers
115 )
116 assert r.status_code == 422, r.text
117 assert _extra(r.json(), "body", "strategy"), r.json()
118
119
120 # ── 2. Query parameters on the issue and release lists ─────────────────────
121
122
123 @pytest.mark.asyncio
124 async def test_issue_list_assignee_filter_is_applied(
125 client: AsyncClient, auth_headers: dict[str, str]
126 ) -> None:
127 rid = await _repo(client, auth_headers)
128 numbers = []
129 for title in ("one", "two", "three"):
130 r = await client.post(f"/api/repos/{rid}/issues", json={"title": title}, headers=auth_headers)
131 numbers.append(r.json()["number"])
132 r = await client.post(f"/api/repos/{rid}/issues/{numbers[1]}/assign", json={"assignee": "alice"}, headers=auth_headers)
133 assert r.status_code == 200, r.text
134
135 r = await client.get(f"/api/repos/{rid}/issues", params={"assignee": "alice"})
136 assert r.status_code == 200, r.text
137 body = r.json()
138 assert [i["number"] for i in body["issues"]] == [numbers[1]] and body["total"] == 1
139 r = await client.get(f"/api/repos/{rid}/issues", params={"assignee": "nobody"})
140 assert r.json()["total"] == 0
141 assert (await client.get(f"/api/repos/{rid}/issues")).json()["total"] == 3
142
143
144 @pytest.mark.asyncio
145 @pytest.mark.parametrize("name", ["status", "per_page", "assignees", "sort"])
146 async def test_issue_list_unknown_query_parameter_is_422(
147 client: AsyncClient, db_session: AsyncSession, name: str
148 ) -> None:
149 repo = await create_repo(db_session, owner="strictq", slug="strict-q-311", visibility="public")
150 r = await client.get(f"/api/repos/{repo.repo_id}/issues", params={name: "closed"})
151 assert r.status_code == 422, r.text
152 assert _extra(r.json(), "query", name), r.json()
153
154
155 @pytest.mark.asyncio
156 async def test_issue_list_pagination_and_cache_buster_still_work(
157 client: AsyncClient, db_session: AsyncSession
158 ) -> None:
159 repo = await create_repo(db_session, owner="strictq", slug="strict-page-311", visibility="public")
160 rid = str(repo.repo_id)
161 for _ in range(3):
162 await create_issue(db_session, rid)
163 r = await client.get(f"/api/repos/{rid}/issues", params={"limit": 2, "state": "open", "label": "x", "_": "123"})
164 assert r.status_code == 200, r.text
165 r = await client.get(f"/api/repos/{rid}/issues", params={"limit": 2})
166 cursor = r.json()["nextCursor"]
167 assert cursor
168 r = await client.get(f"/api/repos/{rid}/issues", params={"limit": 2, "cursor": cursor})
169 assert r.status_code == 200 and len(r.json()["issues"]) == 1
170
171
172 async def _release(client: AsyncClient, headers: dict[str, str], rid: str, tag: str, **kw: object) -> None:
173 r = await client.post(f"/api/repos/{rid}/releases", json={"tag": tag, **kw}, headers=headers)
174 assert r.status_code == 201, r.text
175
176
177 @pytest.mark.asyncio
178 async def test_release_list_channel_and_draft_filters_are_applied(
179 client: AsyncClient, auth_headers: dict[str, str]
180 ) -> None:
181 rid = await _repo(client, auth_headers)
182 await _release(client, auth_headers, rid, "v1.0.0")
183 await _release(client, auth_headers, rid, "v1.1.0-beta.1", channel="beta")
184 await _release(client, auth_headers, rid, "v1.2.0", isDraft=True)
185 await _release(client, auth_headers, rid, "v1.3.0-beta.1", channel="beta", isDraft=True)
186
187 def tags(r) -> list[str]: # type: ignore[no-untyped-def]
188 assert r.status_code == 200, r.text
189 return sorted(x["tag"] for x in r.json()["releases"])
190
191 url = f"/api/repos/{rid}/releases"
192 assert tags(await client.get(url)) == ["v1.0.0", "v1.1.0-beta.1"]
193 assert tags(await client.get(url, params={"channel": "beta"})) == ["v1.1.0-beta.1"]
194 assert tags(await client.get(url, params={"channel": "beta", "draft": "false"})) == ["v1.1.0-beta.1"]
195 assert tags(await client.get(url, params={"draft": "true"})) == ["v1.2.0", "v1.3.0-beta.1"]
196 assert tags(await client.get(url, params={"draft": "true", "channel": "beta"})) == ["v1.3.0-beta.1"]
197 assert (await client.get(url, params={"draft": "true"})).json()["total"] == 2
198
199
200 @pytest.mark.asyncio
201 async def test_anonymous_callers_get_401_for_draft_releases(client: AsyncClient, db_session: AsyncSession) -> None:
202 repo = await create_repo(db_session, owner="someoneelse", slug="drafts-anon-311", visibility="public")
203 r = await client.get(f"/api/repos/{repo.repo_id}/releases", params={"draft": "true"})
204 assert r.status_code == 401, r.text
205 r = await client.get(f"/api/repos/{repo.repo_id}/releases", params={"draft": "false"})
206 assert r.status_code == 200, r.text
207
208
209 @pytest.mark.asyncio
210 async def test_signed_non_writers_get_403_for_draft_releases(
211 client: AsyncClient, db_session: AsyncSession, auth_headers: dict[str, str]
212 ) -> None:
213 repo = await create_repo(db_session, owner="someoneelse", slug="drafts-311", visibility="public")
214 r = await client.get(f"/api/repos/{repo.repo_id}/releases", params={"draft": "true"}, headers=auth_headers)
215 assert r.status_code == 403, r.text
216
217
218 @pytest.mark.asyncio
219 @pytest.mark.parametrize("params,loc", [
220 ({"channel": "bogus"}, None),
221 ({"draft": "maybe"}, None),
222 ({"status": "x"}, "status"),
223 ({"prerelease": "true"}, "prerelease"),
224 ])
225 async def test_release_list_bad_or_unknown_query_is_422(
226 client: AsyncClient, db_session: AsyncSession, params: dict[str, str], loc: str | None
227 ) -> None:
228 repo = await create_repo(db_session, owner="strictq", slug="strict-rel-311", visibility="public")
229 r = await client.get(f"/api/repos/{repo.repo_id}/releases", params={**params, "limit": 5, "_": "1"})
230 assert r.status_code == 422, r.text
231 if loc:
232 assert _extra(r.json(), "query", loc), r.json()
233
234
235 # ── 3. visibility ───────────────────────────────────────────────────────────
236
237
238 @pytest.mark.asyncio
239 async def test_repo_create_rejects_an_unknown_visibility(client: AsyncClient, auth_headers: dict[str, str]) -> None:
240 r = await client.post(
241 "/api/repos", json={"name": "sec", "owner": "testuser", "visibility": "secret"}, headers=auth_headers
242 )
243 assert r.status_code == 422, r.text
244 assert any(e["loc"] == ["body", "visibility"] for e in r.json()["detail"])
245 r = await client.post(
246 "/api/repos", json={"name": "priv", "owner": "testuser", "visibility": "private", "initialize": False},
247 headers=auth_headers,
248 )
249 assert r.status_code == 201 and r.json()["visibility"] == "private"
250
251
252 @pytest.mark.asyncio
253 async def test_repo_settings_rejects_an_unknown_visibility_and_unknown_fields(
254 client: AsyncClient, auth_headers: dict[str, str]
255 ) -> None:
256 rid = await _repo(client, auth_headers)
257 r = await client.patch(f"/api/repos/{rid}/settings", json={"visibility": "secret"}, headers=auth_headers)
258 assert r.status_code == 422, r.text
259 r = await client.patch(f"/api/repos/{rid}/settings", json={"archived": True}, headers=auth_headers)
260 assert r.status_code == 422 and _extra(r.json(), "body", "archived"), r.text
261
262
263 # ── 4. Release tags ─────────────────────────────────────────────────────────
264
265
266 @pytest.mark.asyncio
267 @pytest.mark.parametrize("tag", ["banana", "v1.2", "1.2.3.4", "v01.2.3", "emotion:happy", "v1.2.3-"])
268 async def test_release_tag_must_be_semver(client: AsyncClient, auth_headers: dict[str, str], tag: str) -> None:
269 rid = await _repo(client, auth_headers)
270 r = await client.post(f"/api/repos/{rid}/releases", json={"tag": tag}, headers=auth_headers)
271 assert r.status_code == 422, r.text
272 assert any(e["loc"] == ["body", "tag"] for e in r.json()["detail"])
273
274
275 @pytest.mark.asyncio
276 @pytest.mark.parametrize("tag", ["v1.2.3", "1.2.3", "v2.0.0-beta.1", "v1.0.0+build.7", "v0.2.3-rc.29"])
277 async def test_semver_release_tags_are_accepted(client: AsyncClient, auth_headers: dict[str, str], tag: str) -> None:
278 rid = await _repo(client, auth_headers)
279 await _release(client, auth_headers, rid, tag)
280
281
282 # ── 5. Label-name uniqueness ignores case ───────────────────────────────────
283
284
285 @pytest.mark.asyncio
286 async def test_label_names_are_unique_ignoring_case(client: AsyncClient, auth_headers: dict[str, str]) -> None:
287 rid = await _repo(client, auth_headers)
288 url = f"/api/repos/{rid}/labels"
289 r = await client.post(url, json={"name": "harmony", "color": "#7c3aed"}, headers=auth_headers)
290 assert r.status_code == 201, r.text
291 harmony = r.json()["label_id"] if "label_id" in r.json() else r.json()["labelId"]
292 r = await client.post(url, json={"name": "Harmony", "color": "#7c3aed"}, headers=auth_headers)
293 assert r.status_code == 409, r.text
294 r = await client.post(url, json={"name": "melody", "color": "#7c3aed"}, headers=auth_headers)
295 assert r.status_code == 201, r.text
296 melody = r.json()["label_id"] if "label_id" in r.json() else r.json()["labelId"]
297 # Renaming onto another label's name in a different case is a conflict ...
298 r = await client.patch(f"{url}/{melody}", json={"name": "HARMONY"}, headers=auth_headers)
299 assert r.status_code == 409, r.text
300 # ... but re-casing a label's own name is allowed.
301 r = await client.patch(f"{url}/{harmony}", json={"name": "Harmony"}, headers=auth_headers)
302 assert r.status_code == 200 and r.json()["name"] == "Harmony", r.text
File History 1 commit
sha256:8142f1f2556a271f60c48e1e5c43f8d47fa28e6ac888651ce5cbc48211628ce8 fix(rest): strict REST inputs — unknown body fields and lis… Opus 5.5 minor ⚠ 1 day ago