test_rest_strict_inputs_311.py
python
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