269 lines
12 KiB
Python
269 lines
12 KiB
Python
import asyncio
|
|
import time
|
|
from types import SimpleNamespace
|
|
from unittest.mock import AsyncMock
|
|
|
|
import pytest
|
|
from test_reminders import record
|
|
|
|
from services.storage import ReminderStore
|
|
|
|
|
|
@pytest.fixture
|
|
async def official_plugin(plugin_class, platform_factory):
|
|
platform = platform_factory()
|
|
instance = plugin_class(
|
|
SimpleNamespace(platform_manager=SimpleNamespace(platform_insts=[platform])),
|
|
{"check_interval_seconds": 999, "official_delivery_mode": "passive"},
|
|
)
|
|
await instance.store.initialize()
|
|
instance._ready = True
|
|
await instance._attach_platforms()
|
|
instance.initialize = AsyncMock()
|
|
yield instance, platform
|
|
await instance.terminate()
|
|
|
|
|
|
def lifecycle(event_id="join_1", timestamp=None, destination="group_1"):
|
|
return SimpleNamespace(
|
|
group_openid=destination,
|
|
event_id=event_id,
|
|
timestamp=time.time() if timestamp is None else timestamp,
|
|
)
|
|
|
|
|
|
async def test_default_and_upgrade_use_proactive_without_reply_context(official_plugin):
|
|
instance, platform = official_plugin
|
|
assert instance.delivery_mode == "proactive"
|
|
rem_id = await instance.store.add(record(), 10)
|
|
await instance._check_due()
|
|
sent = platform.get_client().api.post_group_message.call_args.kwargs
|
|
assert "msg_id" not in sent and "event_id" not in sent
|
|
assert (await instance.store.get(rem_id, record()["scope"]))["status"] == "done"
|
|
|
|
|
|
async def test_first_command_guidance_once_per_group_persisted(official_plugin, event_factory):
|
|
instance, _ = official_plugin
|
|
events = [event_factory("/tx help"), event_factory("/tx list", user="other")]
|
|
for event in events:
|
|
await instance.tx(event)
|
|
assert "确认已开启" in events[0].replies[0]
|
|
assert "确认已开启" not in events[1].replies[0]
|
|
other = event_factory("/tx list", group="other")
|
|
await instance.tx(other)
|
|
assert "确认已开启" in other.replies[0]
|
|
reopened = ReminderStore(instance.store.path)
|
|
assert not await reopened.claim_notice("platform_1", "group_1")
|
|
assert await reopened.claim_notice("platform_2", "group_1")
|
|
|
|
|
|
@pytest.mark.parametrize("name", ["qq_official", "qq_official_webhook"])
|
|
async def test_join_uses_event_reply_and_deduplicates(official_plugin, event_factory, name):
|
|
instance, platform = official_plugin
|
|
platform.meta = lambda: SimpleNamespace(id="platform_1", name=name)
|
|
client = platform.get_client()
|
|
event = lifecycle()
|
|
await client.on_group_add_robot(event)
|
|
await client.on_group_add_robot(event)
|
|
assert client.api.post_group_message.await_count == 1
|
|
sent = client.api.post_group_message.call_args.kwargs
|
|
assert sent["event_id"] == "join_1" and "msg_id" not in sent
|
|
assert "群主或管理员" in sent["content"]
|
|
command = event_factory("/tx list")
|
|
await instance.tx(command)
|
|
assert "确认已开启" not in command.replies[0]
|
|
|
|
|
|
async def test_failed_join_falls_back_to_first_command(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
platform.get_client().api.post_group_message.side_effect = RuntimeError("event expired")
|
|
await platform.get_client().on_group_add_robot(lifecycle())
|
|
command = event_factory("/tx list")
|
|
await instance.tx(command)
|
|
assert "确认已开启" in command.replies[0]
|
|
|
|
|
|
async def test_failed_command_notice_is_not_marked_sent(official_plugin, event_factory):
|
|
instance, _ = official_plugin
|
|
command = event_factory()
|
|
command.send = AsyncMock(side_effect=RuntimeError("network error"))
|
|
with pytest.raises(RuntimeError):
|
|
await instance._reply(command, "test")
|
|
assert (await instance.store.permission("platform_1", "group_1"))["notified"] == 0
|
|
retry = event_factory("/tx list")
|
|
await instance.tx(retry)
|
|
assert "确认已开启" in retry.replies[0]
|
|
|
|
|
|
async def test_granted_state_skips_first_use_notice_and_stale_join(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
now = time.time()
|
|
await platform.get_client().on_group_msg_receive(lifecycle("receive", now))
|
|
await platform.get_client().on_group_add_robot(lifecycle("old_join", now - 10))
|
|
command = event_factory("/tx list")
|
|
await instance.tx(command)
|
|
assert "确认已开启" not in command.replies[0]
|
|
platform.get_client().api.post_group_message.assert_not_awaited()
|
|
assert (await instance.store.permission("platform_1", "group_1"))["state"] == "granted"
|
|
|
|
|
|
async def test_permission_error_preserved_then_receive_event_wakes_delivery(official_plugin):
|
|
instance, platform = official_plugin
|
|
api = platform.get_client().api
|
|
api.post_group_message.side_effect = RuntimeError("主动消息失败, 无权限")
|
|
rem_id = await instance.store.add(record(), 10)
|
|
await instance._check_due()
|
|
for _ in range(4):
|
|
await instance._check_due()
|
|
rem = await instance.store.get(rem_id, record()["scope"])
|
|
assert rem["status"] == "active" and rem["failure_count"] == 0
|
|
assert "等待主动消息权限" in instance._format(rem)
|
|
assert rem["retry_at"] > time.time() + 290
|
|
assert api.post_group_message.await_count == 1
|
|
api.post_group_message.side_effect = None
|
|
await platform.get_client().on_group_msg_receive(lifecycle("allow"))
|
|
assert instance._wake.is_set()
|
|
await instance._check_due()
|
|
assert (await instance.store.get(rem_id, record()["scope"]))["status"] == "done"
|
|
|
|
|
|
async def test_reject_holds_tasks_and_permission_check_releases(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
await platform.get_client().on_group_msg_reject(lifecycle("reject"))
|
|
rem_id = await instance.store.add(record(), 10)
|
|
await instance._check_due()
|
|
platform.get_client().api.post_group_message.assert_not_awaited()
|
|
assert (await instance.store.get(rem_id, record()["scope"]))["status"] == "active"
|
|
command = event_factory("/tx permission check")
|
|
await instance.tx(command)
|
|
assert command.stopped
|
|
assert (await instance.store.permission("platform_1", "group_1"))["state"] == "granted"
|
|
sent = platform.get_client().api.post_group_message.call_args.kwargs
|
|
assert "msg_id" not in sent and "event_id" not in sent
|
|
await instance._check_due()
|
|
assert (await instance.store.get(rem_id, record()["scope"]))["status"] == "done"
|
|
|
|
|
|
async def test_permission_check_failure_is_a_passive_reply(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
platform.get_client().api.post_group_message.side_effect = RuntimeError("主动消息失败, 无权限")
|
|
command = event_factory("/tx permission check")
|
|
await instance.tx(command)
|
|
assert "验证失败" in command.replies[0]
|
|
assert command.replies[0].count("确认已开启") == 1
|
|
assert (await instance.store.permission("platform_1", "group_1"))["state"] == "error"
|
|
|
|
|
|
async def test_check_without_message_id_is_not_success(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
platform.get_client().api.post_group_message.return_value = {}
|
|
command = event_factory("/tx permission check")
|
|
await instance.tx(command)
|
|
assert "未返回消息 ID" in command.replies[0]
|
|
assert (await instance.store.permission("platform_1", "group_1"))["state"] != "granted"
|
|
|
|
|
|
async def test_member_cannot_set_authorized_state_by_text(official_plugin, event_factory):
|
|
instance, _ = official_plugin
|
|
command = event_factory("/tx permission 已开启")
|
|
await instance.tx(command)
|
|
assert "用法" in command.replies[0]
|
|
assert (await instance.store.permission("platform_1", "group_1"))["state"] == "unknown"
|
|
|
|
|
|
async def test_bridge_preserves_callbacks_and_overlapping_unload(official_plugin):
|
|
instance, platform = official_plugin
|
|
from reminder_plugin_test.services.permissions import PermissionBridge
|
|
|
|
await instance.terminate()
|
|
client = platform.get_client()
|
|
original = AsyncMock()
|
|
client.on_group_add_robot = original
|
|
handlers = [AsyncMock(), AsyncMock()]
|
|
first = PermissionBridge(platform, handlers[0])
|
|
second = PermissionBridge(platform, handlers[1])
|
|
first.install()
|
|
second.install()
|
|
await first.close()
|
|
await client.on_group_add_robot(lifecycle())
|
|
handlers[0].assert_not_awaited()
|
|
handlers[1].assert_awaited_once()
|
|
original.assert_awaited_once()
|
|
await second.close()
|
|
assert client.on_group_add_robot is original
|
|
assert not hasattr(client, "on_group_msg_receive")
|
|
|
|
|
|
async def test_bridge_close_finishes_pending_event(official_plugin):
|
|
instance, platform = official_plugin
|
|
client = platform.get_client()
|
|
entered, release = asyncio.Event(), asyncio.Event()
|
|
|
|
async def send(**kwargs):
|
|
entered.set()
|
|
await release.wait()
|
|
return {"id": "sent"}
|
|
|
|
client.api.post_group_message.side_effect = send
|
|
event_task = asyncio.create_task(client.on_group_add_robot(lifecycle()))
|
|
await asyncio.wait_for(entered.wait(), 1)
|
|
closing = asyncio.create_task(instance.terminate())
|
|
await asyncio.sleep(0)
|
|
assert not closing.done()
|
|
release.set()
|
|
await asyncio.wait_for(asyncio.gather(closing, event_task), 1)
|
|
assert (await instance.store.permission("platform_1", "group_1"))["notified"] == 1
|
|
|
|
|
|
async def test_concurrent_first_commands_emit_one_notice(official_plugin, event_factory):
|
|
instance, _ = official_plugin
|
|
commands = [event_factory("/tx list", user=f"user_{i}") for i in range(8)]
|
|
await asyncio.gather(*(instance.tx(event) for event in commands))
|
|
assert sum("确认已开启" in event.replies[0] for event in commands) == 1
|
|
|
|
|
|
async def test_repeated_permission_failure_does_not_repeat_notice(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
platform.get_client().api.post_group_message.side_effect = RuntimeError("主动消息失败, 无权限")
|
|
rem_id = await instance.store.add(record(), 10)
|
|
await instance._check_due()
|
|
first = event_factory("/tx list")
|
|
await instance.tx(first)
|
|
assert "确认已开启" in first.replies[0]
|
|
await instance.store.resume(record()["scope"], "user_1", rem_id, 10)
|
|
await instance._check_due()
|
|
second = event_factory("/tx list")
|
|
await instance.tx(second)
|
|
assert "确认已开启" not in second.replies[0]
|
|
rem = await instance.store.get(rem_id, record()["scope"])
|
|
assert rem["status"] == "active" and rem["failure_count"] == 0
|
|
|
|
|
|
async def test_del_and_rejoin_reset_guidance(official_plugin, event_factory):
|
|
instance, platform = official_plugin
|
|
client = platform.get_client()
|
|
stamp = time.time()
|
|
await client.on_group_add_robot(lifecycle("join", stamp))
|
|
await client.on_group_del_robot(lifecycle("del", stamp + 1))
|
|
rem_id = await instance.store.add(record(), 10)
|
|
await instance._check_due()
|
|
assert client.api.post_group_message.await_count == 1
|
|
assert (await instance.store.get(rem_id, record()["scope"]))["status"] == "active"
|
|
await client.on_group_add_robot(lifecycle("rejoin", stamp + 2))
|
|
assert client.api.post_group_message.await_count == 2
|
|
|
|
|
|
async def test_new_and_removed_platforms_attach_and_restore(official_plugin, platform_factory):
|
|
instance, _ = official_plugin
|
|
newcomer = platform_factory("qq_official_webhook")
|
|
original = AsyncMock()
|
|
newcomer.get_client().on_group_msg_receive = original
|
|
instance.context.platform_manager.platform_insts.append(newcomer)
|
|
await instance._attach_platforms()
|
|
await newcomer.get_client().on_group_msg_receive(lifecycle("receive"))
|
|
original.assert_awaited_once()
|
|
instance.context.platform_manager.platform_insts.remove(newcomer)
|
|
await instance._attach_platforms()
|
|
assert newcomer.get_client().on_group_msg_receive is original
|
|
assert not hasattr(newcomer.get_client(), "on_group_add_robot")
|