✨ Feature: 添加 State 响应器触发消息注入 (#1315)

tests/plugins/param/param_state.py

@@ -4,10 +4,14 @@ from nonebot.typing import T_State
 from nonebot.adapters import Message
 from nonebot.params import (
     Command,
+    Keyword,
+    Endswith,
+    Fullmatch,
     RegexDict,
     CommandArg,
     RawCommand,
     RegexGroup,
+    Startswith,
     CommandStart,
     RegexMatched,
     ShellCommandArgs,
@@ -65,3 +69,19 @@ async def regex_group(regex_group: Tuple = RegexGroup()) -> Tuple:
 
 async def regex_matched(regex_matched: str = RegexMatched()) -> str:
     return regex_matched
+
+
+async def startswith(startswith: str = Startswith()) -> str:
+    return startswith
+
+
+async def endswith(endswith: str = Endswith()) -> str:
+    return endswith
+
+
+async def fullmatch(fullmatch: str = Fullmatch()) -> str:
+    return fullmatch
+
+
+async def keyword(keyword: str = Keyword()) -> str:
+    return keyword

tests/test_param.py

@@ -168,15 +168,23 @@ async def test_state(app: App, load_plugin):
         SHELL_ARGS,
         SHELL_ARGV,
         CMD_ARG_KEY,
+        KEYWORD_KEY,
         RAW_CMD_KEY,
         REGEX_GROUP,
+        ENDSWITH_KEY,
         CMD_START_KEY,
+        FULLMATCH_KEY,
         REGEX_MATCHED,
+        STARTSWITH_KEY,
     )
     from plugins.param.param_state import (
         state,
         command,
+        keyword,
+        endswith,
+        fullmatch,
         regex_dict,
+        startswith,
         command_arg,
         raw_command,
         regex_group,
@@ -201,6 +209,10 @@ async def test_state(app: App, load_plugin):
         REGEX_MATCHED: "[cq:test,arg=value]",
         REGEX_GROUP: ("test", "arg=value"),
         REGEX_DICT: {"type": "test", "arg": "value"},
+        STARTSWITH_KEY: "startswith",
+        ENDSWITH_KEY: "endswith",
+        FULLMATCH_KEY: "fullmatch",
+        KEYWORD_KEY: "keyword",
     }
 
     async with app.test_dependent(state, allow_types=[StateParam]) as ctx:
@@ -271,6 +283,30 @@ async def test_state(app: App, load_plugin):
         ctx.pass_params(state=fake_state)
         ctx.should_return(fake_state[REGEX_DICT])
 
+    async with app.test_dependent(
+        startswith, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[STARTSWITH_KEY])
+
+    async with app.test_dependent(
+        endswith, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[ENDSWITH_KEY])
+
+    async with app.test_dependent(
+        fullmatch, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[FULLMATCH_KEY])
+
+    async with app.test_dependent(
+        keyword, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[KEYWORD_KEY])
+
 
 @pytest.mark.asyncio
 async def test_matcher(app: App, load_plugin):

tests/test_rule.py

@@ -65,19 +65,24 @@ async def test_startswith(
     text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import STARTSWITH_KEY
     from nonebot.rule import StartswithRule, startswith
 
     test_startswith = startswith(msg, ignorecase)
     dependent = list(test_startswith.checkers)[0]
     checker = dependent.call
 
+    msg = (msg,) if isinstance(msg, str) else msg
+
     assert isinstance(checker, StartswithRule)
-    assert checker.msg == (msg,) if isinstance(msg, str) else msg
+    assert checker.msg == msg
     assert checker.ignorecase == ignorecase
 
     message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for prefix in msg:
+        state = {STARTSWITH_KEY: prefix}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -103,19 +108,24 @@ async def test_endswith(
     text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import ENDSWITH_KEY
     from nonebot.rule import EndswithRule, endswith
 
     test_endswith = endswith(msg, ignorecase)
     dependent = list(test_endswith.checkers)[0]
     checker = dependent.call
 
+    msg = (msg,) if isinstance(msg, str) else msg
+
     assert isinstance(checker, EndswithRule)
-    assert checker.msg == (msg,) if isinstance(msg, str) else msg
+    assert checker.msg == msg
     assert checker.ignorecase == ignorecase
 
     message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for suffix in msg:
+        state = {ENDSWITH_KEY: suffix}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -141,19 +151,24 @@ async def test_fullmatch(
     text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import FULLMATCH_KEY
     from nonebot.rule import FullmatchRule, fullmatch
 
     test_fullmatch = fullmatch(msg, ignorecase)
     dependent = list(test_fullmatch.checkers)[0]
     checker = dependent.call
 
+    msg = (msg,) if isinstance(msg, str) else msg
+
     assert isinstance(checker, FullmatchRule)
-    assert checker.msg == ((msg,) if isinstance(msg, str) else msg)
+    assert checker.msg == msg
     assert checker.ignorecase == ignorecase
 
     message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for full in msg:
+        state = {FULLMATCH_KEY: full}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -164,6 +179,7 @@ async def test_fullmatch(
         (("key", "foo"), "message", "_foo_", True),
         (("key",), "message", None, False),
         (("key",), "notice", "foo", False),
+        (("key",), "message", "foo", False),
     ],
 )
 async def test_keyword(
@@ -173,6 +189,7 @@ async def test_keyword(
     text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import KEYWORD_KEY
     from nonebot.rule import KeywordsRule, keyword
 
     test_keyword = keyword(*kws)
@@ -184,7 +201,9 @@ async def test_keyword(
 
     message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for kw in kws:
+        state = {KEYWORD_KEY: kw}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio