archived-MoviePilot/tests/test_feishu.py

import sys
import asyncio
import json
import tempfile
import unittest
from types import ModuleType, SimpleNamespace
from unittest.mock import ANY, MagicMock, patch


sys.modules.setdefault("psutil", ModuleType("psutil"))
sys.modules.setdefault("cn2an", ModuleType("cn2an"))
sys.modules.setdefault("dateparser", ModuleType("dateparser"))

if "Pinyin2Hanzi" not in sys.modules:
    pinyin_module = ModuleType("Pinyin2Hanzi")
    setattr(pinyin_module, "is_pinyin", lambda value: False)
    sys.modules["Pinyin2Hanzi"] = pinyin_module

from app.modules.feishu import FeishuModule
from app.modules.feishu.feishu import Feishu
from app.schemas import Notification
from app.schemas.message import (
    ChannelCapability,
    ChannelCapabilityManager,
    MessageResponse,
)
from app.schemas.types import MessageChannel, NotificationType


class TestFeishu(unittest.TestCase):
    @staticmethod
    def _build_client(**kwargs) -> Feishu:
        with (
            patch.object(Feishu, "_build_api_client", return_value=MagicMock()),
            patch.object(Feishu, "_start_ws_client"),
        ):
            return Feishu(
                FEISHU_APP_ID="cli_test_app_id",
                FEISHU_APP_SECRET="cli_test_app_secret",
                name="feishu-test",
                **kwargs,
            )

    @staticmethod
    def _success_response(message_id="om_test", chat_id="oc_test"):
        response = MagicMock()
        response.success.return_value = True
        response.data = SimpleNamespace(
            message_id=message_id,
            chat_id=chat_id,
            msg_type="interactive",
        )
        return response

    @staticmethod
    def _reaction_success_response(reaction_id="reaction_test"):
        response = MagicMock()
        response.success.return_value = True
        response.data = SimpleNamespace(reaction_id=reaction_id)
        return response

    @staticmethod
    def _card_create_success_response(card_id="card_test"):
        response = MagicMock()
        response.success.return_value = True
        response.data = SimpleNamespace(card_id=card_id)
        return response

    @staticmethod
    def _build_message_api(
        create_response=None,
        patch_response=None,
        reply_response=None,
        reaction_create_response=None,
        reaction_delete_response=None,
        card_create_response=None,
        card_settings_response=None,
        card_content_response=None,
        image_create_response=None,
        file_create_response=None,
        image_get_response=None,
        file_get_response=None,
        message_resource_response=None,
    ):
        message_api = SimpleNamespace(
            create=MagicMock(return_value=create_response),
            patch=MagicMock(return_value=patch_response),
            reply=MagicMock(return_value=reply_response),
            update=MagicMock(),
        )
        message_reaction_api = SimpleNamespace(
            create=MagicMock(return_value=reaction_create_response),
            delete=MagicMock(return_value=reaction_delete_response),
        )
        image_api = SimpleNamespace(
            create=MagicMock(return_value=image_create_response),
            get=MagicMock(return_value=image_get_response),
        )
        file_api = SimpleNamespace(
            create=MagicMock(return_value=file_create_response),
            get=MagicMock(return_value=file_get_response),
        )
        message_resource_api = SimpleNamespace(
            get=MagicMock(return_value=message_resource_response),
        )
        api_client = SimpleNamespace(
            im=SimpleNamespace(
                v1=SimpleNamespace(
                    message=message_api,
                    message_reaction=message_reaction_api,
                    image=image_api,
                    file=file_api,
                    message_resource=message_resource_api,
                )
            ),
            cardkit=SimpleNamespace(
                v1=SimpleNamespace(
                    card=SimpleNamespace(
                        create=MagicMock(return_value=card_create_response),
                        settings=MagicMock(return_value=card_settings_response),
                    ),
                    card_element=SimpleNamespace(
                        content=MagicMock(return_value=card_content_response),
                    ),
                )
            ),
        )
        return api_client, message_api

    @staticmethod
    def _resource_response(
        content: bytes,
        file_name: str = "resource.bin",
        content_type: str = "application/octet-stream",
    ):
        response = MagicMock()
        response.code = 0
        response.file = MagicMock()
        response.file.read.return_value = content
        response.file_name = file_name
        response.raw = SimpleNamespace(headers={"Content-Type": content_type})
        return response

    def test_parse_message_returns_callback_message(self):
        client = self._build_client()

        with patch("app.modules.feishu.feishu.UserOper.get_name", return_value=None):
            result = client.parse_message(
                {
                    "type": "cardAction",
                    "callback_data": "approve",
                    "message_id": "om_123",
                    "chat_id": "oc_123",
                    "sender": {
                        "open_id": "ou_user_1",
                        "user_id": "u_user_1",
                        "name": "tester",
                    },
                }
            )

        self.assertIsNotNone(result)
        self.assertEqual(result.channel, MessageChannel.Feishu)
        self.assertEqual(result.userid, "ou_user_1")
        self.assertEqual(result.text, "CALLBACK:approve")
        self.assertTrue(result.is_callback)
        self.assertEqual(result.chat_id, "oc_123")

    def test_extract_card_callback_data_supports_new_and_legacy_values(self):
        self.assertEqual(
            Feishu._extract_card_callback_data({"callback_data": "approve"}),
            "approve",
        )
        self.assertEqual(
            Feishu._extract_card_callback_data({"value": "legacy"}),
            "legacy",
        )
        self.assertEqual(
            Feishu._extract_card_callback_data("direct"),
            "direct",
        )
        self.assertEqual(
            Feishu._extract_card_callback_data({}, name="fallback"),
            "fallback",
        )

    def test_build_event_handler_registers_common_im_events(self):
        registered = []

        class _Builder:
            def __getattr__(self, name):
                if name.startswith("register_"):

                    def _register(handler):
                        registered.append(name)
                        return self

                    return _register
                raise AttributeError(name)

            def build(self):
                return "handler"

        client = self._build_client()
        fake_builder = _Builder()

        with patch(
            "app.modules.feishu.feishu.lark.EventDispatcherHandler.builder",
            return_value=fake_builder,
        ):
            handler = client._build_event_handler()

        self.assertEqual(handler, "handler")
        self.assertIn("register_p2_im_message_receive_v1", registered)
        self.assertIn("register_p2_im_message_message_read_v1", registered)
        self.assertIn("register_p2_im_message_reaction_created_v1", registered)
        self.assertIn("register_p2_im_message_reaction_deleted_v1", registered)
        self.assertIn("register_p2_im_message_recalled_v1", registered)
        self.assertIn(
            "register_p2_im_chat_access_event_bot_p2p_chat_entered_v1", registered
        )
        self.assertIn("register_p2_card_action_trigger", registered)

    def test_parse_message_blocks_non_admin_command(self):
        client = self._build_client(FEISHU_ADMINS="ou_admin")

        with (
            patch("app.modules.feishu.feishu.UserOper.get_name", return_value=None),
            patch.object(
                client, "send_text", return_value={"success": True}
            ) as send_text,
        ):
            result = client.parse_message(
                {
                    "type": "message",
                    "text": "/help",
                    "chat_id": "oc_chat_1",
                    "sender": {
                        "open_id": "ou_user_2",
                        "user_id": "u_user_2",
                        "name": "tester",
                    },
                }
            )

        self.assertIsNone(result)
        send_text.assert_called_once_with(
            "只有管理员才有权限执行此命令",
            userid="ou_user_2",
            chat_id="oc_chat_1",
            receive_id_type="open_id",
        )

    def test_parse_message_maps_feishu_ids_to_moviepilot_username(self):
        client = self._build_client()

        with patch(
            "app.modules.feishu.feishu.UserOper.get_name",
            return_value="moviepilot-user",
        ) as get_name:
            result = client.parse_message(
                {
                    "type": "message",
                    "text": "/ai 添加黑客帝国订阅",
                    "sender": {
                        "open_id": "ou_bound_user",
                        "user_id": "u_bound_user",
                        "name": "ou_bound_user",
                    },
                }
            )

        self.assertIsNotNone(result)
        self.assertEqual(result.userid, "ou_bound_user")
        self.assertEqual(result.username, "moviepilot-user")
        get_name.assert_called_once_with(
            feishu_openid="ou_bound_user",
            feishu_userid="u_bound_user",
        )

    def test_send_notification_uses_direct_card_content(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response()
        )

        result = client.send_notification(
            Notification(
                title="测试标题",
                text="测试正文",
                buttons=[[{"text": "确认", "callback_data": "confirm"}]],
            ),
            userid="ou_user_3",
        )

        self.assertTrue(result["success"])
        request = message_api.create.call_args.args[0]
        self.assertEqual(request.receive_id_type, "open_id")
        self.assertEqual(request.request_body.msg_type, "interactive")

        content = json.loads(request.request_body.content)
        self.assertNotIn("card", content)
        self.assertEqual(content["schema"], "2.0")
        self.assertTrue(content["config"]["update_multi"])
        self.assertEqual(content["body"]["padding"], "12px 12px 12px 12px")
        self.assertEqual(content["body"]["elements"][0]["text_size"], "heading")
        self.assertEqual(content["body"]["elements"][0]["tag"], "markdown")
        button = content["body"]["elements"][-1]["columns"][0]["elements"][0]
        self.assertEqual(button["tag"], "button")
        self.assertNotIn("value", button)
        self.assertEqual(
            button["behaviors"],
            [{"type": "callback", "value": {"callback_data": "confirm"}}],
        )

    def test_send_notification_keeps_markdown_images_for_normal_card(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response()
        )

        result = client.send_notification(
            Notification(
                title="普通通知",
                text="海报：![poster](https://example.com/poster.jpg)",
            ),
            userid="ou_user_img_md",
        )

        self.assertTrue(result["success"])
        request = message_api.create.call_args.args[0]
        content = json.loads(request.request_body.content)
        self.assertEqual(
            content["body"]["elements"][1]["content"],
            "海报：![poster](https://example.com/poster.jpg)",
        )

    def test_send_notification_embeds_remote_image_in_card(self):
        client = self._build_client()
        image_upload_response = MagicMock()
        image_upload_response.success.return_value = True
        image_upload_response.data = SimpleNamespace(image_key="img_v2_remote")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(),
            image_create_response=image_upload_response,
        )

        response = MagicMock()
        response.content = b"png-bytes"
        response.headers = {"Content-Type": "image/png"}

        with patch("app.modules.feishu.feishu.RequestUtils") as request_utils:
            request_utils.return_value.get_res.return_value = response
            result = client.send_notification(
                Notification(
                    title="测试标题",
                    text="测试正文",
                    image="https://example.com/poster.png",
                    buttons=[[{"text": "确认", "callback_data": "confirm"}]],
                ),
                userid="ou_user_img",
            )

        self.assertTrue(result["success"])
        response.close.assert_called_once()
        client._api_client.im.v1.image.create.assert_called_once()
        request = message_api.create.call_args.args[0]
        self.assertEqual(request.request_body.msg_type, "interactive")
        content = json.loads(request.request_body.content)
        self.assertEqual(content["body"]["padding"], "0px 0px 0px 0px")
        image_element = content["body"]["elements"][0]
        self.assertEqual(image_element["tag"], "img")
        self.assertEqual(image_element["img_key"], "img_v2_remote")
        self.assertEqual(content["body"]["elements"][1]["margin"], "12px 12px 0px 12px")
        self.assertEqual(content["body"]["elements"][2]["margin"], "4px 12px 12px 12px")
        self.assertEqual(
            content["body"]["elements"][-1]["margin"], "0px 12px 12px 12px"
        )
        self.assertEqual(content["body"]["elements"][-1]["tag"], "column_set")

    def test_send_notification_supports_user_id_target(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response()
        )

        client.send_notification(
            Notification(title="测试标题", text="测试正文"),
            userid="u_user_4",
            receive_id_type="user_id",
        )

        request = message_api.create.call_args.args[0]
        self.assertEqual(request.receive_id_type, "user_id")

    def test_edit_message_uses_patch_api_for_cards(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response()
        )

        success = client.edit_message(
            message_id="om_456",
            title="测试标题",
            text="测试正文",
            buttons=[[{"text": "确认", "callback_data": "confirm"}]],
        )

        self.assertTrue(success)
        message_api.patch.assert_called_once()
        message_api.update.assert_not_called()

        request = message_api.patch.call_args.args[0]
        self.assertEqual(request.message_id, "om_456")
        content = json.loads(request.request_body.content)
        self.assertNotIn("card", content)
        self.assertEqual(content["schema"], "2.0")
        self.assertTrue(content["config"]["update_multi"])
        self.assertEqual(content["body"]["elements"][0]["tag"], "markdown")
        button = content["body"]["elements"][-1]["columns"][0]["elements"][0]
        self.assertEqual(
            button["behaviors"],
            [{"type": "callback", "value": {"callback_data": "confirm"}}],
        )

    def test_send_notification_replies_when_original_message_id_is_present(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            reply_response=self._success_response(message_id="om_reply")
        )

        result = client.send_notification(
            Notification(title="回复标题", text="回复正文"),
            userid="ou_user_9",
            original_message_id="om_origin",
        )

        self.assertTrue(result["success"])
        message_api.reply.assert_called_once()
        request = message_api.reply.call_args.args[0]
        self.assertEqual(request.message_id, "om_origin")
        self.assertEqual(request.request_body.msg_type, "interactive")

    def test_message_reaction_create_and_delete_use_official_api(self):
        client = self._build_client()
        client._api_client, _ = self._build_message_api(
            reaction_create_response=self._reaction_success_response("reaction_1"),
            reaction_delete_response=self._success_response(),
        )

        reaction_id = client.add_message_reaction(
            "om_origin", Feishu.PROCESSING_REACTION_EMOJI
        )
        deleted = client.delete_message_reaction("om_origin", "reaction_1")

        self.assertEqual(reaction_id, "reaction_1")
        self.assertTrue(deleted)
        create_request = (
            client._api_client.im.v1.message_reaction.create.call_args.args[0]
        )
        self.assertEqual(create_request.message_id, "om_origin")
        self.assertEqual(
            create_request.request_body.reaction_type.emoji_type,
            Feishu.PROCESSING_REACTION_EMOJI,
        )
        delete_request = (
            client._api_client.im.v1.message_reaction.delete.call_args.args[0]
        )
        self.assertEqual(delete_request.message_id, "om_origin")
        self.assertEqual(delete_request.reaction_id, "reaction_1")

    def test_send_notification_uses_streaming_card_for_agent_text(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(
                message_id="om_stream", chat_id="oc_stream"
            ),
            card_create_response=self._card_create_success_response("card_stream"),
        )

        result = client.send_notification(
            Notification(
                mtype=NotificationType.Agent,
                title="MoviePilot助手",
                text="第一帧内容",
            ),
            userid="ou_user_stream",
        )

        self.assertTrue(result["success"])
        self.assertEqual(
            result["metadata"]["feishu_streaming"]["card_id"], "card_stream"
        )
        self.assertEqual(result["metadata"]["feishu_streaming"]["sequence"], 0)
        self.assertEqual(result["metadata"]["feishu_streaming"]["sent_image_urls"], [])
        card_request = client._api_client.cardkit.v1.card.create.call_args.args[0]
        self.assertEqual(card_request.request_body.type, "card_json")
        card_payload = json.loads(card_request.request_body.data)
        self.assertTrue(card_payload["config"]["streaming_mode"])
        self.assertEqual(
            card_payload["body"]["elements"][-1]["element_id"],
            Feishu.STREAM_CARD_BODY_ELEMENT_ID,
        )
        message_request = message_api.create.call_args.args[0]
        self.assertEqual(message_request.request_body.msg_type, "interactive")
        self.assertEqual(
            json.loads(message_request.request_body.content)["data"]["card_id"],
            "card_stream",
        )

    def test_streaming_card_sends_markdown_images_separately(self):
        client = self._build_client()
        image_upload_response = MagicMock()
        image_upload_response.success.return_value = True
        image_upload_response.data = SimpleNamespace(image_key="img_v2_stream")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(
                message_id="om_stream", chat_id="oc_stream"
            ),
            card_create_response=self._card_create_success_response("card_stream"),
            image_create_response=image_upload_response,
        )
        response = MagicMock()
        response.content = b"png-bytes"
        response.headers = {"Content-Type": "image/jpeg"}

        with patch("app.modules.feishu.feishu.RequestUtils") as request_utils:
            request_utils.return_value.get_res.return_value = response
            result = client.send_notification(
                Notification(
                    mtype=NotificationType.Agent,
                    title="MoviePilot助手",
                    text="找到海报 ![poster](https://example.com/poster.jpg)\n[详情](https://example.com/detail)",
                ),
                userid="ou_user_stream",
            )

        self.assertTrue(result["success"])
        card_request = client._api_client.cardkit.v1.card.create.call_args.args[0]
        card_payload = json.loads(card_request.request_body.data)
        body_content = card_payload["body"]["elements"][-1]["content"]
        self.assertNotIn("![poster]", body_content)
        self.assertNotIn("poster.jpg", body_content)
        self.assertIn("poster", body_content)
        self.assertIn("[详情](https://example.com/detail)", body_content)
        self.assertEqual(client._api_client.im.v1.image.create.call_count, 1)
        self.assertEqual(message_api.create.call_count, 2)
        self.assertEqual(
            result["metadata"]["feishu_streaming"]["sent_image_urls"],
            ["https://example.com/poster.jpg"],
        )
        image_request = message_api.create.call_args_list[-1].args[0]
        image_payload = json.loads(image_request.request_body.content)
        self.assertEqual(image_payload["body"]["elements"][0]["img_key"], "img_v2_stream")

    def test_streaming_card_sends_notification_image_separately(self):
        client = self._build_client()
        image_upload_response = MagicMock()
        image_upload_response.success.return_value = True
        image_upload_response.data = SimpleNamespace(image_key="img_v2_agent_image")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(
                message_id="om_stream", chat_id="oc_stream"
            ),
            card_create_response=self._card_create_success_response("card_stream"),
            image_create_response=image_upload_response,
        )
        response = MagicMock()
        response.content = b"png-bytes"
        response.headers = {"Content-Type": "image/png"}

        with patch("app.modules.feishu.feishu.RequestUtils") as request_utils:
            request_utils.return_value.get_res.return_value = response
            result = client.send_notification(
                Notification(
                    mtype=NotificationType.Agent,
                    title="MoviePilot助手",
                    text="第一帧内容",
                    image="https://example.com/agent.png",
                ),
                userid="ou_user_stream",
            )

        self.assertTrue(result["success"])
        self.assertEqual(client._api_client.im.v1.image.create.call_count, 1)
        self.assertEqual(message_api.create.call_count, 2)
        self.assertEqual(
            result["metadata"]["feishu_streaming"]["sent_image_urls"],
            ["https://example.com/agent.png"],
        )
        stream_request = message_api.create.call_args_list[0].args[0]
        image_request = message_api.create.call_args_list[1].args[0]
        self.assertEqual(
            json.loads(stream_request.request_body.content)["data"]["card_id"],
            "card_stream",
        )
        image_payload = json.loads(image_request.request_body.content)
        self.assertEqual(
            image_payload["body"]["elements"][0]["img_key"],
            "img_v2_agent_image",
        )

    def test_send_notification_replies_with_streaming_card_for_agent_text(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            reply_response=self._success_response(
                message_id="om_reply", chat_id="oc_stream"
            ),
            card_create_response=self._card_create_success_response("card_stream"),
        )

        result = client.send_notification(
            Notification(
                mtype=NotificationType.Agent,
                title="MoviePilot助手",
                text="第一帧内容",
            ),
            userid="ou_user_stream",
            original_message_id="om_origin",
        )

        self.assertTrue(result["success"])
        message_api.create.assert_not_called()
        reply_request = message_api.reply.call_args.args[0]
        self.assertEqual(reply_request.message_id, "om_origin")
        self.assertEqual(reply_request.request_body.msg_type, "interactive")
        self.assertEqual(
            json.loads(reply_request.request_body.content)["data"]["card_id"],
            "card_stream",
        )
        self.assertEqual(result["metadata"]["feishu_streaming"]["sequence"], 0)

    def test_edit_replied_streaming_card_uses_first_increment_sequence(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )

        success = client.edit_message(
            message_id="om_reply",
            text="补充内容",
            metadata={
                "feishu_streaming": {
                    "card_id": "card_stream",
                    "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                    "sequence": 0,
                    "sent_image_urls": ["https://example.com/poster.jpg"],
                }
            },
        )

        self.assertTrue(success)
        message_api.patch.assert_not_called()
        content_request = (
            client._api_client.cardkit.v1.card_element.content.call_args.args[0]
        )
        self.assertEqual(content_request.request_body.sequence, 1)

    def test_edit_message_uses_cardkit_content_for_streaming_card(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )

        success = client.edit_message(
            message_id="om_stream",
            text="第二帧内容",
            metadata={
                "feishu_streaming": {
                    "card_id": "card_stream",
                    "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                    "sequence": 0,
                    "sent_image_urls": ["https://example.com/poster.jpg"],
                }
            },
        )

        self.assertTrue(success)
        client._api_client.cardkit.v1.card_element.content.assert_called_once()
        message_api.patch.assert_not_called()
        content_request = (
            client._api_client.cardkit.v1.card_element.content.call_args.args[0]
        )
        self.assertEqual(content_request.card_id, "card_stream")
        self.assertEqual(content_request.element_id, Feishu.STREAM_CARD_BODY_ELEMENT_ID)
        self.assertEqual(content_request.request_body.sequence, 1)

    def test_edit_streaming_card_removes_markdown_image_syntax(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )

        success = client.edit_message(
            message_id="om_stream",
            text="第二帧 ![poster](https://example.com/poster.jpg)",
            metadata={
                "feishu_streaming": {
                    "card_id": "card_stream",
                    "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                    "sequence": 0,
                    "sent_image_urls": ["https://example.com/poster.jpg"],
                }
            },
        )

        self.assertTrue(success)
        message_api.patch.assert_not_called()
        content_request = (
            client._api_client.cardkit.v1.card_element.content.call_args.args[0]
        )
        self.assertEqual(content_request.request_body.content, "第二帧 poster")

    def test_edit_streaming_card_keeps_normal_markdown_links(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )

        success = client.edit_message(
            message_id="om_stream",
            text="第二帧 [详情](https://example.com/detail)",
            chat_id="oc_stream",
            metadata={
                "feishu_streaming": {
                    "card_id": "card_stream",
                    "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                    "sequence": 0,
                    "sent_image_urls": [],
                }
            },
        )

        self.assertTrue(success)
        message_api.patch.assert_not_called()
        client._api_client.im.v1.image.create.assert_not_called()
        content_request = (
            client._api_client.cardkit.v1.card_element.content.call_args.args[0]
        )
        self.assertEqual(
            content_request.request_body.content,
            "第二帧 [详情](https://example.com/detail)",
        )

    def test_edit_streaming_card_hides_incomplete_markdown_image(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )

        success = client.edit_message(
            message_id="om_stream",
            text="第二帧 ![poster](https://example.com/poster",
            chat_id="oc_stream",
            metadata={
                "feishu_streaming": {
                    "card_id": "card_stream",
                    "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                    "sequence": 0,
                    "sent_image_urls": [],
                }
            },
        )

        self.assertTrue(success)
        message_api.patch.assert_not_called()
        client._api_client.im.v1.image.create.assert_not_called()
        content_request = (
            client._api_client.cardkit.v1.card_element.content.call_args.args[0]
        )
        self.assertEqual(content_request.request_body.content, "第二帧")

    def test_edit_streaming_card_hides_incomplete_markdown_image_alt_text(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )

        success = client.edit_message(
            message_id="om_stream",
            text="第二帧 ![poster",
            chat_id="oc_stream",
            metadata={
                "feishu_streaming": {
                    "card_id": "card_stream",
                    "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                    "sequence": 0,
                    "sent_image_urls": [],
                }
            },
        )

        self.assertTrue(success)
        message_api.patch.assert_not_called()
        client._api_client.im.v1.image.create.assert_not_called()
        content_request = (
            client._api_client.cardkit.v1.card_element.content.call_args.args[0]
        )
        self.assertEqual(content_request.request_body.content, "第二帧")

    def test_edit_streaming_card_sends_completed_markdown_image_once(self):
        client = self._build_client()
        image_upload_response = MagicMock()
        image_upload_response.success.return_value = True
        image_upload_response.data = SimpleNamespace(image_key="img_v2_stream_edit")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(message_id="om_img", chat_id="oc_stream"),
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
            image_create_response=image_upload_response,
        )
        metadata = {
            "feishu_streaming": {
                "card_id": "card_stream",
                "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                "sequence": 0,
                "sent_image_urls": [],
            }
        }
        response = MagicMock()
        response.content = b"jpg-bytes"
        response.headers = {"Content-Type": "image/jpeg"}

        with patch("app.modules.feishu.feishu.RequestUtils") as request_utils:
            request_utils.return_value.get_res.return_value = response
            first_success = client.edit_message(
                message_id="om_stream",
                text="第二帧 ![poster](https://example.com/poster.jpg)",
                chat_id="oc_stream",
                metadata=metadata,
            )
            second_success = client.edit_message(
                message_id="om_stream",
                text="第二帧 ![poster](https://example.com/poster.jpg)",
                chat_id="oc_stream",
                metadata=metadata,
            )

        self.assertTrue(first_success)
        self.assertTrue(second_success)
        self.assertEqual(client._api_client.im.v1.image.create.call_count, 1)
        self.assertEqual(
            metadata["feishu_streaming"]["sent_image_urls"],
            ["https://example.com/poster.jpg"],
        )
        image_request = message_api.create.call_args.args[0]
        image_payload = json.loads(image_request.request_body.content)
        self.assertEqual(
            image_payload["body"]["elements"][0]["img_key"],
            "img_v2_stream_edit",
        )

    def test_edit_streaming_card_skips_non_image_markdown_target(self):
        client = self._build_client()
        client._api_client, message_api = self._build_message_api(
            patch_response=self._success_response(),
            card_content_response=self._success_response(),
        )
        metadata = {
            "feishu_streaming": {
                "card_id": "card_stream",
                "element_id": Feishu.STREAM_CARD_BODY_ELEMENT_ID,
                "sequence": 0,
                "sent_image_urls": [],
            }
        }
        response = MagicMock()
        response.content = b"<html></html>"
        response.headers = {"Content-Type": "text/html"}

        with patch("app.modules.feishu.feishu.RequestUtils") as request_utils:
            request_utils.return_value.get_res.return_value = response
            success = client.edit_message(
                message_id="om_stream",
                text="第二帧 ![link](https://example.com/detail)",
                chat_id="oc_stream",
                metadata=metadata,
            )

        self.assertTrue(success)
        client._api_client.im.v1.image.create.assert_not_called()
        self.assertEqual(metadata["feishu_streaming"]["sent_image_urls"], [])
        self.assertEqual(message_api.create.call_count, 0)

    def test_close_streaming_card_updates_card_settings(self):
        client = self._build_client()
        client._api_client, _ = self._build_message_api(
            card_settings_response=self._success_response(),
        )

        success = client.close_streaming_card(card_id="card_stream", sequence=3)

        self.assertTrue(success)
        settings_request = client._api_client.cardkit.v1.card.settings.call_args.args[0]
        self.assertEqual(settings_request.card_id, "card_stream")
        settings_payload = json.loads(settings_request.request_body.settings)
        self.assertFalse(settings_payload["config"]["streaming_mode"])

    def test_parse_message_supports_image_and_file_payloads(self):
        client = self._build_client()

        with patch("app.modules.feishu.feishu.UserOper.get_name", return_value=None):
            image_message = client.parse_message(
                {
                    "type": "message",
                    "text": "",
                    "images": [{"ref": "feishu://image/img_v2_test"}],
                    "message_id": "om_img",
                    "chat_id": "oc_chat",
                    "sender": {
                        "open_id": "ou_user_5",
                        "name": "tester",
                    },
                }
            )

            file_message = client.parse_message(
                {
                    "type": "message",
                    "text": "",
                    "files": [
                        {
                            "ref": "feishu://file/file_key/report.pdf",
                            "name": "report.pdf",
                        }
                    ],
                    "message_id": "om_file",
                    "chat_id": "oc_chat",
                    "sender": {
                        "open_id": "ou_user_6",
                        "name": "tester",
                    },
                }
            )

        self.assertEqual(image_message.images[0].ref, "feishu://image/img_v2_test")
        self.assertEqual(file_message.files[0].ref, "feishu://file/file_key/report.pdf")

    def test_on_message_wraps_feishu_image_ref_with_message_id(self):
        client = self._build_client()
        message = SimpleNamespace(
            message_id="om_img_evt",
            chat_id="oc_chat_evt",
            chat_type="p2p",
            message_type="image",
            content=json.dumps({"image_key": "img_v2_evt"}),
        )
        sender = SimpleNamespace(
            sender_id=SimpleNamespace(open_id="ou_user_evt", user_id=None)
        )
        event = SimpleNamespace(sender=sender, message=message)

        with patch.object(client, "_forward_to_message_chain") as forward:
            client._on_message(SimpleNamespace(event=event))

        payload = forward.call_args.args[0]
        self.assertEqual(
            payload["images"][0]["ref"], "feishu://image/om_img_evt/img_v2_evt"
        )

    def test_on_message_wraps_feishu_audio_ref_with_message_id(self):
        client = self._build_client()
        message = SimpleNamespace(
            message_id="om_audio_evt",
            chat_id="oc_chat_evt",
            chat_type="p2p",
            message_type="audio",
            content=json.dumps(
                {"file_key": "file_audio_evt", "file_name": "voice.opus"}
            ),
        )
        sender = SimpleNamespace(
            sender_id=SimpleNamespace(open_id="ou_user_evt", user_id=None)
        )
        event = SimpleNamespace(sender=sender, message=message)

        with patch.object(client, "_forward_to_message_chain") as forward:
            client._on_message(SimpleNamespace(event=event))

        payload = forward.call_args.args[0]
        self.assertEqual(
            payload["audio_refs"],
            ["feishu://file/om_audio_evt/file_audio_evt/voice.opus"],
        )

    def test_feishu_channel_capabilities_enable_images_and_files(self):
        self.assertTrue(
            ChannelCapabilityManager.supports_capability(
                MessageChannel.Feishu,
                ChannelCapability.IMAGES,
            )
        )
        self.assertTrue(
            ChannelCapabilityManager.supports_capability(
                MessageChannel.Feishu,
                ChannelCapability.FILE_SENDING,
            )
        )

    def test_send_file_uploads_image_then_sends_mixed_card(self):
        client = self._build_client()
        image_upload_response = MagicMock()
        image_upload_response.success.return_value = True
        image_upload_response.data = SimpleNamespace(image_key="img_v2_uploaded")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(message_id="om_image"),
            image_create_response=image_upload_response,
        )

        with tempfile.NamedTemporaryFile(suffix=".png") as fp:
            fp.write(b"png-bytes")
            fp.flush()
            result = client.send_file(
                file_path=fp.name,
                userid="ou_user_7",
                title="图片标题",
                text="图片说明",
            )

        self.assertTrue(result["success"])
        client._api_client.im.v1.image.create.assert_called_once()
        request = message_api.create.call_args.args[0]
        self.assertEqual(request.request_body.msg_type, "interactive")
        content = json.loads(request.request_body.content)
        self.assertEqual(content["body"]["padding"], "0px 0px 0px 0px")
        self.assertEqual(content["body"]["elements"][0]["img_key"], "img_v2_uploaded")
        self.assertEqual(content["body"]["elements"][1]["content"], "图片标题")
        self.assertEqual(content["body"]["elements"][1]["margin"], "12px 12px 0px 12px")
        self.assertEqual(content["body"]["elements"][2]["content"], "图片说明")
        self.assertEqual(content["body"]["elements"][2]["margin"], "4px 12px 12px 12px")

    def test_send_file_keeps_non_image_file_message_and_caption(self):
        client = self._build_client()
        file_upload_response = MagicMock()
        file_upload_response.success.return_value = True
        file_upload_response.data = SimpleNamespace(file_key="file_doc")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(message_id="om_file"),
            file_create_response=file_upload_response,
        )

        with (
            tempfile.NamedTemporaryFile(suffix=".txt") as fp,
            patch.object(
                client, "send_text", return_value={"success": True}
            ) as send_text,
        ):
            fp.write(b"text-bytes")
            fp.flush()
            result = client.send_file(
                file_path=fp.name,
                userid="ou_user_7",
                title="文件标题",
                text="文件说明",
            )

        self.assertTrue(result["success"])
        client._api_client.im.v1.file.create.assert_called_once()
        request = message_api.create.call_args.args[0]
        self.assertEqual(request.request_body.msg_type, "file")
        self.assertEqual(
            json.loads(request.request_body.content)["file_key"], "file_doc"
        )
        send_text.assert_called_once()

    def test_send_voice_uploads_audio_file_and_optionally_sends_caption(self):
        client = self._build_client()
        file_upload_response = MagicMock()
        file_upload_response.success.return_value = True
        file_upload_response.data = SimpleNamespace(file_key="file_audio")
        client._api_client, message_api = self._build_message_api(
            create_response=self._success_response(message_id="om_audio"),
            file_create_response=file_upload_response,
        )

        with tempfile.NamedTemporaryFile(suffix=".opus") as fp:
            fp.write(b"opus-bytes")
            fp.flush()
            with patch.object(
                client, "send_text", return_value={"success": True}
            ) as send_text:
                result = client.send_voice(
                    voice_path=fp.name,
                    userid="ou_user_8",
                    caption="这是说明",
                )

        self.assertTrue(result["success"])
        request = message_api.create.call_args.args[0]
        self.assertEqual(request.request_body.msg_type, "audio")
        self.assertEqual(
            json.loads(request.request_body.content)["file_key"], "file_audio"
        )
        send_text.assert_called_once()

    def test_download_helpers_return_bytes_and_data_url(self):
        client = self._build_client()
        client._api_client, _ = self._build_message_api(
            image_get_response=self._resource_response(
                b"image-bytes", file_name="poster.png", content_type="image/png"
            ),
            file_get_response=self._resource_response(
                b"file-bytes", file_name="report.txt", content_type="text/plain"
            ),
            message_resource_response=self._resource_response(
                b"resource-bytes", file_name="voice.opus", content_type="audio/ogg"
            ),
        )

        image_download = client.download_image_bytes("img_v2_test")
        file_download = client.download_file_bytes("file_test")
        resource_download = client.download_message_resource_bytes(
            "om_test", "file_test", "audio"
        )

        self.assertEqual(image_download[0], b"image-bytes")
        self.assertEqual(file_download[0], b"file-bytes")
        self.assertEqual(resource_download[0], b"resource-bytes")

    def test_module_send_direct_message_prefers_open_id_target(self):
        module = FeishuModule()
        module._channel = MessageChannel.Feishu
        conf = SimpleNamespace(name="feishu-main")
        client = MagicMock()
        client.send_notification.return_value = {
            "success": True,
            "message_id": "om_789",
            "chat_id": "oc_789",
        }

        with (
            patch.object(module, "get_configs", return_value={"feishu-main": conf}),
            patch.object(module, "check_message", return_value=True),
            patch.object(module, "get_instance", return_value=client),
        ):
            response = module.send_direct_message(
                Notification(
                    targets={
                        "feishu_userid": "u_target",
                        "feishu_openid": "ou_target",
                    }
                )
            )

        client.send_notification.assert_called_once_with(
            message=ANY,
            userid="ou_target",
            chat_id=None,
            receive_id_type="open_id",
            original_message_id=None,
        )
        self.assertTrue(response.success)
        self.assertEqual(response.message_id, "om_789")
        self.assertEqual(response.chat_id, "oc_789")

    def test_run_ws_client_binds_thread_local_event_loop(self):
        client = self._build_client()
        original_loop = object()
        fake_ws_client = MagicMock()
        created_loops = []
        real_new_event_loop = asyncio.new_event_loop

        def _new_loop():
            loop = real_new_event_loop()
            created_loops.append(loop)
            return loop

        with (
            patch(
                "app.modules.feishu.feishu.lark_ws_client_module.loop", original_loop
            ),
            patch(
                "app.modules.feishu.feishu.lark_ws_client_module._select",
                new=MagicMock(return_value=None),
            ),
            patch(
                "app.modules.feishu.feishu.asyncio.new_event_loop",
                side_effect=_new_loop,
            ),
            patch(
                "app.modules.feishu.feishu.lark.ws.Client", return_value=fake_ws_client
            ),
            patch.object(
                fake_ws_client, "start", side_effect=lambda: None
            ) as mock_start,
        ):
            client._run_ws_client()

        self.assertIsNone(client._ws_loop)
        mock_start.assert_called_once()
        self.assertEqual(len(created_loops), 1)
        self.assertTrue(created_loops[0].is_closed())

    def test_stop_disconnects_ws_client_via_threadsafe_loop(self):
        client = self._build_client()
        stop_loop = MagicMock()
        stop_loop.is_running.return_value = True
        client._ws_loop = stop_loop
        client._ws_client = MagicMock()
        client._ws_thread = MagicMock()
        client._ws_thread.is_alive.return_value = False

        future = MagicMock()
        future.result.return_value = None

        with patch(
            "app.modules.feishu.feishu.asyncio.run_coroutine_threadsafe",
            return_value=future,
        ) as runner:
            client.stop()

        runner.assert_called_once()
        future.result.assert_called_once_with(timeout=5)

    def test_module_download_helpers_delegate_to_client(self):
        module = FeishuModule()
        client = MagicMock()
        client.download_image_bytes.return_value = (b"image", "poster.png", "image/png")
        client.download_file_bytes.return_value = (b"file", "note.txt", "text/plain")
        client.download_message_resource_bytes.return_value = (
            b"image",
            "poster.png",
            "image/png",
        )

        with (
            patch.object(
                module, "get_config", return_value=SimpleNamespace(name="feishu-main")
            ),
            patch.object(module, "get_instance", return_value=client),
        ):
            data_url = module.download_feishu_image_to_data_url(
                "feishu://image/om_msg/img_v2_xxx", "feishu-main"
            )
            file_bytes = module.download_feishu_file_bytes(
                "feishu://file/file_xxx/note.txt", "feishu-main"
            )
            audio_bytes = module.download_feishu_file_bytes(
                "feishu://file/om_audio/file_audio/voice.opus",
                "feishu-main",
            )

        self.assertTrue(data_url.startswith("data:image/png;base64,"))
        self.assertEqual(file_bytes, b"file")
        self.assertEqual(audio_bytes, b"image")
        client.download_message_resource_bytes.assert_any_call(
            message_id="om_msg",
            file_key="img_v2_xxx",
            resource_type="image",
        )
        client.download_message_resource_bytes.assert_any_call(
            message_id="om_audio",
            file_key="file_audio",
            resource_type="audio",
        )

    def test_module_message_reaction_helpers_delegate_to_client(self):
        module = FeishuModule()
        client = MagicMock()
        client.add_message_reaction.return_value = "reaction_2"
        client.delete_message_reaction.return_value = True

        with (
            patch.object(
                module, "get_config", return_value=SimpleNamespace(name="feishu-main")
            ),
            patch.object(module, "get_instance", return_value=client),
        ):
            reaction_id = module.add_feishu_message_reaction(
                "om_x", "GLANCE", "feishu-main"
            )
            deleted = module.delete_feishu_message_reaction(
                "om_x", "reaction_2", "feishu-main"
            )

        self.assertEqual(reaction_id, "reaction_2")
        self.assertTrue(deleted)

    def test_module_processing_status_uses_reaction_helpers(self):
        module = FeishuModule()
        module._channel = MessageChannel.Feishu

        with (
            patch.object(
                module,
                "add_feishu_message_reaction",
                return_value="reaction_processing",
            ) as add_reaction,
            patch.object(
                module,
                "delete_feishu_message_reaction",
                return_value=True,
            ) as delete_reaction,
        ):
            status = module.mark_message_processing_started(
                channel=MessageChannel.Feishu,
                source="feishu-main",
                userid="ou_x",
                message_id="om_x",
                chat_id="oc_x",
                text="hello",
            )
            deleted = module.mark_message_processing_finished(
                channel=MessageChannel.Feishu,
                source="feishu-main",
                userid="ou_x",
                status=status,
            )

        add_reaction.assert_called_once_with(
            message_id="om_x",
            emoji_type="GLANCE",
            source="feishu-main",
        )
        delete_reaction.assert_called_once_with(
            message_id="om_x",
            reaction_id="reaction_processing",
            source="feishu-main",
        )
        self.assertEqual(status["metadata"]["reaction_id"], "reaction_processing")
        self.assertTrue(deleted)

    def test_module_finalize_message_closes_streaming_card(self):
        module = FeishuModule()
        module._channel = MessageChannel.Feishu
        client = MagicMock()
        client.close_streaming_card.return_value = True

        with (
            patch.object(
                module, "get_config", return_value=SimpleNamespace(name="feishu-main")
            ),
            patch.object(module, "get_instance", return_value=client),
        ):
            success = module.finalize_message(
                MessageResponse(
                    message_id="om_stream",
                    chat_id="oc_stream",
                    channel=MessageChannel.Feishu,
                    source="feishu-main",
                    metadata={
                        "feishu_streaming": {
                            "card_id": "card_stream",
                            "sequence": 2,
                        }
                    },
                    success=True,
                )
            )

        self.assertTrue(success)
        client.close_streaming_card.assert_called_once_with(
            card_id="card_stream", sequence=3
        )

    def test_module_post_message_prefers_file_and_voice_paths(self):
        module = FeishuModule()
        conf = SimpleNamespace(name="feishu-main")
        client = MagicMock()

        with (
            patch.object(module, "get_configs", return_value={"feishu-main": conf}),
            patch.object(module, "check_message", return_value=True),
            patch.object(module, "get_instance", return_value=client),
        ):
            module.post_message(
                Notification(
                    file_path="/tmp/demo.txt",
                    text="说明",
                    title="标题",
                    userid="ou_user",
                )
            )
            module.post_message(
                Notification(
                    voice_path="/tmp/demo.opus",
                    voice_caption="语音说明",
                    userid="ou_user",
                )
            )

        client.send_file.assert_called_once()
        client.send_voice.assert_called_once()

    def test_module_post_message_sends_image_card_before_file_attachment(self):
        module = FeishuModule()
        conf = SimpleNamespace(name="feishu-main")
        client = MagicMock()

        with (
            patch.object(module, "get_configs", return_value={"feishu-main": conf}),
            patch.object(module, "check_message", return_value=True),
            patch.object(module, "get_instance", return_value=client),
        ):
            module.post_message(
                Notification(
                    file_path="/tmp/demo.txt",
                    file_name="demo.txt",
                    image="https://example.com/poster.png",
                    text="说明",
                    title="标题",
                    userid="ou_user",
                )
            )

        client.send_notification.assert_called_once()
        sent_message = client.send_notification.call_args.kwargs["message"]
        self.assertEqual(sent_message.image, "https://example.com/poster.png")
        self.assertIsNone(sent_message.file_path)
        client.send_file.assert_called_once()
        self.assertIsNone(client.send_file.call_args.kwargs.get("title"))
        self.assertIsNone(client.send_file.call_args.kwargs.get("text"))

    def test_module_send_direct_message_sends_image_card_before_file_attachment(self):
        module = FeishuModule()
        module._channel = MessageChannel.Feishu
        conf = SimpleNamespace(name="feishu-main")
        client = MagicMock()
        client.send_notification.return_value = {
            "success": True,
            "message_id": "om_card",
            "chat_id": "oc_card",
        }
        client.send_file.return_value = {"success": True, "message_id": "om_file"}

        with (
            patch.object(module, "get_configs", return_value={"feishu-main": conf}),
            patch.object(module, "check_message", return_value=True),
            patch.object(module, "get_instance", return_value=client),
        ):
            response = module.send_direct_message(
                Notification(
                    channel=MessageChannel.Feishu,
                    source="feishu-main",
                    file_path="/tmp/demo.txt",
                    file_name="demo.txt",
                    image="https://example.com/poster.png",
                    text="说明",
                    title="标题",
                    userid="ou_user",
                )
            )

        self.assertTrue(response.success)
        self.assertEqual(response.message_id, "om_card")
        client.send_notification.assert_called_once()
        client.send_file.assert_called_once()

    def test_module_post_message_passes_original_message_id_for_reply(self):
        module = FeishuModule()
        conf = SimpleNamespace(name="feishu-main")
        client = MagicMock()

        with (
            patch.object(module, "get_configs", return_value={"feishu-main": conf}),
            patch.object(module, "check_message", return_value=True),
            patch.object(module, "get_instance", return_value=client),
        ):
            module.post_message(
                Notification(
                    title="标题",
                    text="正文",
                    userid="ou_user",
                    original_message_id="om_source",
                    original_chat_id="oc_source",
                )
            )

        client.send_notification.assert_called_once()
        self.assertEqual(
            client.send_notification.call_args.kwargs["original_message_id"],
            "om_source",
        )


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