✨ Feature: 新增事件类型过滤 rule (#1183)

tests/plugins/plugin/__init__.py

@@ -0,0 +1 @@
+from . import matchers

tests/plugins/plugin/matchers.py

@@ -0,0 +1,243 @@
+from datetime import datetime, timezone
+
+from nonebot.adapters import Event
+from nonebot import (
+    CommandGroup,
+    MatcherGroup,
+    on,
+    on_type,
+    on_regex,
+    on_notice,
+    on_command,
+    on_keyword,
+    on_message,
+    on_request,
+    on_endswith,
+    on_fullmatch,
+    on_metaevent,
+    on_startswith,
+    on_shell_command,
+)
+
+
+async def rule() -> bool:
+    return True
+
+
+async def permission() -> bool:
+    return True
+
+
+async def handler():
+    return
+
+
+expire_time = datetime.now(timezone.utc)
+priority = 100
+state = {"test": "test"}
+
+
+matcher_on = on(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_metaevent = on_metaevent(
+    rule=rule,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_message = on_message(
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_notice = on_notice(
+    rule=rule,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_request = on_request(
+    rule=rule,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_startswith = on_startswith(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_endswith = on_endswith(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_fullmatch = on_fullmatch(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_keyword = on_keyword(
+    {"test"},
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_command = on_command(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_shell_command = on_shell_command(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_regex = on_regex(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+class TestEvent(Event):
+    ...
+
+
+matcher_on_type = on_type(
+    TestEvent,
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+cmd_group = CommandGroup(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+matcher_sub_cmd = cmd_group.command("sub")
+matcher_sub_shell_cmd = cmd_group.shell_command("sub")
+
+
+matcher_group = MatcherGroup(
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+matcher_group_on = matcher_group.on(type="test")
+matcher_group_on_metaevent = matcher_group.on_metaevent()
+matcher_group_on_message = matcher_group.on_message()
+matcher_group_on_notice = matcher_group.on_notice()
+matcher_group_on_request = matcher_group.on_request()
+matcher_group_on_startswith = matcher_group.on_startswith("test")
+matcher_group_on_endswith = matcher_group.on_endswith("test")
+matcher_group_on_fullmatch = matcher_group.on_fullmatch("test")
+matcher_group_on_keyword = matcher_group.on_keyword({"test"})
+matcher_group_on_command = matcher_group.on_command("test")
+matcher_group_on_shell_command = matcher_group.on_shell_command("test")
+matcher_group_on_regex = matcher_group.on_regex("test")
+matcher_group_on_type = matcher_group.on_type(TestEvent)

tests/test_plugin/test_on.py

@@ -0,0 +1,116 @@
+from typing import Type, Optional
+
+import pytest
+from nonebug import App
+
+
+@pytest.mark.asyncio
+async def test_on(app: App, load_plugin):
+    import nonebot
+    import plugins.plugin.matchers as module
+    from nonebot.typing import T_RuleChecker
+    from nonebot.matcher import Matcher, matchers
+    from nonebot.rule import (
+        RegexRule,
+        IsTypeRule,
+        CommandRule,
+        EndswithRule,
+        KeywordsRule,
+        FullmatchRule,
+        StartswithRule,
+        ShellCommandRule,
+    )
+    from plugins.plugin.matchers import (
+        TestEvent,
+        rule,
+        state,
+        handler,
+        priority,
+        matcher_on,
+        permission,
+        expire_time,
+        matcher_on_type,
+        matcher_sub_cmd,
+        matcher_group_on,
+        matcher_on_regex,
+        matcher_on_notice,
+        matcher_on_command,
+        matcher_on_keyword,
+        matcher_on_message,
+        matcher_on_request,
+        matcher_on_endswith,
+        matcher_on_fullmatch,
+        matcher_on_metaevent,
+        matcher_group_on_type,
+        matcher_on_startswith,
+        matcher_sub_shell_cmd,
+        matcher_group_on_regex,
+        matcher_group_on_notice,
+        matcher_group_on_command,
+        matcher_group_on_keyword,
+        matcher_group_on_message,
+        matcher_group_on_request,
+        matcher_on_shell_command,
+        matcher_group_on_endswith,
+        matcher_group_on_fullmatch,
+        matcher_group_on_metaevent,
+        matcher_group_on_startswith,
+        matcher_group_on_shell_command,
+    )
+
+    plugin = nonebot.get_plugin("plugin")
+
+    def _check(
+        matcher: Type[Matcher],
+        pre_rule: Optional[T_RuleChecker],
+        has_permission: bool,
+    ):
+        assert {dependent.call for dependent in matcher.rule.checkers} == (
+            {pre_rule, rule} if pre_rule else {rule}
+        )
+        if has_permission:
+            assert {dependent.call for dependent in matcher.permission.checkers} == {
+                permission
+            }
+        else:
+            assert not matcher.permission.checkers
+        assert [dependent.call for dependent in matcher.handlers] == [handler]
+        assert matcher.temp is True
+        assert matcher.expire_time == expire_time
+        assert matcher in matchers[priority]
+        assert matcher.block is True
+        assert matcher._default_state == state
+
+        assert matcher.plugin is plugin
+        assert matcher.module is module
+        assert matcher.plugin_name == "plugin"
+        assert matcher.module_name == "plugins.plugin.matchers"
+
+    _check(matcher_on, None, True)
+    _check(matcher_on_metaevent, None, False)
+    _check(matcher_on_message, None, True)
+    _check(matcher_on_notice, None, False)
+    _check(matcher_on_request, None, False)
+    _check(matcher_on_startswith, StartswithRule(("test",)), True)
+    _check(matcher_on_endswith, EndswithRule(("test",)), True)
+    _check(matcher_on_fullmatch, FullmatchRule(("test",)), True)
+    _check(matcher_on_keyword, KeywordsRule("test"), True)
+    _check(matcher_on_command, CommandRule([("test",)]), True)
+    _check(matcher_on_shell_command, ShellCommandRule([("test",)], None), True)
+    _check(matcher_on_regex, RegexRule("test"), True)
+    _check(matcher_on_type, IsTypeRule(TestEvent), True)
+    _check(matcher_sub_cmd, CommandRule([("test", "sub")]), True)
+    _check(matcher_sub_shell_cmd, ShellCommandRule([("test", "sub")], None), True)
+    _check(matcher_group_on, None, True)
+    _check(matcher_group_on_metaevent, None, False)
+    _check(matcher_group_on_message, None, True)
+    _check(matcher_group_on_notice, None, False)
+    _check(matcher_group_on_request, None, False)
+    _check(matcher_group_on_startswith, StartswithRule(("test",)), True)
+    _check(matcher_group_on_endswith, EndswithRule(("test",)), True)
+    _check(matcher_group_on_fullmatch, FullmatchRule(("test",)), True)
+    _check(matcher_group_on_keyword, KeywordsRule("test"), True)
+    _check(matcher_group_on_command, CommandRule([("test",)]), True)
+    _check(matcher_group_on_shell_command, ShellCommandRule([("test",)], None), True)
+    _check(matcher_group_on_regex, RegexRule("test"), True)
+    _check(matcher_group_on_type, IsTypeRule(TestEvent), True)

tests/test_rule.py

@@ -145,7 +145,7 @@ async def test_fullmatch(
     checker = dependent.call
 
     assert isinstance(checker, FullmatchRule)
-    assert checker.msg == {msg} if isinstance(msg, str) else {*msg}
+    assert checker.msg == ((msg,) if isinstance(msg, str) else msg)
     assert checker.ignorecase == ignorecase
 
     message = make_fake_message()(text)
@@ -196,7 +196,7 @@ async def test_command(app: App, cmds: Tuple[Tuple[str, ...]]):
     checker = dependent.call
 
     assert isinstance(checker, CommandRule)
-    assert checker.cmds == list(cmds)
+    assert checker.cmds == cmds
 
     for cmd in cmds:
         state = {PREFIX_KEY: {CMD_KEY: cmd}}
@@ -318,3 +318,24 @@ async def test_to_me(app: App, expected: bool):
 
     event = make_fake_event(_to_me=expected)()
     assert await dependent(event=event) == expected
+
+
+@pytest.mark.asyncio
+async def test_is_type(app: App):
+    from nonebot.rule import IsTypeRule, is_type
+
+    Event1 = make_fake_event()
+    Event2 = make_fake_event()
+    Event3 = make_fake_event()
+
+    test_type = is_type(Event1, Event2)
+    dependent = list(test_type.checkers)[0]
+    checker = dependent.call
+
+    assert isinstance(checker, IsTypeRule)
+
+    event = Event1()
+    assert await dependent(event=event)
+
+    event = Event3()
+    assert not await dependent(event=event)