archived-MoviePilot/tests/test_agent_submit_feedback_issue_tool.py

"""``submit_feedback_issue`` Agent 工具的单元测试。

覆盖范围（按 review 反馈"必修问题 2"补齐）：
- 工厂注册：新工具能被正常加载到默认工具集中
- 静态辅助：URL 构造、Issue body 渲染、日志脱敏、失败分类、长度截断
- ``run()`` 主流程：枚举校验、no_token 降级、API 成功、API 失败 +
  rate_limited 分支、网络异常分支、去重逻辑
- send_tool_message 全部走 mock，保证测试无外部 IO
"""

from __future__ import annotations

import asyncio
import json
import time
import unittest
from unittest.mock import patch
from urllib.parse import quote

from app.agent.tools.factory import MoviePilotToolFactory
from app.agent.tools.impl.submit_feedback_issue import (
    FEEDBACK_REPO,
    MAX_LOGS_CHARS,
    MAX_TITLE_CHARS,
    MAX_URL_LOGS_CHARS,
    USER_DAILY_WINDOW_SECONDS as USER_DAILY_WINDOW_SECONDS_TEST,
    SubmitFeedbackIssueTool,
)
from app.agent.tools.impl.feedback_issue_state import (
    build_feedback_draft_hash,
    feedback_issue_state_store,
)
from app.core.config import settings


class _FakeResponse:
    """``httpx.Response`` 的最小替身，覆盖工具用到的 4 个属性/方法。"""

    def __init__(self, status_code, payload=None, headers=None, text=""):
        self.status_code = status_code
        self._payload = payload
        self.headers = headers or {}
        self.text = text

    def json(self):
        if self._payload is None:
            raise ValueError("no json body")
        return self._payload


def _run(coro):
    """跑一个 coroutine，避免每个用例重复写 asyncio.run。"""
    return asyncio.run(coro)


class TestSubmitFeedbackIssueStaticHelpers(unittest.TestCase):
    """所有静态/类方法的纯函数测试，无副作用、无 IO。"""

    def test_validate_enum_accepts_allowed_values(self):
        self.assertIsNone(
            SubmitFeedbackIssueTool._validate_enum("Docker", ("Docker", "Windows"), "env")
        )

    def test_validate_enum_rejects_disallowed_values(self):
        msg = SubmitFeedbackIssueTool._validate_enum(
            "linux", ("Docker", "Windows"), "env"
        )
        self.assertIsNotNone(msg)
        self.assertIn("Docker", msg)
        self.assertIn("Windows", msg)
        self.assertIn("'linux'", msg)

    def test_truncate_keeps_short_text(self):
        self.assertEqual(SubmitFeedbackIssueTool._truncate("hello", 100), "hello")

    def test_truncate_clips_long_text_with_marker(self):
        out = SubmitFeedbackIssueTool._truncate("a" * 1000, 100)
        self.assertLessEqual(len(out), 100)
        self.assertIn("已截断", out)

    def test_redact_logs_strips_common_secrets(self):
        sample = (
            "Cookie: session=foo; passkey=secret123\n"
            "Authorization: Bearer ghp_abcdefghijklmn\n"
            "api_key=mysecret\n"
            "password: hunter2\n"
            "Set-Cookie: session=foo"
        )
        out = SubmitFeedbackIssueTool._redact_logs(sample)
        self.assertNotIn("ghp_abcdefghijklmn", out)
        self.assertNotIn("mysecret", out)
        self.assertNotIn("hunter2", out)
        self.assertNotIn("secret123", out)
        self.assertIn("<REDACTED>", out)

    def test_redact_logs_preserves_original_separator(self):
        # gemini-code-assist review 提醒：原始分隔符（``:`` 或 ``=``）必须保留
        self.assertIn("api_key=<REDACTED>", SubmitFeedbackIssueTool._redact_logs("api_key=xxx_yy"))
        self.assertIn("api_key: <REDACTED>", SubmitFeedbackIssueTool._redact_logs("api_key: xxxxxx"))
        self.assertIn("password: <REDACTED>", SubmitFeedbackIssueTool._redact_logs("password: xxxx"))
        self.assertIn("token=<REDACTED>", SubmitFeedbackIssueTool._redact_logs("token=xxxx"))

    def test_redact_logs_strips_extended_credentials(self):
        # 扩充后的脱敏需要覆盖：bare GitHub PAT、IM webhook、PT passkey、
        # 邮箱、公网 IP、用户家目录、Windows 用户路径、X-Api-Key 头部、
        # 厂商常见字段（client_secret / corp_secret / webhook 等）、
        # 以及用户身份字段（#5808 教训：userid / username）。
        cases = [
            ("plain bare ghp_xxxxxxxxxxxxxxxxxxxxxx", "ghp_xxxxxxxxxxxxxxxxxxxxxx"),
            ("xoxb-xxxxxxxxxxxx", "xoxb-xxxxxxxxxxxx"),
            ("github_pat_xxxxxxxxxxxxxxxxxxxxxx", "github_pat_xxxxxxxxxxxxxxxxxxxxxx"),
            ("https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=abc123", "key=abc123"),
            ("https://hooks.slack.com/services/T0/B0/abcdef", "abcdef"),
            ("X-Api-Key: secret-xyz-123", "secret-xyz-123"),
            ("client_secret=topsecret_value", "topsecret_value"),
            ("corp_secret: corp_topsecret", "corp_topsecret"),
            ("user@example.com login failed", "user@example.com"),
            ("Connected to 203.0.113.45", "203.0.113.45"),
            ("Path /Users/alice/Library/...", "/Users/alice/"),
            ("Path /home/bob/.config/foo", "/home/bob/"),
            (r"Path C:\Users\Charlie\AppData", r"C:\Users\Charlie\\"),
            ("rsskey=abcd1234efgh", "rsskey=abcd1234efgh"),
            # 用户身份 PII
            ("userid=1234567890, username=fake_user", "1234567890"),
            ("userid=1234567890, username=fake_user", "fake_user"),
            ("user_id: 11111111", "11111111"),
            ("open_id=ou_abcdef", "ou_abcdef"),
            ("union_id=on_xxx123", "on_xxx123"),
            # MoviePilot 会话 ID（embed userid）
            ("Agent推理 session_id=user_1234567890_1779337335 input=...", "1234567890_1779337335"),
            ("session_id=user_1234567890_1779337335 fired", "user_1234567890_1779337335"),
            ("session_id=arbitrary_string_value", "arbitrary_string_value"),
        ]
        for sample, secret_fragment in cases:
            out = SubmitFeedbackIssueTool._redact_logs(sample)
            self.assertNotIn(secret_fragment, out, msg=f"未脱敏: {sample!r} → {out!r}")

    def test_redact_logs_preserves_private_ipv4_addresses(self):
        # 私网地址不脱敏，方便 maintainer 理解部署拓扑
        out = SubmitFeedbackIssueTool._redact_logs(
            "Local 127.0.0.1; LAN 192.168.1.10; container 10.244.5.6; mgmt 172.16.0.1"
        )
        for keep in ("127.0.0.1", "192.168.1.10", "10.244.5.6", "172.16.0.1"):
            self.assertIn(keep, out, msg=f"私网地址被错误脱敏: {keep}")

    def test_sanitize_logs_caps_to_limit_and_redacts(self):
        result = SubmitFeedbackIssueTool._sanitize_logs(
            "Cookie: secret\n" + "A" * 5000, limit=1024
        )
        self.assertNotIn("Cookie: secret", result)
        self.assertIn("Cookie: <REDACTED>", result)
        self.assertLessEqual(len(result), 1024)

    def test_sanitize_logs_returns_empty_for_blank_input(self):
        self.assertEqual(SubmitFeedbackIssueTool._sanitize_logs(None, 1024), "")
        self.assertEqual(SubmitFeedbackIssueTool._sanitize_logs("   \n  ", 1024), "")

    def test_build_issue_body_contains_all_sections(self):
        body = SubmitFeedbackIssueTool._build_issue_body(
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            description="## 现象\n- xxx",
            logs="ERROR demo",
        )
        for section in (
            "### 确认",
            "### 当前程序版本",
            "### 运行环境",
            "### 问题类型",
            "### 问题描述",
            "### 发生问题时系统日志和配置文件",
            "v2.12.2",
            "Docker",
            "主程序运行问题",
            "ERROR demo",
        ):
            self.assertIn(section, body, msg=f"missing: {section!r}")

    def test_build_issue_body_handles_empty_logs(self):
        body = SubmitFeedbackIssueTool._build_issue_body(
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            description="x",
            logs=None,
        )
        self.assertIn("会话中未捕获到相关后端日志。", body)

    def test_build_issue_body_redacts_logs(self):
        body = SubmitFeedbackIssueTool._build_issue_body(
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            description="x",
            logs="Cookie: foo=bar",
        )
        self.assertIn("Cookie: <REDACTED>", body)
        self.assertNotIn("Cookie: foo=bar", body)

    def test_build_issue_body_truncates_oversized_logs(self):
        body = SubmitFeedbackIssueTool._build_issue_body(
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            description="x",
            logs="A" * (MAX_LOGS_CHARS + 1000),
        )
        # logs 段落在 ```bash ... ``` 之间；提取出来验证长度
        log_segment = body.split("```bash\n", 1)[1].rsplit("\n```", 1)[0]
        self.assertLessEqual(len(log_segment), MAX_LOGS_CHARS)
        self.assertIn("已截断", log_segment)

    def test_build_prefill_url_encodes_chinese_correctly(self):
        url = SubmitFeedbackIssueTool._build_prefill_url(
            title="[错误报告]: 版本测试",
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            description="line1\nline2",
            logs=None,
        )
        # "版" 的 UTF-8 percent-encoding 应为 %E7%89%88（曾经被 LLM 翻成 %E7%79%88）
        self.assertIn("%E7%89%88", url)
        # 换行用 %0A 而非 %0D，空格不能用 + 表示
        self.assertIn("%0A", url)
        self.assertNotIn("+", url.split("?", 1)[1])
        # 必须带 template 参数才会进入 Issue Forms 表单
        self.assertIn("template=bug_report.yml", url)

    def test_build_prefill_url_redacts_and_caps_logs(self):
        # gemini-code-assist HIGH 反馈：预填 URL 必须脱敏 + 截断到 3KB
        sensitive_logs = "Cookie: leak_me\n" + ("A" * (MAX_URL_LOGS_CHARS + 5000))
        url = SubmitFeedbackIssueTool._build_prefill_url(
            title="t",
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            description="d",
            logs=sensitive_logs,
        )
        # Cookie 必须不出现在 URL 里
        self.assertNotIn(quote("leak_me", safe=""), url)
        self.assertIn(quote("<REDACTED>", safe=""), url)
        # 总 URL 长度可控（其它字段都很短，所以主要由 logs 决定）
        # logs 的 percent-encoding 膨胀比 ~3x（每个 ASCII A 是 1 byte，不膨胀；
        # 但 marker / 中文会膨胀），用 1.5x 余量验证
        self.assertLess(len(url), MAX_URL_LOGS_CHARS * 2)

    def test_repeat_gibberish_does_not_false_positive_on_separators(self):
        # 修复 review #1：横线 / 等号 / 井号 等 Markdown 分隔符大量重复
        # 不应被判作乱码（合法 description 里很常见）
        from app.agent.tools.impl.submit_feedback_issue import _REPEAT_GIBBERISH
        for legitimate in ("========", "----------", "____", "########",
                           "******", "~~~~~~~~", "```python```",
                           "..........", "//////", "++++++"):
            self.assertIsNone(_REPEAT_GIBBERISH.search(legitimate),
                              msg=f"误判分隔符：{legitimate!r}")
        # 但真正的字母/汉字重复应该照样命中
        for gibberish in ("aaaaaaaa", "为为为为为为为为", "11111111"):
            self.assertIsNotNone(_REPEAT_GIBBERISH.search(gibberish),
                                 msg=f"应判作乱码：{gibberish!r}")

    def test_check_content_quality_empty_title_after_prefix(self):
        # title 完全只有 ``[错误报告]:`` 前缀、正文为空也应被拒
        err = SubmitFeedbackIssueTool._check_content_quality(
            title="[错误报告]:",
            description="正常长度的描述，包含现象和复现步骤，行行行行行行行" * 3,
            original_user_request="用户反馈订阅刷新接口返回 500，希望提交上游 Issue",
        )
        self.assertIsNotNone(err)
        self.assertIn("标题正文太短", err)

    def test_normalize_username_handles_drift(self):
        # 修复 review #3：username 拼写漂移要被归一化到同一个桶
        self.assertEqual(SubmitFeedbackIssueTool._normalize_username("Admin"), "admin")
        self.assertEqual(SubmitFeedbackIssueTool._normalize_username("  admin "), "admin")
        self.assertEqual(SubmitFeedbackIssueTool._normalize_username("ADMIN"), "admin")
        self.assertEqual(SubmitFeedbackIssueTool._normalize_username(""), "")
        self.assertEqual(SubmitFeedbackIssueTool._normalize_username(None), "")

    def test_user_submissions_eviction_keeps_dict_bounded(self):
        # 修复 review #3：恶意 / 漂移 username 不应该把 _user_submissions 撑爆
        from app.agent.tools.impl.submit_feedback_issue import (
            MAX_USER_SUBMISSIONS_BUCKETS,
        )
        SubmitFeedbackIssueTool._user_submissions.clear()
        # 灌入超过上限的不同 username
        for i in range(MAX_USER_SUBMISSIONS_BUCKETS + 50):
            SubmitFeedbackIssueTool._record_user_submission(f"user{i}")
        self.assertLessEqual(
            len(SubmitFeedbackIssueTool._user_submissions),
            MAX_USER_SUBMISSIONS_BUCKETS,
        )

    def test_check_user_rate_limit_clears_fully_expired_bucket(self):
        # 修复 review：24h 之前的桶应该被清掉而不是留个空 list 永驻
        SubmitFeedbackIssueTool._user_submissions.clear()
        SubmitFeedbackIssueTool._user_submissions["staleuser"] = [
            time.time() - (USER_DAILY_WINDOW_SECONDS_TEST + 60),
        ]
        result = SubmitFeedbackIssueTool._check_user_rate_limit("staleuser")
        self.assertIsNone(result)
        self.assertNotIn("staleuser", SubmitFeedbackIssueTool._user_submissions)

    def test_classify_failure_handles_main_branches(self):
        self.assertEqual(SubmitFeedbackIssueTool._classify_failure(401), "no_permission")
        self.assertEqual(SubmitFeedbackIssueTool._classify_failure(404), "no_permission")
        self.assertEqual(
            SubmitFeedbackIssueTool._classify_failure(403),
            "no_permission",
        )
        self.assertEqual(SubmitFeedbackIssueTool._classify_failure(422), "invalid_payload")
        self.assertEqual(SubmitFeedbackIssueTool._classify_failure(500), "github_unavailable")
        self.assertEqual(SubmitFeedbackIssueTool._classify_failure(502), "github_unavailable")
        self.assertEqual(SubmitFeedbackIssueTool._classify_failure(None), "api_error")

    def test_classify_failure_detects_rate_limit_on_403(self):
        self.assertEqual(
            SubmitFeedbackIssueTool._classify_failure(
                403, headers={"X-RateLimit-Remaining": "0"}
            ),
            "rate_limited",
        )
        # 大小写不敏感
        self.assertEqual(
            SubmitFeedbackIssueTool._classify_failure(
                403, headers={"x-ratelimit-remaining": "0"}
            ),
            "rate_limited",
        )
        # 仍有余量时按无权限分类
        self.assertEqual(
            SubmitFeedbackIssueTool._classify_failure(
                403, headers={"X-RateLimit-Remaining": "10"}
            ),
            "no_permission",
        )

    def test_safe_response_dict_falls_back_for_array_or_invalid_json(self):
        # 合法 dict
        self.assertEqual(
            SubmitFeedbackIssueTool._safe_response_dict(
                _FakeResponse(200, payload={"message": "ok"})
            ),
            {"message": "ok"},
        )
        # array 不是 dict，应返回空 dict 而不是抛 AttributeError
        self.assertEqual(
            SubmitFeedbackIssueTool._safe_response_dict(
                _FakeResponse(200, payload=[1, 2, 3])
            ),
            {},
        )
        # 非 JSON 响应
        self.assertEqual(
            SubmitFeedbackIssueTool._safe_response_dict(_FakeResponse(500)),
            {},
        )


class TestSubmitFeedbackIssueRun(unittest.TestCase):
    """``run()`` 主流程测试；外部 HTTP / send_tool_message 全部 mock。"""

    def setUp(self):
        # 每个用例独立清空进程级去重缓存与 per-user rate limit 状态
        SubmitFeedbackIssueTool._recent_submissions.clear()
        SubmitFeedbackIssueTool._user_submissions.clear()
        feedback_issue_state_store.clear()
        # 默认无 token，避免误打真实 GitHub API
        self._token_backup = settings.GITHUB_TOKEN
        settings.GITHUB_TOKEN = None
        self.tool = SubmitFeedbackIssueTool(session_id="s", user_id="u")
        # rate-limit 校验依赖 username；默认给一个合法 admin，单独的测试可覆盖
        self.tool._username = "admin"
        self.push_calls = []

        # _push_url_to_user 现在直接走 ToolChain().async_post_message 并
        # 关闭网页预览（修复 #5806 一次提交渲染 3 张预览卡的问题）。测试
        # 用 mock 直接替换该方法，捕获 url/title/hint 三元组即可。
        async def fake_push(_self, url, title, hint):
            self.push_calls.append({"text": f"{hint}\n\n{url}", "title": title, "url": url})
            return True

        self._push_patcher = patch.object(
            SubmitFeedbackIssueTool, "_push_url_to_user", new=fake_push
        )
        self._push_patcher.start()

        # 默认放行 superuser 校验，单独的拒绝用例会覆盖这个 stub
        async def fake_enforce(_self):
            return None

        self._enforce_patcher = patch.object(
            SubmitFeedbackIssueTool, "_enforce_superuser", new=fake_enforce
        )
        self._enforce_patcher.start()

    def tearDown(self):
        self._enforce_patcher.stop()
        self._push_patcher.stop()
        settings.GITHUB_TOKEN = self._token_backup

    def _good_kwargs(self, **overrides):
        """构造一份能通过 enum / 质量 / rate-limit 全部检查的合规 payload。

        默认 admin username 由 _enforce_superuser mock 放行，但 rate-limit
        和 quality gate 是独立检查，必须用 ≥50 字的真实样式 description 与
        非黑词单 title。"""
        kwargs = dict(
            explanation="user authorized to submit a feedback issue upstream",
            title="[错误报告]: 订阅刷新接口返回 500 错误码",
            version="v2.12.2",
            environment="Docker",
            issue_type="主程序运行问题",
            original_user_request="订阅刷新接口返回 500，帮我提交上游 Issue",
            description=(
                "## 现象\n"
                "- 订阅刷新接口持续返回 500，调用 /api/v1/subscribe/refresh\n"
                "## 复现\n"
                "1. 在 WebUI 触发刷新订阅\n"
                "2. 后端日志出现 RecognizeError，前端弹出 500\n"
                "## 期望\n"
                "正常完成订阅刷新流程，无 500 错误。"
            ),
        )
        kwargs.update(overrides)
        diagnostics = feedback_issue_state_store.create_diagnostics(
            session_id=self.tool._session_id,
            user_id=self.tool._user_id,
            username=self.tool._username,
            logs=kwargs.get("logs") or "ERROR demo feedback diagnostics",
            source_files=["/tmp/moviepilot.log"],
            found=True,
        )
        kwargs.setdefault("diagnostics_id", diagnostics.diagnostics_id)
        draft_hash = build_feedback_draft_hash(
            title=SubmitFeedbackIssueTool._truncate(
                kwargs["title"], MAX_TITLE_CHARS, marker="…"
            ),
            version=kwargs["version"],
            environment=kwargs["environment"],
            issue_type=kwargs["issue_type"],
            description=kwargs["description"],
            original_user_request=kwargs["original_user_request"],
            logs=kwargs.get("logs") if kwargs.get("logs") is not None else diagnostics.logs,
            diagnostics_id=kwargs["diagnostics_id"],
        )
        confirmation = feedback_issue_state_store.create_confirmation(
            session_id=self.tool._session_id,
            user_id=self.tool._user_id,
            username=self.tool._username,
            draft_hash=draft_hash,
            diagnostics_id=kwargs["diagnostics_id"],
        )
        feedback_issue_state_store.mark_confirmed(
            confirmation.confirmation_token,
            session_id=self.tool._session_id,
            user_id=self.tool._user_id,
        )
        kwargs.setdefault("confirmation_token", confirmation.confirmation_token)
        return kwargs

    def test_rejects_non_superuser_caller(self):
        # 关闭默认放行 stub，让真正的 _enforce_superuser 走 UserOper 路径
        self._enforce_patcher.stop()

        class _NonAdminUser:
            is_superuser = False

        async def fake_get(_self, name):
            return _NonAdminUser()

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.UserOper.async_get_by_name",
            new=fake_get,
        ):
            self.tool._username = "regular-user"
            result = _run(self.tool.run(**self._good_kwargs()))

        # 重启动 enforce stub 给 tearDown 用
        self._enforce_patcher.start()

        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "forbidden")
        # 不应执行任何下游副作用
        self.assertEqual(self.push_calls, [])
        self.assertEqual(SubmitFeedbackIssueTool._recent_submissions, {})

    def test_rejects_when_username_missing(self):
        self._enforce_patcher.stop()
        self.tool._username = ""
        result = _run(self.tool.run(**self._good_kwargs()))
        self._enforce_patcher.start()

        data = json.loads(result)
        self.assertEqual(data["reason"], "forbidden")
        self.assertIn("没有绑定", data["message"])

    def test_allows_superuser(self):
        self._enforce_patcher.stop()

        class _Admin:
            is_superuser = True

        async def fake_get(_self, name):
            return _Admin()

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.UserOper.async_get_by_name",
            new=fake_get,
        ):
            self.tool._username = "admin-user"
            result = _run(self.tool.run(**self._good_kwargs()))

        self._enforce_patcher.start()
        data = json.loads(result)
        # superuser 放行后会落到 no_token 兜底（settings.GITHUB_TOKEN=None）
        self.assertEqual(data["reason"], "no_token")

    def test_rejects_invalid_environment_before_calling_api(self):
        result = _run(self.tool.run(**self._good_kwargs(environment="linux")))
        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "invalid_input")
        self.assertEqual(self.push_calls, [])

    def test_rejects_invalid_issue_type(self):
        result = _run(self.tool.run(**self._good_kwargs(issue_type="random")))
        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "invalid_input")

    def test_rejects_without_diagnostics_record(self):
        kwargs = self._good_kwargs()
        kwargs["diagnostics_id"] = "missing-diagnostics"
        result = _run(self.tool.run(**kwargs))
        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "diagnostics_required")

    def test_rejects_without_confirmed_preview_token(self):
        kwargs = self._good_kwargs()
        kwargs["confirmation_token"] = "not-confirmed"
        result = _run(self.tool.run(**kwargs))
        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "confirmation_required")

    def test_no_token_branch_pushes_prefill_url_and_hides_it_from_llm(self):
        result = _run(self.tool.run(**self._good_kwargs()))
        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "no_token")
        self.assertTrue(data["url_delivered"])
        # 关键不变量：URL 不应该回流给 LLM 转述
        self.assertIsNone(data["prefill_url"])
        # send_tool_message 必须被调一次，且消息体内含完整 URL
        self.assertEqual(len(self.push_calls), 1)
        self.assertIn("https://github.com/jxxghp/MoviePilot/issues/new", self.push_calls[0]["text"])

    def test_truncates_oversized_title_before_submission(self):
        title = "[错误报告]: " + ("超长" * 200)
        result = _run(self.tool.run(**self._good_kwargs(title=title)))
        data = json.loads(result)
        self.assertEqual(data["reason"], "no_token")
        # pushed message contains the truncated title via dedup-trail check;
        # we can't see the actual title pushed, but we can confirm dedup uses
        # the truncated form by re-submitting and verifying dedup hit.
        SubmitFeedbackIssueTool._recent_submissions.clear()
        # And verify directly:
        truncated = SubmitFeedbackIssueTool._truncate(title, MAX_TITLE_CHARS, marker="…")
        self.assertLessEqual(len(truncated), MAX_TITLE_CHARS)

    def test_success_branch_records_submission_and_dedups_next_call(self):
        settings.GITHUB_TOKEN = "ghp_test_token"

        async def fake_post(_self, url, **kw):
            return _FakeResponse(
                201,
                payload={
                    "html_url": "https://github.com/jxxghp/MoviePilot/issues/9999",
                    "number": 9999,
                },
            )

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.AsyncRequestUtils.post_res",
            new=fake_post,
        ):
            first = _run(self.tool.run(**self._good_kwargs()))
            # 第二次同 payload 应被 60s dedup 拦下；rate-limit 窗口比 dedup 窗口大，
            # 测试想验证的是 dedup，所以手动清掉 per-user rate-limit 状态避免被
            # 先一步 rate-limited（rate-limit 优先级在 dedup 之前）。
            SubmitFeedbackIssueTool._user_submissions.clear()
            second = _run(self.tool.run(**self._good_kwargs()))

        d1 = json.loads(first)
        d2 = json.loads(second)
        self.assertTrue(d1["success"])
        self.assertEqual(d1["repo"], FEEDBACK_REPO)
        self.assertEqual(d1["issue_number"], 9999)
        self.assertIsNone(d1["issue_url"])  # URL 走 send_tool_message
        self.assertTrue(d1["url_delivered"])

        # 第二次相同提交应被去重拒绝
        self.assertFalse(d2["success"])
        self.assertEqual(d2["reason"], "duplicate")

    def test_rate_limited_branch_when_403_with_zero_remaining(self):
        settings.GITHUB_TOKEN = "ghp_test_token"

        async def fake_post(_self, url, **kw):
            return _FakeResponse(
                403,
                payload={"message": "API rate limit exceeded"},
                headers={"X-RateLimit-Remaining": "0"},
            )

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.AsyncRequestUtils.post_res",
            new=fake_post,
        ):
            result = _run(self.tool.run(**self._good_kwargs()))

        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "rate_limited")
        self.assertTrue(data["url_delivered"])
        # 限流时不应该提示用户去改 token
        self.assertNotIn("Token", data["message"][:80])

    def test_no_permission_branch_when_403_with_remaining(self):
        settings.GITHUB_TOKEN = "ghp_test_token"

        async def fake_post(_self, url, **kw):
            return _FakeResponse(
                403,
                payload={"message": "Resource not accessible by personal access token"},
                headers={"X-RateLimit-Remaining": "4990"},
            )

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.AsyncRequestUtils.post_res",
            new=fake_post,
        ):
            result = _run(self.tool.run(**self._good_kwargs()))

        data = json.loads(result)
        self.assertEqual(data["reason"], "no_permission")
        # 应该提示重新配 token
        self.assertIn("Token", data["message"])

    def test_invalid_payload_branch_when_422(self):
        settings.GITHUB_TOKEN = "ghp_test_token"

        async def fake_post(_self, url, **kw):
            return _FakeResponse(
                422,
                payload={"message": "Validation Failed", "errors": []},
            )

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.AsyncRequestUtils.post_res",
            new=fake_post,
        ):
            result = _run(self.tool.run(**self._good_kwargs()))

        data = json.loads(result)
        self.assertEqual(data["reason"], "invalid_payload")

    def test_network_error_branch_when_exception_raised(self):
        settings.GITHUB_TOKEN = "ghp_test_token"

        async def fake_post(_self, url, **kw):
            raise ConnectionError("simulated DNS failure")

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.AsyncRequestUtils.post_res",
            new=fake_post,
        ):
            result = _run(self.tool.run(**self._good_kwargs()))

        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "network_error")
        self.assertTrue(data["url_delivered"])

    def test_dedup_blocks_repeat_within_window_for_attempted_api_call(self):
        settings.GITHUB_TOKEN = "ghp_test_token"

        async def fake_post(_self, url, **kw):
            return _FakeResponse(500, payload={"message": "internal"})

        with patch(
            "app.agent.tools.impl.submit_feedback_issue.AsyncRequestUtils.post_res",
            new=fake_post,
        ):
            first = _run(self.tool.run(**self._good_kwargs()))
            # 与 success 测试同理：清掉 rate-limit 状态，验证 dedup 独立生效
            SubmitFeedbackIssueTool._user_submissions.clear()
            second = _run(self.tool.run(**self._good_kwargs()))

        d1 = json.loads(first)
        d2 = json.loads(second)
        self.assertEqual(d1["reason"], "github_unavailable")
        # 即便首次失败也应进入 dedup 窗口，避免 LLM loop 不断重试同一提交
        self.assertEqual(d2["reason"], "duplicate")

    # ------------------------------------------------------------------
    # 内容质量门槛
    # ------------------------------------------------------------------
    def test_rejects_short_description(self):
        result = _run(self.tool.run(**self._good_kwargs(description="只有这么几个字")))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertIn("问题描述太短", data["message"])

    def test_rejects_short_title(self):
        result = _run(self.tool.run(**self._good_kwargs(title="[错误报告]: 短")))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertIn("标题正文太短", data["message"])

    def test_rejects_blocklisted_phrase_in_title(self):
        result = _run(self.tool.run(**self._good_kwargs(
            title="[错误报告]: 这是一个测试 issue 看看"
        )))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertIn("测试 issue", data["message"])

    def test_rejects_pipeline_test_intent_phrases(self):
        # "我是开发者，反馈一个测试 ISSUE，看能否跑通" 这类口语化请求
        # 不能被 Agent 改写成真实样式 Issue 后提交到上游。
        for phrase in ("看能否跑通", "跑通流程", "链路测试", "测试提交"):
            with self.subTest(phrase=phrase):
                result = _run(self.tool.run(**self._good_kwargs(
                    title=f"[错误报告]: 订阅刷新接口异常{phrase}",
                )))
                data = json.loads(result)
                self.assertEqual(data["reason"], "rejected_quality")
                self.assertIn(phrase, data["message"])

    def test_rejects_pipeline_test_intent_from_original_request(self):
        # 即使 title/description 被 Agent 改写成真实样式，只要原始用户请求
        # 暴露了"测试 ISSUE / 看能否跑通"意图，也必须在工具层拒绝。
        context = {}
        self.tool.set_agent_context(context)
        result = _run(self.tool.run(**self._good_kwargs(
            title="[错误报告]: TMDB识别错误，将《吞噬星空》识别为其他作品",
            original_user_request="我是开发者，为我反馈一个测试 ISSUE，看能否跑通",
            description=(
                "## 现象\n"
                "TMDB识别错误，将动画《吞噬星空》识别为其他作品。\n\n"
                "## 复现步骤\n"
                "1. 搜索或订阅《吞噬星空》\n"
                "2. 系统尝试识别该媒体\n"
                "3. 识别结果错误，匹配到其他作品\n\n"
                "## 期望行为\n"
                "正确识别《吞噬星空》并匹配正确的TMDB ID。"
            ),
        )))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertIn("测试 issue", data["message"])
        self.assertTrue(context.get("feedback_issue_rejected_quality"))
        self.assertIn("测试 issue", context.get("feedback_issue_rejected_quality_reason", ""))

    def test_submit_schema_rejects_logs_parameter(self):
        # 日志已经从 Agent 入参中移除：现在通过 diagnostics_id 在服务端 state
        # store 流转。pydantic schema 不应再声明 logs 字段，确保 LangChain
        # 在调用 _arun 时校验失败，挡住"agent 试图传 logs"的回归。
        from app.agent.tools.impl.submit_feedback_issue import (
            SubmitFeedbackIssueInput,
        )
        self.assertNotIn("logs", SubmitFeedbackIssueInput.model_fields)
        from app.agent.tools.impl.prepare_feedback_issue import (
            PrepareFeedbackIssueInput,
        )
        self.assertNotIn("logs", PrepareFeedbackIssueInput.model_fields)

    def test_rejects_unstructured_synthetic_description(self):
        # 截图里的第二次路径会把一句泛泛的"用户反馈..."提交成正式 Issue；
        # 工具层应要求至少包含现象 / 复现 / 期望信号，防止伪造问题跑通链路。
        result = _run(self.tool.run(**self._good_kwargs(
            title="[错误报告]: 下载任务完成后无法自动移动文件",
            description=(
                "用户反馈在下载任务完成后，系统无法按照配置的规则自动将文件移动到"
                "媒体库目录。请协助排查转移模块与下载器之间的联动是否存在异常。"
            ),
        )))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertIn("结构信息", data["message"])

    def test_rejects_gibberish_repeat_pattern(self):
        # 用不在黑词单里的字符做 ≥8 连重复（"为" * 9），并搭配足够长的中文
        # 正文凑过 50 字门槛但不踩 lorem/test 等黑词
        result = _run(self.tool.run(**self._good_kwargs(
            description="为为为为为为为为为 这里再写一段足够长的正文描述实际问题"
                        "包含现象与复现步骤以及预期行为，方便维护者跟进"
        )))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertIn("乱码", data["message"])

    def test_quality_reject_does_not_emit_prefill_url(self):
        # 质量拒绝必须**不**返回 prefill_url——不能给"测试 issue"留旁路
        result = _run(self.tool.run(**self._good_kwargs(description="x")))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rejected_quality")
        self.assertNotIn("prefill_url", data)
        self.assertEqual(self.push_calls, [])

    # ------------------------------------------------------------------
    # Per-user rate limit
    # ------------------------------------------------------------------
    def test_rate_limit_cooldown_kicks_in_after_first_submission(self):
        # 第一次走 no_token 兜底就会 _record_user_submission；第二次立即重试
        # 应该被 30 分钟冷却挡掉
        self.tool._username = "admin1"
        first = _run(self.tool.run(**self._good_kwargs()))
        d1 = json.loads(first)
        self.assertEqual(d1["reason"], "no_token")

        # 紧接着第二次（不同标题，绕过 dedup）
        second_kwargs = self._good_kwargs(
            title="[错误报告]: 另一个完全不同的后端报错"
        )
        second = _run(self.tool.run(**second_kwargs))
        d2 = json.loads(second)
        self.assertEqual(d2["reason"], "rate_limited_user")
        # rate limit 命中后仍要推送 prefill_url 让用户有手动路径
        self.assertTrue(d2["url_delivered"])
        self.assertIn("30 分钟", d2["message"])

    def test_rate_limit_daily_quota_exhausts_after_n_submissions(self):
        self.tool._username = "admin1"
        # 直接灌满 quota：手动写入 10 条 24h 内的时间戳（绕过冷却需要把它们
        # 设成都 > 30 分钟前，让冷却放行但 quota 已满）
        long_ago = time.time() - (40 * 60)  # 40 分钟前，绕过 30 分钟冷却
        SubmitFeedbackIssueTool._user_submissions["admin1"] = [
            long_ago - i for i in range(10)
        ]
        result = _run(self.tool.run(**self._good_kwargs()))
        data = json.loads(result)
        self.assertEqual(data["reason"], "rate_limited_user")
        self.assertIn("24 小时配额", data["message"])

    def test_rate_limit_resets_for_different_user(self):
        # 即使一个用户被限流，另一个 admin 不应受影响
        SubmitFeedbackIssueTool._user_submissions["admin1"] = [time.time()]
        self.tool._username = "admin2"
        result = _run(self.tool.run(**self._good_kwargs()))
        data = json.loads(result)
        # admin2 没用过额度，走 no_token 兜底而不是 rate_limited
        self.assertEqual(data["reason"], "no_token")


class TestSubmitFeedbackIssueFactoryRegistration(unittest.TestCase):
    def test_factory_registers_submit_feedback_issue_tool(self):
        with patch(
            "app.agent.tools.factory.PluginManager.get_plugin_agent_tools",
            return_value=[],
        ):
            tools = MoviePilotToolFactory.create_tools(
                session_id="feedback-issue-session",
                user_id="10001",
            )

        tool_names = {tool.name for tool in tools}
        self.assertIn("collect_feedback_diagnostics", tool_names)
        self.assertIn("prepare_feedback_issue", tool_names)
        self.assertIn("submit_feedback_issue", tool_names)


class TestCollectFeedbackDiagnosticsFiltering(unittest.TestCase):
    """``_normalize_keywords`` / ``_filter_lines`` 的纯函数测试。"""

    def test_normalize_keywords_drops_vague_terms(self):
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool,
        )

        out = CollectFeedbackDiagnosticsTool._normalize_keywords(
            "今天 TMDB 一直在报错，反馈这个问题",
            ["TMDB", "错误", "异常", "scrape_metadata", "x"],  # x 太短
        )
        # 通用词被剔除，具体词保留
        self.assertIn("TMDB", out)
        self.assertIn("scrape_metadata", out)
        self.assertNotIn("错误", out)
        self.assertNotIn("异常", out)
        self.assertNotIn("x", out)

    def test_filter_lines_excludes_history_outside_time_window(self):
        from datetime import datetime, timedelta
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool,
        )

        now = datetime.now()
        old = now - timedelta(hours=3)
        recent = now - timedelta(minutes=5)
        text = "\n".join([
            f"【INFO】{old.strftime('%Y-%m-%d %H:%M:%S')},123 - tmdb - TMDB lookup failed (历史)",
            f"【ERROR】{recent.strftime('%Y-%m-%d %H:%M:%S')},123 - tmdb - TMDB lookup failed (当前)",
            "    Traceback (most recent call last):",
            "      File 'x.py', line 1, in <module>",
        ])
        out = CollectFeedbackDiagnosticsTool._filter_lines(
            text,
            keywords=["TMDB"],
            max_lines=80,
            window_start=now - timedelta(minutes=30),
        )
        joined = "\n".join(out)
        self.assertIn("当前", joined)
        self.assertNotIn("历史", joined)
        # Traceback 续行紧跟在窗口内的 ERROR 行后面，应保留
        self.assertIn("Traceback", joined)

    def test_filter_lines_drops_agent_meta_noise(self):
        """#5808 教训：诊断段几乎全是 agent 自身 tool dispatch / 消息推送日志，
        真正的 RateLimitError 被挤掉。filter 必须把 meta-noise 模块剔除。"""
        from datetime import datetime, timedelta
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool,
        )

        now = datetime.now()
        recent = (now - timedelta(minutes=5)).strftime("%Y-%m-%d %H:%M:%S")
        text = "\n".join([
            f"【DEBUG】{recent},100 - base.py - Executing tool collect_feedback_diagnostics ...",
            f"【INFO】{recent},110 - agent - Agent推理: input=大模型出错",
            f"【INFO】{recent},120 - message.py - 发送消息：{{'title': '确认提交问题反馈'...}}",
            f"【DEBUG】{recent},130 - chain - 请求系统模块执行：post_message",
            f"【DEBUG】{recent},140 - telegram - 收到来自 TG.v2 的Telegram消息",
            f"【ERROR】{recent},200 - app.modules.openai - RateLimitError 429",
            "    Traceback (most recent call last):",
            f"【WARNING】{recent},300 - app.chain.recommend - 推荐接口降级",
        ])
        out = CollectFeedbackDiagnosticsTool._filter_lines(
            text, keywords=["大模型", "RateLimitError"], max_lines=80,
            window_start=now - timedelta(minutes=30),
        )
        joined = "\n".join(out)
        # meta-noise 全部丢弃
        for noise in ("Executing tool", "Agent推理", "发送消息", "post_message",
                      "TG.v2 的Telegram消息"):
            self.assertNotIn(noise, joined, msg=f"agent meta-noise 漏过: {noise}")
        # 真实信号保留
        self.assertIn("RateLimitError", joined)
        self.assertIn("Traceback", joined)
        # WARNING 行不命中 keywords 但属于真实模块——这里不强求保留
        # （keyword 过滤逻辑不改）

    def test_filter_lines_drops_orphan_continuations_outside_window(self):
        # 续行所属的最近一条时间戳在窗口外时不应被错误收入
        from datetime import datetime, timedelta
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool,
        )

        now = datetime.now()
        old = now - timedelta(hours=3)
        text = "\n".join([
            f"【ERROR】{old.strftime('%Y-%m-%d %H:%M:%S')},000 - tmdb - 历史报错",
            "    Traceback (历史续行)",
        ])
        out = CollectFeedbackDiagnosticsTool._filter_lines(
            text, keywords=["TMDB"], max_lines=80,
            window_start=now - timedelta(minutes=30),
        )
        self.assertEqual(out, [])


class TestCollectFeedbackDiagnosticsIntentGate(unittest.TestCase):
    """入口意图门：用户原话没有"反馈/提 issue"等明确意图时，工具必须拒绝。

    防止 Agent 在用户随口提到「TMDB 报错」「下载没动」时擅自跳过本地诊断、
    直接跳进反馈流程刷上游 Issue 列表。"""

    def setUp(self):
        from app.agent.tools.impl.feedback_issue_state import feedback_issue_state_store

        feedback_issue_state_store.clear()

    def _build_tool(self):
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool,
        )

        return CollectFeedbackDiagnosticsTool(session_id="s", user_id="42")

    def test_has_explicit_feedback_intent_recognizes_chinese_phrases(self):
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool as T,
        )

        for explicit in (
            "今天 TMDB 一直在报错，反馈这个问题",  # 含"反馈"
            "TMDB 出错了，帮我提 issue",
            "给 MP 提个 bug，下载没动",
            "让上游修一下这个错",
            "submit an issue: telegram bot keeps disconnecting",
            "请提交问题反馈：scrape 总失败",
        ):
            self.assertTrue(
                T._has_explicit_feedback_intent(explicit),
                msg=f"应识别为明确反馈意图: {explicit!r}",
            )

    def test_has_explicit_feedback_intent_rejects_plain_complaints(self):
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool as T,
        )

        for plain in (
            "TMDB 一直在报错",  # 仅描述问题、没要求反馈
            "下载没动了，怎么办",
            "订阅没生效",
            "图片刷不出来",
            "数据库响应比较慢",
            "TMDB API failing today",
        ):
            self.assertFalse(
                T._has_explicit_feedback_intent(plain),
                msg=f"不应识别为反馈意图: {plain!r}",
            )

    def test_run_refuses_without_explicit_intent(self):
        tool = self._build_tool()
        result = asyncio.run(
            tool.run(
                explanation="x",
                original_user_request="TMDB 报错了",
                keywords=["TMDB"],
            )
        )
        data = json.loads(result)
        self.assertFalse(data["success"])
        self.assertEqual(data["reason"], "no_explicit_feedback_intent")
        # 引导回归本地诊断路径
        self.assertIn("query_subscribes", data["message"])

    def test_run_allows_with_explicit_intent(self):
        # 配上路径 stub 让真实路径不读磁盘
        from datetime import datetime
        from pathlib import Path
        from app.agent.tools.impl import collect_feedback_diagnostics as cfd

        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        log_text = f"【ERROR】{now_str},000 - tmdb - TMDB lookup failed"

        tool = self._build_tool()
        with patch.object(
            cfd.CollectFeedbackDiagnosticsTool,
            "_read_tail",
            return_value=log_text,
        ), patch.object(
            cfd.CollectFeedbackDiagnosticsTool,
            "_candidate_log_files",
            return_value=[Path("/fake/moviepilot.log")],
        ):
            result = asyncio.run(
                tool.run(
                    explanation="x",
                    original_user_request="TMDB 报错，反馈 issue",
                    keywords=["TMDB"],
                )
            )
        data = json.loads(result)
        # 走完正常路径
        self.assertTrue(data["success"])
        self.assertIn("diagnostics_id", data)


class TestCollectFeedbackDiagnosticsResponse(unittest.TestCase):
    """``collect_feedback_diagnostics`` 必须把日志只缓存到 state store，
    不能把日志正文回流到 LLM 上下文里。曾经返回完整 logs，导致 LLM 在下
    一步把 6KB 日志重新当 args 传给 prepare 工具，单轮延迟到分钟级。
    这个保护用 unit test 钉死。"""

    def setUp(self):
        from app.agent.tools.impl.feedback_issue_state import feedback_issue_state_store

        feedback_issue_state_store.clear()
        self._state_store = feedback_issue_state_store

    def _build_tool(self):
        from app.agent.tools.impl.collect_feedback_diagnostics import (
            CollectFeedbackDiagnosticsTool,
        )

        return CollectFeedbackDiagnosticsTool(
            session_id="sess",
            user_id="42",
        )

    def test_run_does_not_return_raw_log_text(self):
        from datetime import datetime
        from pathlib import Path
        from app.agent.tools.impl import collect_feedback_diagnostics as cfd

        # 用近 1 分钟内的时间戳，确保通过时间窗过滤
        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        big_log = "\n".join(
            f"【ERROR】{now_str},000 - mod{i} - ERROR something" for i in range(500)
        )
        tool = self._build_tool()
        with patch.object(
            cfd.CollectFeedbackDiagnosticsTool,
            "_read_tail",
            return_value=big_log,
        ), patch.object(
            cfd.CollectFeedbackDiagnosticsTool,
            "_candidate_log_files",
            return_value=[Path("/fake/moviepilot.log")],
        ):
            result = asyncio.run(
                tool.run(
                    explanation="x",
                    # 必须带明确反馈意图，否则被入口门拦下；这里同时验
                    # 证日志正文不会回流到 LLM。
                    original_user_request="something is broken，帮我提 issue",
                    keywords=["ERROR"],
                )
            )

        data = json.loads(result)
        # 关键不变量：返回值不含 logs 字段，也不含任何日志正文片段
        self.assertNotIn("logs", data)
        for key, value in data.items():
            if isinstance(value, str):
                self.assertNotIn(
                    "ERROR something",
                    value,
                    msg=f"字段 {key} 泄漏了日志正文：{value[:80]!r}",
                )
        # 必带的摘要字段
        self.assertIn("diagnostics_id", data)
        self.assertIn("log_bytes", data)
        self.assertIn("log_lines", data)
        # 日志确实进了 state store
        record = self._state_store.get_diagnostics(
            data["diagnostics_id"], session_id="sess", user_id="42"
        )
        self.assertIsNotNone(record)
        self.assertIn("ERROR something", record.logs)


if __name__ == "__main__":
    unittest.main()