1470 lines
58 KiB
Python
1470 lines
58 KiB
Python
|
from __future__ import annotations
|
||
|
|
|
||
|
|
import asyncio
|
||
|
|
import os
|
||
|
|
import time
|
||
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
||
|
|
|
||
|
|
import pytest
|
||
|
|
|
||
|
|
from yuxi.channels.adapters.zalo_user.constants import (
|
||
|
|
ZALO_TEXT_LIMIT,
|
||
|
|
ZALO_REACTION_EMOJIS,
|
||
|
|
REACTION_ALIAS_MAP,
|
||
|
|
TARGET_PREFIXES,
|
||
|
|
DEFAULT_BRIDGE_URL,
|
||
|
|
DEFAULT_MAX_SEND_PER_MINUTE,
|
||
|
|
DEFAULT_CIRCUIT_BREAKER_THRESHOLD,
|
||
|
|
DEFAULT_CIRCUIT_BREAKER_RECOVERY,
|
||
|
|
ZaloCredentialStage,
|
||
|
|
)
|
||
|
|
|
||
|
|
from yuxi.channels.models import (
|
||
|
|
ChannelIdentity,
|
||
|
|
ChannelMessage,
|
||
|
|
ChannelResponse,
|
||
|
|
ChannelType,
|
||
|
|
ChatType,
|
||
|
|
DeliveryResult,
|
||
|
|
EventType,
|
||
|
|
MessageType,
|
||
|
|
HealthStatus,
|
||
|
|
ChannelStatus,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# BackoffManager
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestBackoffManager:
|
||
|
|
def test_initial_state(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager()
|
||
|
|
assert bm.attempts == 0
|
||
|
|
|
||
|
|
def test_should_reconnect_within_limit(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager()
|
||
|
|
assert bm.should_reconnect(max_attempts=10) is True
|
||
|
|
|
||
|
|
def test_should_reconnect_exceeds_limit(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager()
|
||
|
|
bm._attempt = 10
|
||
|
|
assert bm.should_reconnect(max_attempts=10) is False
|
||
|
|
|
||
|
|
def test_reset(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager()
|
||
|
|
bm._attempt = 5
|
||
|
|
bm.reset()
|
||
|
|
assert bm.attempts == 0
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_wait_increments_attempt(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager(base_delay=0.001, max_delay=0.01)
|
||
|
|
await bm.wait()
|
||
|
|
assert bm.attempts == 1
|
||
|
|
await bm.wait()
|
||
|
|
assert bm.attempts == 2
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_wait_respects_max_delay(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager(base_delay=0.001, max_delay=0.005, multiplier=1000, jitter=0)
|
||
|
|
await bm.wait()
|
||
|
|
await bm.wait()
|
||
|
|
|
||
|
|
def test_custom_parameters(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.backoff import BackoffManager
|
||
|
|
bm = BackoffManager(base_delay=5.0, max_delay=120.0, multiplier=3.0, jitter=0.2)
|
||
|
|
assert bm._base_delay == 5.0
|
||
|
|
assert bm._max_delay == 120.0
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# MessageDedup
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestMessageDedup:
|
||
|
|
def test_initial_state(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
assert len(md) == 0
|
||
|
|
|
||
|
|
def test_first_message_not_duplicate(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
assert md.is_duplicate("msg_001") is False
|
||
|
|
|
||
|
|
def test_check_and_mark_first_time(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
assert md.check_and_mark("msg_001") is False
|
||
|
|
|
||
|
|
def test_check_and_mark_duplicate(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
md.mark_seen("msg_001")
|
||
|
|
assert md.check_and_mark("msg_001") is True
|
||
|
|
|
||
|
|
def test_is_duplicate_after_mark(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
md.mark_seen("msg_001")
|
||
|
|
assert md.is_duplicate("msg_001") is True
|
||
|
|
|
||
|
|
def test_multiple_messages(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
for i in range(10):
|
||
|
|
assert md.check_and_mark(f"msg_{i:03d}") is False
|
||
|
|
for i in range(10):
|
||
|
|
assert md.check_and_mark(f"msg_{i:03d}") is True
|
||
|
|
|
||
|
|
def test_clear(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup()
|
||
|
|
md.mark_seen("msg_001")
|
||
|
|
md.clear()
|
||
|
|
assert len(md) == 0
|
||
|
|
|
||
|
|
def test_max_size_eviction(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup(max_size=5)
|
||
|
|
for i in range(10):
|
||
|
|
md.mark_seen(f"msg_{i:03d}")
|
||
|
|
assert len(md) <= 5
|
||
|
|
|
||
|
|
def test_custom_ttl(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.dedup import MessageDedup
|
||
|
|
md = MessageDedup(ttl=1)
|
||
|
|
md.mark_seen("old_msg")
|
||
|
|
md._seen["old_msg"] = time.monotonic() - 999
|
||
|
|
assert len(md) == 0
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# RateLimiter
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestRateLimiterComprehensive:
|
||
|
|
def test_initial_state(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter()
|
||
|
|
assert rl.max_per_minute == DEFAULT_MAX_SEND_PER_MINUTE
|
||
|
|
|
||
|
|
def test_custom_limit(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter(max_per_minute=10)
|
||
|
|
assert rl.max_per_minute == 10
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_and_wait_within_limit(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter(max_per_minute=10)
|
||
|
|
rl._send_times.clear()
|
||
|
|
await rl.check_and_wait()
|
||
|
|
assert len(rl._send_times) == 1
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_and_wait_appends_timestamp(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter(max_per_minute=10)
|
||
|
|
rl._send_times.clear()
|
||
|
|
await rl.check_and_wait()
|
||
|
|
assert len(rl._send_times) == 1
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_and_wait_below_limit(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter(max_per_minute=5)
|
||
|
|
now = time.monotonic()
|
||
|
|
rl._send_times.extend([now - 1])
|
||
|
|
await rl.check_and_wait()
|
||
|
|
assert len(rl._send_times) == 2
|
||
|
|
|
||
|
|
def test_cleanup_removes_expired(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter(max_per_minute=10)
|
||
|
|
now = time.monotonic()
|
||
|
|
rl._send_times.extend([now - 120, now - 90, now - 61, now - 30, now - 5])
|
||
|
|
rl._cleanup()
|
||
|
|
assert len(rl._send_times) == 2
|
||
|
|
assert rl._send_times[0] == now - 30
|
||
|
|
assert rl._send_times[1] == now - 5
|
||
|
|
|
||
|
|
def test_cleanup_empty(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.rate_limiter import RateLimiter
|
||
|
|
rl = RateLimiter()
|
||
|
|
rl._cleanup()
|
||
|
|
assert len(rl._send_times) == 0
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# OutboundSequencer
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestOutboundSequencer:
|
||
|
|
def test_initial_state(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import OutboundSequencer
|
||
|
|
seq = OutboundSequencer()
|
||
|
|
assert seq._seq == 0
|
||
|
|
|
||
|
|
def test_next_increments(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import OutboundSequencer
|
||
|
|
seq = OutboundSequencer()
|
||
|
|
assert seq.next() == 1
|
||
|
|
assert seq.next() == 2
|
||
|
|
|
||
|
|
def test_next_with_chat_id(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import OutboundSequencer
|
||
|
|
seq = OutboundSequencer()
|
||
|
|
seq.next("chat_a")
|
||
|
|
assert seq.last_for_chat("chat_a") == 1
|
||
|
|
seq.next("chat_b")
|
||
|
|
assert seq.last_for_chat("chat_b") == 2
|
||
|
|
|
||
|
|
def test_last_for_chat_unknown_returns_zero(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import OutboundSequencer
|
||
|
|
seq = OutboundSequencer()
|
||
|
|
assert seq.last_for_chat("unknown") == 0
|
||
|
|
|
||
|
|
def test_reset(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import OutboundSequencer
|
||
|
|
seq = OutboundSequencer()
|
||
|
|
seq.next("chat_a")
|
||
|
|
seq.next("chat_b")
|
||
|
|
seq.reset()
|
||
|
|
assert seq._seq == 0
|
||
|
|
assert seq.last_for_chat("chat_a") == 0
|
||
|
|
assert seq.last_for_chat("chat_b") == 0
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# MessageIdTracker + message_sid functions
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestMessageSidFunctions:
|
||
|
|
def test_resolve_message_ids_single(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import resolve_message_ids
|
||
|
|
result = resolve_message_ids("msg_001")
|
||
|
|
assert result == {"msg_id": "msg_001", "cli_msg_id": None}
|
||
|
|
|
||
|
|
def test_resolve_message_ids_dual(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import resolve_message_ids
|
||
|
|
result = resolve_message_ids("msg_001:cli_001")
|
||
|
|
assert result == {"msg_id": "msg_001", "cli_msg_id": "cli_001"}
|
||
|
|
|
||
|
|
def test_format_message_id_no_cli(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import format_message_id
|
||
|
|
assert format_message_id("msg_001") == "msg_001"
|
||
|
|
|
||
|
|
def test_format_message_id_with_cli(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import format_message_id
|
||
|
|
assert format_message_id("msg_001", "cli_001") == "msg_001:cli_001"
|
||
|
|
|
||
|
|
def test_extract_msg_id_no_cli(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import extract_msg_id
|
||
|
|
result = extract_msg_id({"message_id": "msg_001"})
|
||
|
|
assert result == "msg_001"
|
||
|
|
|
||
|
|
def test_extract_msg_id_with_cli(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import extract_msg_id
|
||
|
|
result = extract_msg_id({"message_id": "msg_001", "cli_msg_id": "cli_001"})
|
||
|
|
assert result == "msg_001:cli_001"
|
||
|
|
|
||
|
|
|
||
|
|
class TestMessageIdTracker:
|
||
|
|
def test_initial_state(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker()
|
||
|
|
assert len(tracker) == 0
|
||
|
|
|
||
|
|
def test_track_and_lookup(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker()
|
||
|
|
tracker.track("msg_001", "conv_abc")
|
||
|
|
assert tracker.lookup("msg_001") == "conv_abc"
|
||
|
|
|
||
|
|
def test_lookup_unknown(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker()
|
||
|
|
assert tracker.lookup("unknown") is None
|
||
|
|
|
||
|
|
def test_resolve(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker()
|
||
|
|
tracker.track("msg_001", "conv_abc")
|
||
|
|
result = tracker.resolve("msg_001")
|
||
|
|
assert result["msg_id"] == "msg_001"
|
||
|
|
assert result["conversation_id"] == "conv_abc"
|
||
|
|
|
||
|
|
def test_resolve_with_cli(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker()
|
||
|
|
tracker.track("msg_001:cli_001", "conv_abc")
|
||
|
|
result = tracker.resolve("msg_001:cli_001")
|
||
|
|
assert result["msg_id"] == "msg_001"
|
||
|
|
assert result["cli_msg_id"] == "cli_001"
|
||
|
|
assert result["conversation_id"] == "conv_abc"
|
||
|
|
|
||
|
|
def test_max_size_eviction(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker(max_size=5)
|
||
|
|
for i in range(10):
|
||
|
|
tracker.track(f"msg_{i:03d}", f"conv_{i:03d}")
|
||
|
|
assert len(tracker) <= 5
|
||
|
|
|
||
|
|
def test_clear(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.message_sid import MessageIdTracker
|
||
|
|
tracker = MessageIdTracker()
|
||
|
|
tracker.track("msg_001", "conv_abc")
|
||
|
|
tracker.clear()
|
||
|
|
assert len(tracker) == 0
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# SendCache
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestSendCache:
|
||
|
|
def test_first_send_not_cached(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send_cache import SendCache
|
||
|
|
sc = SendCache()
|
||
|
|
assert sc.check_and_set("chat_1", "hello", 1) is True
|
||
|
|
|
||
|
|
def test_duplicate_send_cached(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send_cache import SendCache
|
||
|
|
sc = SendCache()
|
||
|
|
sc.check_and_set("chat_1", "hello", 1)
|
||
|
|
assert sc.check_and_set("chat_1", "hello", 1) is False
|
||
|
|
|
||
|
|
def test_different_seq_not_duplicate(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send_cache import SendCache
|
||
|
|
sc = SendCache()
|
||
|
|
sc.check_and_set("chat_1", "hello", 1)
|
||
|
|
assert sc.check_and_set("chat_1", "hello", 2) is True
|
||
|
|
|
||
|
|
def test_different_chat_not_duplicate(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send_cache import SendCache
|
||
|
|
sc = SendCache()
|
||
|
|
sc.check_and_set("chat_1", "hello", 1)
|
||
|
|
assert sc.check_and_set("chat_2", "hello", 1) is True
|
||
|
|
|
||
|
|
def test_clear(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send_cache import SendCache
|
||
|
|
sc = SendCache()
|
||
|
|
sc.check_and_set("chat_1", "hello")
|
||
|
|
sc.clear()
|
||
|
|
assert len(sc) == 0
|
||
|
|
|
||
|
|
def test_max_entries_eviction(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send_cache import SendCache
|
||
|
|
sc = SendCache(max_entries=5)
|
||
|
|
for i in range(10):
|
||
|
|
sc.check_and_set(f"chat_{i}", f"msg_{i}")
|
||
|
|
assert len(sc) <= 5
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# allow_from
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestAllowFrom:
|
||
|
|
def test_resolve_empty_entries(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import resolve_allow_from_entries
|
||
|
|
result = resolve_allow_from_entries([], [])
|
||
|
|
assert result == []
|
||
|
|
|
||
|
|
def test_resolve_zalo_prefix_numeric(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import resolve_allow_from_entries
|
||
|
|
result = resolve_allow_from_entries(["zalo:12345"], [])
|
||
|
|
assert result == ["12345"]
|
||
|
|
|
||
|
|
def test_resolve_zalo_prefix_by_name(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import resolve_allow_from_entries
|
||
|
|
friends = [
|
||
|
|
{"user_id": "111", "display_name": "Alice"},
|
||
|
|
{"user_id": "222", "display_name": "Bob"},
|
||
|
|
]
|
||
|
|
result = resolve_allow_from_entries(["zalo:alice"], friends)
|
||
|
|
assert result == ["111"]
|
||
|
|
|
||
|
|
def test_resolve_numeric_entry(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import resolve_allow_from_entries
|
||
|
|
result = resolve_allow_from_entries(["12345"], [])
|
||
|
|
assert result == ["12345"]
|
||
|
|
|
||
|
|
def test_resolve_by_name_in_friends(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import resolve_allow_from_entries
|
||
|
|
friends = [{"user_id": "333", "display_name": "Charlie"}]
|
||
|
|
result = resolve_allow_from_entries(["charlie"], friends)
|
||
|
|
assert result == ["333"]
|
||
|
|
|
||
|
|
def test_resolve_empty_entry_skipped(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import resolve_allow_from_entries
|
||
|
|
result = resolve_allow_from_entries(["", "zalo:12345", ""], [])
|
||
|
|
assert result == ["12345"]
|
||
|
|
|
||
|
|
def test_check_allow_from_empty_list(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import check_allow_from
|
||
|
|
assert check_allow_from("12345", []) is True
|
||
|
|
|
||
|
|
def test_check_allow_from_matched(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import check_allow_from
|
||
|
|
assert check_allow_from("12345", ["zalo:12345"]) is True
|
||
|
|
|
||
|
|
def test_check_allow_from_not_matched(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import check_allow_from
|
||
|
|
assert check_allow_from("99999", ["zalo:12345"]) is False
|
||
|
|
|
||
|
|
def test_normalize_zalo_prefix(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import normalize_allow_from_entry
|
||
|
|
assert normalize_allow_from_entry("zalo:12345") == "zalo:12345"
|
||
|
|
|
||
|
|
def test_normalize_numeric_adds_prefix(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import normalize_allow_from_entry
|
||
|
|
assert normalize_allow_from_entry("12345") == "zalo:12345"
|
||
|
|
|
||
|
|
def test_normalize_non_numeric(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.allow_from import normalize_allow_from_entry
|
||
|
|
assert normalize_allow_from_entry("alice") == "alice"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# status_issues
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestStatusIssues:
|
||
|
|
def test_all_normal(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
bridge_url="https://example.com",
|
||
|
|
)
|
||
|
|
assert len(issues) == 1
|
||
|
|
assert issues[0]["level"] == "info"
|
||
|
|
|
||
|
|
def test_not_authenticated(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="uninitialized",
|
||
|
|
adapter_status="disconnected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
)
|
||
|
|
error_levels = [i["level"] for i in issues if i["level"] == "error"]
|
||
|
|
assert len(error_levels) >= 1
|
||
|
|
|
||
|
|
def test_qr_expired(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="qr_expired",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
)
|
||
|
|
error_messages = [i["message"] for i in issues]
|
||
|
|
assert any("QR" in m for m in error_messages)
|
||
|
|
|
||
|
|
def test_qr_declined(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="qr_declined",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
)
|
||
|
|
error_messages = [i["message"] for i in issues]
|
||
|
|
assert any("拒绝" in m for m in error_messages)
|
||
|
|
|
||
|
|
def test_dm_policy_open_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="open",
|
||
|
|
group_policy="allowlist",
|
||
|
|
)
|
||
|
|
assert any(i["level"] == "warn" for i in issues)
|
||
|
|
|
||
|
|
def test_group_policy_open_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="open",
|
||
|
|
)
|
||
|
|
assert any(i["level"] == "warn" for i in issues)
|
||
|
|
|
||
|
|
def test_non_https_bridge_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
bridge_url="http://remote.example.com",
|
||
|
|
)
|
||
|
|
assert any(i["level"] == "warn" for i in issues)
|
||
|
|
|
||
|
|
def test_no_warning_for_localhost_http(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
bridge_url="http://localhost:5556",
|
||
|
|
)
|
||
|
|
has_non_https_warn = any("HTTPS" in i.get("message", "") for i in issues if i["level"] == "warn")
|
||
|
|
assert not has_non_https_warn
|
||
|
|
|
||
|
|
def test_reconnect_attempts_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="connected",
|
||
|
|
dm_policy="pairing",
|
||
|
|
group_policy="allowlist",
|
||
|
|
reconnect_attempts=20,
|
||
|
|
)
|
||
|
|
assert any(i["level"] == "warn" for i in issues)
|
||
|
|
|
||
|
|
def test_adapter_error_status(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_issues
|
||
|
|
issues = collect_status_issues(
|
||
|
|
credential_stage="connected",
|
||
|
|
adapter_status="error",
|
||
|
|
last_error="Connection refused",
|
||
|
|
)
|
||
|
|
error_issues = [i for i in issues if i["level"] == "error"]
|
||
|
|
assert len(error_issues) >= 1
|
||
|
|
|
||
|
|
def test_status_snapshot_fields(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.status_issues import collect_status_snapshot_fields
|
||
|
|
fields = collect_status_snapshot_fields({
|
||
|
|
"dm_policy": "allowlist",
|
||
|
|
"group_policy": "open",
|
||
|
|
"allow_from": ["a", "b"],
|
||
|
|
"markdown": False,
|
||
|
|
"auth_type": "cookie",
|
||
|
|
})
|
||
|
|
assert fields["dm_policy"] == "allowlist"
|
||
|
|
assert fields["group_policy"] == "open"
|
||
|
|
assert fields["allow_from_count"] == 2
|
||
|
|
assert fields["markdown_enabled"] is False
|
||
|
|
assert fields["auth_type"] == "cookie"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# security_audit
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestSecurityAudit:
|
||
|
|
def test_empty_config_group_policy_default_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
|
||
|
|
def test_dm_policy_open_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({"dm_policy": "open"})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert any("DM policy" in f["message"] for f in findings)
|
||
|
|
|
||
|
|
def test_group_policy_open_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({"group_policy": "open"})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert any("Group policy" in f["message"] for f in findings)
|
||
|
|
|
||
|
|
def test_dangerously_allow_name_matching_error(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({"dangerously_allow_name_matching": True})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert findings[0]["level"] == "error"
|
||
|
|
|
||
|
|
def test_allowlist_no_entries_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({"dm_policy": "allowlist", "allow_from": []})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert any("allow_from" in f["message"] for f in findings)
|
||
|
|
|
||
|
|
def test_group_allowlist_no_entries_warning(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({
|
||
|
|
"group_policy": "allowlist",
|
||
|
|
"group_allow_from": [],
|
||
|
|
"groups": {},
|
||
|
|
})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert any("group_allow_from" in f["message"] for f in findings)
|
||
|
|
|
||
|
|
def test_tool_deny_findings(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({
|
||
|
|
"groups": {
|
||
|
|
"g_001": {
|
||
|
|
"tools": {
|
||
|
|
"deny": ["send_message"],
|
||
|
|
},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert any("send_message" in f["message"] for f in findings)
|
||
|
|
|
||
|
|
def test_qr_login_default_poll_info(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import collect_security_audit_findings
|
||
|
|
findings = collect_security_audit_findings({"auth_type": "qr"})
|
||
|
|
assert len(findings) >= 1
|
||
|
|
assert any("QR login" in f["message"] for f in findings)
|
||
|
|
|
||
|
|
def test_security_audit_finding_to_dict(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.security_audit import SecurityAuditFinding
|
||
|
|
finding = SecurityAuditFinding("warn", "test message", "test detail")
|
||
|
|
d = finding.to_dict()
|
||
|
|
assert d["level"] == "warn"
|
||
|
|
assert d["message"] == "test message"
|
||
|
|
assert d["detail"] == "test detail"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# probe
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestProbe:
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_bridge_health_healthy(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.probe import check_bridge_health
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
base_url = "http://localhost:5556"
|
||
|
|
async def check_health(self):
|
||
|
|
return {"ok": True, "status": "running", "service": "zalo-bridge"}
|
||
|
|
|
||
|
|
result = await check_bridge_health(FakeBridge())
|
||
|
|
assert result.status == "healthy"
|
||
|
|
assert result.metadata["service"] == "zalo-bridge"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_bridge_health_degraded(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.probe import check_bridge_health
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
base_url = "http://localhost:5556"
|
||
|
|
async def check_health(self):
|
||
|
|
return {"ok": False, "message": "service degraded"}
|
||
|
|
|
||
|
|
result = await check_bridge_health(FakeBridge())
|
||
|
|
assert result.status == "degraded"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_bridge_health_connect_error(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.probe import check_bridge_health
|
||
|
|
import httpx
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
base_url = "http://localhost:5556"
|
||
|
|
async def check_health(self):
|
||
|
|
raise httpx.ConnectError("connection refused")
|
||
|
|
|
||
|
|
result = await check_bridge_health(FakeBridge())
|
||
|
|
assert result.status == "unhealthy"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_check_bridge_health_generic_error(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.probe import check_bridge_health
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
base_url = "http://localhost:5556"
|
||
|
|
async def check_health(self):
|
||
|
|
raise RuntimeError("unknown error")
|
||
|
|
|
||
|
|
result = await check_bridge_health(FakeBridge())
|
||
|
|
assert result.status == "unhealthy"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# Session functions
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestSessionComprehensive:
|
||
|
|
def test_resolve_chat_id_zalouser_prefix(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_chat_id
|
||
|
|
chat_id, chat_type = resolve_chat_id("zalouser:12345")
|
||
|
|
assert chat_id == "12345"
|
||
|
|
assert chat_type == "user"
|
||
|
|
|
||
|
|
def test_resolve_chat_id_group_prefix(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_chat_id
|
||
|
|
chat_id, chat_type = resolve_chat_id("group:g_001")
|
||
|
|
assert chat_id == "g_001"
|
||
|
|
assert chat_type == "group"
|
||
|
|
|
||
|
|
def test_resolve_chat_id_zalo_prefix(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_chat_id
|
||
|
|
chat_id, chat_type = resolve_chat_id("zalo:12345")
|
||
|
|
assert chat_id == "12345"
|
||
|
|
assert chat_type == "user"
|
||
|
|
|
||
|
|
def test_resolve_chat_id_plain(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_chat_id
|
||
|
|
chat_id, chat_type = resolve_chat_id("plain_text")
|
||
|
|
assert chat_id == "plain_text"
|
||
|
|
assert chat_type is None
|
||
|
|
|
||
|
|
def test_looks_like_id_digits(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import looks_like_id
|
||
|
|
assert looks_like_id("12345") is True
|
||
|
|
|
||
|
|
def test_looks_like_id_with_prefix(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import looks_like_id
|
||
|
|
assert looks_like_id("zalo:12345") is True
|
||
|
|
|
||
|
|
def test_looks_like_id_plain_text(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import looks_like_id
|
||
|
|
assert looks_like_id("hello") is False
|
||
|
|
|
||
|
|
def test_looks_like_id_empty(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import looks_like_id
|
||
|
|
assert looks_like_id("") is False
|
||
|
|
|
||
|
|
def test_parse_outbound_target_direct(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import parse_outbound_target
|
||
|
|
result = parse_outbound_target("zalouser:12345")
|
||
|
|
assert result["thread_id"] == "12345"
|
||
|
|
assert result["is_group"] is False
|
||
|
|
assert result["chat_type"] == "user"
|
||
|
|
|
||
|
|
def test_parse_outbound_target_group(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import parse_outbound_target
|
||
|
|
result = parse_outbound_target("group:g_001")
|
||
|
|
assert result["thread_id"] == "g_001"
|
||
|
|
assert result["is_group"] is True
|
||
|
|
assert result["chat_type"] == "group"
|
||
|
|
|
||
|
|
def test_parse_outbound_target_plain(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import parse_outbound_target
|
||
|
|
result = parse_outbound_target("hello")
|
||
|
|
assert result["thread_id"] == "hello"
|
||
|
|
assert result["is_group"] is False
|
||
|
|
assert result["chat_type"] == "direct"
|
||
|
|
|
||
|
|
def test_check_group_tool_policy_no_config(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_group_tool_policy
|
||
|
|
assert check_group_tool_policy("chat_1", "send_message", {}) is True
|
||
|
|
|
||
|
|
def test_check_group_tool_policy_denied(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_group_tool_policy
|
||
|
|
config = {
|
||
|
|
"groups": {
|
||
|
|
"chat_1": {"tools": {"deny": ["send_message"]}},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
assert check_group_tool_policy("chat_1", "send_message", config) is False
|
||
|
|
|
||
|
|
def test_check_group_tool_policy_allowed(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_group_tool_policy
|
||
|
|
config = {
|
||
|
|
"groups": {
|
||
|
|
"chat_1": {"tools": {"allow": ["search"]}},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
assert check_group_tool_policy("chat_1", "send_message", config) is False
|
||
|
|
assert check_group_tool_policy("chat_1", "search", config) is True
|
||
|
|
|
||
|
|
def test_resolve_agent_route_unknown_chat_type(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_agent_route
|
||
|
|
route = resolve_agent_route("zalo_user", "chat_1", "user_1", "unknown", {"default_agent_id": "default"})
|
||
|
|
assert "unknown" in route
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_resolve_targets_numeric_direct(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_targets
|
||
|
|
results = await resolve_targets(["12345"], [], [])
|
||
|
|
assert len(results) == 1
|
||
|
|
assert results[0]["resolved_type"] == "direct"
|
||
|
|
assert results[0]["resolved_id"] == "12345"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_resolve_targets_by_name(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_targets
|
||
|
|
friends = [{"user_id": "111", "display_name": "Alice"}]
|
||
|
|
results = await resolve_targets(["alice"], friends, [])
|
||
|
|
assert len(results) == 1
|
||
|
|
assert results[0]["resolved_id"] == "111"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_resolve_targets_group_by_name(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_targets
|
||
|
|
groups = [{"group_id": "g_001", "name": "Test Group"}]
|
||
|
|
results = await resolve_targets(["test group"], [], groups)
|
||
|
|
assert len(results) == 1
|
||
|
|
assert results[0]["resolved_id"] == "g_001"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_resolve_targets_empty(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_targets
|
||
|
|
results = await resolve_targets([""], [], [])
|
||
|
|
assert len(results) == 1
|
||
|
|
assert results[0]["resolved_id"] is None
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_resolve_targets_not_found(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import resolve_targets
|
||
|
|
results = await resolve_targets(["nonexistent"], [], [])
|
||
|
|
assert len(results) == 1
|
||
|
|
assert "error" in results[0]
|
||
|
|
|
||
|
|
def test_check_dm_policy_unknown_policy(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_dm_policy
|
||
|
|
assert check_dm_policy("user_1", {"dm_policy": "unknown_policy"}, set()) is False
|
||
|
|
|
||
|
|
def test_check_group_policy_unknown_policy(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_group_policy
|
||
|
|
assert check_group_policy("chat_1", "user_1", {"group_policy": "unknown_policy"}) is False
|
||
|
|
|
||
|
|
def test_check_group_policy_allowlist_per_group(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_group_policy
|
||
|
|
config = {
|
||
|
|
"group_policy": "allowlist",
|
||
|
|
"groups": {
|
||
|
|
"chat_1": {"allow_from": ["zalo:user_1"]},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
assert check_group_policy("chat_1", "user_1", config) is True
|
||
|
|
assert check_group_policy("chat_1", "user_2", config) is False
|
||
|
|
|
||
|
|
def test_check_mention_required_wildcard_config(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_mention_required
|
||
|
|
config = {"groups": {"*": {"require_mention": True}}}
|
||
|
|
assert check_mention_required("chat_1", "hello", config, "Bot") is False
|
||
|
|
assert check_mention_required("chat_1", "@Bot hello", config, "Bot") is True
|
||
|
|
|
||
|
|
def test_check_mention_required_no_bot_names(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.session import check_mention_required
|
||
|
|
config = {"groups": {"chat_1": {"require_mention": True}}}
|
||
|
|
assert check_mention_required("chat_1", "hello", config, "") is True
|
||
|
|
|
||
|
|
def test_implicit_mention(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import implicit_mention
|
||
|
|
assert implicit_mention("hello Bot", ["Bot"]) is True
|
||
|
|
assert implicit_mention("@Bot hello", ["Bot"]) is False
|
||
|
|
|
||
|
|
def test_can_resolve_explicit_mention(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import can_resolve_explicit_mention
|
||
|
|
assert can_resolve_explicit_mention("@Bot help", ["Bot"]) is True
|
||
|
|
assert can_resolve_explicit_mention("hello", ["Bot"]) is False
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# send.py functions
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestSendHelpers:
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_typing_success(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_typing
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_typing(self, conversation_id):
|
||
|
|
return {"ok": True}
|
||
|
|
|
||
|
|
result = await send_typing(FakeBridge(), "chat_1")
|
||
|
|
assert result.success is True
|
||
|
|
assert result.metadata["action"] == "typing"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_typing_error(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_typing
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_typing(self, conversation_id):
|
||
|
|
raise RuntimeError("fail")
|
||
|
|
|
||
|
|
result = await send_typing(FakeBridge(), "chat_1")
|
||
|
|
assert result.success is False
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_delivered_event(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_delivered_event
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_delivered(self, conversation_id, msg_id):
|
||
|
|
return {"ok": True}
|
||
|
|
|
||
|
|
result = await send_delivered_event(FakeBridge(), "chat_1", "msg_1")
|
||
|
|
assert result.success is True
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_seen_event(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_seen_event
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_seen(self, conversation_id, msg_id):
|
||
|
|
return {"ok": True}
|
||
|
|
|
||
|
|
result = await send_seen_event(FakeBridge(), "chat_1", "msg_1")
|
||
|
|
assert result.success is True
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_link(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_link
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_message(self, payload):
|
||
|
|
return DeliveryResult(success=True, message_id="msg_link")
|
||
|
|
|
||
|
|
result = await send_link(FakeBridge(), "chat_1", "http://example.com", "caption")
|
||
|
|
assert result.success is True
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_link_no_caption(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_link
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_message(self, payload):
|
||
|
|
return DeliveryResult(success=True)
|
||
|
|
|
||
|
|
result = await send_link(FakeBridge(), "chat_1", "http://example.com")
|
||
|
|
assert result.success is True
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_audio(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import send_audio
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_message(self, payload):
|
||
|
|
return DeliveryResult(success=True, message_id="audio_msg")
|
||
|
|
|
||
|
|
result = await send_audio(FakeBridge(), "chat_1", "http://example.com/audio.mp3")
|
||
|
|
assert result.success is True
|
||
|
|
|
||
|
|
def test_derive_file_name_with_extension(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _derive_file_name
|
||
|
|
name = _derive_file_name("http://example.com/music.mp3", "audio", "audio.mp3")
|
||
|
|
assert name == "music.mp3"
|
||
|
|
|
||
|
|
def test_derive_file_name_with_query(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _derive_file_name
|
||
|
|
name = _derive_file_name("http://example.com/video.mp4?token=abc", "video", "video.mp4")
|
||
|
|
assert name == "video.mp4"
|
||
|
|
|
||
|
|
def test_derive_file_name_no_extension(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _derive_file_name
|
||
|
|
name = _derive_file_name("http://example.com/file", "image", "image.jpg")
|
||
|
|
assert name == "image.jpg"
|
||
|
|
|
||
|
|
def test_build_send_payload_disable_notification(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _build_send_payload
|
||
|
|
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="silent message",
|
||
|
|
metadata={"disable_notification": True},
|
||
|
|
)
|
||
|
|
payload = _build_send_payload(response, {})
|
||
|
|
assert payload["disable_notification"] is True
|
||
|
|
|
||
|
|
def test_build_send_payload_ttl(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _build_send_payload
|
||
|
|
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="ttl test",
|
||
|
|
metadata={"ttl": 3600},
|
||
|
|
)
|
||
|
|
payload = _build_send_payload(response, {})
|
||
|
|
assert payload["ttl"] == 3600
|
||
|
|
|
||
|
|
def test_build_send_payload_custom_text_styles(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _build_send_payload
|
||
|
|
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="styled",
|
||
|
|
metadata={"custom_text_styles": [{"offset": 0, "length": 4, "style": "bold"}]},
|
||
|
|
)
|
||
|
|
payload = _build_send_payload(response, {})
|
||
|
|
assert payload["custom_text_styles"] == [{"offset": 0, "length": 4, "style": "bold"}]
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_one_success_first_attempt(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _send_one
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_message(self, payload):
|
||
|
|
return DeliveryResult(success=True, message_id="msg_001")
|
||
|
|
|
||
|
|
result = await _send_one(FakeBridge(), {}, {})
|
||
|
|
assert result.success is True
|
||
|
|
assert result.message_id == "msg_001"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_one_non_retriable_error(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _send_one
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_message(self, payload):
|
||
|
|
return DeliveryResult(success=False, error="session_expired: invalid cookie")
|
||
|
|
|
||
|
|
result = await _send_one(FakeBridge(), {}, {})
|
||
|
|
assert result.success is False
|
||
|
|
assert "session_expired" in result.error
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_one_retry_exhausted(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.send import _send_one
|
||
|
|
|
||
|
|
class FakeBridge:
|
||
|
|
async def send_message(self, payload):
|
||
|
|
raise RuntimeError("always fails")
|
||
|
|
|
||
|
|
result = await _send_one(
|
||
|
|
FakeBridge(),
|
||
|
|
{},
|
||
|
|
{"retry": {"attempts": 2, "min_delay_ms": 1, "max_delay_ms": 10}},
|
||
|
|
)
|
||
|
|
assert result.success is False
|
||
|
|
assert "always fails" in result.error
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# _env_fallback
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestEnvFallback:
|
||
|
|
def test_env_fallback_from_config(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import _env_fallback
|
||
|
|
result = _env_fallback("TEST_KEY", {"test_key": "config_val"}, "test_key", "default_val")
|
||
|
|
assert result == "config_val"
|
||
|
|
|
||
|
|
def test_env_fallback_from_env(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import _env_fallback
|
||
|
|
os.environ["ZALOUSER_TEST_KEY"] = "env_val"
|
||
|
|
try:
|
||
|
|
result = _env_fallback("ZALOUSER_TEST_KEY", {}, "test_key", "default_val")
|
||
|
|
assert result == "env_val"
|
||
|
|
finally:
|
||
|
|
del os.environ["ZALOUSER_TEST_KEY"]
|
||
|
|
|
||
|
|
def test_env_fallback_default(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import _env_fallback
|
||
|
|
result = _env_fallback("NONEXISTENT_KEY", {}, "test_key", "default_val")
|
||
|
|
assert result == "default_val"
|
||
|
|
|
||
|
|
def test_env_fallback_none_config_val_uses_env(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import _env_fallback
|
||
|
|
os.environ["ZALOUSER_FB_KEY"] = "from_env"
|
||
|
|
try:
|
||
|
|
result = _env_fallback("ZALOUSER_FB_KEY", {"fb_key": None}, "fb_key", "default")
|
||
|
|
assert result == "from_env"
|
||
|
|
finally:
|
||
|
|
del os.environ["ZALOUSER_FB_KEY"]
|
||
|
|
|
||
|
|
def test_env_fallback_multiple_env_keys(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import _env_fallback
|
||
|
|
os.environ["SECOND_KEY"] = "second_val"
|
||
|
|
try:
|
||
|
|
result = _env_fallback(["FIRST_KEY", "SECOND_KEY"], {}, "key", "default")
|
||
|
|
assert result == "second_val"
|
||
|
|
finally:
|
||
|
|
del os.environ["SECOND_KEY"]
|
||
|
|
|
||
|
|
def test_env_fallback_empty_config(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import _env_fallback
|
||
|
|
os.environ["ZALOUSER_EMPTY_TEST"] = "from_env"
|
||
|
|
try:
|
||
|
|
result = _env_fallback("ZALOUSER_EMPTY_TEST", None, "test_key", "default")
|
||
|
|
assert result == "from_env"
|
||
|
|
finally:
|
||
|
|
del os.environ["ZALOUSER_EMPTY_TEST"]
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# Adapter methods (format_outbound, get_status_snapshot, send with cb)
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
@pytest.fixture
|
||
|
|
def zalo_adapter():
|
||
|
|
from yuxi.channels.adapters.zalo_user.adapter import ZaloUserAdapter
|
||
|
|
return ZaloUserAdapter({
|
||
|
|
"bridge_url": "http://localhost:5556",
|
||
|
|
"auth_type": "qr",
|
||
|
|
})
|
||
|
|
|
||
|
|
|
||
|
|
class TestAdapterFormatOutbound:
|
||
|
|
def test_format_outbound_plain_text(self, zalo_adapter):
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="Hello World",
|
||
|
|
)
|
||
|
|
payload = zalo_adapter.format_outbound(response)
|
||
|
|
assert payload["text"] == "Hello World"
|
||
|
|
assert payload["message_type"] == "text"
|
||
|
|
|
||
|
|
def test_format_outbound_with_markdown(self, zalo_adapter):
|
||
|
|
zalo_adapter._config["markdown"] = True
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="**bold** text",
|
||
|
|
)
|
||
|
|
payload = zalo_adapter.format_outbound(response)
|
||
|
|
assert "styled_paragraphs" in payload or payload["text"] == "**bold** text"
|
||
|
|
|
||
|
|
def test_format_outbound_markdown_disabled(self, zalo_adapter):
|
||
|
|
zalo_adapter._config["markdown"] = False
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="**bold** text",
|
||
|
|
)
|
||
|
|
payload = zalo_adapter.format_outbound(response)
|
||
|
|
assert "styled_paragraphs" not in payload
|
||
|
|
|
||
|
|
|
||
|
|
class TestAdapterGetStatusSnapshot:
|
||
|
|
def test_get_status_snapshot(self, zalo_adapter):
|
||
|
|
snapshot = zalo_adapter.get_status_snapshot()
|
||
|
|
assert snapshot.account_id == ""
|
||
|
|
assert snapshot.name == "unknown"
|
||
|
|
assert snapshot.dm_policy == "pairing"
|
||
|
|
assert snapshot.group_policy == "allowlist"
|
||
|
|
|
||
|
|
def test_get_status_snapshot_with_account(self, zalo_adapter):
|
||
|
|
zalo_adapter._account_info = {"user_id": "123", "display_name": "TestUser"}
|
||
|
|
zalo_adapter._credential_mgr.mark_connected({"user_id": "123"})
|
||
|
|
snapshot = zalo_adapter.get_status_snapshot()
|
||
|
|
assert snapshot.account_id == "123"
|
||
|
|
assert snapshot.name == "TestUser"
|
||
|
|
assert snapshot.linked is True
|
||
|
|
|
||
|
|
|
||
|
|
class TestAdapterSend:
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_not_connected(self, zalo_adapter):
|
||
|
|
response = ChannelResponse(
|
||
|
|
identity=ChannelIdentity(
|
||
|
|
channel_id="zalo_user",
|
||
|
|
channel_type=ChannelType.ZALO_USER,
|
||
|
|
channel_user_id="bot",
|
||
|
|
channel_chat_id="conv_abc",
|
||
|
|
),
|
||
|
|
message_type=MessageType.TEXT,
|
||
|
|
content="test",
|
||
|
|
)
|
||
|
|
result = await zalo_adapter.send(response)
|
||
|
|
assert result.success is False
|
||
|
|
assert "Not connected" in result.error
|
||
|
|
|
||
|
|
|
||
|
|
class TestAdapterListMethods:
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_list_friends_no_bridge(self, zalo_adapter):
|
||
|
|
zalo_adapter._friends_cache = [{"id": "1", "name": "Alice"}]
|
||
|
|
result = await zalo_adapter.list_friends()
|
||
|
|
assert result == [{"id": "1", "name": "Alice"}]
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_list_groups_no_bridge(self, zalo_adapter):
|
||
|
|
zalo_adapter._group_cache = [{"group_id": "g_1", "name": "Test"}]
|
||
|
|
result = await zalo_adapter.list_groups()
|
||
|
|
assert result == [{"group_id": "g_1", "name": "Test"}]
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_list_group_members_no_bridge(self, zalo_adapter):
|
||
|
|
result = await zalo_adapter.list_group_members("g_001")
|
||
|
|
assert result == []
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_get_account_info_no_bridge(self, zalo_adapter):
|
||
|
|
result = await zalo_adapter.get_account_info()
|
||
|
|
assert "display_name" in result
|
||
|
|
assert "user_id" in result
|
||
|
|
|
||
|
|
|
||
|
|
class TestAdapterProperties:
|
||
|
|
def test_account_id(self, zalo_adapter):
|
||
|
|
assert zalo_adapter.account_id == ""
|
||
|
|
|
||
|
|
def test_account_name(self, zalo_adapter):
|
||
|
|
assert zalo_adapter.account_name == "unknown"
|
||
|
|
|
||
|
|
def test_config_get_set(self, zalo_adapter):
|
||
|
|
assert zalo_adapter.config["bridge_url"] == "http://localhost:5556"
|
||
|
|
zalo_adapter.config = {"bridge_url": "http://new:5556"}
|
||
|
|
assert zalo_adapter.config["bridge_url"] == "http://new:5556"
|
||
|
|
|
||
|
|
def test_dm_policy_default(self, zalo_adapter):
|
||
|
|
assert zalo_adapter.dm_policy == "pairing"
|
||
|
|
|
||
|
|
def test_group_policy_default(self, zalo_adapter):
|
||
|
|
assert zalo_adapter.group_policy == "allowlist"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_logout(self, zalo_adapter):
|
||
|
|
zalo_adapter._status = ChannelStatus.CONNECTED
|
||
|
|
result = await zalo_adapter.logout()
|
||
|
|
assert result["status"] == "logged_out"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_receive_empty(self, zalo_adapter):
|
||
|
|
messages = []
|
||
|
|
async for msg in zalo_adapter.receive():
|
||
|
|
messages.append(msg)
|
||
|
|
assert len(messages) == 0
|
||
|
|
|
||
|
|
def test_normalize_inbound_delegates(self, zalo_adapter):
|
||
|
|
msg = zalo_adapter.normalize_inbound({
|
||
|
|
"from_id": "12345",
|
||
|
|
"conversation_id": "conv_abc",
|
||
|
|
"conversation_type": "direct",
|
||
|
|
"timestamp": 1700000000000,
|
||
|
|
})
|
||
|
|
assert msg.identity.channel_id == "zalo_user"
|
||
|
|
assert msg.chat_type == ChatType.DIRECT
|
||
|
|
|
||
|
|
|
||
|
|
class TestAdapterReloadConfig:
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_reload_config_updates_fields(self, zalo_adapter):
|
||
|
|
await zalo_adapter.reload_config({
|
||
|
|
"bridge_url": "http://localhost:5556",
|
||
|
|
"dm_policy": "open",
|
||
|
|
"history_limit": 200,
|
||
|
|
})
|
||
|
|
assert zalo_adapter.dm_policy == "open"
|
||
|
|
assert zalo_adapter._history_limit == 200
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_reload_config_changes_bridge_url_reconnects(self, zalo_adapter):
|
||
|
|
zalo_adapter._status = ChannelStatus.CONNECTED
|
||
|
|
await zalo_adapter.reload_config({
|
||
|
|
"bridge_url": "http://newhost:5556",
|
||
|
|
"dm_policy": "pairing",
|
||
|
|
})
|
||
|
|
assert zalo_adapter._resolve_bridge_url() == "http://newhost:5556"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# Constants verification
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestConstants:
|
||
|
|
def test_zalo_text_limit(self):
|
||
|
|
assert ZALO_TEXT_LIMIT == 2000
|
||
|
|
|
||
|
|
def test_reaction_emojis_count(self):
|
||
|
|
assert len(ZALO_REACTION_EMOJIS) == 6
|
||
|
|
|
||
|
|
def test_reaction_alias_map_count(self):
|
||
|
|
assert len(REACTION_ALIAS_MAP) == 18
|
||
|
|
|
||
|
|
def test_target_prefixes(self):
|
||
|
|
assert TARGET_PREFIXES["zalouser:"] == "user"
|
||
|
|
assert TARGET_PREFIXES["group:"] == "group"
|
||
|
|
assert TARGET_PREFIXES["g:"] == "group"
|
||
|
|
|
||
|
|
def test_default_bridge_url(self):
|
||
|
|
assert DEFAULT_BRIDGE_URL == "http://localhost:5556"
|
||
|
|
|
||
|
|
def test_default_max_send_per_minute(self):
|
||
|
|
assert DEFAULT_MAX_SEND_PER_MINUTE == 30
|
||
|
|
|
||
|
|
def test_circuit_breaker_defaults(self):
|
||
|
|
assert DEFAULT_CIRCUIT_BREAKER_THRESHOLD == 5
|
||
|
|
assert DEFAULT_CIRCUIT_BREAKER_RECOVERY == 60
|
||
|
|
|
||
|
|
def test_credential_stages(self):
|
||
|
|
assert ZaloCredentialStage.UNINITIALIZED == "uninitialized"
|
||
|
|
assert ZaloCredentialStage.QR_PENDING == "qr_pending"
|
||
|
|
assert ZaloCredentialStage.QR_SCANNED == "qr_scanned"
|
||
|
|
assert ZaloCredentialStage.QR_DECLINED == "qr_declined"
|
||
|
|
assert ZaloCredentialStage.QR_EXPIRED == "qr_expired"
|
||
|
|
assert ZaloCredentialStage.CONNECTED == "connected"
|
||
|
|
assert ZaloCredentialStage.LOGGED_OUT == "logged_out"
|
||
|
|
assert ZaloCredentialStage.ERROR == "error"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# normalize edge cases
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestNormalizeEdgeCases:
|
||
|
|
def test_map_attachment_type_photo(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _map_attachment_type
|
||
|
|
assert _map_attachment_type("photo") == "image"
|
||
|
|
|
||
|
|
def test_map_attachment_type_voice(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _map_attachment_type
|
||
|
|
assert _map_attachment_type("voice") == "audio"
|
||
|
|
|
||
|
|
def test_map_attachment_type_document(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _map_attachment_type
|
||
|
|
assert _map_attachment_type("document") == "file"
|
||
|
|
|
||
|
|
def test_map_attachment_type_sticker(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _map_attachment_type
|
||
|
|
assert _map_attachment_type("sticker") == "sticker"
|
||
|
|
|
||
|
|
def test_map_attachment_type_unknown(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _map_attachment_type
|
||
|
|
assert _map_attachment_type("unknown_type") == "file"
|
||
|
|
|
||
|
|
def test_derive_filename_from_url(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _derive_filename_from_url
|
||
|
|
name = _derive_filename_from_url("http://example.com/photo.jpg", "image")
|
||
|
|
assert name == "photo.jpg"
|
||
|
|
|
||
|
|
def test_derive_filename_from_url_no_path(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _derive_filename_from_url
|
||
|
|
name = _derive_filename_from_url("", "image")
|
||
|
|
assert name == ""
|
||
|
|
|
||
|
|
def test_derive_filename_from_url_empty_path(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _derive_filename_from_url
|
||
|
|
name = _derive_filename_from_url("http://example.com", "video")
|
||
|
|
assert name == "video.mp4"
|
||
|
|
|
||
|
|
def test_derive_filename_from_url_audio_fallback(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import _derive_filename_from_url
|
||
|
|
name = _derive_filename_from_url("http://example.com/", "audio")
|
||
|
|
assert name == "audio.mp3"
|
||
|
|
|
||
|
|
def test_normalize_inbound_with_caption(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import normalize_inbound
|
||
|
|
result = normalize_inbound("zalo_user", {
|
||
|
|
"from_id": "12345",
|
||
|
|
"conversation_id": "conv_abc",
|
||
|
|
"message_id": "msg_001",
|
||
|
|
"caption": "Check this photo",
|
||
|
|
"conversation_type": "direct",
|
||
|
|
"timestamp": 1700000000000,
|
||
|
|
})
|
||
|
|
assert result.content == "Check this photo"
|
||
|
|
|
||
|
|
def test_normalize_inbound_with_metadata_fields(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.normalize import normalize_inbound
|
||
|
|
result = normalize_inbound("zalo_user", {
|
||
|
|
"from_id": "12345",
|
||
|
|
"conversation_id": "conv_abc",
|
||
|
|
"message_id": "msg_001",
|
||
|
|
"conversation_type": "direct",
|
||
|
|
"timestamp": 1700000000000,
|
||
|
|
"uidFrom": "uid123",
|
||
|
|
"idTo": "id456",
|
||
|
|
"st": 1,
|
||
|
|
"at": 0,
|
||
|
|
"cmd": 0,
|
||
|
|
"ts": 1700000000,
|
||
|
|
"cli_msg_id": "cli_001",
|
||
|
|
"msg_type": "text",
|
||
|
|
"zalo_event": "message",
|
||
|
|
"from_avatar": "http://avatar.url",
|
||
|
|
})
|
||
|
|
assert result.metadata["uid_from"] == "uid123"
|
||
|
|
assert result.metadata["id_to"] == "id456"
|
||
|
|
assert result.metadata["cli_msg_id"] == "cli_001"
|
||
|
|
assert result.metadata["msg_type"] == "text"
|
||
|
|
assert result.metadata["sender_avatar_url"] == "http://avatar.url"
|
||
|
|
assert result.metadata["zalo_event"] == "message"
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# BridgeClient static methods
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestBridgeClientStatic:
|
||
|
|
def test_ws_url_from_http_self_listen_false(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.bridge import _ws_url_from_http
|
||
|
|
url = _ws_url_from_http("http://localhost:5556", self_listen=False)
|
||
|
|
assert url == "ws://localhost:5556/messages/stream?self_listen=false"
|
||
|
|
|
||
|
|
def test_ws_url_from_https_self_listen_false(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.bridge import _ws_url_from_http
|
||
|
|
url = _ws_url_from_http("https://bridge.example.com", self_listen=False)
|
||
|
|
assert url == "wss://bridge.example.com/messages/stream?self_listen=false"
|
||
|
|
|
||
|
|
def test_bridge_client_invalid_url(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.bridge import BridgeClient
|
||
|
|
with pytest.raises(ValueError, match="bridge_url must start with"):
|
||
|
|
BridgeClient(bridge_url="localhost:5556")
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# Adapter send methods - remove_reaction, delete_message, edit_message (not connected)
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestAdapterSendMethods:
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_remove_reaction_not_connected(self, zalo_adapter):
|
||
|
|
result = await zalo_adapter.remove_reaction("chat_1", "msg_1")
|
||
|
|
assert result.success is False
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_send_reaction_delete_reaction(self, zalo_adapter):
|
||
|
|
result = await zalo_adapter.send_reaction("chat_1", "msg_1", "")
|
||
|
|
assert result.success is False
|
||
|
|
|
||
|
|
|
||
|
|
# ========================================================================
|
||
|
|
# reaction edge cases
|
||
|
|
# ========================================================================
|
||
|
|
|
||
|
|
class TestReactionEdgeCases:
|
||
|
|
def test_is_valid_reaction_with_whitespace(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.reaction import is_valid_reaction
|
||
|
|
assert is_valid_reaction(" like ") is True
|
||
|
|
|
||
|
|
def test_is_delete_reaction_single_space(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.reaction import is_delete_reaction
|
||
|
|
assert is_delete_reaction(" ") is True
|
||
|
|
|
||
|
|
def test_normalize_reaction_icon_strips_spaces(self):
|
||
|
|
from yuxi.channels.adapters.zalo_user.reaction import normalize_reaction_icon
|
||
|
|
assert normalize_reaction_icon(" like ") == "\U0001f44d"
|