From 6c949fab5a3c29e4eb88d15000e2632eb1ff66ee Mon Sep 17 00:00:00 2001 From: William Bergamin Date: Mon, 16 Mar 2026 16:48:11 -0400 Subject: [PATCH 1/3] chore: improve testing around assistant utilities --- tests/scenario_tests/test_events_assistant.py | 130 +++++++-- ...est_events_assistant_without_middleware.py | 246 ++++++++++++++++ .../test_events_assistant.py | 136 +++++++-- ...est_events_assistant_without_middleware.py | 266 ++++++++++++++++++ 4 files changed, 724 insertions(+), 54 deletions(-) create mode 100644 tests/scenario_tests/test_events_assistant_without_middleware.py create mode 100644 tests/scenario_tests_async/test_events_assistant_without_middleware.py diff --git a/tests/scenario_tests/test_events_assistant.py b/tests/scenario_tests/test_events_assistant.py index 07f7ede53..1c31aa94c 100644 --- a/tests/scenario_tests/test_events_assistant.py +++ b/tests/scenario_tests/test_events_assistant.py @@ -1,4 +1,4 @@ -from time import sleep +import time from slack_sdk.web import WebClient @@ -10,6 +10,13 @@ from tests.utils import remove_os_env_temporarily, restore_os_env +def assert_target_called(called: dict, timeout: float = 2.0): + deadline = time.time() + timeout + while called["value"] is False and time.time() < deadline: + time.sleep(0.1) + assert called["value"] is True + + class TestEventsAssistant: valid_token = "xoxb-valid" mock_api_server_base_url = "http://localhost:8888" @@ -26,78 +33,147 @@ def teardown_method(self): cleanup_mock_web_api_server(self) restore_os_env(self.old_os_env) - def test_assistant_threads(self): + def test_thread_started(self): app = App(client=self.web_client) assistant = Assistant() - - state = {"called": False} - - def assert_target_called(): - count = 0 - while state["called"] is False and count < 20: - sleep(0.1) - count += 1 - assert state["called"] is True - state["called"] = False + called = {"value": False} @assistant.thread_started - def start_thread(say: Say, set_suggested_prompts: SetSuggestedPrompts, context: BoltContext): + def start_thread(say: Say, set_suggested_prompts: SetSuggestedPrompts, set_status: SetStatus, context: BoltContext): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" + assert set_status.thread_ts == context.thread_ts + assert say.thread_ts == context.thread_ts say("Hi, how can I help you today?") set_suggested_prompts(prompts=[{"title": "What does SLACK stand for?", "message": "What does SLACK stand for?"}]) set_suggested_prompts( prompts=[{"title": "What does SLACK stand for?", "message": "What does SLACK stand for?"}], title="foo" ) - state["called"] = True + called["value"] = True + + app.assistant(assistant) + + request = BoltRequest(body=thread_started_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + assert_target_called(called) + + def test_thread_context_changed(self): + app = App(client=self.web_client) + assistant = Assistant() + called = {"value": False} @assistant.thread_context_changed def handle_thread_context_changed(context: BoltContext): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" - state["called"] = True + called["value"] = True + + app.assistant(assistant) + + request = BoltRequest(body=thread_context_changed_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + assert_target_called(called) + + def test_user_message(self): + app = App(client=self.web_client) + assistant = Assistant() + called = {"value": False} @assistant.user_message def handle_user_message(say: Say, set_status: SetStatus, context: BoltContext): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts try: set_status("is typing...") say("Here you are!") - state["called"] = True + called["value"] = True except Exception as e: say(f"Oops, something went wrong (error: {e}") app.assistant(assistant) - request = BoltRequest(body=thread_started_event_body, mode="socket_mode") + request = BoltRequest(body=user_message_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 - assert_target_called() + assert_target_called(called) - request = BoltRequest(body=thread_context_changed_event_body, mode="socket_mode") - response = app.dispatch(request) - assert response.status == 200 - assert_target_called() + def test_user_message_with_assistant_thread(self): + app = App(client=self.web_client) + assistant = Assistant() + called = {"value": False} - request = BoltRequest(body=user_message_event_body, mode="socket_mode") - response = app.dispatch(request) - assert response.status == 200 - assert_target_called() + @assistant.user_message + def handle_user_message(say: Say, set_status: SetStatus, context: BoltContext): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + try: + set_status("is typing...") + say("Here you are!") + called["value"] = True + except Exception as e: + say(f"Oops, something went wrong (error: {e}") + + app.assistant(assistant) request = BoltRequest(body=user_message_event_body_with_assistant_thread, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 - assert_target_called() + assert_target_called(called) + + def test_message_changed(self): + app = App(client=self.web_client) + assistant = Assistant() + + @assistant.user_message + def handle_user_message(): + assert False, "This handler should not be called" + + @assistant.bot_message + def handle_bot_message(): + assert False, "This handler should not be called" + + app.assistant(assistant) request = BoltRequest(body=message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 + def test_channel_user_message_ignored(self): + app = App(client=self.web_client) + assistant = Assistant() + + @assistant.user_message + def handle_user_message(): + assert False, "This handler should not be called" + + @assistant.bot_message + def handle_bot_message(): + assert False, "This handler should not be called" + + app.assistant(assistant) + request = BoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 404 + def test_channel_message_changed_ignored(self): + app = App(client=self.web_client) + assistant = Assistant() + + @assistant.user_message + def handle_user_message(): + assert False, "This handler should not be called" + + @assistant.bot_message + def handle_bot_message(): + assert False, "This handler should not be called" + + app.assistant(assistant) + request = BoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 404 diff --git a/tests/scenario_tests/test_events_assistant_without_middleware.py b/tests/scenario_tests/test_events_assistant_without_middleware.py new file mode 100644 index 000000000..209620339 --- /dev/null +++ b/tests/scenario_tests/test_events_assistant_without_middleware.py @@ -0,0 +1,246 @@ +import time + +from slack_sdk.web import WebClient + +from slack_bolt import App, BoltRequest, Say, SetStatus, SetTitle, SaveThreadContext, BoltContext +from slack_bolt.context.get_thread_context.get_thread_context import GetThreadContext +from slack_bolt.context.set_suggested_prompts.set_suggested_prompts import SetSuggestedPrompts +from tests.mock_web_api_server import ( + setup_mock_web_api_server, + cleanup_mock_web_api_server, +) +from tests.scenario_tests.test_events_assistant import ( + channel_message_changed_event_body, + channel_user_message_event_body, + message_changed_event_body, + thread_context_changed_event_body, + thread_started_event_body, + user_message_event_body, + user_message_event_body_with_assistant_thread, +) +from tests.utils import remove_os_env_temporarily, restore_os_env + + +def assert_target_called(called: dict, timeout: float = 2.0): + deadline = time.time() + timeout + while called["value"] is False and time.time() < deadline: + time.sleep(0.1) + assert called["value"] is True + + +class TestEventsAssistantWithoutMiddleware: + valid_token = "xoxb-valid" + mock_api_server_base_url = "http://localhost:8888" + web_client = WebClient( + token=valid_token, + base_url=mock_api_server_base_url, + ) + + def setup_method(self): + self.old_os_env = remove_os_env_temporarily() + setup_mock_web_api_server(self) + + def teardown_method(self): + cleanup_mock_web_api_server(self) + restore_os_env(self.old_os_env) + + def test_thread_started(self): + app = App(client=self.web_client) + called = {"value": False} + + @app.event("assistant_thread_started") + def handle_assistant_thread_started( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + say("Hi, how can I help you today?") + set_suggested_prompts(prompts=[{"title": "What does SLACK stand for?", "message": "What does SLACK stand for?"}]) + called["value"] = True + + request = BoltRequest(body=thread_started_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + assert_target_called(called) + + def test_thread_context_changed(self): + app = App(client=self.web_client) + called = {"value": False} + + @app.event("assistant_thread_context_changed") + def handle_assistant_thread_context_changed( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say is not None + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + called["value"] = True + + request = BoltRequest(body=thread_context_changed_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + assert_target_called(called) + + def test_user_message(self): + app = App(client=self.web_client) + called = {"value": False} + + @app.message("") + def handle_message( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + try: + set_status("is typing...") + say("Here you are!") + called["value"] = True + except Exception as e: + say(f"Oops, something went wrong (error: {e}") + + request = BoltRequest(body=user_message_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + assert_target_called(called) + + def test_user_message_with_assistant_thread(self): + app = App(client=self.web_client) + called = {"value": False} + + @app.message("") + def handle_message( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + try: + set_status("is typing...") + say("Here you are!") + called["value"] = True + except Exception as e: + say(f"Oops, something went wrong (error: {e}") + + request = BoltRequest(body=user_message_event_body_with_assistant_thread, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + assert_target_called(called) + + def test_message_changed(self): + app = App(client=self.web_client) + + @app.event("message") + def handle_message_event( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.thread_ts is not None + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + + request = BoltRequest(body=message_changed_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + + def test_channel_user_message(self): + app = App(client=self.web_client) + + @app.event("message") + def handle_message_event( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.thread_ts is not None + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + + request = BoltRequest(body=channel_user_message_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 + + def test_channel_message_changed(self): + app = App(client=self.web_client) + + @app.event("message") + def handle_message_event( + say: Say, + set_status: SetStatus, + set_title: SetTitle, + set_suggested_prompts: SetSuggestedPrompts, + get_thread_context: GetThreadContext, + save_thread_context: SaveThreadContext, + context: BoltContext, + ): + assert context.thread_ts is not None + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + + request = BoltRequest(body=channel_message_changed_event_body, mode="socket_mode") + response = app.dispatch(request) + assert response.status == 200 diff --git a/tests/scenario_tests_async/test_events_assistant.py b/tests/scenario_tests_async/test_events_assistant.py index b131b4e38..91e836264 100644 --- a/tests/scenario_tests_async/test_events_assistant.py +++ b/tests/scenario_tests_async/test_events_assistant.py @@ -1,4 +1,5 @@ import asyncio +import time import pytest from slack_sdk.web.async_client import AsyncWebClient @@ -17,6 +18,13 @@ from tests.utils import remove_os_env_temporarily, restore_os_env +async def assert_target_called(called: dict, timeout: float = 2.0): + deadline = time.time() + timeout + while called["value"] is False and time.time() < deadline: + await asyncio.sleep(0.1) + assert called["value"] is True + + class TestAsyncEventsAssistant: valid_token = "xoxb-valid" mock_api_server_base_url = "http://localhost:8888" @@ -29,6 +37,7 @@ class TestAsyncEventsAssistant: def setup_teardown(self): old_os_env = remove_os_env_temporarily() setup_mock_web_api_server_async(self) + try: yield # run the test here finally: @@ -36,25 +45,16 @@ def setup_teardown(self): restore_os_env(old_os_env) @pytest.mark.asyncio - async def test_assistant_events(self): + async def test_thread_started(self): app = AsyncApp(client=self.web_client) - assistant = AsyncAssistant() - - state = {"called": False} - - async def assert_target_called(): - count = 0 - while state["called"] is False and count < 20: - await asyncio.sleep(0.1) - count += 1 - assert state["called"] is True - state["called"] = False + called = {"value": False} @assistant.thread_started async def start_thread(say: AsyncSay, set_suggested_prompts: AsyncSetSuggestedPrompts, context: AsyncBoltContext): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts await say("Hi, how can I help you today?") await set_suggested_prompts( prompts=[{"title": "What does SLACK stand for?", "message": "What does SLACK stand for?"}] @@ -63,55 +63,137 @@ async def start_thread(say: AsyncSay, set_suggested_prompts: AsyncSetSuggestedPr prompts=[{"title": "What does SLACK stand for?", "message": "What does SLACK stand for?"}], title="foo", ) - state["called"] = True + called["value"] = True + + app.assistant(assistant) + + request = AsyncBoltRequest(body=thread_started_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_thread_context_changed(self): + app = AsyncApp(client=self.web_client) + assistant = AsyncAssistant() + called = {"value": False} @assistant.thread_context_changed - async def handle_user_message(context: AsyncBoltContext): + async def handle_thread_context_changed(context: AsyncBoltContext): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" - state["called"] = True + called["value"] = True + + app.assistant(assistant) + + request = AsyncBoltRequest(body=thread_context_changed_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_user_message(self): + app = AsyncApp(client=self.web_client) + assistant = AsyncAssistant() + called = {"value": False} @assistant.user_message async def handle_user_message(say: AsyncSay, set_status: AsyncSetStatus, context: AsyncBoltContext): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts try: await set_status("is typing...") await say("Here you are!") - state["called"] = True + called["value"] = True except Exception as e: await say(f"Oops, something went wrong (error: {e}") app.assistant(assistant) - request = AsyncBoltRequest(body=thread_started_event_body, mode="socket_mode") + request = AsyncBoltRequest(body=user_message_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 - await assert_target_called() + await assert_target_called(called) - request = AsyncBoltRequest(body=thread_context_changed_event_body, mode="socket_mode") - response = await app.async_dispatch(request) - assert response.status == 200 - await assert_target_called() + @pytest.mark.asyncio + async def test_user_message_with_assistant_thread(self): + app = AsyncApp(client=self.web_client) + assistant = AsyncAssistant() + called = {"value": False} - request = AsyncBoltRequest(body=user_message_event_body, mode="socket_mode") - response = await app.async_dispatch(request) - assert response.status == 200 - await assert_target_called() + @assistant.user_message + async def handle_user_message(say: AsyncSay, set_status: AsyncSetStatus, context: AsyncBoltContext): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + try: + await set_status("is typing...") + await say("Here you are!") + called["value"] = True + except Exception as e: + await say(f"Oops, something went wrong (error: {e}") + + app.assistant(assistant) request = AsyncBoltRequest(body=user_message_event_body_with_assistant_thread, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 - await assert_target_called() + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_message_changed(self): + app = AsyncApp(client=self.web_client) + assistant = AsyncAssistant() + + @assistant.user_message + async def handle_user_message(): + assert False, "This handler should not be called" + + @assistant.bot_message + async def handle_bot_message(): + assert False, "This handler should not be called" + + app.assistant(assistant) request = AsyncBoltRequest(body=message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 + @pytest.mark.asyncio + async def test_channel_user_message_ignored(self): + app = AsyncApp(client=self.web_client) + assistant = AsyncAssistant() + + @assistant.user_message + async def handle_user_message(): + assert False, "This handler should not be called" + + @assistant.bot_message + async def handle_bot_message(): + assert False, "This handler should not be called" + + app.assistant(assistant) + request = AsyncBoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 404 + @pytest.mark.asyncio + async def test_channel_message_changed_ignored(self): + app = AsyncApp(client=self.web_client) + assistant = AsyncAssistant() + + @assistant.user_message + async def handle_user_message(): + assert False, "This handler should not be called" + + @assistant.bot_message + async def handle_bot_message(): + assert False, "This handler should not be called" + + app.assistant(assistant) + request = AsyncBoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 404 diff --git a/tests/scenario_tests_async/test_events_assistant_without_middleware.py b/tests/scenario_tests_async/test_events_assistant_without_middleware.py new file mode 100644 index 000000000..dad926c06 --- /dev/null +++ b/tests/scenario_tests_async/test_events_assistant_without_middleware.py @@ -0,0 +1,266 @@ +import asyncio +import time + +import pytest +from slack_sdk.web.async_client import AsyncWebClient + +from slack_bolt.app.async_app import AsyncApp +from slack_bolt.context.async_context import AsyncBoltContext +from slack_bolt.context.say.async_say import AsyncSay +from slack_bolt.context.set_status.async_set_status import AsyncSetStatus +from slack_bolt.context.set_title.async_set_title import AsyncSetTitle +from slack_bolt.context.set_suggested_prompts.async_set_suggested_prompts import AsyncSetSuggestedPrompts +from slack_bolt.context.get_thread_context.async_get_thread_context import AsyncGetThreadContext +from slack_bolt.context.save_thread_context.async_save_thread_context import AsyncSaveThreadContext +from slack_bolt.request.async_request import AsyncBoltRequest +from tests.mock_web_api_server import ( + cleanup_mock_web_api_server_async, + setup_mock_web_api_server_async, +) +from tests.scenario_tests_async.test_events_assistant import ( + channel_message_changed_event_body, + channel_user_message_event_body, + message_changed_event_body, + thread_context_changed_event_body, + thread_started_event_body, + user_message_event_body, + user_message_event_body_with_assistant_thread, +) +from tests.utils import remove_os_env_temporarily, restore_os_env + + +async def assert_target_called(called: dict, timeout: float = 2.0): + deadline = time.time() + timeout + while called["value"] is False and time.time() < deadline: + await asyncio.sleep(0.1) + assert called["value"] is True + + +class TestAsyncEventsAssistantWithoutMiddleware: + valid_token = "xoxb-valid" + mock_api_server_base_url = "http://localhost:8888" + web_client = AsyncWebClient( + token=valid_token, + base_url=mock_api_server_base_url, + ) + + @pytest.fixture(scope="function", autouse=True) + def setup_teardown(self): + old_os_env = remove_os_env_temporarily() + setup_mock_web_api_server_async(self) + + try: + yield + finally: + cleanup_mock_web_api_server_async(self) + restore_os_env(old_os_env) + + @pytest.mark.asyncio + async def test_thread_started(self): + app = AsyncApp(client=self.web_client) + called = {"value": False} + + @app.event("assistant_thread_started") + async def handle_assistant_thread_started( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + await say("Hi, how can I help you today?") + await set_suggested_prompts( + prompts=[{"title": "What does SLACK stand for?", "message": "What does SLACK stand for?"}] + ) + called["value"] = True + + request = AsyncBoltRequest(body=thread_started_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_thread_context_changed(self): + app = AsyncApp(client=self.web_client) + called = {"value": False} + + @app.event("assistant_thread_context_changed") + async def handle_assistant_thread_context_changed( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say is not None + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + called["value"] = True + + request = AsyncBoltRequest(body=thread_context_changed_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_user_message(self): + app = AsyncApp(client=self.web_client) + called = {"value": False} + + @app.message("") + async def handle_message( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + try: + await set_status("is typing...") + await say("Here you are!") + called["value"] = True + except Exception as e: + await say(f"Oops, something went wrong (error: {e}") + + request = AsyncBoltRequest(body=user_message_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_user_message_with_assistant_thread(self): + app = AsyncApp(client=self.web_client) + called = {"value": False} + + @app.message("") + async def handle_message( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.channel_id == "D111" + assert context.thread_ts == "1726133698.626339" + assert say.thread_ts == context.thread_ts + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + try: + await set_status("is typing...") + await say("Here you are!") + called["value"] = True + except Exception as e: + await say(f"Oops, something went wrong (error: {e}") + + request = AsyncBoltRequest(body=user_message_event_body_with_assistant_thread, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + await assert_target_called(called) + + @pytest.mark.asyncio + async def test_message_changed(self): + app = AsyncApp(client=self.web_client) + + @app.event("message") + async def handle_message_event( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.thread_ts is not None + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + + request = AsyncBoltRequest(body=message_changed_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + + @pytest.mark.asyncio + async def test_channel_user_message(self): + app = AsyncApp(client=self.web_client) + + @app.event("message") + async def handle_message_event( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.thread_ts is not None + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + + request = AsyncBoltRequest(body=channel_user_message_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 + + @pytest.mark.asyncio + async def test_channel_message_changed(self): + app = AsyncApp(client=self.web_client) + + @app.event("message") + async def handle_message_event( + say: AsyncSay, + set_status: AsyncSetStatus, + set_title: AsyncSetTitle, + set_suggested_prompts: AsyncSetSuggestedPrompts, + get_thread_context: AsyncGetThreadContext, + save_thread_context: AsyncSaveThreadContext, + context: AsyncBoltContext, + ): + assert context.thread_ts is not None + assert say.thread_ts == context.thread_ts + assert set_status is not None + assert set_title is not None + assert set_suggested_prompts is not None + assert get_thread_context is not None + assert save_thread_context is not None + + request = AsyncBoltRequest(body=channel_message_changed_event_body, mode="socket_mode") + response = await app.async_dispatch(request) + assert response.status == 200 From 9cc2bb37e907a56e080699e242c7fd720746ad47 Mon Sep 17 00:00:00 2001 From: William Bergamin Date: Mon, 16 Mar 2026 18:18:04 -0400 Subject: [PATCH 2/3] Improve based on feedback --- tests/scenario_tests/test_events_assistant.py | 29 +++++++++------ ...est_events_assistant_without_middleware.py | 27 +++++++------- .../test_events_assistant.py | 36 ++++++++++++------- ...est_events_assistant_without_middleware.py | 28 ++++++++------- 4 files changed, 72 insertions(+), 48 deletions(-) diff --git a/tests/scenario_tests/test_events_assistant.py b/tests/scenario_tests/test_events_assistant.py index 1c31aa94c..333375523 100644 --- a/tests/scenario_tests/test_events_assistant.py +++ b/tests/scenario_tests/test_events_assistant.py @@ -10,11 +10,11 @@ from tests.utils import remove_os_env_temporarily, restore_os_env -def assert_target_called(called: dict, timeout: float = 2.0): +def assert_target_called(called: dict, expected: bool = True, timeout: float = 0.5): deadline = time.time() + timeout - while called["value"] is False and time.time() < deadline: + while called["value"] is not expected and time.time() < deadline: time.sleep(0.1) - assert called["value"] is True + assert called["value"] is expected class TestEventsAssistant: @@ -91,7 +91,7 @@ def handle_user_message(say: Say, set_status: SetStatus, context: BoltContext): say("Here you are!") called["value"] = True except Exception as e: - say(f"Oops, something went wrong (error: {e}") + say(f"Oops, something went wrong (error: {e})") app.assistant(assistant) @@ -115,7 +115,7 @@ def handle_user_message(say: Say, set_status: SetStatus, context: BoltContext): say("Here you are!") called["value"] = True except Exception as e: - say(f"Oops, something went wrong (error: {e}") + say(f"Oops, something went wrong (error: {e})") app.assistant(assistant) @@ -127,56 +127,63 @@ def handle_user_message(say: Say, set_status: SetStatus, context: BoltContext): def test_message_changed(self): app = App(client=self.web_client) assistant = Assistant() + called = {"value": False} @assistant.user_message def handle_user_message(): - assert False, "This handler should not be called" + called["value"] = True @assistant.bot_message def handle_bot_message(): - assert False, "This handler should not be called" + called["value"] = True app.assistant(assistant) request = BoltRequest(body=message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 + assert_target_called(called, key="user_message", expected=False) + assert_target_called(called, key="bot_message", expected=False) def test_channel_user_message_ignored(self): app = App(client=self.web_client) assistant = Assistant() + called = {"value": False} @assistant.user_message def handle_user_message(): - assert False, "This handler should not be called" + called["value"] = True @assistant.bot_message def handle_bot_message(): - assert False, "This handler should not be called" + called["value"] = True app.assistant(assistant) request = BoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 404 + assert_target_called(called, expected=False) def test_channel_message_changed_ignored(self): app = App(client=self.web_client) assistant = Assistant() + called = {"value": False} @assistant.user_message def handle_user_message(): - assert False, "This handler should not be called" + called["value"] = True @assistant.bot_message def handle_bot_message(): - assert False, "This handler should not be called" + called["value"] = True app.assistant(assistant) request = BoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 404 + assert_target_called(called, expected=False) def build_payload(event: dict) -> dict: diff --git a/tests/scenario_tests/test_events_assistant_without_middleware.py b/tests/scenario_tests/test_events_assistant_without_middleware.py index 209620339..9a59e98c5 100644 --- a/tests/scenario_tests/test_events_assistant_without_middleware.py +++ b/tests/scenario_tests/test_events_assistant_without_middleware.py @@ -1,5 +1,3 @@ -import time - from slack_sdk.web import WebClient from slack_bolt import App, BoltRequest, Say, SetStatus, SetTitle, SaveThreadContext, BoltContext @@ -18,16 +16,10 @@ user_message_event_body, user_message_event_body_with_assistant_thread, ) +from tests.scenario_tests.test_events_assistant import assert_target_called from tests.utils import remove_os_env_temporarily, restore_os_env -def assert_target_called(called: dict, timeout: float = 2.0): - deadline = time.time() + timeout - while called["value"] is False and time.time() < deadline: - time.sleep(0.1) - assert called["value"] is True - - class TestEventsAssistantWithoutMiddleware: valid_token = "xoxb-valid" mock_api_server_base_url = "http://localhost:8888" @@ -91,7 +83,7 @@ def handle_assistant_thread_context_changed( ): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" - assert say is not None + assert say.thread_ts == context.thread_ts assert set_status is not None assert set_title is not None assert set_suggested_prompts is not None @@ -121,6 +113,7 @@ def handle_message( assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" assert say.thread_ts == context.thread_ts + assert set_status is not None assert set_title is not None assert set_suggested_prompts is not None assert get_thread_context is not None @@ -130,7 +123,7 @@ def handle_message( say("Here you are!") called["value"] = True except Exception as e: - say(f"Oops, something went wrong (error: {e}") + say(f"Oops, something went wrong (error: {e})") request = BoltRequest(body=user_message_event_body, mode="socket_mode") response = app.dispatch(request) @@ -154,6 +147,7 @@ def handle_message( assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" assert say.thread_ts == context.thread_ts + assert set_status is not None assert set_title is not None assert set_suggested_prompts is not None assert get_thread_context is not None @@ -163,7 +157,7 @@ def handle_message( say("Here you are!") called["value"] = True except Exception as e: - say(f"Oops, something went wrong (error: {e}") + say(f"Oops, something went wrong (error: {e})") request = BoltRequest(body=user_message_event_body_with_assistant_thread, mode="socket_mode") response = app.dispatch(request) @@ -172,6 +166,7 @@ def handle_message( def test_message_changed(self): app = App(client=self.web_client) + called = {"value": False} @app.event("message") def handle_message_event( @@ -190,13 +185,16 @@ def handle_message_event( assert set_suggested_prompts is not None assert get_thread_context is not None assert save_thread_context is not None + called["value"] = True request = BoltRequest(body=message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 + assert_target_called(called) def test_channel_user_message(self): app = App(client=self.web_client) + called = {"value": False} @app.event("message") def handle_message_event( @@ -215,13 +213,16 @@ def handle_message_event( assert set_suggested_prompts is not None assert get_thread_context is not None assert save_thread_context is not None + called["value"] = True request = BoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 + assert_target_called(called) def test_channel_message_changed(self): app = App(client=self.web_client) + called = {"value": False} @app.event("message") def handle_message_event( @@ -240,7 +241,9 @@ def handle_message_event( assert set_suggested_prompts is not None assert get_thread_context is not None assert save_thread_context is not None + called["value"] = True request = BoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 + assert_target_called(called) diff --git a/tests/scenario_tests_async/test_events_assistant.py b/tests/scenario_tests_async/test_events_assistant.py index 91e836264..61700dc1f 100644 --- a/tests/scenario_tests_async/test_events_assistant.py +++ b/tests/scenario_tests_async/test_events_assistant.py @@ -18,11 +18,11 @@ from tests.utils import remove_os_env_temporarily, restore_os_env -async def assert_target_called(called: dict, timeout: float = 2.0): +async def assert_target_called(called: dict, expected: bool = True, timeout: float = 0.5): deadline = time.time() + timeout - while called["value"] is False and time.time() < deadline: + while called["value"] is not expected and time.time() < deadline: await asyncio.sleep(0.1) - assert called["value"] is True + assert called["value"] is expected class TestAsyncEventsAssistant: @@ -51,9 +51,15 @@ async def test_thread_started(self): called = {"value": False} @assistant.thread_started - async def start_thread(say: AsyncSay, set_suggested_prompts: AsyncSetSuggestedPrompts, context: AsyncBoltContext): + async def start_thread( + say: AsyncSay, + set_suggested_prompts: AsyncSetSuggestedPrompts, + set_status: AsyncSetStatus, + context: AsyncBoltContext, + ): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" + assert set_status.thread_ts == context.thread_ts assert say.thread_ts == context.thread_ts await say("Hi, how can I help you today?") await set_suggested_prompts( @@ -107,7 +113,7 @@ async def handle_user_message(say: AsyncSay, set_status: AsyncSetStatus, context await say("Here you are!") called["value"] = True except Exception as e: - await say(f"Oops, something went wrong (error: {e}") + await say(f"Oops, something went wrong (error: {e})") app.assistant(assistant) @@ -132,7 +138,7 @@ async def handle_user_message(say: AsyncSay, set_status: AsyncSetStatus, context await say("Here you are!") called["value"] = True except Exception as e: - await say(f"Oops, something went wrong (error: {e}") + await say(f"Oops, something went wrong (error: {e})") app.assistant(assistant) @@ -145,58 +151,64 @@ async def handle_user_message(say: AsyncSay, set_status: AsyncSetStatus, context async def test_message_changed(self): app = AsyncApp(client=self.web_client) assistant = AsyncAssistant() + called = {"value": False} @assistant.user_message async def handle_user_message(): - assert False, "This handler should not be called" + called["value"] = True @assistant.bot_message async def handle_bot_message(): - assert False, "This handler should not be called" + called["value"] = True app.assistant(assistant) request = AsyncBoltRequest(body=message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 + await assert_target_called(called, expected=False) @pytest.mark.asyncio async def test_channel_user_message_ignored(self): app = AsyncApp(client=self.web_client) assistant = AsyncAssistant() + called = {"value": False} @assistant.user_message async def handle_user_message(): - assert False, "This handler should not be called" + called["value"] = True @assistant.bot_message async def handle_bot_message(): - assert False, "This handler should not be called" + called["value"] = True app.assistant(assistant) request = AsyncBoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 404 + await assert_target_called(called, expected=False) @pytest.mark.asyncio async def test_channel_message_changed_ignored(self): app = AsyncApp(client=self.web_client) assistant = AsyncAssistant() + called = {"value": False} @assistant.user_message async def handle_user_message(): - assert False, "This handler should not be called" + called["value"] = True @assistant.bot_message async def handle_bot_message(): - assert False, "This handler should not be called" + called["value"] = True app.assistant(assistant) request = AsyncBoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 404 + await assert_target_called(called, expected=False) def build_payload(event: dict) -> dict: diff --git a/tests/scenario_tests_async/test_events_assistant_without_middleware.py b/tests/scenario_tests_async/test_events_assistant_without_middleware.py index dad926c06..ac4b9b836 100644 --- a/tests/scenario_tests_async/test_events_assistant_without_middleware.py +++ b/tests/scenario_tests_async/test_events_assistant_without_middleware.py @@ -1,6 +1,3 @@ -import asyncio -import time - import pytest from slack_sdk.web.async_client import AsyncWebClient @@ -26,16 +23,10 @@ user_message_event_body, user_message_event_body_with_assistant_thread, ) +from tests.scenario_tests_async.test_events_assistant import assert_target_called from tests.utils import remove_os_env_temporarily, restore_os_env -async def assert_target_called(called: dict, timeout: float = 2.0): - deadline = time.time() + timeout - while called["value"] is False and time.time() < deadline: - await asyncio.sleep(0.1) - assert called["value"] is True - - class TestAsyncEventsAssistantWithoutMiddleware: valid_token = "xoxb-valid" mock_api_server_base_url = "http://localhost:8888" @@ -106,7 +97,7 @@ async def handle_assistant_thread_context_changed( ): assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" - assert say is not None + assert say.thread_ts == context.thread_ts assert set_status is not None assert set_title is not None assert set_suggested_prompts is not None @@ -137,6 +128,7 @@ async def handle_message( assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" assert say.thread_ts == context.thread_ts + assert set_status is not None assert set_title is not None assert set_suggested_prompts is not None assert get_thread_context is not None @@ -146,7 +138,7 @@ async def handle_message( await say("Here you are!") called["value"] = True except Exception as e: - await say(f"Oops, something went wrong (error: {e}") + await say(f"Oops, something went wrong (error: {e})") request = AsyncBoltRequest(body=user_message_event_body, mode="socket_mode") response = await app.async_dispatch(request) @@ -171,6 +163,7 @@ async def handle_message( assert context.channel_id == "D111" assert context.thread_ts == "1726133698.626339" assert say.thread_ts == context.thread_ts + assert set_status is not None assert set_title is not None assert set_suggested_prompts is not None assert get_thread_context is not None @@ -180,7 +173,7 @@ async def handle_message( await say("Here you are!") called["value"] = True except Exception as e: - await say(f"Oops, something went wrong (error: {e}") + await say(f"Oops, something went wrong (error: {e})") request = AsyncBoltRequest(body=user_message_event_body_with_assistant_thread, mode="socket_mode") response = await app.async_dispatch(request) @@ -190,6 +183,7 @@ async def handle_message( @pytest.mark.asyncio async def test_message_changed(self): app = AsyncApp(client=self.web_client) + called = {"value": False} @app.event("message") async def handle_message_event( @@ -208,14 +202,17 @@ async def handle_message_event( assert set_suggested_prompts is not None assert get_thread_context is not None assert save_thread_context is not None + called["value"] = True request = AsyncBoltRequest(body=message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 + await assert_target_called(called) @pytest.mark.asyncio async def test_channel_user_message(self): app = AsyncApp(client=self.web_client) + called = {"value": False} @app.event("message") async def handle_message_event( @@ -234,14 +231,17 @@ async def handle_message_event( assert set_suggested_prompts is not None assert get_thread_context is not None assert save_thread_context is not None + called["value"] = True request = AsyncBoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 + await assert_target_called(called) @pytest.mark.asyncio async def test_channel_message_changed(self): app = AsyncApp(client=self.web_client) + called = {"value": False} @app.event("message") async def handle_message_event( @@ -260,7 +260,9 @@ async def handle_message_event( assert set_suggested_prompts is not None assert get_thread_context is not None assert save_thread_context is not None + called["value"] = True request = AsyncBoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 + await assert_target_called(called) From 5a753038c2c998ec0f885e611093a5387f0792e1 Mon Sep 17 00:00:00 2001 From: William Bergamin Date: Mon, 16 Mar 2026 18:38:05 -0400 Subject: [PATCH 3/3] minor fixes and simplification --- tests/scenario_tests/test_events_assistant.py | 13 +++---- ...est_events_assistant_without_middleware.py | 38 +++++++++---------- .../test_events_assistant.py | 12 +++--- ...est_events_assistant_without_middleware.py | 38 +++++++++---------- 4 files changed, 50 insertions(+), 51 deletions(-) diff --git a/tests/scenario_tests/test_events_assistant.py b/tests/scenario_tests/test_events_assistant.py index 333375523..3372380fd 100644 --- a/tests/scenario_tests/test_events_assistant.py +++ b/tests/scenario_tests/test_events_assistant.py @@ -10,11 +10,11 @@ from tests.utils import remove_os_env_temporarily, restore_os_env -def assert_target_called(called: dict, expected: bool = True, timeout: float = 0.5): +def assert_target_called(called: dict, timeout: float = 0.5): deadline = time.time() + timeout - while called["value"] is not expected and time.time() < deadline: + while called["value"] is not True and time.time() < deadline: time.sleep(0.1) - assert called["value"] is expected + assert called["value"] is True class TestEventsAssistant: @@ -142,8 +142,7 @@ def handle_bot_message(): request = BoltRequest(body=message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 200 - assert_target_called(called, key="user_message", expected=False) - assert_target_called(called, key="bot_message", expected=False) + assert called["value"] is False def test_channel_user_message_ignored(self): app = App(client=self.web_client) @@ -163,7 +162,7 @@ def handle_bot_message(): request = BoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 404 - assert_target_called(called, expected=False) + assert called["value"] is False def test_channel_message_changed_ignored(self): app = App(client=self.web_client) @@ -183,7 +182,7 @@ def handle_bot_message(): request = BoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = app.dispatch(request) assert response.status == 404 - assert_target_called(called, expected=False) + assert called["value"] is False def build_payload(event: dict) -> dict: diff --git a/tests/scenario_tests/test_events_assistant_without_middleware.py b/tests/scenario_tests/test_events_assistant_without_middleware.py index 9a59e98c5..5307aa4c6 100644 --- a/tests/scenario_tests/test_events_assistant_without_middleware.py +++ b/tests/scenario_tests/test_events_assistant_without_middleware.py @@ -8,6 +8,7 @@ cleanup_mock_web_api_server, ) from tests.scenario_tests.test_events_assistant import ( + assert_target_called, channel_message_changed_event_body, channel_user_message_event_body, message_changed_event_body, @@ -16,7 +17,6 @@ user_message_event_body, user_message_event_body_with_assistant_thread, ) -from tests.scenario_tests.test_events_assistant import assert_target_called from tests.utils import remove_os_env_temporarily, restore_os_env @@ -178,13 +178,13 @@ def handle_message_event( save_thread_context: SaveThreadContext, context: BoltContext, ): - assert context.thread_ts is not None + assert context.thread_ts is None assert say.thread_ts == context.thread_ts - assert set_status is not None - assert set_title is not None - assert set_suggested_prompts is not None - assert get_thread_context is not None - assert save_thread_context is not None + assert set_status is None + assert set_title is None + assert set_suggested_prompts is None + assert get_thread_context is None + assert save_thread_context is None called["value"] = True request = BoltRequest(body=message_changed_event_body, mode="socket_mode") @@ -206,13 +206,13 @@ def handle_message_event( save_thread_context: SaveThreadContext, context: BoltContext, ): - assert context.thread_ts is not None + assert context.thread_ts is None assert say.thread_ts == context.thread_ts - assert set_status is not None - assert set_title is not None - assert set_suggested_prompts is not None - assert get_thread_context is not None - assert save_thread_context is not None + assert set_status is None + assert set_title is None + assert set_suggested_prompts is None + assert get_thread_context is None + assert save_thread_context is None called["value"] = True request = BoltRequest(body=channel_user_message_event_body, mode="socket_mode") @@ -234,13 +234,13 @@ def handle_message_event( save_thread_context: SaveThreadContext, context: BoltContext, ): - assert context.thread_ts is not None + assert context.thread_ts is None assert say.thread_ts == context.thread_ts - assert set_status is not None - assert set_title is not None - assert set_suggested_prompts is not None - assert get_thread_context is not None - assert save_thread_context is not None + assert set_status is None + assert set_title is None + assert set_suggested_prompts is None + assert get_thread_context is None + assert save_thread_context is None called["value"] = True request = BoltRequest(body=channel_message_changed_event_body, mode="socket_mode") diff --git a/tests/scenario_tests_async/test_events_assistant.py b/tests/scenario_tests_async/test_events_assistant.py index 61700dc1f..c6d04474d 100644 --- a/tests/scenario_tests_async/test_events_assistant.py +++ b/tests/scenario_tests_async/test_events_assistant.py @@ -18,11 +18,11 @@ from tests.utils import remove_os_env_temporarily, restore_os_env -async def assert_target_called(called: dict, expected: bool = True, timeout: float = 0.5): +async def assert_target_called(called: dict, timeout: float = 0.5): deadline = time.time() + timeout - while called["value"] is not expected and time.time() < deadline: + while called["value"] is not True and time.time() < deadline: await asyncio.sleep(0.1) - assert called["value"] is expected + assert called["value"] is True class TestAsyncEventsAssistant: @@ -166,7 +166,7 @@ async def handle_bot_message(): request = AsyncBoltRequest(body=message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 200 - await assert_target_called(called, expected=False) + assert called["value"] is False @pytest.mark.asyncio async def test_channel_user_message_ignored(self): @@ -187,7 +187,7 @@ async def handle_bot_message(): request = AsyncBoltRequest(body=channel_user_message_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 404 - await assert_target_called(called, expected=False) + assert called["value"] is False @pytest.mark.asyncio async def test_channel_message_changed_ignored(self): @@ -208,7 +208,7 @@ async def handle_bot_message(): request = AsyncBoltRequest(body=channel_message_changed_event_body, mode="socket_mode") response = await app.async_dispatch(request) assert response.status == 404 - await assert_target_called(called, expected=False) + assert called["value"] is False def build_payload(event: dict) -> dict: diff --git a/tests/scenario_tests_async/test_events_assistant_without_middleware.py b/tests/scenario_tests_async/test_events_assistant_without_middleware.py index ac4b9b836..92f488ff3 100644 --- a/tests/scenario_tests_async/test_events_assistant_without_middleware.py +++ b/tests/scenario_tests_async/test_events_assistant_without_middleware.py @@ -15,6 +15,7 @@ setup_mock_web_api_server_async, ) from tests.scenario_tests_async.test_events_assistant import ( + assert_target_called, channel_message_changed_event_body, channel_user_message_event_body, message_changed_event_body, @@ -23,7 +24,6 @@ user_message_event_body, user_message_event_body_with_assistant_thread, ) -from tests.scenario_tests_async.test_events_assistant import assert_target_called from tests.utils import remove_os_env_temporarily, restore_os_env @@ -195,13 +195,13 @@ async def handle_message_event( save_thread_context: AsyncSaveThreadContext, context: AsyncBoltContext, ): - assert context.thread_ts is not None + assert context.thread_ts is None assert say.thread_ts == context.thread_ts - assert set_status is not None - assert set_title is not None - assert set_suggested_prompts is not None - assert get_thread_context is not None - assert save_thread_context is not None + assert set_status is None + assert set_title is None + assert set_suggested_prompts is None + assert get_thread_context is None + assert save_thread_context is None called["value"] = True request = AsyncBoltRequest(body=message_changed_event_body, mode="socket_mode") @@ -224,13 +224,13 @@ async def handle_message_event( save_thread_context: AsyncSaveThreadContext, context: AsyncBoltContext, ): - assert context.thread_ts is not None + assert context.thread_ts is None assert say.thread_ts == context.thread_ts - assert set_status is not None - assert set_title is not None - assert set_suggested_prompts is not None - assert get_thread_context is not None - assert save_thread_context is not None + assert set_status is None + assert set_title is None + assert set_suggested_prompts is None + assert get_thread_context is None + assert save_thread_context is None called["value"] = True request = AsyncBoltRequest(body=channel_user_message_event_body, mode="socket_mode") @@ -253,13 +253,13 @@ async def handle_message_event( save_thread_context: AsyncSaveThreadContext, context: AsyncBoltContext, ): - assert context.thread_ts is not None + assert context.thread_ts is None assert say.thread_ts == context.thread_ts - assert set_status is not None - assert set_title is not None - assert set_suggested_prompts is not None - assert get_thread_context is not None - assert save_thread_context is not None + assert set_status is None + assert set_title is None + assert set_suggested_prompts is None + assert get_thread_context is None + assert save_thread_context is None called["value"] = True request = AsyncBoltRequest(body=channel_message_changed_event_body, mode="socket_mode")