Creator App Tests / PR Spam Gate (push) Skipped
Frontend Tests / PR Spam Gate (push) Skipped
NPM Format (website & console) / PR Spam Gate (push) Skipped
Pre-commit Checks / PR Spam Gate (push) Skipped
QwenPaw Creator Plugin Release / check-version (push) Canceled after 0s
QwenPaw Creator Plugin Release / upload-oss (push) Canceled after 0s
Tests / PR Spam Gate (push) Skipped
CodeQL / CodeQL (python) (push) Canceled after 0s
CodeQL / CodeQL (typescript) (push) Canceled after 0s
Creator App Tests / Creator Backend Tests (push) Canceled after 0s
Creator App Tests / Creator UI Build & Tests (push) Canceled after 0s
E2E Smoke Tests / Playwright UI Smoke (push) Canceled after 0s
Frontend Tests / Detect console changes (push) Canceled after 0s
NPM Format (website & console) / website format check (push) Canceled after 0s
NPM Format (website & console) / console format check (push) Canceled after 0s
Pre-commit Checks / Pre-commit (push) Canceled after 0s
QwenPaw Data Plugin Release / check-version (push) Canceled after 0s
Tests / Detect code changes (push) Canceled after 0s
Frontend Tests / Vitest Unit Tests (push) Canceled after 0s
Frontend Tests / Frontend Summary (push) Canceled after 0s
QwenPaw Data Plugin Release / upload-oss (push) Canceled after 0s
Tests / Maintainer Approval (push) Canceled after 0s
Tests / Unit Tests - py3.11 - macos-latest (push) Canceled after 0s
Tests / Unit Tests - py3.11 - ubuntu-latest (push) Canceled after 0s
Tests / Unit Tests - py3.13 - ubuntu-latest (push) Canceled after 0s
Tests / Unit Tests - py3.11 - windows-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - macos-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - ubuntu-latest (push) Canceled after 0s
Tests / Contract Tests - py3.13 - ubuntu-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - windows-latest (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - fallback (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p2 (push) Canceled after 0s
Tests / Coverage Report (push) Canceled after 0s
Tests / Test Summary (push) Canceled after 0s
3578 lines
116 KiB
Python
3578 lines
116 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
Feishu Channel Unit Tests
|
|
|
|
Comprehensive unit tests for FeishuChannel covering:
|
|
- Initialization and configuration (from_env, from_config)
|
|
- Session ID resolution and routing
|
|
- Receive ID store management (for proactive send)
|
|
- Message deduplication
|
|
- Nickname caching
|
|
- Utility methods (sync and async)
|
|
- Send methods
|
|
|
|
Test Patterns:
|
|
- Uses tmp_path fixture for temporary paths
|
|
- Uses AsyncMock for async methods
|
|
- @pytest.mark.asyncio only on async test methods
|
|
|
|
Run:
|
|
pytest tests/unit/channels/test_feishu.py -v
|
|
pytest tests/unit/channels/test_feishu.py::TestFeishuChannelInit -v
|
|
"""
|
|
|
|
# pylint: disable=redefined-outer-name,protected-access,unused-argument
|
|
# pylint: disable=broad-exception-raised,unused-import,unused-variable
|
|
from __future__ import annotations
|
|
|
|
|
|
import asyncio
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Generator
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from qwenpaw.app.channels.renderer import ChannelDisplayConfig
|
|
from qwenpaw.app.channels.base import ContentType, OutgoingContentPart
|
|
|
|
# =============================================================================
|
|
# Fixtures
|
|
# =============================================================================
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_process_handler() -> AsyncMock:
|
|
"""Mock process handler that yields simple events."""
|
|
|
|
async def mock_process(*_args, **_kwargs):
|
|
mock_event = MagicMock()
|
|
mock_event.object = "message"
|
|
mock_event.status = "completed"
|
|
mock_event.type = "text"
|
|
yield mock_event
|
|
|
|
return AsyncMock(side_effect=mock_process)
|
|
|
|
|
|
@pytest.fixture
|
|
def temp_media_dir(tmp_path) -> Path:
|
|
"""Temporary directory for media files."""
|
|
media_dir = tmp_path / ".copaw" / "media"
|
|
media_dir.mkdir(parents=True, exist_ok=True)
|
|
return media_dir
|
|
|
|
|
|
@pytest.fixture
|
|
def temp_workspace_dir(tmp_path) -> Path:
|
|
"""Temporary workspace directory."""
|
|
workspace = tmp_path / ".copaw" / "workspace"
|
|
workspace.mkdir(parents=True, exist_ok=True)
|
|
return workspace
|
|
|
|
|
|
@pytest.fixture
|
|
def feishu_channel(
|
|
mock_process_handler,
|
|
temp_media_dir,
|
|
) -> Generator:
|
|
"""Create a FeishuChannel instance for testing."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_app_id_123456",
|
|
app_secret="test_app_secret_abcdef",
|
|
bot_prefix="[TestBot] ",
|
|
media_dir=str(temp_media_dir),
|
|
display_config=ChannelDisplayConfig(
|
|
show_tool_calls=False,
|
|
show_tool_results=False,
|
|
),
|
|
)
|
|
yield channel
|
|
|
|
|
|
@pytest.fixture
|
|
def feishu_channel_with_workspace(
|
|
mock_process_handler,
|
|
temp_workspace_dir,
|
|
) -> Generator:
|
|
"""Create a FeishuChannel with workspace for testing."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_app_id_789",
|
|
app_secret="test_app_secret_xyz",
|
|
bot_prefix="[WorkspaceBot] ",
|
|
workspace_dir=temp_workspace_dir,
|
|
display_config=ChannelDisplayConfig(
|
|
show_tool_calls=False,
|
|
show_tool_results=False,
|
|
),
|
|
)
|
|
yield channel
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_lark_client():
|
|
"""Mock lark_oapi client."""
|
|
mock_client = MagicMock()
|
|
mock_client._config = MagicMock()
|
|
return mock_client
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Initialization and Configuration
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelInit:
|
|
"""
|
|
Tests for FeishuChannel initialization and factory methods.
|
|
Verifies correct storage of configuration parameters.
|
|
"""
|
|
|
|
def test_init_stores_basic_config(
|
|
self,
|
|
mock_process_handler,
|
|
temp_media_dir,
|
|
):
|
|
"""Constructor should store all basic configuration parameters."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="my_app_id",
|
|
app_secret="my_app_secret",
|
|
bot_prefix="[Bot] ",
|
|
encrypt_key="my_encrypt_key",
|
|
verification_token="my_token",
|
|
media_dir=str(temp_media_dir),
|
|
)
|
|
|
|
assert channel.enabled is True
|
|
assert channel.app_id == "my_app_id"
|
|
assert channel.app_secret == "my_app_secret"
|
|
assert channel.bot_prefix == "[Bot] "
|
|
assert channel.encrypt_key == "my_encrypt_key"
|
|
assert channel.verification_token == "my_token"
|
|
assert channel.channel == "feishu"
|
|
|
|
def test_init_uses_default_domain(self, mock_process_handler):
|
|
"""Constructor should default domain to 'feishu'."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
)
|
|
|
|
assert channel.domain == "feishu"
|
|
|
|
def test_init_accepts_lark_domain(self, mock_process_handler):
|
|
"""Constructor should accept 'lark' as domain."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
domain="lark",
|
|
)
|
|
|
|
assert channel.domain == "lark"
|
|
|
|
def test_init_rejects_invalid_domain(self, mock_process_handler):
|
|
"""Constructor should fallback to 'feishu' for invalid domain."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
domain="invalid_domain",
|
|
)
|
|
|
|
assert channel.domain == "feishu"
|
|
|
|
def test_init_creates_required_data_structures(
|
|
self,
|
|
mock_process_handler,
|
|
):
|
|
"""Constructor should initialize required internal data structures."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
)
|
|
|
|
# Message ID deduplication
|
|
assert hasattr(channel, "_processed_message_ids")
|
|
assert isinstance(channel._processed_message_ids, dict)
|
|
|
|
# Receive ID store
|
|
assert hasattr(channel, "_receive_id_store")
|
|
assert isinstance(channel._receive_id_store, dict)
|
|
|
|
# Nickname cache
|
|
assert hasattr(channel, "_nickname_cache")
|
|
assert isinstance(channel._nickname_cache, dict)
|
|
|
|
# Clock offset
|
|
assert hasattr(channel, "_clock_offset")
|
|
assert channel._clock_offset == 0
|
|
|
|
def test_init_creates_locks(self, mock_process_handler):
|
|
"""Constructor should create required locks for thread safety."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=True,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
)
|
|
|
|
# Receive ID lock
|
|
assert hasattr(channel, "_receive_id_lock")
|
|
lock_type = type(channel._receive_id_lock).__name__
|
|
assert "Lock" in lock_type
|
|
|
|
# Nickname cache lock
|
|
assert hasattr(channel, "_nickname_cache_lock")
|
|
lock_type = type(channel._nickname_cache_lock).__name__
|
|
assert "Lock" in lock_type
|
|
|
|
def test_channel_type_is_feishu(self, feishu_channel):
|
|
"""Channel type must be 'feishu'."""
|
|
assert feishu_channel.channel == "feishu"
|
|
|
|
|
|
class TestFeishuChannelFromEnv:
|
|
"""Tests for from_env factory method."""
|
|
|
|
def test_from_env_reads_basic_env_vars(
|
|
self,
|
|
mock_process_handler,
|
|
monkeypatch,
|
|
):
|
|
"""from_env should read basic environment variables."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
monkeypatch.setenv("FEISHU_CHANNEL_ENABLED", "0")
|
|
monkeypatch.setenv("FEISHU_APP_ID", "env_app_id")
|
|
monkeypatch.setenv("FEISHU_APP_SECRET", "env_app_secret")
|
|
monkeypatch.setenv("FEISHU_BOT_PREFIX", "[EnvBot] ")
|
|
monkeypatch.setenv("FEISHU_ENCRYPT_KEY", "env_encrypt_key")
|
|
monkeypatch.setenv("FEISHU_VERIFICATION_TOKEN", "env_token")
|
|
|
|
channel = FeishuChannel.from_env(mock_process_handler)
|
|
|
|
assert channel.enabled is False
|
|
assert channel.app_id == "env_app_id"
|
|
assert channel.app_secret == "env_app_secret"
|
|
assert channel.bot_prefix == "[EnvBot] "
|
|
assert channel.encrypt_key == "env_encrypt_key"
|
|
assert channel.verification_token == "env_token"
|
|
|
|
def test_from_env_reads_domain(self, mock_process_handler, monkeypatch):
|
|
"""from_env should read FEISHU_DOMAIN environment variable."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
monkeypatch.setenv("FEISHU_APP_ID", "test_id")
|
|
monkeypatch.setenv("FEISHU_APP_SECRET", "test_secret")
|
|
monkeypatch.setenv("FEISHU_DOMAIN", "lark")
|
|
|
|
channel = FeishuChannel.from_env(mock_process_handler)
|
|
|
|
assert channel.domain == "lark"
|
|
|
|
def test_from_env_allow_from_parsing(
|
|
self,
|
|
mock_process_handler,
|
|
monkeypatch,
|
|
):
|
|
"""from_env should parse FEISHU_ALLOW_FROM correctly."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
monkeypatch.setenv("FEISHU_APP_ID", "test_id")
|
|
monkeypatch.setenv("FEISHU_APP_SECRET", "test_secret")
|
|
monkeypatch.setenv("FEISHU_ALLOW_FROM", "user1,user2,user3")
|
|
|
|
channel = FeishuChannel.from_env(mock_process_handler)
|
|
|
|
assert "user1" in channel.allow_from
|
|
assert "user2" in channel.allow_from
|
|
assert "user3" in channel.allow_from
|
|
|
|
def test_from_env_allow_from_empty(
|
|
self,
|
|
mock_process_handler,
|
|
monkeypatch,
|
|
):
|
|
"""from_env should handle empty FEISHU_ALLOW_FROM."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
monkeypatch.setenv("FEISHU_APP_ID", "test_id")
|
|
monkeypatch.setenv("FEISHU_APP_SECRET", "test_secret")
|
|
monkeypatch.setenv("FEISHU_ALLOW_FROM", "")
|
|
|
|
channel = FeishuChannel.from_env(mock_process_handler)
|
|
|
|
assert channel.allow_from == set()
|
|
|
|
def test_from_env_require_mention(self, mock_process_handler, monkeypatch):
|
|
"""from_env should parse FEISHU_REQUIRE_MENTION correctly."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
monkeypatch.setenv("FEISHU_APP_ID", "test_id")
|
|
monkeypatch.setenv("FEISHU_APP_SECRET", "test_secret")
|
|
monkeypatch.setenv("FEISHU_REQUIRE_MENTION", "1")
|
|
|
|
channel = FeishuChannel.from_env(mock_process_handler)
|
|
|
|
assert channel.require_mention is True
|
|
|
|
def test_from_env_defaults(self, mock_process_handler, monkeypatch):
|
|
"""from_env should use sensible defaults."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
monkeypatch.setenv("FEISHU_APP_ID", "test_id")
|
|
monkeypatch.setenv("FEISHU_APP_SECRET", "test_secret")
|
|
monkeypatch.delenv("FEISHU_CHANNEL_ENABLED", raising=False)
|
|
monkeypatch.delenv("FEISHU_BOT_PREFIX", raising=False)
|
|
monkeypatch.delenv("FEISHU_REQUIRE_MENTION", raising=False)
|
|
monkeypatch.delenv("FEISHU_DOMAIN", raising=False)
|
|
|
|
channel = FeishuChannel.from_env(mock_process_handler)
|
|
|
|
assert channel.enabled is False # Default disabled
|
|
assert channel.bot_prefix == "" # Default empty
|
|
assert channel.require_mention is False # Default False
|
|
assert channel.domain == "feishu" # Default domain
|
|
|
|
|
|
class TestFeishuChannelFromConfig:
|
|
"""Tests for from_config factory method."""
|
|
|
|
def test_from_config_uses_config_values(self, mock_process_handler):
|
|
"""from_config should use values from config object."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
from qwenpaw.config.config import FeishuConfig
|
|
|
|
config = FeishuConfig(
|
|
enabled=False,
|
|
app_id="config_app_id",
|
|
app_secret="config_app_secret",
|
|
bot_prefix="[ConfigBot] ",
|
|
encrypt_key="config_key",
|
|
verification_token="config_token",
|
|
dm_policy="allowlist",
|
|
group_policy="allowlist",
|
|
require_mention=True,
|
|
domain="lark",
|
|
)
|
|
|
|
channel = FeishuChannel.from_config(
|
|
process=mock_process_handler,
|
|
config=config,
|
|
)
|
|
|
|
assert channel.enabled is False
|
|
assert channel.app_id == "config_app_id"
|
|
assert channel.app_secret == "config_app_secret"
|
|
assert channel.bot_prefix == "[ConfigBot] "
|
|
assert channel.encrypt_key == "config_key"
|
|
assert channel.verification_token == "config_token"
|
|
assert channel.dm_policy == "allowlist"
|
|
assert channel.group_policy == "allowlist"
|
|
assert channel.require_mention is True
|
|
assert channel.domain == "lark"
|
|
|
|
def test_from_config_with_workspace(self, mock_process_handler, tmp_path):
|
|
"""from_config should use workspace_dir when provided."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
from qwenpaw.config.config import FeishuConfig
|
|
|
|
config = FeishuConfig(
|
|
enabled=True,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
)
|
|
|
|
workspace_dir = tmp_path / "workspace"
|
|
workspace_dir.mkdir()
|
|
|
|
channel = FeishuChannel.from_config(
|
|
process=mock_process_handler,
|
|
config=config,
|
|
workspace_dir=workspace_dir,
|
|
)
|
|
|
|
assert channel._workspace_dir == workspace_dir
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Session ID Resolution
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelResolveSessionId:
|
|
"""Tests for session ID resolution."""
|
|
|
|
def test_resolve_session_id_with_group_chat(self, feishu_channel):
|
|
"""Should use chat_id for group chat session ID."""
|
|
meta = {
|
|
"feishu_chat_id": "oc_1234567890abcdef",
|
|
"feishu_chat_type": "group",
|
|
}
|
|
|
|
session_id = feishu_channel.resolve_session_id("sender_123", meta)
|
|
|
|
# Should be: last4(app_id) + _ + last8(chat_id)
|
|
assert "3456" in session_id # last 4 of "test_app_id_123456"
|
|
assert "0abcdef" in session_id # last 8 of chat_id
|
|
|
|
def test_resolve_session_id_with_p2p_chat(self, feishu_channel):
|
|
"""Should use sender_id for p2p chat session ID."""
|
|
meta = {
|
|
"feishu_chat_id": "",
|
|
"feishu_chat_type": "p2p",
|
|
}
|
|
|
|
session_id = feishu_channel.resolve_session_id(
|
|
"ou_abcdef1234567890",
|
|
meta,
|
|
)
|
|
|
|
assert "567890" in session_id # last 8 of sender_id
|
|
|
|
def test_resolve_session_id_fallback_to_chat_id(self, feishu_channel):
|
|
"""Should fallback to chat_id when no sender_id."""
|
|
meta = {
|
|
"feishu_chat_id": "oc_fallback12345",
|
|
"feishu_chat_type": "p2p",
|
|
}
|
|
|
|
session_id = feishu_channel.resolve_session_id("", meta)
|
|
|
|
assert "ack12345" in session_id # last 8 of chat_id
|
|
|
|
def test_resolve_session_id_no_chat_no_sender(self, feishu_channel):
|
|
"""Should use channel prefix when no chat_id or sender_id."""
|
|
meta = {
|
|
"feishu_chat_id": "",
|
|
"feishu_chat_type": "p2p",
|
|
}
|
|
|
|
session_id = feishu_channel.resolve_session_id("", meta)
|
|
|
|
assert session_id.startswith("feishu:")
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Receive ID Store Management (Critical for proactive send)
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelReceiveIdStore:
|
|
"""
|
|
Tests for receive_id store storage and retrieval.
|
|
|
|
The receive_id store is used for proactive send (cron jobs).
|
|
It persists to disk so send can work after restart.
|
|
"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_save_receive_id_stores_in_memory(self, feishu_channel):
|
|
"""Saving receive_id should store it in memory."""
|
|
await feishu_channel._save_receive_id(
|
|
session_id="test_session_123",
|
|
receive_id="ou_receiver456",
|
|
receive_id_type="open_id",
|
|
)
|
|
|
|
assert "test_session_123" in feishu_channel._receive_id_store
|
|
stored = feishu_channel._receive_id_store["test_session_123"]
|
|
assert stored == ("open_id", "ou_receiver456")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_save_receive_id_persists_to_disk(
|
|
self,
|
|
feishu_channel_with_workspace,
|
|
temp_workspace_dir,
|
|
):
|
|
"""Saving receive_id should persist to disk for recovery."""
|
|
channel = feishu_channel_with_workspace
|
|
|
|
await channel._save_receive_id(
|
|
session_id="disk_test_session",
|
|
receive_id="ou_disk_user",
|
|
receive_id_type="open_id",
|
|
)
|
|
|
|
# Check file exists
|
|
store_path = temp_workspace_dir / "feishu_receive_ids.json"
|
|
assert store_path.exists()
|
|
|
|
# Verify content
|
|
with open(store_path, "r", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
|
|
assert "disk_test_session" in data
|
|
assert data["disk_test_session"] == ["open_id", "ou_disk_user"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_load_receive_id_from_memory(self, feishu_channel):
|
|
"""Loading receive_id should first check memory."""
|
|
# Pre-populate memory store
|
|
feishu_channel._receive_id_store["mem_test"] = (
|
|
"chat_id",
|
|
"oc_mem_chat",
|
|
)
|
|
|
|
result = await feishu_channel._load_receive_id("mem_test")
|
|
|
|
assert result == ("chat_id", "oc_mem_chat")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_load_receive_id_from_disk(
|
|
self,
|
|
feishu_channel_with_workspace,
|
|
temp_workspace_dir,
|
|
):
|
|
"""Loading receive_id should fallback to disk if not in memory."""
|
|
channel = feishu_channel_with_workspace
|
|
|
|
# Create file manually
|
|
store_path = temp_workspace_dir / "feishu_receive_ids.json"
|
|
data = {
|
|
"disk_test": ["open_id", "ou_from_disk"],
|
|
}
|
|
with open(store_path, "w", encoding="utf-8") as f:
|
|
json.dump(data, f)
|
|
|
|
result = await channel._load_receive_id("disk_test")
|
|
|
|
assert result == ("open_id", "ou_from_disk")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_load_receive_id_not_found_returns_none(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Loading non-existent receive_id should return None."""
|
|
result = await feishu_channel._load_receive_id("nonexistent")
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_load_receive_id_empty_session_returns_none(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Loading with empty session_id should return None."""
|
|
result = await feishu_channel._load_receive_id("")
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_save_receive_id_empty_session_skips(self, feishu_channel):
|
|
"""Saving with empty session_id should be skipped."""
|
|
await feishu_channel._save_receive_id(
|
|
session_id="",
|
|
receive_id="ou_test",
|
|
receive_id_type="open_id",
|
|
)
|
|
|
|
assert "" not in feishu_channel._receive_id_store
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_save_receive_id_empty_receive_id_skips(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Saving with empty receive_id should be skipped."""
|
|
await feishu_channel._save_receive_id(
|
|
session_id="test_session",
|
|
receive_id="",
|
|
receive_id_type="open_id",
|
|
)
|
|
|
|
assert "test_session" not in feishu_channel._receive_id_store
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_save_receive_id_also_keys_by_open_id(self, feishu_channel):
|
|
"""Saving should also key by open_id for direct lookup."""
|
|
await feishu_channel._save_receive_id(
|
|
session_id="session_abc",
|
|
receive_id="ou_direct_user",
|
|
receive_id_type="open_id",
|
|
)
|
|
|
|
# Should be accessible by open_id too
|
|
result = await feishu_channel._load_receive_id("ou_direct_user")
|
|
assert result == ("open_id", "ou_direct_user")
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Route from Handle
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelRouteFromHandle:
|
|
"""Tests for _route_from_handle method."""
|
|
|
|
def test_route_from_handle_session_key(self, feishu_channel):
|
|
"""Should parse feishu:sw: prefix as session_key."""
|
|
result = feishu_channel._route_from_handle("feishu:sw:abc123")
|
|
|
|
assert result["session_key"] == "abc123"
|
|
|
|
def test_route_from_handle_chat_id(self, feishu_channel):
|
|
"""Should parse feishu:chat_id: prefix."""
|
|
result = feishu_channel._route_from_handle("feishu:chat_id:oc_test123")
|
|
|
|
assert result["receive_id_type"] == "chat_id"
|
|
assert result["receive_id"] == "oc_test123"
|
|
|
|
def test_route_from_handle_open_id(self, feishu_channel):
|
|
"""Should parse feishu:open_id: prefix."""
|
|
result = feishu_channel._route_from_handle(
|
|
"feishu:open_id:ou_user456",
|
|
)
|
|
|
|
assert result["receive_id_type"] == "open_id"
|
|
assert result["receive_id"] == "ou_user456"
|
|
|
|
def test_route_from_handle_direct_chat_id(self, feishu_channel):
|
|
"""Should recognize raw chat_id starting with oc_."""
|
|
result = feishu_channel._route_from_handle("oc_direct_chat")
|
|
|
|
assert result["receive_id_type"] == "chat_id"
|
|
assert result["receive_id"] == "oc_direct_chat"
|
|
|
|
def test_route_from_handle_direct_open_id(self, feishu_channel):
|
|
"""Should recognize raw open_id starting with ou_."""
|
|
result = feishu_channel._route_from_handle("ou_direct_user")
|
|
|
|
assert result["receive_id_type"] == "open_id"
|
|
assert result["receive_id"] == "ou_direct_user"
|
|
|
|
def test_route_from_handle_fallback(self, feishu_channel):
|
|
"""Should default to open_id for unknown formats."""
|
|
result = feishu_channel._route_from_handle("random_id")
|
|
|
|
assert result["receive_id_type"] == "open_id"
|
|
assert result["receive_id"] == "random_id"
|
|
|
|
|
|
# =============================================================================
|
|
# P1: To Handle from Target
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelToHandleFromTarget:
|
|
"""Tests for to_handle_from_target method."""
|
|
|
|
def test_to_handle_from_target_with_session(self, feishu_channel):
|
|
"""Should create handle with session_id."""
|
|
result = feishu_channel.to_handle_from_target(
|
|
user_id="ou_user123",
|
|
session_id="session_abc",
|
|
)
|
|
|
|
assert result == "feishu:sw:session_abc"
|
|
|
|
def test_to_handle_from_target_without_session(self, feishu_channel):
|
|
"""Should fallback to user_id when no session."""
|
|
result = feishu_channel.to_handle_from_target(
|
|
user_id="ou_user456",
|
|
session_id="",
|
|
)
|
|
|
|
assert result == "feishu:open_id:ou_user456"
|
|
|
|
def test_to_handle_from_target_empty_user_and_session(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Should return empty string when both are empty."""
|
|
result = feishu_channel.to_handle_from_target(
|
|
user_id="",
|
|
session_id="",
|
|
)
|
|
|
|
assert result == "feishu:open_id:"
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Message Deduplication
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelMessageDeduplication:
|
|
"""
|
|
Tests for message deduplication.
|
|
|
|
Feishu may retry message delivery; we need to dedup by message_id.
|
|
"""
|
|
|
|
def test_message_id_tracked(self, feishu_channel):
|
|
"""Processed message IDs should be tracked."""
|
|
from qwenpaw.app.channels.feishu.constants import (
|
|
FEISHU_PROCESSED_IDS_MAX,
|
|
)
|
|
|
|
# Initially empty
|
|
assert len(feishu_channel._processed_message_ids) == 0
|
|
|
|
# Add a message ID
|
|
feishu_channel._processed_message_ids["msg_123"] = None
|
|
|
|
assert "msg_123" in feishu_channel._processed_message_ids
|
|
|
|
def test_message_id_trims_when_over_limit(self, feishu_channel):
|
|
"""Old message IDs should be trimmed when over limit."""
|
|
from qwenpaw.app.channels.feishu.constants import (
|
|
FEISHU_PROCESSED_IDS_MAX,
|
|
)
|
|
|
|
max_size = FEISHU_PROCESSED_IDS_MAX
|
|
|
|
# Add more IDs than the limit
|
|
for i in range(max_size + 10):
|
|
feishu_channel._processed_message_ids[f"msg_{i}"] = None
|
|
# Simulate the trimming behavior
|
|
while len(feishu_channel._processed_message_ids) > max_size:
|
|
feishu_channel._processed_message_ids.popitem(last=False)
|
|
|
|
# Should be at most max_size
|
|
assert len(feishu_channel._processed_message_ids) <= max_size
|
|
|
|
|
|
# =============================================================================
|
|
# P2: Utility Functions - Synchronous
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelSyncUtilities:
|
|
"""Tests for synchronous utility methods."""
|
|
|
|
def test_build_post_content_text_only(self, feishu_channel):
|
|
"""Should build post content with text only."""
|
|
result = feishu_channel._build_post_content("Hello World", [])
|
|
|
|
assert "zh_cn" in result
|
|
assert "content" in result["zh_cn"]
|
|
assert result["zh_cn"]["content"][0][0]["tag"] == "md"
|
|
assert result["zh_cn"]["content"][0][0]["text"] == "Hello World"
|
|
|
|
def test_build_post_content_with_images(self, feishu_channel):
|
|
"""Should build post content with images."""
|
|
result = feishu_channel._build_post_content(
|
|
"See this:",
|
|
["img_key_1", "img_key_2"],
|
|
)
|
|
|
|
content = result["zh_cn"]["content"]
|
|
assert len(content) == 3 # text + 2 images
|
|
assert content[0][0]["tag"] == "md"
|
|
assert content[1][0]["tag"] == "img"
|
|
assert content[1][0]["image_key"] == "img_key_1"
|
|
assert content[2][0]["tag"] == "img"
|
|
|
|
def test_build_post_content_empty(self, feishu_channel):
|
|
"""Should handle empty content gracefully."""
|
|
result = feishu_channel._build_post_content("", [])
|
|
|
|
# Should have a placeholder
|
|
assert result["zh_cn"]["content"][0][0]["text"] == "[empty]"
|
|
|
|
def test_receive_id_store_path_with_workspace(
|
|
self,
|
|
feishu_channel_with_workspace,
|
|
temp_workspace_dir,
|
|
):
|
|
"""Should use workspace directory when available."""
|
|
path = feishu_channel_with_workspace._receive_id_store_path()
|
|
|
|
assert path == temp_workspace_dir / "feishu_receive_ids.json"
|
|
|
|
def test_get_on_reply_sent_args(self, feishu_channel):
|
|
"""Should return user_id and session_id."""
|
|
mock_request = MagicMock()
|
|
mock_request.user_id = "user_123"
|
|
mock_request.session_id = "session_456"
|
|
|
|
result = feishu_channel.get_on_reply_sent_args(
|
|
mock_request,
|
|
"to_handle",
|
|
)
|
|
|
|
assert result == ("user_123", "session_456")
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Enabled Check
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelEnabledCheck:
|
|
"""Tests for enabled/disabled behavior."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_content_parts_returns_none_when_disabled(
|
|
self,
|
|
mock_process_handler,
|
|
temp_media_dir,
|
|
):
|
|
"""send_content_parts should return None when channel disabled."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=False,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
media_dir=str(temp_media_dir),
|
|
)
|
|
|
|
result = await channel.send_content_parts(
|
|
to_handle="feishu:sw:test",
|
|
parts=[],
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_returns_none_when_disabled(
|
|
self,
|
|
mock_process_handler,
|
|
temp_media_dir,
|
|
):
|
|
"""send should return None when channel disabled."""
|
|
from qwenpaw.app.channels.feishu.channel import FeishuChannel
|
|
|
|
channel = FeishuChannel(
|
|
process=mock_process_handler,
|
|
enabled=False,
|
|
app_id="test_id",
|
|
app_secret="test_secret",
|
|
bot_prefix="",
|
|
media_dir=str(temp_media_dir),
|
|
)
|
|
|
|
# Should not raise and should return silently
|
|
await channel.send(
|
|
to_handle="feishu:sw:test",
|
|
text="Hello",
|
|
)
|
|
|
|
# If we get here without error, the test passed
|
|
assert True
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Build Agent Request
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelBuildAgentRequest:
|
|
"""Tests for build_agent_request_from_native method."""
|
|
|
|
def test_build_agent_request_from_native_basic(self, feishu_channel):
|
|
"""Should build AgentRequest from native payload."""
|
|
payload = {
|
|
"channel_id": "feishu",
|
|
"sender_id": "sender#1234",
|
|
"user_id": "user#5678",
|
|
"session_id": "session_abc",
|
|
"content_parts": [{"type": "text", "text": "Hello"}],
|
|
"meta": {"feishu_chat_id": "oc_test"},
|
|
}
|
|
|
|
result = feishu_channel.build_agent_request_from_native(payload)
|
|
|
|
assert hasattr(result, "channel_meta")
|
|
assert result.channel_meta.get("feishu_chat_id") == "oc_test"
|
|
|
|
def test_build_agent_request_uses_payload_session_id(self, feishu_channel):
|
|
"""Should use session_id from payload when available."""
|
|
payload = {
|
|
"channel_id": "feishu",
|
|
"sender_id": "sender#1234",
|
|
"session_id": "explicit_session",
|
|
"content_parts": [],
|
|
"meta": {},
|
|
}
|
|
|
|
result = feishu_channel.build_agent_request_from_native(payload)
|
|
|
|
assert result.session_id == "explicit_session"
|
|
|
|
def test_build_agent_request_extracts_sender_from_meta(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Should prefer feishu_sender_id from meta for user_id."""
|
|
payload = {
|
|
"channel_id": "feishu",
|
|
"sender_id": "display#1234",
|
|
"user_id": "fallback#5678",
|
|
"session_id": "session_abc",
|
|
"content_parts": [],
|
|
"meta": {"feishu_sender_id": "ou_real_sender"},
|
|
}
|
|
|
|
result = feishu_channel.build_agent_request_from_native(payload)
|
|
|
|
assert result.user_id == "ou_real_sender"
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Merge Native Items
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelMergeNativeItems:
|
|
"""Tests for merge_native_items method."""
|
|
|
|
def test_merge_native_items_concat_content_parts(self, feishu_channel):
|
|
"""Should concatenate content_parts from multiple items."""
|
|
items = [
|
|
{
|
|
"channel_id": "feishu",
|
|
"sender_id": "user1",
|
|
"content_parts": [{"type": "text", "text": "Hello "}],
|
|
"meta": {"seq": 1},
|
|
},
|
|
{
|
|
"channel_id": "feishu",
|
|
"sender_id": "user1",
|
|
"content_parts": [{"type": "text", "text": "World"}],
|
|
"meta": {"seq": 2},
|
|
},
|
|
]
|
|
|
|
result = feishu_channel.merge_native_items(items)
|
|
|
|
assert len(result["content_parts"]) == 2
|
|
assert result["content_parts"][0]["text"] == "Hello "
|
|
assert result["content_parts"][1]["text"] == "World"
|
|
|
|
def test_merge_native_items_empty_list(self, feishu_channel):
|
|
"""Should return None for empty list."""
|
|
result = feishu_channel.merge_native_items([])
|
|
|
|
assert result is None
|
|
|
|
def test_merge_native_items_single_item(self, feishu_channel):
|
|
"""Should return merged item for single item."""
|
|
items = [
|
|
{
|
|
"channel_id": "feishu",
|
|
"sender_id": "user1",
|
|
"content_parts": [{"type": "image", "url": "img.jpg"}],
|
|
"meta": {"id": "msg_1"},
|
|
},
|
|
]
|
|
|
|
result = feishu_channel.merge_native_items(items)
|
|
|
|
assert len(result["content_parts"]) == 1
|
|
assert result["sender_id"] == "user1"
|
|
|
|
def test_merge_native_items_uses_last_sender(self, feishu_channel):
|
|
"""Should use sender_id from last item."""
|
|
items = [
|
|
{
|
|
"channel_id": "feishu",
|
|
"sender_id": "old_sender",
|
|
"content_parts": [],
|
|
"meta": {},
|
|
},
|
|
{
|
|
"channel_id": "feishu",
|
|
"sender_id": "new_sender",
|
|
"content_parts": [],
|
|
"meta": {},
|
|
},
|
|
]
|
|
|
|
result = feishu_channel.merge_native_items(items)
|
|
|
|
assert result["sender_id"] == "new_sender"
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Get Receive for Send
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelGetReceiveForSend:
|
|
"""Tests for _get_receive_for_send method."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_receive_from_meta(self, feishu_channel):
|
|
"""Should prefer receive_id from meta."""
|
|
meta = {
|
|
"feishu_receive_id": "ou_from_meta",
|
|
"feishu_receive_id_type": "open_id",
|
|
}
|
|
|
|
result = await feishu_channel._get_receive_for_send(
|
|
"feishu:sw:any",
|
|
meta,
|
|
)
|
|
|
|
assert result == ("open_id", "ou_from_meta")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_receive_from_store(self, feishu_channel):
|
|
"""Should load from store when session_key provided."""
|
|
# Pre-populate store
|
|
feishu_channel._receive_id_store["my_session"] = (
|
|
"chat_id",
|
|
"oc_stored_chat",
|
|
)
|
|
|
|
result = await feishu_channel._get_receive_for_send(
|
|
"feishu:sw:my_session",
|
|
{},
|
|
)
|
|
|
|
assert result == ("chat_id", "oc_stored_chat")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_receive_from_direct_chat_id(self, feishu_channel):
|
|
"""Should handle direct chat_id."""
|
|
result = await feishu_channel._get_receive_for_send(
|
|
"feishu:chat_id:oc_direct123",
|
|
{},
|
|
)
|
|
|
|
assert result == ("chat_id", "oc_direct123")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_receive_returns_none_when_not_found(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Should return None when receive_id cannot be resolved."""
|
|
result = await feishu_channel._get_receive_for_send(
|
|
"feishu:sw:unknown_session",
|
|
{},
|
|
)
|
|
|
|
assert result is None
|
|
|
|
|
|
# =============================================================================
|
|
# P2: File Upload Size Check
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelFileUpload:
|
|
"""Tests for file upload size checking."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_rejects_too_large(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
):
|
|
"""Should return None for files exceeding max size."""
|
|
from qwenpaw.app.channels.feishu.constants import FEISHU_FILE_MAX_BYTES
|
|
|
|
# Create a file just over the limit
|
|
large_file = tmp_path / "large.bin"
|
|
large_file.write_bytes(b"x" * (FEISHU_FILE_MAX_BYTES + 1))
|
|
|
|
# Mock client to avoid SDK calls
|
|
feishu_channel._client = MagicMock()
|
|
|
|
result = await feishu_channel._upload_file(str(large_file))
|
|
|
|
assert result is None
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Part to Image Bytes
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelPartToImageBytes:
|
|
"""Tests for _part_to_image_bytes method."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_part_to_image_bytes_from_base64(self, feishu_channel):
|
|
"""Should decode base64 image data."""
|
|
import base64
|
|
|
|
part = MagicMock()
|
|
part.image_url = "data:image/png;base64,aGVsbG8="
|
|
part.filename = "test.png"
|
|
|
|
data, filename = await feishu_channel._part_to_image_bytes(part)
|
|
|
|
assert data == b"hello"
|
|
assert filename == "test.png"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_part_to_image_bytes_invalid_base64(self, feishu_channel):
|
|
"""Should handle invalid base64 gracefully."""
|
|
part = MagicMock()
|
|
part.image_url = "data:image/png;base64,!!!invalid!!!"
|
|
part.filename = "test.png"
|
|
|
|
data, filename = await feishu_channel._part_to_image_bytes(part)
|
|
|
|
assert data is None
|
|
assert filename == "test.png"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_part_to_image_bytes_no_url(self, feishu_channel):
|
|
"""Should return (None, filename) when no image_url."""
|
|
part = MagicMock()
|
|
part.image_url = None
|
|
part.filename = "none.png"
|
|
|
|
data, filename = await feishu_channel._part_to_image_bytes(part)
|
|
|
|
assert data is None
|
|
assert filename == "none.png"
|
|
|
|
|
|
# =============================================================================
|
|
# P2: Part to File Path or URL
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelPartToFilePathOrUrl:
|
|
"""Tests for _part_to_file_path_or_url method."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_part_to_file_path_from_base64(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
):
|
|
"""Should save base64 data to temp file and return path."""
|
|
import base64
|
|
|
|
# Use actual media dir
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
test_data = b"test file content"
|
|
b64_data = base64.b64encode(test_data).decode()
|
|
|
|
part = MagicMock()
|
|
part.file_url = f"data:application/octet-stream;base64,{b64_data}"
|
|
part.filename = "test.txt"
|
|
|
|
result = await feishu_channel._part_to_file_path_or_url(part)
|
|
|
|
assert result is not None
|
|
assert Path(result).exists()
|
|
assert Path(result).read_bytes() == test_data
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_part_to_file_path_invalid_base64(self, feishu_channel):
|
|
"""Should return None for invalid base64."""
|
|
part = MagicMock()
|
|
part.file_url = "data:application/octet-stream;base64,!!!invalid!!!"
|
|
part.filename = "test.txt"
|
|
|
|
result = await feishu_channel._part_to_file_path_or_url(part)
|
|
|
|
assert result is None
|
|
|
|
def test_part_to_file_path_with_local_path(self, feishu_channel, tmp_path):
|
|
"""Should return path for existing local file."""
|
|
test_file = tmp_path / "local.txt"
|
|
test_file.write_text("local content")
|
|
|
|
part = MagicMock()
|
|
part.file_url = str(test_file)
|
|
part.filename = "local.txt"
|
|
|
|
result = asyncio.run(
|
|
feishu_channel._part_to_file_path_or_url(part),
|
|
)
|
|
|
|
assert result == str(test_file)
|
|
|
|
def test_part_to_file_path_with_http_url(self, feishu_channel):
|
|
"""Should return HTTP URL directly."""
|
|
part = MagicMock()
|
|
part.file_url = "https://example.com/file.pdf"
|
|
part.filename = "file.pdf"
|
|
|
|
result = asyncio.run(
|
|
feishu_channel._part_to_file_path_or_url(part),
|
|
)
|
|
|
|
assert result == "https://example.com/file.pdf"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_part_to_file_path_with_file_url(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
):
|
|
"""Should handle file:// URLs."""
|
|
test_file = tmp_path / "file_url_test.txt"
|
|
test_file.write_text("content via file url")
|
|
|
|
part = MagicMock()
|
|
part.file_url = f"file://{test_file}"
|
|
part.filename = "file_url_test.txt"
|
|
|
|
result = await feishu_channel._part_to_file_path_or_url(part)
|
|
|
|
assert result == str(test_file)
|
|
|
|
|
|
# =============================================================================
|
|
# P2: Load/Store File Backward Compatibility
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelReceiveIdStoreBackwardCompat:
|
|
"""Tests for backward compatibility in receive_id store."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_load_receive_id_store_backward_compat(
|
|
self,
|
|
feishu_channel_with_workspace,
|
|
temp_workspace_dir,
|
|
):
|
|
"""Should handle old format [receive_id, receive_id_type]."""
|
|
channel = feishu_channel_with_workspace
|
|
|
|
# Create file with old format (reversed order)
|
|
store_path = temp_workspace_dir / "feishu_receive_ids.json"
|
|
old_data = {
|
|
"old_session": ["ou_old_user", "open_id"], # [id, type] old format
|
|
}
|
|
with open(store_path, "w", encoding="utf-8") as f:
|
|
json.dump(old_data, f)
|
|
|
|
# Load should normalize to (type, id) format
|
|
channel._load_receive_id_store_from_disk()
|
|
|
|
assert "old_session" in channel._receive_id_store
|
|
# Should be stored as (type, id)
|
|
assert channel._receive_id_store["old_session"] == (
|
|
"open_id",
|
|
"ou_old_user",
|
|
)
|
|
|
|
|
|
# =============================================================================
|
|
# P2: Fetch Bytes from URL
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelFetchBytesFromUrl:
|
|
"""Tests for _fetch_bytes_from_url method."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_fetch_bytes_no_http_client(self, feishu_channel):
|
|
"""Should return None when http_client not initialized."""
|
|
feishu_channel._http_client = None
|
|
|
|
result = await feishu_channel._fetch_bytes_from_url(
|
|
"https://example.com/file.txt",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_fetch_bytes_from_local_file(self, feishu_channel, tmp_path):
|
|
"""Should read local file directly."""
|
|
# Use actual media dir
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
test_file = tmp_path / "test.txt"
|
|
test_file.write_text("file content")
|
|
|
|
# Mock http_client to verify it's not used
|
|
feishu_channel._http_client = MagicMock()
|
|
|
|
result = await feishu_channel._fetch_bytes_from_url(
|
|
f"file://{test_file}",
|
|
)
|
|
|
|
assert result == b"file content"
|
|
feishu_channel._http_client.get.assert_not_called()
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Get On Reply Sent Args
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelGetOnReplySentArgs:
|
|
"""Tests for get_on_reply_sent_args method."""
|
|
|
|
def test_returns_user_id_and_session_id(self, feishu_channel):
|
|
"""Should return tuple of (user_id, session_id)."""
|
|
mock_request = MagicMock()
|
|
mock_request.user_id = "u123"
|
|
mock_request.session_id = "s456"
|
|
|
|
result = feishu_channel.get_on_reply_sent_args(mock_request, "handle")
|
|
|
|
assert result == ("u123", "s456")
|
|
|
|
def test_handles_empty_values(self, feishu_channel):
|
|
"""Should handle empty values gracefully."""
|
|
mock_request = MagicMock()
|
|
mock_request.user_id = ""
|
|
mock_request.session_id = ""
|
|
|
|
result = feishu_channel.get_on_reply_sent_args(mock_request, "handle")
|
|
|
|
assert result == ("", "")
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Get To Handle From Request
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelGetToHandleFromRequest:
|
|
"""Tests for get_to_handle_from_request method."""
|
|
|
|
def test_returns_session_based_handle(self, feishu_channel):
|
|
"""Should return feishu:sw: prefix with session_id."""
|
|
mock_request = MagicMock()
|
|
mock_request.session_id = "abc123"
|
|
mock_request.user_id = "user456"
|
|
|
|
result = feishu_channel.get_to_handle_from_request(mock_request)
|
|
|
|
assert result == "feishu:sw:abc123"
|
|
|
|
def test_fallbacks_to_user_id(self, feishu_channel):
|
|
"""Should fallback to feishu:open_id: when no session_id."""
|
|
mock_request = MagicMock()
|
|
mock_request.session_id = ""
|
|
mock_request.user_id = "user789"
|
|
|
|
result = feishu_channel.get_to_handle_from_request(mock_request)
|
|
|
|
assert result == "feishu:open_id:user789"
|
|
|
|
def test_returns_empty_when_both_empty(self, feishu_channel):
|
|
"""Should return empty string when both are empty."""
|
|
mock_request = MagicMock()
|
|
mock_request.session_id = ""
|
|
mock_request.user_id = ""
|
|
|
|
result = feishu_channel.get_to_handle_from_request(mock_request)
|
|
|
|
assert result == ""
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Complex Method Tests - _on_message
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelOnMessageComplex:
|
|
"""P1: Complex method tests for _on_message.
|
|
|
|
Method characteristics:
|
|
- Multi-branch logic for different message types
|
|
- Message deduplication
|
|
- Media download integration
|
|
- Bot mention handling
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def mock_message_data(self):
|
|
"""Create mock message data structure."""
|
|
data = MagicMock()
|
|
data.event = MagicMock()
|
|
data.event.message = MagicMock()
|
|
data.event.message.message_id = "msg_12345"
|
|
data.event.message.chat_id = "chat_67890"
|
|
data.event.message.chat_type = "p2p"
|
|
data.event.message.message_type = "text"
|
|
data.event.message.content = '{"text": "Hello world"}'
|
|
data.event.message.mentions = []
|
|
data.event.sender = MagicMock()
|
|
data.event.sender.sender_type = "user"
|
|
data.event.sender.sender_id = MagicMock()
|
|
data.event.sender.sender_id.open_id = "user_open_id_123"
|
|
data.event.sender.name = "Test User"
|
|
return data
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_text_basic(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test handling basic text message."""
|
|
# _process is async generator, verify message marked as processed
|
|
await feishu_channel._on_message(mock_message_data)
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_duplicated_message_skipped(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test deduplication: same message_id marked as processed."""
|
|
msg_id = "msg_duplicate_test"
|
|
mock_message_data.event.message.message_id = msg_id
|
|
|
|
# First call
|
|
await feishu_channel._on_message(mock_message_data)
|
|
# Verify message was tracked
|
|
assert msg_id in feishu_channel._processed_message_ids
|
|
|
|
# Second call with same id should still work but not re-process
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_self_bot_sender_skipped(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test messages sent by the bot itself are ignored."""
|
|
captured = {}
|
|
|
|
def capture_enqueue(native):
|
|
captured["native"] = native
|
|
|
|
feishu_channel._enqueue = capture_enqueue
|
|
feishu_channel._bot_open_id = "user_open_id_123"
|
|
mock_message_data.event.sender.sender_type = "bot"
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
assert "native" not in captured
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_other_bot_sender_processed(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test messages sent by another bot are processed."""
|
|
captured = {}
|
|
|
|
def capture_enqueue(native):
|
|
captured["native"] = native
|
|
|
|
feishu_channel._enqueue = capture_enqueue
|
|
feishu_channel._bot_open_id = "self_bot_open_id"
|
|
mock_message_data.event.sender.sender_type = "bot"
|
|
mock_message_data.event.sender.sender_id.open_id = "other_bot_open_id"
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
assert "native" in captured
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_empty_data_returns_early(self, feishu_channel):
|
|
"""Test None data returns early."""
|
|
feishu_channel._process = AsyncMock()
|
|
await feishu_channel._on_message(None)
|
|
feishu_channel._process.assert_not_called()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_no_event_returns_early(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test missing event returns early."""
|
|
feishu_channel._process = AsyncMock()
|
|
mock_message_data.event = None
|
|
await feishu_channel._on_message(mock_message_data)
|
|
feishu_channel._process.assert_not_called()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_image_type(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test image message handling."""
|
|
feishu_channel._download_image_resource = AsyncMock(
|
|
return_value="/path/to/image.jpg",
|
|
)
|
|
mock_message_data.event.message.message_type = "image"
|
|
mock_message_data.event.message.content = '{"image_key": "img_123"}'
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
feishu_channel._download_image_resource.assert_called_once_with(
|
|
"msg_12345",
|
|
"img_123",
|
|
)
|
|
# Verify message was tracked
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_image_download_failure(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test image download failure handling."""
|
|
feishu_channel._download_image_resource = AsyncMock(return_value=None)
|
|
mock_message_data.event.message.message_type = "image"
|
|
mock_message_data.event.message.content = '{"image_key": "img_123"}'
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
# Message should still be processed with failure text
|
|
feishu_channel._download_image_resource.assert_called_once()
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_file_type(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test file message handling."""
|
|
feishu_channel._download_file_resource = AsyncMock(
|
|
return_value="/path/to/file.pdf",
|
|
)
|
|
mock_message_data.event.message.message_type = "file"
|
|
mock_message_data.event.message.content = (
|
|
'{"file_key": "file_123", "file_name": "test.pdf"}'
|
|
)
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
feishu_channel._download_file_resource.assert_called_once()
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_audio_type(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test audio message handling."""
|
|
feishu_channel._download_file_resource = AsyncMock(
|
|
return_value="/path/to/audio.opus",
|
|
)
|
|
mock_message_data.event.message.message_type = "audio"
|
|
mock_message_data.event.message.content = '{"file_key": "audio_123"}'
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
feishu_channel._download_file_resource.assert_called_once()
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_unknown_type(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test unknown message type handling."""
|
|
mock_message_data.event.message.message_type = "unknown_type"
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
# Message should still be processed with placeholder text
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_with_bot_mention(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test bot mention detection and removal."""
|
|
feishu_channel._bot_open_id = "bot_open_id_456"
|
|
mock_message_data.event.message.content = '{"text": "@_user_1 Hello"}'
|
|
# Create proper mock structure for mentions
|
|
mention_mock = MagicMock()
|
|
mention_mock.id = MagicMock()
|
|
mention_mock.id.open_id = "bot_open_id_456"
|
|
mention_mock.key = "@_user_1"
|
|
mock_message_data.event.message.mentions = [mention_mock]
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
# Message should still be processed
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_post_with_images(
|
|
self,
|
|
feishu_channel,
|
|
mock_message_data,
|
|
):
|
|
"""Test post message handling."""
|
|
feishu_channel._download_image_resource = AsyncMock(
|
|
return_value="/path/to/img.jpg",
|
|
)
|
|
mock_message_data.event.message.message_type = "post"
|
|
# Use a simple post format that actually works with extract_post_text
|
|
content = '{"title": "Test", "content": [[{"tag": "text"}]]}'
|
|
mock_message_data.event.message.content = content
|
|
|
|
await feishu_channel._on_message(mock_message_data)
|
|
|
|
assert "msg_12345" in feishu_channel._processed_message_ids
|
|
|
|
|
|
# =============================================================================
|
|
# P1: Send Methods Tests (Fixed)
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelSendMethodsFixed:
|
|
"""P1: Fixed tests for send methods with correct signatures."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_text_success(self, feishu_channel):
|
|
"""Test successful text message send."""
|
|
feishu_channel._send_message = AsyncMock(return_value="msg_id_123")
|
|
feishu_channel._get_tenant_access_token = AsyncMock(
|
|
return_value="token_123",
|
|
)
|
|
|
|
body = "Hello world"
|
|
result = await feishu_channel._send_text(
|
|
"open_id",
|
|
"user_open_id",
|
|
body,
|
|
)
|
|
|
|
assert result is not None
|
|
feishu_channel._send_message.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_text_with_table(self, feishu_channel):
|
|
"""Test text with markdown table sends as card."""
|
|
feishu_channel._send_message = AsyncMock(return_value="msg_id_123")
|
|
feishu_channel._get_tenant_access_token = AsyncMock(
|
|
return_value="token_123",
|
|
)
|
|
|
|
body = "| Header |\n|--------|\n| Value |"
|
|
result = await feishu_channel._send_text(
|
|
"open_id",
|
|
"user_open_id",
|
|
body,
|
|
)
|
|
|
|
# Should still succeed (method chunks tables into cards)
|
|
assert result is not None
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Download Image Resource
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelDownloadImageResource:
|
|
"""Tests for _download_image_resource method.
|
|
|
|
Covers:
|
|
- Download success with different image formats
|
|
- SDK failure handling
|
|
- Empty response handling
|
|
- File extension detection
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def mock_get_message_resource_request(self):
|
|
"""Mock GetMessageResourceRequest builder."""
|
|
mock_builder = MagicMock()
|
|
mock_request = MagicMock()
|
|
mock_builder.message_id.return_value = mock_builder
|
|
mock_builder.file_key.return_value = mock_builder
|
|
mock_builder.type.return_value = mock_builder
|
|
mock_builder.build.return_value = mock_request
|
|
|
|
with patch(
|
|
"qwenpaw.app.channels.feishu.channel.GetMessageResourceRequest",
|
|
) as mock_class:
|
|
mock_class.builder.return_value = mock_builder
|
|
yield mock_class, mock_request
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_image_success(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should download image successfully and return path."""
|
|
from io import BytesIO
|
|
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Mock SDK response
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.file = BytesIO(b"fake_image_data_jpg_content")
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_image_resource(
|
|
"msg_123",
|
|
"img_key_456",
|
|
)
|
|
|
|
assert result is not None
|
|
assert "msg_123" in result
|
|
assert "img_key_456" in result
|
|
assert Path(result).exists()
|
|
assert Path(result).read_bytes() == b"fake_image_data_jpg_content"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_image_sdk_failure(
|
|
self,
|
|
feishu_channel,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should return None when SDK call fails."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = False
|
|
mock_response.code = 400
|
|
mock_response.msg = "Bad Request"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_image_resource(
|
|
"msg_123",
|
|
"img_key_456",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_image_empty_response(
|
|
self,
|
|
feishu_channel,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should return None when response file is empty."""
|
|
from io import BytesIO
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.file = BytesIO(b"") # Empty content
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_image_resource(
|
|
"msg_123",
|
|
"img_key_456",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_image_exception_handling(
|
|
self,
|
|
feishu_channel,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should handle exceptions gracefully and return None."""
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
side_effect=Exception("Network error"),
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_image_resource(
|
|
"msg_123",
|
|
"img_key_456",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_image_sanitizes_key(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should sanitize image key for safe filename."""
|
|
from io import BytesIO
|
|
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.file = BytesIO(b"fake_image_data")
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
# Use key with special characters
|
|
result = await feishu_channel._download_image_resource(
|
|
"msg_123",
|
|
"img<key>with/special:chars",
|
|
)
|
|
|
|
assert result is not None
|
|
# Check that special chars are removed or replaced
|
|
assert Path(result).exists()
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Download File Resource
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelDownloadFileResource:
|
|
"""Tests for _download_file_resource method.
|
|
|
|
Covers:
|
|
- Download success with filename hint
|
|
- SDK failure handling
|
|
- Extension detection from content
|
|
- Empty response handling
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def mock_get_message_resource_request(self):
|
|
"""Mock GetMessageResourceRequest builder."""
|
|
mock_builder = MagicMock()
|
|
mock_request = MagicMock()
|
|
mock_builder.message_id.return_value = mock_builder
|
|
mock_builder.file_key.return_value = mock_builder
|
|
mock_builder.type.return_value = mock_builder
|
|
mock_builder.build.return_value = mock_request
|
|
|
|
with patch(
|
|
"qwenpaw.app.channels.feishu.channel.GetMessageResourceRequest",
|
|
) as mock_class:
|
|
mock_class.builder.return_value = mock_builder
|
|
yield mock_class, mock_request
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_file_success(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should download file successfully with filename hint."""
|
|
from io import BytesIO
|
|
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.file = BytesIO(b"pdf_file_content_with_pdf_signature")
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_file_resource(
|
|
"msg_123",
|
|
"file_key_456",
|
|
"document.pdf",
|
|
)
|
|
|
|
assert result is not None
|
|
assert "document.pdf" in result
|
|
assert Path(result).exists()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_file_sdk_failure(
|
|
self,
|
|
feishu_channel,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should return None when SDK call fails."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = False
|
|
mock_response.code = 403
|
|
mock_response.msg = "Permission denied"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_file_resource(
|
|
"msg_123",
|
|
"file_key_456",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_file_empty_response(
|
|
self,
|
|
feishu_channel,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should return None when response file is empty."""
|
|
from io import BytesIO
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.file = BytesIO(b"")
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_file_resource(
|
|
"msg_123",
|
|
"file_key_456",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_file_detects_extension(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should detect file extension from content when hint is generic."""
|
|
from io import BytesIO
|
|
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
# JPEG signature
|
|
mock_response.file = BytesIO(
|
|
b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00",
|
|
)
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_file_resource(
|
|
"msg_123",
|
|
"file_key_456",
|
|
"file.bin",
|
|
)
|
|
|
|
assert result is not None
|
|
assert Path(result).exists()
|
|
# Should detect extension from content
|
|
assert result.endswith((".jpg", ".jpeg", ".bin"))
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_download_file_exception_handling(
|
|
self,
|
|
feishu_channel,
|
|
mock_get_message_resource_request,
|
|
):
|
|
"""Should handle exceptions gracefully and return None."""
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message_resource.aget = AsyncMock(
|
|
side_effect=Exception("Download failed"),
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._download_file_resource(
|
|
"msg_123",
|
|
"file_key_456",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Upload Image
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelUploadImage:
|
|
"""Tests for _upload_image method.
|
|
|
|
Covers:
|
|
- Upload success
|
|
- SDK failure handling
|
|
- Missing client handling
|
|
- Response data extraction
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def mock_create_image_request(self):
|
|
"""Mock CreateImageRequest and CreateImageRequestBody builder."""
|
|
mock_body_builder = MagicMock()
|
|
mock_body = MagicMock()
|
|
mock_body_builder.image_type.return_value = mock_body_builder
|
|
mock_body_builder.image.return_value = mock_body_builder
|
|
mock_body_builder.build.return_value = mock_body
|
|
|
|
mock_request_builder = MagicMock()
|
|
mock_request = MagicMock()
|
|
mock_request_builder.request_body.return_value = mock_request_builder
|
|
mock_request_builder.build.return_value = mock_request
|
|
|
|
with (
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.CreateImageRequestBody",
|
|
) as mock_body_class,
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.CreateImageRequest",
|
|
) as mock_request_class,
|
|
):
|
|
mock_body_class.builder.return_value = mock_body_builder
|
|
mock_request_class.builder.return_value = mock_request_builder
|
|
yield mock_request_class, mock_request
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_image_success(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_image_request,
|
|
):
|
|
"""Should upload image successfully and return image_key."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.image_key = "img_key_abc123"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.image.acreate = AsyncMock(return_value=mock_response)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_image(
|
|
b"fake_image_data",
|
|
"test.png",
|
|
)
|
|
|
|
assert result == "img_key_abc123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_image_no_client(self, feishu_channel):
|
|
"""Should return None when client is not initialized."""
|
|
feishu_channel._client = None
|
|
|
|
result = await feishu_channel._upload_image(
|
|
b"fake_image_data",
|
|
"test.png",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_image_sdk_failure(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_image_request,
|
|
):
|
|
"""Should return None when SDK upload fails."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = False
|
|
mock_response.code = 413
|
|
mock_response.msg = "File too large"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.image.acreate = AsyncMock(return_value=mock_response)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_image(
|
|
b"fake_image_data",
|
|
"test.png",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_image_exception_handling(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_image_request,
|
|
):
|
|
"""Should handle exceptions gracefully and return None."""
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.image.acreate = AsyncMock(
|
|
side_effect=Exception("Upload failed"),
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_image(
|
|
b"fake_image_data",
|
|
"test.png",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Upload File
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelUploadFile:
|
|
"""Tests for _upload_file method.
|
|
|
|
Covers:
|
|
- Upload success with different file types
|
|
- File type detection
|
|
- Large file rejection
|
|
- URL download and upload
|
|
- SDK failure handling
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def mock_create_file_request(self):
|
|
"""Mock CreateFileRequest and CreateFileRequestBody builder."""
|
|
mock_body_builder = MagicMock()
|
|
mock_body = MagicMock()
|
|
mock_body_builder.file_type.return_value = mock_body_builder
|
|
mock_body_builder.file_name.return_value = mock_body_builder
|
|
mock_body_builder.file.return_value = mock_body_builder
|
|
mock_body_builder.build.return_value = mock_body
|
|
|
|
mock_request_builder = MagicMock()
|
|
mock_request = MagicMock()
|
|
mock_request_builder.request_body.return_value = mock_request_builder
|
|
mock_request_builder.build.return_value = mock_request
|
|
|
|
with (
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.CreateFileRequestBody",
|
|
) as mock_body_class,
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.CreateFileRequest",
|
|
) as mock_request_class,
|
|
):
|
|
mock_body_class.builder.return_value = mock_body_builder
|
|
mock_request_class.builder.return_value = mock_request_builder
|
|
yield mock_request_class, mock_request
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_success_doc_types(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_create_file_request,
|
|
):
|
|
"""Should upload local file successfully with correct file_type."""
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Create test files with different extensions
|
|
test_files = [
|
|
("test.pdf", b"pdf content", "pdf"),
|
|
("test.doc", b"doc content", "doc"),
|
|
("test.docx", b"docx content", "doc"),
|
|
("test.xls", b"xls content", "xls"),
|
|
("test.xlsx", b"xlsx content", "xls"),
|
|
("test.ppt", b"ppt content", "ppt"),
|
|
("test.pptx", b"pptx content", "ppt"),
|
|
]
|
|
|
|
for filename, content, expected_type in test_files:
|
|
test_file = tmp_path / filename
|
|
test_file.write_bytes(content)
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.file_key = f"file_key_{filename}"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.file.acreate = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_file(str(test_file))
|
|
|
|
assert result == f"file_key_{filename}"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_rejects_large_file(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
):
|
|
"""Should return None for files exceeding max size."""
|
|
from qwenpaw.app.channels.feishu.constants import FEISHU_FILE_MAX_BYTES
|
|
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Create oversized file
|
|
large_file = tmp_path / "large.bin"
|
|
large_file.write_bytes(b"x" * (FEISHU_FILE_MAX_BYTES + 1))
|
|
|
|
feishu_channel._client = MagicMock()
|
|
|
|
result = await feishu_channel._upload_file(str(large_file))
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_from_http_url(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_create_file_request,
|
|
):
|
|
"""Should download from URL and upload."""
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Mock HTTP client for URL fetch
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 200
|
|
mock_response.content = b"downloaded_file_content"
|
|
|
|
mock_http_client = MagicMock()
|
|
mock_http_client.get = AsyncMock(return_value=mock_response)
|
|
feishu_channel._http_client = mock_http_client
|
|
|
|
mock_sdk_response = MagicMock()
|
|
mock_sdk_response.success.return_value = True
|
|
mock_sdk_response.data = MagicMock()
|
|
mock_sdk_response.data.file_key = "file_key_from_url"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.file.acreate = AsyncMock(
|
|
return_value=mock_sdk_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_file(
|
|
"https://example.com/file.txt",
|
|
)
|
|
|
|
assert result == "file_key_from_url"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_missing_file(self, feishu_channel):
|
|
"""Should return None for non-existent file."""
|
|
feishu_channel._client = MagicMock()
|
|
feishu_channel._http_client = MagicMock()
|
|
|
|
result = await feishu_channel._upload_file(
|
|
"/nonexistent/path/file.txt",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_sdk_failure(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_create_file_request,
|
|
):
|
|
"""Should return None when SDK upload fails."""
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
test_file = tmp_path / "test.txt"
|
|
test_file.write_text("test content")
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = False
|
|
mock_response.code = 500
|
|
mock_response.msg = "Internal error"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.file.acreate = AsyncMock(return_value=mock_response)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_file(str(test_file))
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_upload_file_stream_type(
|
|
self,
|
|
feishu_channel,
|
|
tmp_path,
|
|
mock_create_file_request,
|
|
):
|
|
"""Should use 'stream' file_type for unknown extensions."""
|
|
feishu_channel._media_dir = tmp_path / "media"
|
|
feishu_channel._media_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
test_file = tmp_path / "unknown.xyz"
|
|
test_file.write_bytes(b"some content")
|
|
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.file_key = "file_key_xyz"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.file.acreate = AsyncMock(return_value=mock_response)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._upload_file(str(test_file))
|
|
|
|
assert result == "file_key_xyz"
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Send Message
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelSendMessage:
|
|
"""Tests for _send_message and _send_text methods.
|
|
|
|
Covers:
|
|
- Send success with different message types
|
|
- Failure handling
|
|
- Interactive card message
|
|
- Missing client handling
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def mock_create_message_request(self):
|
|
"""Mock CreateMessageRequest and CreateMessageRequestBody builder."""
|
|
mock_body_builder = MagicMock()
|
|
mock_body = MagicMock()
|
|
mock_body_builder.receive_id.return_value = mock_body_builder
|
|
mock_body_builder.msg_type.return_value = mock_body_builder
|
|
mock_body_builder.content.return_value = mock_body_builder
|
|
mock_body_builder.build.return_value = mock_body
|
|
|
|
mock_request_builder = MagicMock()
|
|
mock_request = MagicMock()
|
|
mock_request_builder.receive_id_type.return_value = (
|
|
mock_request_builder
|
|
)
|
|
mock_request_builder.request_body.return_value = mock_request_builder
|
|
mock_request_builder.build.return_value = mock_request
|
|
|
|
with (
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.CreateMessageRequestBody",
|
|
) as mock_body_class,
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.CreateMessageRequest",
|
|
) as mock_request_class,
|
|
):
|
|
mock_body_class.builder.return_value = mock_body_builder
|
|
mock_request_class.builder.return_value = mock_request_builder
|
|
yield mock_request_class, mock_request
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_success_post(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_message_request,
|
|
):
|
|
"""Should send post message successfully."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.message_id = "msg_id_abc123"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.acreate = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
content = (
|
|
'{"zh_cn": {"content": [[{"tag": "text", "text": "Hello"}]]}}'
|
|
)
|
|
result = await feishu_channel._send_message(
|
|
"open_id",
|
|
"user_open_id",
|
|
"post",
|
|
content,
|
|
)
|
|
|
|
assert result == "msg_id_abc123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_success_image(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_message_request,
|
|
):
|
|
"""Should send image message successfully."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.message_id = "msg_id_img_123"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.acreate = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
content = '{"image_key": "img_key_123"}'
|
|
result = await feishu_channel._send_message(
|
|
"open_id",
|
|
"user_open_id",
|
|
"image",
|
|
content,
|
|
)
|
|
|
|
assert result == "msg_id_img_123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_success_file(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_message_request,
|
|
):
|
|
"""Should send file message successfully."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.message_id = "msg_id_file_123"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.acreate = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
content = '{"file_key": "file_key_123"}'
|
|
result = await feishu_channel._send_message(
|
|
"open_id",
|
|
"user_open_id",
|
|
"file",
|
|
content,
|
|
)
|
|
|
|
assert result == "msg_id_file_123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_success_interactive(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_message_request,
|
|
):
|
|
"""Should send interactive card message successfully."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = True
|
|
mock_response.data = MagicMock()
|
|
mock_response.data.message_id = "msg_id_card_123"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.acreate = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
content = '{"config": {}, "elements": []}'
|
|
result = await feishu_channel._send_message(
|
|
"chat_id",
|
|
"oc_group_123",
|
|
"interactive",
|
|
content,
|
|
)
|
|
|
|
assert result == "msg_id_card_123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_failure(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_message_request,
|
|
):
|
|
"""Should return None when SDK send fails."""
|
|
mock_response = MagicMock()
|
|
mock_response.success.return_value = False
|
|
mock_response.code = 400
|
|
mock_response.msg = "Invalid receive_id"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.acreate = AsyncMock(
|
|
return_value=mock_response,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
content = '{"text": "Hello"}'
|
|
result = await feishu_channel._send_message(
|
|
"open_id",
|
|
"invalid_user",
|
|
"text",
|
|
content,
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_no_client(self, feishu_channel):
|
|
"""Should return None when client is not initialized."""
|
|
feishu_channel._client = None
|
|
|
|
result = await feishu_channel._send_message(
|
|
"open_id",
|
|
"user_open_id",
|
|
"text",
|
|
'{"text": "Hello"}',
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_message_exception_handling(
|
|
self,
|
|
feishu_channel,
|
|
mock_create_message_request,
|
|
):
|
|
"""Should handle exceptions gracefully and return None."""
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.acreate = AsyncMock(
|
|
side_effect=Exception("Send failed"),
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._send_message(
|
|
"open_id",
|
|
"user_open_id",
|
|
"text",
|
|
'{"text": "Hello"}',
|
|
)
|
|
|
|
assert result is None
|
|
|
|
|
|
class TestFeishuChannelSendText:
|
|
"""Tests for _send_text method specifically."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_text_basic(self, feishu_channel):
|
|
"""Should send basic text as post message."""
|
|
feishu_channel._send_message = AsyncMock(return_value="msg_id_123")
|
|
|
|
result = await feishu_channel._send_text(
|
|
"open_id",
|
|
"user_open_id",
|
|
"Hello world",
|
|
)
|
|
|
|
assert result == "msg_id_123"
|
|
feishu_channel._send_message.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_text_with_markdown_table(self, feishu_channel):
|
|
"""Should send text with table as interactive card."""
|
|
feishu_channel._send_message = AsyncMock(return_value="msg_id_card")
|
|
|
|
body = "| Header 1 | Header 2 |\n|----------|----------|\n"
|
|
body += "| Cell 1 | Cell 2 |"
|
|
result = await feishu_channel._send_text(
|
|
"open_id",
|
|
"user_open_id",
|
|
body,
|
|
)
|
|
|
|
assert result == "msg_id_card"
|
|
# Should be sent as interactive type
|
|
call_args = feishu_channel._send_message.call_args
|
|
assert call_args[0][2] == "interactive" # msg_type
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_text_empty_body(self, feishu_channel):
|
|
"""Should handle empty body."""
|
|
feishu_channel._send_message = AsyncMock(return_value="msg_id_empty")
|
|
|
|
result = await feishu_channel._send_text(
|
|
"open_id",
|
|
"user_open_id",
|
|
"",
|
|
)
|
|
|
|
assert result == "msg_id_empty"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_text_exception_handling(self, feishu_channel):
|
|
"""Should propagate exceptions from _send_message since _send_text
|
|
does not have a try-except block. In real usage, _send_message
|
|
catches its own exceptions and returns None."""
|
|
feishu_channel._send_message = AsyncMock(
|
|
side_effect=Exception("Send failed"),
|
|
)
|
|
|
|
# _send_text does not wrap _send_message in try-except,
|
|
# so exception propagates
|
|
with pytest.raises(Exception, match="Send failed"):
|
|
await feishu_channel._send_text(
|
|
"open_id",
|
|
"user_open_id",
|
|
"Hello",
|
|
)
|
|
|
|
|
|
# =============================================================================
|
|
# P2: Exception Path Tests
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelExceptions:
|
|
"""P2: Exception handling tests."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_fetch_bytes_http_error_response(self, feishu_channel):
|
|
"""Test fetch bytes with HTTP error response."""
|
|
mock_response = MagicMock()
|
|
mock_response.status_code = 404
|
|
mock_response.text = "Not found"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.get = AsyncMock(return_value=mock_response)
|
|
|
|
with patch("httpx.AsyncClient") as mock_client_class:
|
|
mock_client_class.return_value.__aenter__ = AsyncMock(
|
|
return_value=mock_client,
|
|
)
|
|
mock_client_class.return_value.__aexit__ = AsyncMock(
|
|
return_value=None,
|
|
)
|
|
|
|
result = await feishu_channel._fetch_bytes_from_url(
|
|
"https://example.com/file.jpg",
|
|
)
|
|
|
|
assert result is None
|
|
|
|
|
|
# =============================================================================
|
|
# P0: Thread (Topic) Reply Support
|
|
# =============================================================================
|
|
|
|
|
|
class TestFeishuChannelThreadReply:
|
|
"""Tests for thread/topic reply functionality.
|
|
|
|
Covers:
|
|
- _on_message extracts thread_id into meta
|
|
- user_id overridden to thread:{short_id} for topic messages
|
|
- _reply_in_thread method
|
|
- send_content_parts thread reply path (text, image, file)
|
|
- on_streaming_start skips thread messages
|
|
- _before_consume_process skips streaming card pre-creation for threads
|
|
"""
|
|
|
|
# -------------------------------------------------------------------------
|
|
# _on_message: thread_id extraction and user_id override
|
|
# -------------------------------------------------------------------------
|
|
|
|
@pytest.fixture
|
|
def mock_thread_message_data(self):
|
|
"""Create mock message data with thread_id."""
|
|
data = MagicMock()
|
|
data.event = MagicMock()
|
|
data.event.message = MagicMock()
|
|
data.event.message.message_id = "msg_thread_001"
|
|
data.event.message.chat_id = "oc_thread_group"
|
|
data.event.message.chat_type = "group"
|
|
data.event.message.message_type = "text"
|
|
data.event.message.content = '{"text": "Hello in thread"}'
|
|
data.event.message.thread_id = "omt_thread_root_abc123"
|
|
data.event.message.parent_id = ""
|
|
data.event.message.mentions = []
|
|
data.event.sender = MagicMock()
|
|
data.event.sender.sender_type = "user"
|
|
data.event.sender.sender_id = MagicMock()
|
|
data.event.sender.sender_id.open_id = "ou_user_in_thread"
|
|
data.event.sender.name = "Thread User"
|
|
return data
|
|
|
|
@pytest.fixture
|
|
def mock_reply_message_request(self):
|
|
"""Patch ReplyMessageRequest and ReplyMessageRequestBody."""
|
|
mock_builder = MagicMock()
|
|
mock_request = MagicMock()
|
|
mock_builder.message_id.return_value = mock_builder
|
|
mock_builder.request_body.return_value = mock_builder
|
|
mock_builder.build.return_value = mock_request
|
|
|
|
mock_body_builder = MagicMock()
|
|
mock_body = MagicMock()
|
|
mock_body_builder.msg_type.return_value = mock_body_builder
|
|
mock_body_builder.content.return_value = mock_body_builder
|
|
mock_body_builder.reply_in_thread.return_value = mock_body_builder
|
|
mock_body_builder.uuid.return_value = mock_body_builder
|
|
mock_body_builder.build.return_value = mock_body
|
|
|
|
with (
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.ReplyMessageRequest",
|
|
) as mock_request_class,
|
|
patch(
|
|
"qwenpaw.app.channels.feishu.channel.ReplyMessageRequestBody",
|
|
) as mock_body_class,
|
|
):
|
|
mock_request_class.builder.return_value = mock_builder
|
|
mock_body_class.builder.return_value = mock_body_builder
|
|
yield
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_extracts_thread_id_to_meta(
|
|
self,
|
|
feishu_channel,
|
|
mock_thread_message_data,
|
|
):
|
|
"""Should extract thread_id into channel_meta."""
|
|
# Use a container to capture the enqueued native payload
|
|
captured = {}
|
|
|
|
def capture_enqueue(native):
|
|
captured["native"] = native
|
|
|
|
feishu_channel._enqueue = capture_enqueue
|
|
|
|
await feishu_channel._on_message(mock_thread_message_data)
|
|
|
|
assert "native" in captured
|
|
meta = captured["native"].get("meta", {})
|
|
assert meta.get("feishu_thread_id") == "omt_thread_root_abc123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_no_thread_id_not_in_meta(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Should not include thread_id in meta when not present."""
|
|
data = MagicMock()
|
|
data.event = MagicMock()
|
|
data.event.message = MagicMock()
|
|
data.event.message.message_id = "msg_no_thread"
|
|
data.event.message.chat_id = "oc_no_thread"
|
|
data.event.message.chat_type = "group"
|
|
data.event.message.message_type = "text"
|
|
data.event.message.content = '{"text": "Normal message"}'
|
|
data.event.message.thread_id = ""
|
|
data.event.message.mentions = []
|
|
data.event.sender = MagicMock()
|
|
data.event.sender.sender_type = "user"
|
|
data.event.sender.sender_id = MagicMock()
|
|
data.event.sender.sender_id.open_id = "ou_normal_user"
|
|
data.event.sender.name = "Normal User"
|
|
|
|
captured = {}
|
|
|
|
def capture_enqueue(native):
|
|
captured["native"] = native
|
|
|
|
feishu_channel._enqueue = capture_enqueue
|
|
|
|
await feishu_channel._on_message(data)
|
|
|
|
assert "native" in captured
|
|
meta = captured["native"].get("meta", {})
|
|
assert "feishu_thread_id" not in meta
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_thread_overrides_user_id(
|
|
self,
|
|
feishu_channel,
|
|
mock_thread_message_data,
|
|
):
|
|
"""Should override user_id to thread:{short_id} for thread msgs."""
|
|
captured = {}
|
|
|
|
def capture_enqueue(native):
|
|
captured["native"] = native
|
|
|
|
feishu_channel._enqueue = capture_enqueue
|
|
|
|
await feishu_channel._on_message(mock_thread_message_data)
|
|
|
|
assert "native" in captured
|
|
native = captured["native"]
|
|
# user_id should be thread:{shortened_thread_id}
|
|
assert native["user_id"].startswith("thread:")
|
|
assert "abc123" in native["user_id"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_message_thread_overrides_shared_mode(
|
|
self,
|
|
feishu_channel,
|
|
mock_thread_message_data,
|
|
):
|
|
"""Thread override should win over shared group mode."""
|
|
feishu_channel.group_session_mode = "shared"
|
|
captured = {}
|
|
|
|
def capture_enqueue(native):
|
|
captured["native"] = native
|
|
|
|
feishu_channel._enqueue = capture_enqueue
|
|
|
|
await feishu_channel._on_message(mock_thread_message_data)
|
|
|
|
assert "native" in captured
|
|
native = captured["native"]
|
|
# Must be thread:..., not group:...
|
|
assert native["user_id"].startswith("thread:")
|
|
|
|
# -------------------------------------------------------------------------
|
|
# _reply_in_thread method
|
|
# -------------------------------------------------------------------------
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_reply_in_thread_success(
|
|
self,
|
|
feishu_channel,
|
|
mock_reply_message_request,
|
|
):
|
|
"""Should call reply API and return message_id."""
|
|
mock_resp = MagicMock()
|
|
mock_resp.success.return_value = True
|
|
mock_resp.data = MagicMock()
|
|
mock_resp.data.message_id = "reply_msg_001"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.areply = AsyncMock(
|
|
return_value=mock_resp,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._reply_in_thread(
|
|
"omt_root_123",
|
|
"post",
|
|
'{"zh_cn": {"content": []}}',
|
|
)
|
|
|
|
assert result == "reply_msg_001"
|
|
mock_client.im.v1.message.areply.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_reply_in_thread_no_client(self, feishu_channel):
|
|
"""Should return None when client is not initialized."""
|
|
feishu_channel._client = None
|
|
|
|
result = await feishu_channel._reply_in_thread(
|
|
"omt_root_123",
|
|
"post",
|
|
'{"zh_cn": {"content": []}}',
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_reply_in_thread_empty_message_id(self, feishu_channel):
|
|
"""Should return None when message_id is empty."""
|
|
feishu_channel._client = MagicMock()
|
|
|
|
result = await feishu_channel._reply_in_thread(
|
|
"",
|
|
"post",
|
|
'{"zh_cn": {"content": []}}',
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_reply_in_thread_sdk_failure(self, feishu_channel):
|
|
"""Should return None when SDK reply fails."""
|
|
mock_resp = MagicMock()
|
|
mock_resp.success.return_value = False
|
|
mock_resp.code = 10003
|
|
mock_resp.msg = "Bad request"
|
|
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.areply = AsyncMock(
|
|
return_value=mock_resp,
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._reply_in_thread(
|
|
"omt_root_123",
|
|
"post",
|
|
'{"zh_cn": {"content": []}}',
|
|
)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_reply_in_thread_exception(self, feishu_channel):
|
|
"""Should handle exceptions gracefully and return None."""
|
|
mock_client = MagicMock()
|
|
mock_client.im.v1.message.areply = AsyncMock(
|
|
side_effect=Exception("Reply failed"),
|
|
)
|
|
feishu_channel._client = mock_client
|
|
|
|
result = await feishu_channel._reply_in_thread(
|
|
"omt_root_123",
|
|
"post",
|
|
'{"zh_cn": {"content": []}}',
|
|
)
|
|
|
|
assert result is None
|
|
|
|
# -------------------------------------------------------------------------
|
|
# send_content_parts: thread reply path
|
|
# -------------------------------------------------------------------------
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_content_parts_thread_text(self, feishu_channel):
|
|
"""Should use _reply_in_thread for text in thread mode."""
|
|
feishu_channel._reply_in_thread = AsyncMock(
|
|
return_value="thread_reply_id",
|
|
)
|
|
|
|
result = await feishu_channel.send_content_parts(
|
|
to_handle="feishu:sw:test_session",
|
|
parts=[
|
|
MagicMock(
|
|
type=ContentType.TEXT,
|
|
text="Hello in thread",
|
|
spec=OutgoingContentPart,
|
|
),
|
|
],
|
|
meta={
|
|
"feishu_thread_id": "omt_thread_root",
|
|
"feishu_message_id": "msg_root_001",
|
|
"feishu_receive_id": "oc_group_123",
|
|
"feishu_receive_id_type": "chat_id",
|
|
},
|
|
)
|
|
|
|
assert result == "thread_reply_id"
|
|
feishu_channel._reply_in_thread.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_content_parts_thread_image(self, feishu_channel):
|
|
"""Should upload image and reply in thread for image parts."""
|
|
feishu_channel._part_to_image_bytes = AsyncMock(
|
|
return_value=(b"fake_image_data", "test.png"),
|
|
)
|
|
feishu_channel._upload_image = AsyncMock(
|
|
return_value="img_key_thread",
|
|
)
|
|
feishu_channel._reply_in_thread = AsyncMock(
|
|
return_value="thread_img_reply",
|
|
)
|
|
|
|
part = MagicMock(spec=OutgoingContentPart)
|
|
part.type = ContentType.IMAGE
|
|
part.image_url = "data:image/png;base64,aGVsbG8="
|
|
part.filename = "test.png"
|
|
|
|
result = await feishu_channel.send_content_parts(
|
|
to_handle="feishu:sw:test_session",
|
|
parts=[part],
|
|
meta={
|
|
"feishu_thread_id": "omt_thread_root",
|
|
"feishu_message_id": "msg_root_001",
|
|
"feishu_receive_id": "oc_group_123",
|
|
"feishu_receive_id_type": "chat_id",
|
|
},
|
|
)
|
|
|
|
assert result == "thread_img_reply"
|
|
feishu_channel._upload_image.assert_called_once_with(
|
|
b"fake_image_data",
|
|
"test.png",
|
|
)
|
|
feishu_channel._reply_in_thread.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_content_parts_thread_file(self, feishu_channel):
|
|
"""Should upload file and reply in thread for file parts."""
|
|
feishu_channel._part_to_file_path_or_url = AsyncMock(
|
|
return_value="/tmp/test_doc.pdf",
|
|
)
|
|
feishu_channel._upload_file = AsyncMock(
|
|
return_value="file_key_thread",
|
|
)
|
|
feishu_channel._reply_in_thread = AsyncMock(
|
|
return_value="thread_file_reply",
|
|
)
|
|
|
|
part = MagicMock(spec=OutgoingContentPart)
|
|
part.type = ContentType.FILE
|
|
part.file_url = "file:///tmp/test_doc.pdf"
|
|
part.filename = "test_doc.pdf"
|
|
|
|
result = await feishu_channel.send_content_parts(
|
|
to_handle="feishu:sw:test_session",
|
|
parts=[part],
|
|
meta={
|
|
"feishu_thread_id": "omt_thread_root",
|
|
"feishu_message_id": "msg_root_001",
|
|
"feishu_receive_id": "oc_group_123",
|
|
"feishu_receive_id_type": "chat_id",
|
|
},
|
|
)
|
|
|
|
assert result == "thread_file_reply"
|
|
feishu_channel._upload_file.assert_called_once()
|
|
feishu_channel._reply_in_thread.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_content_parts_thread_audio_file(self, feishu_channel):
|
|
"""Should use audio msg_type for ogg/opus files in thread."""
|
|
feishu_channel._part_to_file_path_or_url = AsyncMock(
|
|
return_value="/tmp/audio.opus",
|
|
)
|
|
feishu_channel._upload_file = AsyncMock(
|
|
return_value="file_key_audio",
|
|
)
|
|
feishu_channel._reply_in_thread = AsyncMock(
|
|
return_value="thread_audio_reply",
|
|
)
|
|
|
|
part = MagicMock(spec=OutgoingContentPart)
|
|
part.type = ContentType.AUDIO
|
|
part.file_url = "file:///tmp/audio.opus"
|
|
part.filename = "audio.opus"
|
|
|
|
result = await feishu_channel.send_content_parts(
|
|
to_handle="feishu:sw:test_session",
|
|
parts=[part],
|
|
meta={
|
|
"feishu_thread_id": "omt_thread_root",
|
|
"feishu_message_id": "msg_root_001",
|
|
"feishu_receive_id": "oc_group_123",
|
|
"feishu_receive_id_type": "chat_id",
|
|
},
|
|
)
|
|
|
|
assert result == "thread_audio_reply"
|
|
feishu_channel._reply_in_thread.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_content_parts_no_thread_uses_normal_path(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Without thread_id, normal send path should be used."""
|
|
feishu_channel._send_text = AsyncMock(return_value="normal_msg_id")
|
|
|
|
result = await feishu_channel.send_content_parts(
|
|
to_handle="feishu:sw:test_session",
|
|
parts=[
|
|
MagicMock(
|
|
type=ContentType.TEXT,
|
|
text="Normal message",
|
|
spec=OutgoingContentPart,
|
|
),
|
|
],
|
|
meta={
|
|
"feishu_receive_id": "oc_group_123",
|
|
"feishu_receive_id_type": "chat_id",
|
|
},
|
|
)
|
|
|
|
assert result == "normal_msg_id"
|
|
feishu_channel._send_text.assert_called_once()
|
|
|
|
# -------------------------------------------------------------------------
|
|
# Streaming: skip for thread messages
|
|
# -------------------------------------------------------------------------
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_streaming_start_skips_thread(self, feishu_channel):
|
|
"""on_streaming_start should skip when feishu_thread_id is set."""
|
|
feishu_channel.streaming_enabled = True
|
|
feishu_channel._get_receive_for_send = AsyncMock(
|
|
return_value=("chat_id", "oc_test"),
|
|
)
|
|
|
|
await feishu_channel.on_streaming_start(
|
|
request=MagicMock(),
|
|
to_handle="feishu:sw:test",
|
|
event=MagicMock(),
|
|
send_meta={"feishu_thread_id": "omt_thread_root"},
|
|
stream_type="message",
|
|
)
|
|
|
|
feishu_channel._get_receive_for_send.assert_not_called()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_on_streaming_start_proceeds_without_thread(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""Without thread_id, normal streaming start should proceed."""
|
|
feishu_channel.streaming_enabled = True
|
|
feishu_channel._get_receive_for_send = AsyncMock(
|
|
return_value=("chat_id", "oc_test"),
|
|
)
|
|
feishu_channel._create_streaming_card = AsyncMock(
|
|
return_value={"card_id": "card_001", "message_id": "msg_001"},
|
|
)
|
|
|
|
await feishu_channel.on_streaming_start(
|
|
request=MagicMock(),
|
|
to_handle="feishu:sw:test",
|
|
event=MagicMock(),
|
|
send_meta={},
|
|
stream_type="message",
|
|
)
|
|
|
|
feishu_channel._get_receive_for_send.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_before_consume_process_skips_streaming_for_thread(
|
|
self,
|
|
feishu_channel,
|
|
):
|
|
"""_before_consume_process should skip card pre-creation for thread."""
|
|
feishu_channel.streaming_enabled = True
|
|
feishu_channel._create_streaming_card = AsyncMock(
|
|
return_value={"card_id": "card_001"},
|
|
)
|
|
|
|
request = MagicMock()
|
|
request.session_id = "test_session"
|
|
request.channel_meta = {
|
|
"feishu_receive_id": "oc_test",
|
|
"feishu_receive_id_type": "chat_id",
|
|
"feishu_thread_id": "omt_thread_root",
|
|
}
|
|
|
|
await feishu_channel._before_consume_process(request)
|
|
|
|
feishu_channel._create_streaming_card.assert_not_called()
|
|
|
|
|
|
# =============================================================================
|
|
# Tests for extract_interactive_text (utils)
|
|
# =============================================================================
|
|
|
|
|
|
# pylint: disable=unsupported-membership-test
|
|
class TestExtractInteractiveText:
|
|
"""Unit tests for extract_interactive_text()."""
|
|
|
|
def test_extracts_title_and_elements(self):
|
|
from qwenpaw.app.channels.feishu.utils import extract_interactive_text
|
|
|
|
payload = json.dumps(
|
|
{
|
|
"title": "Card Title",
|
|
"elements": [
|
|
[{"tag": "text", "text": "Hello world"}],
|
|
],
|
|
},
|
|
)
|
|
result = extract_interactive_text(payload)
|
|
assert result is not None
|
|
assert "Card Title" in result
|
|
assert "Hello world" in result
|
|
|
|
def test_cardkit_v2_body_elements(self):
|
|
"""CardKit v2 nests elements under body — must still extract."""
|
|
from qwenpaw.app.channels.feishu.utils import extract_interactive_text
|
|
|
|
payload = json.dumps(
|
|
{
|
|
"header": {"title": {"content": "V2 Card"}},
|
|
"body": {
|
|
"elements": [
|
|
{"tag": "text", "text": "Body content here"},
|
|
],
|
|
},
|
|
},
|
|
)
|
|
result = extract_interactive_text(payload)
|
|
assert result is not None
|
|
assert "V2 Card" in result
|
|
assert "Body content here" in result
|
|
|
|
def test_extracts_links_as_markdown(self):
|
|
from qwenpaw.app.channels.feishu.utils import extract_interactive_text
|
|
|
|
payload = json.dumps(
|
|
{
|
|
"elements": [
|
|
[
|
|
{
|
|
"tag": "a",
|
|
"text": "Click me",
|
|
"href": "https://example.com",
|
|
},
|
|
],
|
|
],
|
|
},
|
|
)
|
|
result = extract_interactive_text(payload)
|
|
assert result is not None
|
|
assert "[Click me](https://example.com)" in result
|
|
|
|
def test_returns_none_for_empty_or_invalid(self):
|
|
from qwenpaw.app.channels.feishu.utils import extract_interactive_text
|
|
|
|
assert extract_interactive_text(None) is None
|
|
assert extract_interactive_text("") is None
|
|
assert extract_interactive_text("{broken") is None
|
|
assert extract_interactive_text(json.dumps({"other": "data"})) is None
|
|
|
|
def test_title_only(self):
|
|
from qwenpaw.app.channels.feishu.utils import extract_interactive_text
|
|
|
|
result = extract_interactive_text(json.dumps({"title": "Hello"}))
|
|
assert result == "Hello"
|
|
|
|
def test_header_title_content(self):
|
|
from qwenpaw.app.channels.feishu.utils import extract_interactive_text
|
|
|
|
payload = json.dumps(
|
|
{
|
|
"header": {"title": {"content": "Header Title"}},
|
|
},
|
|
)
|
|
result = extract_interactive_text(payload)
|
|
assert result == "Header Title"
|
|
|
|
|
|
# =============================================================================
|
|
# Tests for _parse_message_content (channel)
|
|
# =============================================================================
|
|
|
|
|
|
class TestParseMessageContent:
|
|
"""Tests for the shared _parse_message_content engine.
|
|
|
|
Returns (main_text, error_hints, content_parts).
|
|
"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_text_basic(self, feishu_channel):
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
content_parts,
|
|
) = await feishu_channel._parse_message_content(
|
|
"text",
|
|
'{"text": "Hello world"}',
|
|
"msg_001",
|
|
)
|
|
assert main_text == "Hello world"
|
|
assert error_hints == []
|
|
assert content_parts == []
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_text_empty(self, feishu_channel):
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
_,
|
|
) = await feishu_channel._parse_message_content(
|
|
"text",
|
|
'{"text": ""}',
|
|
"msg_002",
|
|
)
|
|
assert main_text is None
|
|
assert error_hints == []
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_text_whitespace_only(self, feishu_channel):
|
|
main_text, _, _ = await feishu_channel._parse_message_content(
|
|
"text",
|
|
'{"text": " "}',
|
|
"msg_003",
|
|
)
|
|
assert main_text is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_post_basic(self, feishu_channel):
|
|
content = json.dumps(
|
|
{
|
|
"content": [[{"tag": "text", "text": "Post body"}]],
|
|
},
|
|
)
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
_,
|
|
) = await feishu_channel._parse_message_content(
|
|
"post",
|
|
content,
|
|
"msg_010",
|
|
)
|
|
assert main_text is not None
|
|
assert "Post body" in main_text
|
|
assert error_hints == []
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_image_missing_key(self, feishu_channel):
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
content_parts,
|
|
) = await feishu_channel._parse_message_content(
|
|
"image",
|
|
'{"other": "val"}',
|
|
"msg_020",
|
|
)
|
|
assert main_text is None
|
|
assert "[image: missing key]" in error_hints
|
|
assert content_parts == []
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_image_download_success(self, feishu_channel):
|
|
feishu_channel._download_image_resource = AsyncMock(
|
|
return_value="/tmp/img.jpg",
|
|
)
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
content_parts,
|
|
) = await feishu_channel._parse_message_content(
|
|
"image",
|
|
'{"image_key": "img_abc"}',
|
|
"msg_021",
|
|
)
|
|
assert main_text is None
|
|
assert error_hints == []
|
|
assert len(content_parts) == 1
|
|
assert content_parts[0].image_url == "/tmp/img.jpg"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_file_missing_key(self, feishu_channel):
|
|
_, error_hints, _ = await feishu_channel._parse_message_content(
|
|
"file",
|
|
'{"other": "val"}',
|
|
"msg_030",
|
|
)
|
|
assert "[file: missing key]" in error_hints
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_audio_download_success(self, feishu_channel):
|
|
feishu_channel._download_file_resource = AsyncMock(
|
|
return_value="/tmp/audio.opus",
|
|
)
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
content_parts,
|
|
) = await feishu_channel._parse_message_content(
|
|
"audio",
|
|
'{"file_key": "file_abc"}',
|
|
"msg_031",
|
|
)
|
|
assert main_text is None
|
|
assert error_hints == []
|
|
assert len(content_parts) == 1
|
|
assert content_parts[0].type == ContentType.AUDIO
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_interactive_basic(self, feishu_channel):
|
|
content = json.dumps(
|
|
{
|
|
"header": {"title": {"content": "Card Title"}},
|
|
"body": {"elements": [{"tag": "text", "text": "Card body"}]},
|
|
},
|
|
)
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
_,
|
|
) = await feishu_channel._parse_message_content(
|
|
"interactive",
|
|
content,
|
|
"msg_040",
|
|
)
|
|
assert main_text is not None
|
|
assert "Card Title" in main_text
|
|
assert "Card body" in main_text
|
|
assert error_hints == []
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_interactive_empty_returns_none(self, feishu_channel):
|
|
content = json.dumps({"other": "data"})
|
|
main_text, _, _ = await feishu_channel._parse_message_content(
|
|
"interactive",
|
|
content,
|
|
"msg_041",
|
|
)
|
|
assert main_text is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_unknown_type_returns_empty(self, feishu_channel):
|
|
(
|
|
main_text,
|
|
error_hints,
|
|
content_parts,
|
|
) = await feishu_channel._parse_message_content(
|
|
"sticker",
|
|
"{}",
|
|
"msg_099",
|
|
)
|
|
assert main_text is None
|
|
assert error_hints == []
|
|
assert content_parts == []
|
|
|
|
|
|
# =============================================================================
|
|
# Tests for _process_quoted_message (channel)
|
|
# =============================================================================
|
|
|
|
|
|
class TestProcessQuotedMessage:
|
|
"""Tests for _process_quoted_message."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quoted_text_message(self, feishu_channel):
|
|
feishu_channel._fetch_quoted_message_content = AsyncMock(
|
|
return_value=("text", '{"text": "Original message"}'),
|
|
)
|
|
text_parts = ["My reply"]
|
|
content_parts = []
|
|
await feishu_channel._process_quoted_message(
|
|
"parent_123",
|
|
text_parts,
|
|
content_parts,
|
|
)
|
|
assert text_parts[0] == "[quoted message: Original message]"
|
|
assert text_parts[1] == "My reply"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quoted_image_with_label(self, feishu_channel):
|
|
feishu_channel._fetch_quoted_message_content = AsyncMock(
|
|
return_value=("image", '{"image_key": "img_abc"}'),
|
|
)
|
|
feishu_channel._download_image_resource = AsyncMock(
|
|
return_value="/tmp/img.jpg",
|
|
)
|
|
text_parts = ["Reply text"]
|
|
content_parts = []
|
|
await feishu_channel._process_quoted_message(
|
|
"parent_456",
|
|
text_parts,
|
|
content_parts,
|
|
)
|
|
# Pure image — should still add a label
|
|
assert text_parts[0] == "[quoted image]"
|
|
assert text_parts[1] == "Reply text"
|
|
assert len(content_parts) == 1
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quoted_interactive_card(self, feishu_channel):
|
|
card_content = json.dumps(
|
|
{
|
|
"header": {"title": {"content": "Card Title"}},
|
|
"body": {"elements": [{"tag": "text", "text": "Card body"}]},
|
|
},
|
|
)
|
|
feishu_channel._fetch_quoted_message_content = AsyncMock(
|
|
return_value=("interactive", card_content),
|
|
)
|
|
text_parts = ["My reply"]
|
|
content_parts = []
|
|
await feishu_channel._process_quoted_message(
|
|
"parent_789",
|
|
text_parts,
|
|
content_parts,
|
|
)
|
|
assert "quoted interactive card:" in text_parts[0]
|
|
assert "Card Title" in text_parts[0]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quoted_fetch_failure_no_change(self, feishu_channel):
|
|
feishu_channel._fetch_quoted_message_content = AsyncMock(
|
|
return_value=None,
|
|
)
|
|
text_parts = ["My reply"]
|
|
content_parts = []
|
|
await feishu_channel._process_quoted_message(
|
|
"parent_000",
|
|
text_parts,
|
|
content_parts,
|
|
)
|
|
assert text_parts == ["My reply"]
|
|
assert not content_parts
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quoted_error_hints_preserved(self, feishu_channel):
|
|
feishu_channel._fetch_quoted_message_content = AsyncMock(
|
|
return_value=("image", '{"other": "no key"}'),
|
|
)
|
|
text_parts = ["Reply"]
|
|
content_parts = []
|
|
await feishu_channel._process_quoted_message(
|
|
"parent_err",
|
|
text_parts,
|
|
content_parts,
|
|
)
|
|
assert text_parts[0] == "[quoted image]"
|
|
assert any("missing key" in t for t in text_parts)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quoted_lines_order_preserved(self, feishu_channel):
|
|
"""Error hints after post with failed downloads stay ordered."""
|
|
content = json.dumps(
|
|
{
|
|
"content": [[{"tag": "text", "text": "Post text"}]],
|
|
},
|
|
)
|
|
feishu_channel._fetch_quoted_message_content = AsyncMock(
|
|
return_value=("post", content),
|
|
)
|
|
text_parts = ["Reply"]
|
|
content_parts = []
|
|
await feishu_channel._process_quoted_message(
|
|
"parent_order",
|
|
text_parts,
|
|
content_parts,
|
|
)
|
|
# quoted label should be first, reply should be last
|
|
assert text_parts[0].startswith("[quoted message:")
|
|
assert text_parts[-1] == "Reply"
|