@kernel-sig/console 0.1.0

package/backend/tests/test_health.py

@@ -0,0 +1,63 @@
+import pytest
+from fastapi.testclient import TestClient
+
+from app.core.config import get_settings
+
+SECRET = "0123456789abcdef0123456789abcdef"
+
+
+@pytest.fixture
+def client(monkeypatch):
+    monkeypatch.setenv("KSC_SECRET_KEY", SECRET)
+    get_settings.cache_clear()
+    from app.main import create_app
+
+    with TestClient(create_app()) as c:
+        yield c
+    get_settings.cache_clear()
+
+
+def test_healthz_returns_ok(client):
+    resp = client.get("/api/v1/healthz")
+    assert resp.status_code == 200
+    assert resp.json() == {"status": "ok"}
+
+
+def test_healthz_sets_request_id_header(client):
+    resp = client.get("/api/v1/healthz")
+    assert len(resp.headers["x-request-id"]) == 32
+
+
+def test_inbound_request_id_is_echoed(client):
+    resp = client.get("/api/v1/healthz", headers={"X-Request-ID": "abc123"})
+    assert resp.headers["x-request-id"] == "abc123"
+
+
+def test_response_time_header_present(client):
+    resp = client.get("/api/v1/healthz")
+    assert float(resp.headers["x-response-time-ms"]) >= 0
+
+
+def test_unauthenticated_request_returns_problem_details(client):
+    resp = client.get("/api/v1/auth/me")
+    assert resp.status_code == 401
+    body = resp.json()
+    assert body["code"] == "unauthorized"
+    assert body["status"] == 401
+    assert body["instance"] == "/api/v1/auth/me"
+    assert "type" in body
+
+
+def test_validation_error_returns_problem_details(client):
+    """登录请求缺少 password 字段 → 422 且符合 Problem Details 格式。"""
+    resp = client.post("/api/v1/auth/login", json={"username": "x"})
+    assert resp.status_code == 422
+    body = resp.json()
+    assert body["code"] == "validation_error"
+    assert body["context"]["errors"][0]["field"] == "password"
+
+
+def test_openapi_schema_is_available(client):
+    resp = client.get("/api/openapi.json")
+    assert resp.status_code == 200
+    assert "paths" in resp.json()

package/backend/tests/test_llm_provider.py

@@ -0,0 +1,320 @@
+"""LLM 网关行为测试。
+
+用 MockTransport 断言**实际发出的请求**（鉴权头、payload、重试次数），
+以及对各种畸形响应的处理 —— 模型返回不合规格式是常态，不是异常。
+"""
+
+import json
+
+import httpx
+import pytest
+
+from app.integrations.llm.provider import (
+    ChatMessage,
+    CompletionRequest,
+    LLMAuthError,
+    LLMRateLimitError,
+    LLMResponseError,
+    LLMUpstreamError,
+    OpenAICompatibleProvider,
+    extract_json,
+)
+
+BASE = "https://api.example.com/v1"
+
+
+@pytest.fixture(autouse=True)
+def _no_sleep(monkeypatch):
+    async def _instant(*args, **kwargs):
+        return None
+
+    monkeypatch.setattr(OpenAICompatibleProvider, "_backoff", staticmethod(_instant))
+
+
+def make_provider(handler, **kwargs) -> OpenAICompatibleProvider:
+    return OpenAICompatibleProvider(
+        name="test",
+        base_url=BASE,
+        api_key="sk-test",
+        default_model="test-model",
+        transport=httpx.MockTransport(handler),
+        **kwargs,
+    )
+
+
+def _ok(content: str, **usage) -> httpx.Response:
+    return httpx.Response(
+        200,
+        json={
+            "model": "test-model",
+            "choices": [{"message": {"content": content}, "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 10, "completion_tokens": 20, **usage},
+        },
+    )
+
+
+def _request(**overrides) -> CompletionRequest:
+    base: dict = {"messages": [ChatMessage(role="user", content="hi")], "model": "test-model"}
+    base.update(overrides)
+    return CompletionRequest(**base)
+
+
+# --- 请求构造 ---------------------------------------------------------
+
+
+async def test_sends_bearer_auth_header():
+    seen: dict[str, str] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.update(dict(request.headers))
+        return _ok("hello")
+
+    async with make_provider(handler) as provider:
+        await provider.complete(_request())
+
+    assert seen.get("authorization") == "Bearer sk-test"
+
+
+async def test_omits_auth_header_when_no_key():
+    """本地 vLLM / Ollama 通常不校验鉴权，无 key 时不应发空头。"""
+    seen: dict[str, str] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.update(dict(request.headers))
+        return _ok("hi")
+
+    provider = OpenAICompatibleProvider(
+        name="local",
+        base_url="http://localhost:11434/v1",
+        api_key="",
+        transport=httpx.MockTransport(handler),
+    )
+    async with provider:
+        await provider.complete(_request())
+    assert "authorization" not in seen
+
+
+async def test_posts_to_chat_completions():
+    captured: dict = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured["path"] = request.url.path
+        captured["body"] = json.loads(request.content)
+        return _ok("hi")
+
+    async with make_provider(handler) as provider:
+        await provider.complete(_request(temperature=0.3, max_tokens=100))
+
+    assert captured["path"] == "/v1/chat/completions"
+    body = captured["body"]
+    assert body["model"] == "test-model"
+    assert body["temperature"] == 0.3
+    assert body["max_tokens"] == 100
+    assert body["messages"] == [{"role": "user", "content": "hi"}]
+    assert body["stream"] is False
+
+
+async def test_json_mode_sets_response_format():
+    captured: dict = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured.update(json.loads(request.content))
+        return _ok("{}")
+
+    async with make_provider(handler) as provider:
+        await provider.complete(_request(json_mode=True))
+
+    assert captured["response_format"] == {"type": "json_object"}
+
+
+async def test_falls_back_to_default_model():
+    captured: dict = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured.update(json.loads(request.content))
+        return _ok("hi")
+
+    async with make_provider(handler) as provider:
+        await provider.complete(_request(model=""))
+
+    assert captured["model"] == "test-model"
+
+
+async def test_empty_base_url_rejected():
+    with pytest.raises(ValueError, match="base_url"):
+        OpenAICompatibleProvider(name="x", base_url="", api_key="k")
+
+
+# --- 响应解析 ---------------------------------------------------------
+
+
+async def test_returns_content_and_usage():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return _ok("结果", prompt_tokens=7, completion_tokens=3)
+
+    async with make_provider(handler) as provider:
+        result = await provider.complete(_request())
+
+    assert result.content == "结果"
+    assert result.prompt_tokens == 7
+    assert result.completion_tokens == 3
+    assert result.total_tokens == 10
+
+
+async def test_tolerates_missing_usage():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"choices": [{"message": {"content": "x"}}], "model": "m"})
+
+    async with make_provider(handler) as provider:
+        result = await provider.complete(_request())
+    assert result.total_tokens == 0
+
+
+async def test_malformed_response_raises():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"unexpected": "shape"})
+
+    async with make_provider(handler) as provider:
+        with pytest.raises(LLMResponseError, match="不符合预期"):
+            await provider.complete(_request())
+
+
+# --- 错误映射 ---------------------------------------------------------
+
+
+async def test_401_raises_auth_error():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(401, json={"error": {"message": "invalid key"}})
+
+    async with make_provider(handler) as provider:
+        with pytest.raises(LLMAuthError, match="凭据无效"):
+            await provider.complete(_request())
+
+
+async def test_429_preserves_rate_limit_semantics():
+    calls = {"n": 0}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        return httpx.Response(429, json={"error": {"message": "slow down"}})
+
+    async with make_provider(handler) as provider:
+        with pytest.raises(LLMRateLimitError):
+            await provider.complete(_request())
+    assert calls["n"] == 3
+
+
+async def test_retries_then_succeeds():
+    calls = {"n": 0}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        return (
+            httpx.Response(500, json={"error": {"message": "boom"}})
+            if calls["n"] < 3
+            else _ok("ok")
+        )
+
+    async with make_provider(handler) as provider:
+        result = await provider.complete(_request())
+
+    assert calls["n"] == 3
+    assert result.content == "ok"
+    assert provider.retries == 2
+
+
+async def test_network_error_wrapped():
+    def handler(request: httpx.Request) -> httpx.Response:
+        raise httpx.ConnectTimeout("timeout")
+
+    async with make_provider(handler) as provider:
+        with pytest.raises(LLMUpstreamError, match="网络请求失败"):
+            await provider.complete(_request())
+
+
+async def test_error_message_is_surfaced():
+    """上游的错误文案要透传，否则排查时只剩一个状态码。"""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(400, json={"error": {"message": "model not found: gpt-x"}})
+
+    async with make_provider(handler) as provider:
+        with pytest.raises(LLMUpstreamError, match="model not found"):
+            await provider.complete(_request())
+
+
+# --- 流式输出 ---------------------------------------------------------
+
+
+async def test_stream_yields_content_chunks():
+    def handler(request: httpx.Request) -> httpx.Response:
+        lines = [
+            'data: {"choices":[{"delta":{"content":"你"}}]}',
+            'data: {"choices":[{"delta":{"content":"好"}}]}',
+            "data: [DONE]",
+        ]
+        return httpx.Response(200, text="\n".join(lines) + "\n")
+
+    async with make_provider(handler) as provider:
+        chunks = [chunk async for chunk in provider.stream(_request())]
+
+    assert chunks == ["你", "好"]
+
+
+async def test_stream_ignores_non_data_lines():
+    def handler(request: httpx.Request) -> httpx.Response:
+        text = ': keep-alive\n\ndata: {"choices":[{"delta":{"content":"x"}}]}\ndata: [DONE]\n'
+        return httpx.Response(200, text=text)
+
+    async with make_provider(handler) as provider:
+        chunks = [chunk async for chunk in provider.stream(_request())]
+    assert chunks == ["x"]
+
+
+# --- 结构化输出解析 ---------------------------------------------------
+
+
+def test_extract_json_from_clean_output():
+    assert extract_json('{"kind": "bugfix"}')["kind"] == "bugfix"
+
+
+def test_extract_json_from_fenced_output():
+    """模型常不顾"只输出 JSON"的指示，加上 ```json 围栏。"""
+    assert extract_json('```json\n{"kind": "cve"}\n```')["kind"] == "cve"
+
+
+def test_extract_json_from_prose_wrapped_output():
+    text = '好的，我的判断如下：\n{"kind": "backport", "confidence": 0.9}\n希望有帮助。'
+    assert extract_json(text)["kind"] == "backport"
+
+
+def test_extract_json_with_nested_braces():
+    text = '{"risks": [{"file": "net/x.c", "meta": {"line": 10}}]}'
+    assert extract_json(text)["risks"][0]["file"] == "net/x.c"
+
+
+@pytest.mark.parametrize("text", ["", "   ", "完全没有 JSON"])
+def test_extract_json_fails_loudly_on_garbage(text):
+    """解析失败必须显式报错 —— 把散文塞进结构化字段比失败更糟。"""
+    with pytest.raises(LLMResponseError):
+        extract_json(text)
+
+
+def test_extract_json_rejects_non_object():
+    with pytest.raises(LLMResponseError, match="期望 JSON 对象"):
+        extract_json("[1, 2, 3]")
+
+
+def test_stats_tracked():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return _ok("x")
+
+    import asyncio
+
+    async def run():
+        async with make_provider(handler) as provider:
+            await provider.complete(_request())
+            await provider.complete(_request())
+            return provider.requests
+
+    assert asyncio.run(run()) == 2

package/backend/tests/test_meeting_domain.py

@@ -0,0 +1,169 @@
+"""SIG 例会纪要解析。
+
+样本取自 ``etherpad.openeuler.org/p/Kernel-meetings`` 的真实片段，包括
+几处刻意保留的原样错误（截断的链接、重复的议题编号、模板占位行）——
+解析器就是为容忍它们才这么写的。
+"""
+
+from datetime import date
+
+from app.domain.meeting import parse_pad, parse_progress_report
+
+MEETING = """\
+【2026/9/4 14:00 Kernel SIG 双周例会】
+轮值主持：关文涛【轮值主持顺序：曾昭荣->桑力鹏->廖涛->吴腾达->陈玮->关文涛】
+下次轮值主持：曾昭荣
+会议链接：https://meeting.huaweicloud.com:36443/#/j/989418007
+会议纪要：https://etherpad.openeuler.org/p/Kernel-meetings
+
+一、上期遗留问题跟踪
+二、议题列表
+议题一：进展update（吴腾达）
+【OLK-6.6】
+OLK-6.6开发分支tag更新到6.6.0-170.0.0，期间合入补丁590个
+git log 6.6.0-167.0.0..6.6.0-170.0.0 --oneline --no-merges | wc -l
+ISO镜像和update rpm包获取链接：
+        https://repo.openeuler.org/openEuler-24.03-LTS-SP1
+        https://repo.openeuler.org/openEuler-24.03-LTS-SP3
+CVE: (124)
+CVE-2026-74739,CVE-2026-74544,CVE-2026-74439
+Bugfix:
+nfs: use nfsi->rwsem to protect traversal of the file lock list
+                https://atomgit.com/openeuler/kernel/pull/26235
+USB: serial: io_ti: fix heap overflow in get_manuf_info()
+                https://atomgit.com/openeuler/kernel/pull/
+Feature:
+KVM: arm64:Add pvqspinlock
+                https://gitcode.com/openeuler/kernel/pull/26044
+LTS：
+[OLK-6.6][linux-6.6.y sync] Backport 6.6.151-6.6.152 LTS Patches
+                https://atomgit.com/openeuler/kernel/pull/26808
+
+议题二：fs/exfat模块committer申报（池志凌）
+上游fs/exfat的贡献者
+atomgit id：chizl
+
+议题X：其他议题在这里补充，格式：议题名称（汇报人）
+
+三、遗留问题
+某个待跟踪的问题
+"""
+
+
+NESTED = """\
+【2026/9/4 14:00 Kernel SIG 双周例会】
+轮值主持：甲
+下次轮值主持：乙
+议题一：进展update（甲）
+【OLK-5.10】
+OLK-5.10开发分支tag更新到5.10.0-331.0.0，期间合入补丁123个
+【OLK-6.6】
+OLK-6.6开发分支tag更新到6.6.0-165.0.0，期间合入补丁1712个
+【2026/8/21 Kernel SIG 双周例会】
+轮值主持：丙
+议题一：某议题（丁）
+"""
+
+
+def test_parses_header_fields():
+    (meeting,) = parse_pad(MEETING)
+    assert meeting.date == date(2026, 9, 4)
+    assert meeting.time == "14:00"
+    assert meeting.title == "Kernel SIG 双周例会"
+    assert meeting.host == "关文涛"
+    assert meeting.next_host == "曾昭荣"
+    assert meeting.meeting_url == "https://meeting.huaweicloud.com:36443/#/j/989418007"
+    assert meeting.minutes_url == "https://etherpad.openeuler.org/p/Kernel-meetings"
+    assert meeting.host_order[0] == "曾昭荣"
+    assert len(meeting.host_order) == 6
+
+
+def test_template_agenda_is_dropped():
+    """「其他议题在这里补充」是给人填的模板，收录它会凭空造出一个议题。"""
+    (meeting,) = parse_pad(MEETING)
+    titles = [agenda.title for agenda in meeting.agendas]
+    assert titles == ["进展update", "fs/exfat模块committer申报"]
+    assert all("在这里补充" not in title for title in titles)
+
+
+def test_agenda_owner_in_fullwidth_and_halfwidth_parens():
+    (meeting,) = parse_pad(MEETING)
+    assert meeting.agendas[0].owner == "吴腾达"
+    assert meeting.agendas[1].owner == "池志凌"
+
+
+def test_legacy_section_captured():
+    (meeting,) = parse_pad(MEETING)
+    assert meeting.legacy == "某个待跟踪的问题"
+
+
+def test_meeting_without_time_still_parses():
+    text = "【2026/7/10 Kernel SIG 双周例会】\n轮值主持：桑力鹏\n"
+    (meeting,) = parse_pad(text)
+    assert (meeting.date, meeting.time, meeting.host) == (date(2026, 7, 10), None, "桑力鹏")
+
+
+def test_progress_block_fields():
+    (meeting,) = parse_pad(MEETING)
+    (progress,) = meeting.agendas[0].progress
+    assert progress.branch == "OLK-6.6"
+    assert progress.from_tag == "6.6.0-167.0.0"
+    assert progress.to_tag == "6.6.0-170.0.0"
+    assert progress.patch_count == 590
+    assert len(progress.iso_urls) == 2
+    assert progress.cve_ids == ["CVE-2026-74739", "CVE-2026-74544", "CVE-2026-74439"]
+
+
+def test_progress_groups_and_items():
+    (meeting,) = parse_pad(MEETING)
+    (progress,) = meeting.agendas[0].progress
+    assert [group.name for group in progress.groups] == ["Bugfix", "Feature", "LTS"]
+
+    bugfix = progress.groups[0]
+    assert [item.pull_number for item in bugfix.items] == [26235, None]
+    assert bugfix.items[0].title.startswith("nfs: use nfsi->rwsem")
+
+    # gitcode 与 atomgit 两个域名都在用，都要认出编号
+    assert progress.groups[1].items[0].pull_number == 26044
+    assert progress.groups[2].items[0].pull_number == 26808
+
+
+def test_truncated_url_keeps_title_but_not_a_guessed_number():
+    """实测存在 ".../pull/" 这种被截断的链接。丢掉整条比猜个编号诚实。"""
+    (meeting,) = parse_pad(MEETING)
+    item = meeting.agendas[0].progress[0].groups[0].items[1]
+    assert item.pull_number is None
+    assert "io_ti" in item.title
+
+
+def test_next_meeting_header_terminates_the_block():
+    """新会议标题必须截断上一场，否则一场会议会把之后所有会议吞掉。"""
+    meetings = parse_pad(NESTED)
+    assert [m.date for m in meetings] == [date(2026, 9, 4), date(2026, 8, 21)]
+    assert [p.branch for p in meetings[0].agendas[0].progress] == ["OLK-5.10", "OLK-6.6"]
+    assert meetings[0].agendas[0].progress[1].patch_count == 1712
+    assert meetings[1].agendas[0].title == "某议题"
+
+
+def test_bracketed_prefix_is_a_patch_title_not_a_progress_block():
+    """「【OLK-6.6】drm: add ...」是带分支前缀的补丁标题，不是版本报告。"""
+    blocks = parse_progress_report("【OLK-6.6】drm: add display driver for EG210\n")
+    assert blocks == []
+
+
+def test_iso_label_is_not_taken_as_a_group():
+    (meeting,) = parse_pad(MEETING)
+    names = [group.name for group in meeting.agendas[0].progress[0].groups]
+    assert not any("ISO" in name or "获取链接" in name for name in names)
+
+
+def test_empty_and_garbage_input_is_survivable():
+    """上游是外部输入。解析失败只该少一条信息，不该让整页消失。"""
+    assert parse_pad("") == []
+    assert parse_pad("这里没有任何会议标题\n随便写点什么\n") == []
+
+
+def test_invalid_date_drops_only_that_meeting():
+    text = "【2026/2/30 坏日期】\n轮值主持：甲\n【2026/3/6 Kernel SIG 双周例会】\n轮值主持：乙\n"
+    meetings = parse_pad(text)
+    assert [m.date for m in meetings] == [date(2026, 3, 6)]

package/backend/tests/test_permissions.py

@@ -0,0 +1,69 @@
+import pytest
+
+from app.core.permissions import (
+    ROLE_PERMISSIONS,
+    Permission,
+    Role,
+    role_has_permission,
+)
+
+
+def test_role_ordering_is_hierarchical():
+    assert Role.VIEWER < Role.REVIEWER < Role.COMMITTER < Role.MAINTAINER < Role.ADMIN
+
+
+def test_viewer_can_only_read():
+    assert role_has_permission(Role.VIEWER, Permission.VIEW)
+    assert not role_has_permission(Role.VIEWER, Permission.TRIGGER_ANALYSIS)
+
+
+def test_reviewer_can_trigger_analysis_but_not_write_back():
+    assert role_has_permission(Role.REVIEWER, Permission.TRIGGER_ANALYSIS)
+    assert not role_has_permission(Role.REVIEWER, Permission.WRITE_BACK)
+
+
+def test_committer_can_classify_and_write_back():
+    assert role_has_permission(Role.COMMITTER, Permission.CLASSIFY)
+    assert role_has_permission(Role.COMMITTER, Permission.WRITE_BACK)
+    assert not role_has_permission(Role.COMMITTER, Permission.MANAGE_USERS)
+
+
+def test_maintainer_can_manage_repository_not_users():
+    assert role_has_permission(Role.MAINTAINER, Permission.MANAGE_REPOSITORY)
+    assert not role_has_permission(Role.MAINTAINER, Permission.MANAGE_USERS)
+
+
+def test_admin_has_every_permission():
+    for permission in Permission:
+        assert role_has_permission(Role.ADMIN, permission)
+
+
+def test_higher_role_inherits_lower_role_permissions():
+    """层级继承：committer 拥有 reviewer 与 viewer 的全部权限。"""
+    assert ROLE_PERMISSIONS[Role.REVIEWER] <= ROLE_PERMISSIONS[Role.COMMITTER]
+    assert ROLE_PERMISSIONS[Role.COMMITTER] <= ROLE_PERMISSIONS[Role.MAINTAINER]
+    assert ROLE_PERMISSIONS[Role.MAINTAINER] <= ROLE_PERMISSIONS[Role.ADMIN]
+
+
+def test_no_role_granted_permissions_outside_enum():
+    for role in Role:
+        assert ROLE_PERMISSIONS[role] <= set(Permission)
+
+
+def test_role_accepts_string_name():
+    assert role_has_permission("ADMIN", Permission.MANAGE_USERS)
+    assert not role_has_permission("VIEWER", Permission.MANAGE_USERS)
+
+
+def test_unknown_role_has_no_permission():
+    assert not role_has_permission("nonsense", Permission.VIEW)
+
+
+def test_role_labels_are_localized():
+    assert Role.ADMIN.label == "管理员"
+    assert Role.MAINTAINER.label == "维护者"
+
+
+@pytest.mark.parametrize("role", list(Role))
+def test_every_role_can_view(role):
+    assert role_has_permission(role, Permission.VIEW)

package/backend/tests/test_pull_query_wiring.py

@@ -0,0 +1,66 @@
+"""列表与分面接口的参数装配。
+
+这个测试的存在理由很具体：给 ``Selection`` 加了一个筛选维度后，只改了
+``_selection`` 的签名与其中一处调用点，另一处漏传。类型检查发现不了
+（缺的是运行时才绑定的关键字参数），既有的单元测试也没覆盖到处理函数，
+最后是浏览器端 e2e 才抓出来 —— 表现是"整个列表页空掉"，
+而报错信息指向框架内部。这本可以在提交前几秒内发现。
+
+所以这里用 ast 精确解析每个调用点传了哪些关键字，逐一比对。
+不用正则：正则版本我写错过一次，测试比被测代码还脆是没有意义的。
+"""
+
+import ast
+import inspect
+from pathlib import Path
+
+from app.api.v1 import pulls
+from app.services import pull_query
+
+SOURCE = Path(inspect.getfile(pulls))
+
+
+def _call_sites() -> list[set[str]]:
+    """源码里所有 ``_selection(...)`` 调用所传的关键字集合。"""
+    tree = ast.parse(SOURCE.read_text(encoding="utf-8"))
+    sites: list[set[str]] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        name = func.id if isinstance(func, ast.Name) else getattr(func, "attr", None)
+        if name == "_selection":
+            sites.append({kw.arg for kw in node.keywords if kw.arg})
+    return sites
+
+
+def test_selection_covers_every_filter_dimension():
+    """Selection 的每个筛选维度都要能经由 _selection 传入。
+
+    ``q`` 与 ``search`` 是同一件事的两个名字（前者是查询参数惯例，
+    后者是领域模型的措辞），因此单独映射，不做强行改名。
+    """
+    parameters = set(inspect.signature(pulls._selection).parameters) - {"return"}
+    alias = {"q": "search"}
+
+    uncovered = {
+        field
+        for field in pull_query.Selection.__dataclass_fields__
+        if field not in {alias.get(name, name) for name in parameters}
+    }
+    assert not uncovered, f"_selection 未覆盖这些筛选维度：{sorted(uncovered)}"
+
+
+def test_all_call_sites_pass_the_same_parameters():
+    """两处调用（列表与分面）必须传同一组参数。
+
+    只要有一处漏传，FastAPI 就会把 TypeError 变成 500，
+    而使用者看到的是"列表空了"。
+    """
+    sites = _call_sites()
+    assert len(sites) >= 2, "预期至少两处调用（列表与分面）"
+
+    reference = max(sites, key=len)
+    for index, site in enumerate(sites):
+        missing = reference - site
+        assert not missing, f"第 {index + 1} 处 _selection 调用漏传：{sorted(missing)}"