Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
import asyncio
import sys
import unittest
from types import SimpleNamespace
from unittest.mock import patch
from config.v2_config import SlackConfig
from modules.im import slack as slack_module
from modules.im.base import InlineButton, InlineKeyboard, MessageContext
from modules.im.slack import SlackApiError, SlackBot
class _OfflineWebClient:
"""The Slack web client a bot builds here: no network, and it names the bot ``U_BOT``."""
def __init__(self, *args, **kwargs):
pass
async def auth_test(self):
return {"user_id": "U_BOT"}
# Module-scoped so it holds under pytest and under ``unittest.main()`` alike.
_offline_web_client = patch.object(slack_module, "AsyncWebClient", _OfflineWebClient)
def setUpModule():
_offline_web_client.start()
def tearDownModule():
_offline_web_client.stop()
class _ResponseLike:
def __init__(self, data):
self._data = data
def get(self, key, default=None):
return self._data.get(key, default)
class SlackDmMentionTests(unittest.IsolatedAsyncioTestCase):
async def test_add_reaction_maps_unicode_robot_to_slack_name(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
calls = []
class _WebClient:
async def reactions_add(self, **kwargs):
calls.append(kwargs)
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
ok = await slack.add_reaction(context, "1710000000.000010", "🤖")
self.assertTrue(ok)
self.assertEqual(calls[0]["name"], "robot_face")
async def test_add_reaction_maps_queued_ok_hand_to_slack_name(self):
# Regression: the queued 👌 reaction must map to the Slack short name
# "ok_hand"; sending the raw unicode returns invalid_name and the queued
# indicator silently never appears.
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
calls = []
class _WebClient:
async def reactions_add(self, **kwargs):
calls.append(kwargs)
async def reactions_remove(self, **kwargs):
calls.append(kwargs)
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
self.assertTrue(await slack.add_reaction(context, "1710000000.000010", "👌"))
self.assertTrue(await slack.remove_reaction(context, "1710000000.000010", "👌"))
self.assertEqual([c["name"] for c in calls], ["ok_hand", "ok_hand"])
async def test_add_reaction_warns_on_unmapped_unicode_emoji(self):
# Safeguard: an unmapped raw-unicode reaction emoji must log a WARNING so a
# future emoji that Slack would reject (invalid_name) is not lost silently.
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
class _WebClient:
async def reactions_add(self, **kwargs):
return None
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
with self.assertLogs("modules.im.slack", level="WARNING") as captured:
await slack.add_reaction(context, "1710000000.000010", "🎉")
self.assertTrue(any("no short-name mapping" in m for m in captured.output))
async def test_add_reaction_maps_eyes_to_slack_name(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
calls = []
class _WebClient:
async def reactions_add(self, **kwargs):
calls.append(kwargs)
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
self.assertTrue(await slack.add_reaction(context, "1710000000.000010", "👀"))
self.assertEqual(calls[0]["name"], "eyes")
async def test_send_message_does_not_set_unfurl_params_by_default(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000010"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
message_ts = await slack.send_message(context, "https://example.com", parse_mode="markdown")
self.assertEqual(message_ts, "1710000000.000010")
self.assertNotIn("unfurl_links", sent_payloads[0])
self.assertNotIn("unfurl_media", sent_payloads[0])
async def test_send_markdown_message_uses_native_markdown_block_with_buttons(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000020"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Continue", callback_data="quick_reply:Continue")]])
text = "| Col 1 | Col 2 |\n| ----- | ----- |\n| A | B |"
message_ts = await slack.send_markdown_message(context, text, keyboard=keyboard)
self.assertEqual(message_ts, "1710000000.000020")
# Notifications and screen readers get the top-level text, which Slack reads as mrkdwn.
self.assertEqual(sent_payloads[0]["text"], "*Col 1* | *Col 2*\nA | B")
self.assertEqual(sent_payloads[0]["blocks"][0], {"type": "markdown", "text": text})
self.assertEqual(sent_payloads[0]["blocks"][1]["type"], "actions")
self.assertEqual(sent_payloads[0]["blocks"][1]["elements"][0]["value"], "quick_reply:Continue")
async def test_send_markdown_message_falls_back_when_native_block_is_rejected(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
if len(sent_payloads) == 1:
raise SlackApiError("invalid blocks", response=_ResponseLike({"error": "invalid_blocks"}))
return {"ts": "1710000000.000021"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
text = "| Col 1 | Col 2 |\n| ----- | ----- |\n| A | B |"
message_ts = await slack.send_markdown_message(context, text)
self.assertEqual(message_ts, "1710000000.000021")
self.assertEqual(sent_payloads[0]["blocks"][0], {"type": "markdown", "text": text})
self.assertEqual(sent_payloads[1]["blocks"][0]["type"], "section")
self.assertEqual(sent_payloads[1]["blocks"][0]["text"]["type"], "mrkdwn")
async def test_send_markdown_message_long_button_fallback_preserves_reply_to(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000022"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Continue", callback_data="quick_reply:Continue")]])
text = "x" * 12001
message_ts = await slack.send_markdown_message(
context,
text,
keyboard=keyboard,
reply_to="1710000000.000001",
)
self.assertEqual(message_ts, "1710000000.000022")
self.assertGreater(len(sent_payloads), 1)
self.assertTrue(all(payload["thread_ts"] == "1710000000.000001" for payload in sent_payloads))
self.assertEqual(sent_payloads[-1]["blocks"][-1]["type"], "actions")
async def test_send_markdown_message_button_rejection_fallback_preserves_reply_to(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
if len(sent_payloads) == 1:
raise SlackApiError("invalid blocks", response=_ResponseLike({"error": "invalid_blocks"}))
return {"ts": "1710000000.000023"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Continue", callback_data="quick_reply:Continue")]])
message_ts = await slack.send_markdown_message(
context,
"markdown table",
keyboard=keyboard,
reply_to="1710000000.000001",
)
self.assertEqual(message_ts, "1710000000.000023")
self.assertEqual(sent_payloads[0]["thread_ts"], "1710000000.000001")
self.assertEqual(sent_payloads[1]["thread_ts"], "1710000000.000001")
self.assertEqual(sent_payloads[1]["blocks"][-1]["type"], "actions")
async def test_send_message_disables_link_unfurl_when_configured(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", disable_link_unfurl=True))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000011"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
message_ts = await slack.send_message(context, "https://example.com", parse_mode="markdown")
self.assertEqual(message_ts, "1710000000.000011")
self.assertIs(sent_payloads[0]["unfurl_links"], False)
self.assertIs(sent_payloads[0]["unfurl_media"], False)
async def test_send_dm_disables_link_unfurl_when_configured(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", disable_link_unfurl=True))
sent_payloads = []
class _WebClient:
async def conversations_open(self, users):
return {"ok": True, "channel": {"id": "D123"}}
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000012"}
slack.web_client = _WebClient()
message_ts = await slack.send_dm("U123", "https://example.com")
self.assertEqual(message_ts, "1710000000.000012")
self.assertEqual(sent_payloads[0]["channel"], "D123")
self.assertIs(sent_payloads[0]["unfurl_links"], False)
self.assertIs(sent_payloads[0]["unfurl_media"], False)
async def test_send_message_with_buttons_disables_link_unfurl_when_configured(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", disable_link_unfurl=True))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000013"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Open", callback_data="open")]])
message_ts = await slack.send_message_with_buttons(
context,
"https://example.com",
keyboard,
parse_mode="markdown",
)
self.assertEqual(message_ts, "1710000000.000013")
self.assertIs(sent_payloads[0]["unfurl_links"], False)
self.assertIs(sent_payloads[0]["unfurl_media"], False)
self.assertEqual(
sent_payloads[0]["blocks"][0]["text"]["text"],
"<https://example.com>",
)
self.assertIs(sent_payloads[0]["blocks"][0]["text"]["verbatim"], True)
async def test_send_message_with_buttons_linkifies_only_bare_urls_for_verbatim_blocks(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", disable_link_unfurl=True))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000014"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Open", callback_data="open")]])
text = (
"Open https://example.com/path?a=1&b=2.\n"
"Existing <https://example.org|Example>.\n"
"Mail <mailto:[email protected]|Visit https://status.example.com now>.\n"
"Date <!date^1392734382^{date_short}^https://date.example/|Feb 18>.\n"
"Comparison 1 < 2 https://compare.example.\n"
"Inline `https://code.example`.\n"
"```\nhttps://block.example\n```"
)
await slack.send_message_with_buttons(context, text, keyboard, parse_mode="markdown")
block_text = sent_payloads[0]["blocks"][0]["text"]["text"]
self.assertIn("<https://example.com/path?a=1&b=2>.", block_text)
self.assertIn("<https://example.org|Example>", block_text)
self.assertIn("<mailto:[email protected]|Visit https://status.example.com now>", block_text)
self.assertIn("<!date^1392734382^{date_short}^https://date.example/|Feb 18>", block_text)
self.assertIn("Comparison 1 < 2 <https://compare.example>.", block_text)
self.assertIn("`https://code.example`", block_text)
self.assertIn("```\nhttps://block.example\n```", block_text)
self.assertNotIn("<<https://example.org", block_text)
async def test_send_message_with_buttons_keeps_default_preview_behavior(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": "1710000000.000015"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Open", callback_data="open")]])
await slack.send_message_with_buttons(
context,
"https://example.com",
keyboard,
parse_mode="markdown",
)
self.assertEqual(sent_payloads[0]["blocks"][0]["text"]["text"], "https://example.com")
self.assertNotIn("unfurl_links", sent_payloads[0])
self.assertNotIn("unfurl_media", sent_payloads[0])
async def test_send_message_with_buttons_splits_when_linkified_text_exceeds_section_limit(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", disable_link_unfurl=True))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": f"1710000000.00001{len(sent_payloads)}"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Open", callback_data="open")]])
text = " ".join(["https://example.com/" + ("x" * 60) for _ in range(45)])
await slack.send_message_with_buttons(context, text, keyboard, parse_mode="markdown")
self.assertGreater(len(sent_payloads), 1)
final_payload = sent_payloads[-1]
self.assertLessEqual(len(final_payload["blocks"][0]["text"]["text"]), 3000)
self.assertEqual(final_payload["blocks"][1]["type"], "actions")
async def test_send_message_with_buttons_keeps_linkified_long_url_under_section_limit(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", disable_link_unfurl=True))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": f"1710000000.00002{len(sent_payloads)}"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="Open", callback_data="open")]])
long_url = "https://example.com/" + ("x" * 1500)
await slack.send_message_with_buttons(
context,
f"{long_url} tail",
keyboard,
parse_mode="markdown",
)
block_text = sent_payloads[-1]["blocks"][0]["text"]["text"]
self.assertIn(f"<{long_url}>", block_text)
self.assertLessEqual(len(block_text), 3000)
self.assertEqual(sent_payloads[-1]["blocks"][1]["type"], "actions")
async def test_linkify_skips_url_too_long_for_explicit_slack_link(self):
long_url = "https://example.com/" + ("x" * 2980)
text = SlackBot._linkify_bare_urls_for_verbatim_mrkdwn(long_url)
self.assertEqual(text, long_url)
self.assertLessEqual(len(text), 3000)
async def test_send_message_recovers_dm_channel_after_channel_not_found(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_channels = []
sent_thread_ts = []
class _WebClient:
def __init__(self):
self.fail_once = True
async def chat_postMessage(self, **kwargs):
sent_channels.append(kwargs["channel"])
sent_thread_ts.append(kwargs.get("thread_ts"))
if self.fail_once:
self.fail_once = False
raise sys.modules["slack_sdk.errors"].SlackApiError(
"channel missing",
response={"error": "channel_not_found"},
)
return {"ts": "1710000000.000001"}
async def conversations_open(self, users):
return {"ok": True, "channel": {"id": "D999"}}
slack.web_client = _WebClient()
context = MessageContext(
user_id="U123",
channel_id="D123",
thread_id="1710000000.000100",
platform_specific={"is_dm": True},
)
message_ts = await slack.send_message(context, "hello", parse_mode="markdown")
self.assertEqual(message_ts, "1710000000.000001")
self.assertEqual(sent_channels, ["D123", "D999"])
self.assertEqual(sent_thread_ts, ["1710000000.000100", None])
self.assertEqual(context.channel_id, "D999")
self.assertIsNone(context.thread_id)
async def test_send_message_with_buttons_recovers_dm_channel_after_channel_not_found(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_channels = []
sent_thread_ts = []
class _WebClient:
def __init__(self):
self.fail_once = True
async def chat_postMessage(self, **kwargs):
sent_channels.append(kwargs["channel"])
sent_thread_ts.append(kwargs.get("thread_ts"))
if self.fail_once:
self.fail_once = False
raise sys.modules["slack_sdk.errors"].SlackApiError(
"channel missing",
response={"error": "channel_not_found"},
)
return {"ts": "1710000000.000002"}
async def conversations_open(self, users):
return {"ok": True, "channel": {"id": "D999"}}
slack.web_client = _WebClient()
context = MessageContext(
user_id="U123",
channel_id="D123",
thread_id="1710000000.000100",
platform_specific={"is_dm": True},
)
keyboard = InlineKeyboard(buttons=[[InlineButton(text="One", callback_data="choose:1")]])
message_ts = await slack.send_message_with_buttons(context, "hello", keyboard, parse_mode="markdown")
self.assertEqual(message_ts, "1710000000.000002")
self.assertEqual(sent_channels, ["D123", "D999"])
self.assertEqual(sent_thread_ts, ["1710000000.000100", None])
self.assertEqual(context.channel_id, "D999")
self.assertIsNone(context.thread_id)
async def test_send_message_recovers_stale_dm_context_even_when_bound_channel_changed(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_channels = []
class _WebClient:
def __init__(self):
self.fail_once = True
async def chat_postMessage(self, **kwargs):
sent_channels.append(kwargs["channel"])
if self.fail_once:
self.fail_once = False
raise sys.modules["slack_sdk.errors"].SlackApiError(
"channel missing",
response={"error": "channel_not_found"},
)
return {"ts": "1710000000.000003"}
async def conversations_open(self, users):
assert users == ["U123"]
return {"ok": True, "channel": {"id": "D999"}}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="D999")
return None
class _SettingsManager:
def get_store(self):
return _Store()
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
context = MessageContext(
user_id="U123",
channel_id="D_OLD",
thread_id="1710000000.000100",
platform_specific={"is_dm": True},
)
message_ts = await slack.send_message(context, "hello", parse_mode="markdown")
self.assertEqual(message_ts, "1710000000.000003")
self.assertEqual(sent_channels, ["D_OLD", "D999"])
self.assertEqual(context.channel_id, "D999")
self.assertIsNone(context.thread_id)
async def test_send_message_with_buttons_splits_long_text_before_button_block(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
sent_payloads = []
class _WebClient:
async def chat_postMessage(self, **kwargs):
sent_payloads.append(kwargs)
return {"ts": f"1710000000.00000{len(sent_payloads)}"}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
keyboard = InlineKeyboard(buttons=[[InlineButton(text="One", callback_data="choose:1")]])
text = "\n\n".join([f"Paragraph {index} {'x' * 120}" for index in range(30)])
message_ts = await slack.send_message_with_buttons(context, text, keyboard, parse_mode="markdown")
self.assertEqual(message_ts, "1710000000.000002")
self.assertEqual(len(sent_payloads), 2)
self.assertEqual(sent_payloads[0]["text"] + sent_payloads[1]["text"], text)
self.assertTrue(all(len(payload["text"]) <= 3000 for payload in sent_payloads))
self.assertFalse(any(block["type"] == "actions" for block in sent_payloads[0].get("blocks", [])))
self.assertEqual(sent_payloads[1]["blocks"][0]["type"], "section")
self.assertEqual(sent_payloads[1]["blocks"][1]["type"], "actions")
async def test_remove_inline_keyboard_uses_visible_chunk_for_long_text(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
updates = []
class _WebClient:
async def chat_update(self, **kwargs):
updates.append(kwargs)
return {"ok": True}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
text = "\n\n".join([f"Paragraph {index} {'x' * 120}" for index in range(30)])
ok = await slack.remove_inline_keyboard(context, "1710000000.000002", text=text, parse_mode="markdown")
self.assertTrue(ok)
self.assertEqual(len(updates), 1)
self.assertLessEqual(len(updates[0]["text"]), 3000)
self.assertEqual(updates[0]["text"], slack._get_visible_text(text))
self.assertEqual(updates[0]["blocks"][0]["type"], "section")
def test_split_text_keeps_boundary_chunk_within_limit(self):
chunks = SlackBot._split_text("a" * 3000 + " " + "b", 3000)
self.assertEqual(chunks, ["a" * 3000, " b"])
self.assertTrue(all(len(chunk) <= 3000 for chunk in chunks))
async def test_get_user_info_prefers_normalized_profile_names(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
class _WebClient:
async def users_info(self, user):
return {
"user": {
"id": user,
"name": "cyh",
"real_name": "Alex Raw",
"profile": {
"display_name": "Alex Raw Display",
"display_name_normalized": "Alex",
"real_name_normalized": "Alex",
"email": "[email protected]",
},
}
}
slack.web_client = _WebClient()
user_info = await slack.get_user_info("U0E0FM3QT")
self.assertEqual(user_info["display_name"], "Alex")
self.assertEqual(user_info["real_name"], "Alex")
self.assertEqual(user_info["name"], "cyh")
async def test_dm_mention_only_falls_through_as_empty_message(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
async def _on_message(context, text):
received["channel_id"] = context.channel_id
received["thread_id"] = context.thread_id
received["text"] = text
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-mention-only",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D123",
"user": "U123",
"text": "<@U_BOT>",
"ts": "1710000000.000100",
},
}
await slack._handle_event(payload)
self.assertEqual(
received,
{
"channel_id": "D123",
"thread_id": "1710000000.000100",
"text": "",
},
)
async def test_dm_mention_with_text_preserves_raw_text_for_agent(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
async def _on_message(context, text):
received["text"] = text
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-mention-text",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D123",
"user": "U123",
"text": "<@U_BOT> hello",
"ts": "1710000000.000200",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "<@U_BOT> hello"})
async def test_dm_file_share_sets_the_separate_attachment_classification(self):
"""Scenario: MEMORY-IM-ATTACH-001."""
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
async def _on_message(context, text):
received.update(
text=text,
ordinary_text=context.is_original_human_text,
ordinary_attachment=context.is_original_human_attachment,
files=[file.name for file in context.files or ()],
)
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-file-share",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"subtype": "file_share",
"channel": "D123",
"channel_type": "im",
"user": "U123",
"text": "remember this receipt",
"ts": "1710000000.000201",
"files": [
{
"id": "F123",
"name": "receipt.pdf",
"mimetype": "application/pdf",
"size": 128,
"url_private_download": "https://files.slack.test/receipt.pdf",
}
],
"blocks": [
{
"type": "rich_text",
"elements": [
{
"type": "rich_text_section",
"elements": [
{"type": "text", "text": "remember this receipt"}
],
}
],
}
],
},
}
await slack._handle_event(payload)
self.assertEqual(
received,
{
"text": "remember this receipt",
"ordinary_text": False,
"ordinary_attachment": True,
"files": ["receipt.pdf"],
},
)
async def test_bound_user_message_from_mismatched_dm_channel_is_ignored(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {"called": False}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="D_REAL")
return None
def find_channel(self, channel_id, platform=None):
if channel_id == "C123":
return SimpleNamespace(enabled=True)
return None
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
class _WebClient:
async def conversations_open(self, users):
assert users == ["U123"]
return {"ok": True, "channel": {"id": "D_REAL"}}
async def _on_message(_context, _text):
received["called"] = True
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-mismatch",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D_OTHER",
"user": "U123",
"text": "hello",
"ts": "1710000000.000250",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_bound_user_message_repairs_missing_dm_channel_binding(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
updates = []
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="")
return None
def update_user_fields(self, user_id, *, platform=None, **values):
updates.append((user_id, values.get("dm_chat_id", ""), platform))
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
class _WebClient:
async def conversations_open(self, users):
assert users == ["U123"]
return {"ok": True, "channel": {"id": "D_REAL"}}
async def _on_message(_context, text):
received["text"] = text
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-repair-missing-binding",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D_REAL",
"user": "U123",
"text": "hello",
"ts": "1710000000.000255",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "hello"})
self.assertEqual(updates, [("U123", "D_REAL", "slack")])
async def test_bound_user_missing_dm_channel_still_ignores_wrong_dm(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {"called": False}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="")
return None
def update_user_fields(self, user_id, *, platform=None, **values):
return True
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
class _WebClient:
async def conversations_open(self, users):
assert users == ["U123"]
return {"ok": True, "channel": {"id": "D_REAL"}}
async def _on_message(_context, _text):
received["called"] = True
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-missing-binding-wrong-channel",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D_OTHER",
"user": "U123",
"text": "hello",
"ts": "1710000000.000257",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_bound_user_mismatched_dm_channel_lookup_error_falls_back_to_processing(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="D_STALE")
return None
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
class _WebClient:
async def conversations_open(self, users):
raise sys.modules["slack_sdk.errors"].SlackApiError(
"rate limited",
response={"error": "ratelimited"},
)
async def _on_message(_context, text):
received["text"] = text
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-lookup-error",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D_REAL",
"user": "U123",
"text": "hello after lookup error",
"ts": "1710000000.0002575",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "hello after lookup error"})
async def test_bound_user_mismatched_dm_channel_missing_lookup_result_falls_back_to_processing(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="D_STALE")
return None
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
class _WebClient:
async def conversations_open(self, users):
return {"ok": False, "error": "ratelimited"}
async def _on_message(_context, text):
received["text"] = text
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-lookup-none",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D_REAL",
"user": "U123",
"text": "hello after empty lookup",
"ts": "1710000000.0002576",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "hello after empty lookup"})
async def test_bound_user_channel_message_is_not_blocked_by_dm_guard(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="D_REAL")
return None
def find_channel(self, channel_id, platform=None):
if channel_id == "C123":
return SimpleNamespace(enabled=True)
return None
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
async def _on_message(_context, text):
received["text"] = text
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-bound-user-channel-message",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C123",
"user": "U123",
"text": "hello from channel",
"ts": "1710000000.000258",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "hello from channel"})
async def test_bound_user_message_from_recorded_dm_channel_still_processes(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
class _Store:
def maybe_reload(self):
return None
def get_user(self, user_id, platform=None):
if user_id == "U123":
return SimpleNamespace(dm_chat_id="D_REAL")
return None
def is_bound_user(self, user_id, platform=None):
return user_id == "U123"
class _SettingsManager:
def get_store(self):
return _Store()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
async def _on_message(_context, text):
received["text"] = text
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-match",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D_REAL",
"user": "U123",
"text": "hello",
"ts": "1710000000.000260",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "hello"})
async def test_channel_mention_still_waits_for_app_mention(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {"called": False}
async def _on_message(_context, _text):
received["called"] = True
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-channel-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C123",
"user": "U123",
"text": "<@U_BOT>",
"ts": "1710000000.000300",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_slack_connect_channel_mention_falls_back_to_message_event(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = {}
class _WebClient:
async def conversations_info(self, channel):
return _ResponseLike({"channel": {"id": channel, "is_ext_shared": True}})
async def _on_message(context, text):
received["text"] = text
received["thread_id"] = context.thread_id
received["bot_mention"] = (context.platform_specific or {}).get("bot_mention")
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-slack-connect-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> please help",
"ts": "1710000000.000350",
},
}
await slack._handle_event(payload)
self.assertEqual(
received,
{
"text": "<@U_BOT> please help",
"thread_id": "1710000000.000350",
"bot_mention": "<@U_BOT>",
},
)
async def test_slack_connect_mention_only_falls_back_as_empty_message(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = {}
class _WebClient:
async def conversations_info(self, channel):
return {"channel": {"id": channel, "is_ext_shared": True}}
async def _on_message(context, text):
received["text"] = text
received["thread_id"] = context.thread_id
received["control_text"] = (context.platform_specific or {}).get("control_text")
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-slack-connect-mention-only",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> \n",
"ts": "1710000000.000355",
},
}
await slack._handle_event(payload)
self.assertEqual(
received,
{
"text": "",
"thread_id": "1710000000.000355",
"control_text": "",
},
)
async def test_slack_connect_mid_text_mention_is_forwarded_raw_in_message_fallback(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = {}
class _WebClient:
async def conversations_info(self, channel):
return {"channel": {"id": channel, "is_ext_shared": True}}
async def _on_message(_context, text):
received["text"] = text
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-slack-connect-mid-text-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"user": "U123",
"text": "please <@U_BOT> help",
"ts": "1710000000.000355",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "please <@U_BOT> help"})
async def test_slack_connect_other_bot_mention_is_forwarded_raw(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = {}
class _WebClient:
async def conversations_info(self, channel):
return {"channel": {"id": channel, "is_ext_shared": True}}
async def _on_message(context, text):
received["user_id"] = context.user_id
received["text"] = text
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-slack-connect-other-bot-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"bot_id": "B_OTHER",
"bot_profile": {"user_id": "U_OTHER_BOT"},
"text": "handoff to <@U_BOT> please",
"ts": "1710000000.000356",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"user_id": "U_OTHER_BOT", "text": "handoff to <@U_BOT> please"})
async def test_own_bot_message_is_ignored_even_when_mentioned(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", app_id="A_SELF"))
received = {"called": False}
async def _on_message(_context, _text):
received["called"] = True
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-own-bot-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"bot_id": "B_SELF",
"bot_profile": {"user_id": "U_BOT", "app_id": "A_SELF"},
"text": "<@U_BOT> loop",
"ts": "1710000000.000357",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_own_bot_message_with_top_level_app_id_is_ignored(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", app_id="A_SELF"))
received = {"called": False}
async def _on_message(_context, _text):
received["called"] = True
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-own-bot-top-level-app",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"bot_id": "B_SELF",
"app_id": "A_SELF",
"text": "<@U_BOT> loop",
"ts": "1710000000.000358",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_own_bot_message_with_auth_test_bot_id_is_ignored_without_app_id(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {"called": False}
class _WebClient:
async def auth_test(self):
return {"user_id": "U_BOT", "bot_id": "B_SELF"}
async def _on_message(_context, _text):
received["called"] = True
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-own-bot-auth-bot-id",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"bot_id": "B_SELF",
"text": "<@U_BOT> loop",
"ts": "1710000000.000359",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_slack_connect_channel_mention_marks_thread_active(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
marked = []
class _WebClient:
async def conversations_info(self, channel):
return {"channel": {"id": channel, "is_ext_shared": True}}
class _Sessions:
def mark_thread_active(self, user_id, channel_id, thread_id):
marked.append((user_id, channel_id, thread_id))
class _SettingsManager:
sessions = _Sessions()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
async def _on_message(_context, _text):
return None
slack.web_client = _WebClient()
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-slack-connect-mark-thread",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> please help",
"ts": "1710000000.000360",
},
}
await slack._handle_event(payload)
self.assertEqual(marked, [("U123", "C_CONNECT", "1710000000.000360")])
async def test_active_thread_requires_fresh_mention_when_require_mention_enabled(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = []
class _Sessions:
def is_thread_active(self, _user_id, _channel_id, _thread_ts):
return True
def is_thread_active_for_user(self, _user_id, _channel_id, _thread_ts):
return False
class _SettingsManager:
sessions = _Sessions()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
async def _on_message(_context, text):
received.append(text)
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-active-thread-no-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C123",
"user": "U123",
"text": "@colleague take a look",
"ts": "1710000000.000361",
"thread_ts": "1710000000.000360",
},
}
await slack._handle_event(payload)
self.assertEqual(received, [])
async def test_scheduled_active_thread_still_bypasses_mention_requirement(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = []
class _Sessions:
def is_thread_active(self, _user_id, _channel_id, _thread_ts):
return True
def is_thread_active_for_user(self, user_id, channel_id, thread_ts):
return user_id == "scheduled" and channel_id == "C123" and thread_ts == "1710000000.000360"
class _SettingsManager:
sessions = _Sessions()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
async def _on_message(_context, text):
received.append(text)
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-scheduled-thread-no-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C123",
"user": "U123",
"text": "scheduled follow-up context",
"ts": "1710000000.000362",
"thread_ts": "1710000000.000360",
},
}
await slack._handle_event(payload)
self.assertEqual(received, ["scheduled follow-up context"])
async def test_socket_mode_events_ack_before_message_processing_finishes(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
started = asyncio.Event()
release = asyncio.Event()
received = []
acks = []
class _Client:
async def send_socket_mode_response(self, response):
acks.append(response)
async def _on_message(_context, text):
started.set()
await release.wait()
received.append(text)
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-ack-before-processing",
"team_id": "T1",
"event": {
"type": "message",
"channel": "D123",
"user": "U123",
"text": "hello",
"ts": "1710000000.000370",
},
}
await slack._handle_socket_mode_request(
_Client(),
SimpleNamespace(type="events_api", envelope_id="env-1", payload=payload),
)
self.assertEqual(len(acks), 1)
self.assertEqual(received, [])
await asyncio.wait_for(started.wait(), timeout=1)
release.set()
if slack._event_tasks:
await asyncio.gather(*list(slack._event_tasks))
self.assertEqual(received, ["hello"])
async def test_slack_event_dedup_uses_persistent_runtime_claim(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
claims = set()
calls = []
received = []
class _Sessions:
def try_record_runtime_event(self, record_type, record_key, payload=None, *, ttl_seconds=None):
calls.append((record_type, record_key, payload, ttl_seconds))
key = (record_type, record_key)
if key in claims:
return False
claims.add(key)
return True
class _SettingsManager:
sessions = _Sessions()
def get_require_mention(self, _channel_id, global_default=False):
return global_default
async def _on_message(_context, text):
received.append(text)
slack.set_settings_manager(_SettingsManager())
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-persistent-dedup",
"team_id": "T1",
"event": {
"type": "message",
"channel": "D123",
"user": "U123",
"text": "hello",
"ts": "1710000000.000371",
},
}
await slack._handle_event(payload)
await slack._handle_event(payload)
self.assertEqual(received, ["hello"])
self.assertEqual(calls[0][0], "slack_event")
self.assertEqual(calls[0][1], "T1:evt-persistent-dedup")
self.assertEqual(calls[0][3], 300)
async def test_async_close_drains_pending_event_tasks_before_closing_web_client(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
started = asyncio.Event()
release = asyncio.Event()
events = []
class _WebClient:
async def close(self):
events.append("web-close")
async def _handler():
events.append("handler-start")
started.set()
await release.wait()
events.append("handler-finish")
slack.web_client = _WebClient()
task = asyncio.create_task(_handler())
slack._event_tasks.add(task)
task.add_done_callback(slack._handle_event_task_done)
await asyncio.wait_for(started.wait(), timeout=1)
close_task = asyncio.create_task(slack._async_close())
await asyncio.sleep(0)
self.assertEqual(events, ["handler-start"])
release.set()
await asyncio.wait_for(close_task, timeout=1)
self.assertEqual(events, ["handler-start", "handler-finish", "web-close"])
self.assertEqual(slack._event_tasks, set())
async def test_async_close_cancels_event_tasks_after_drain_timeout(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
started = asyncio.Event()
canceled = asyncio.Event()
async def _handler():
started.set()
try:
await asyncio.Event().wait()
except asyncio.CancelledError:
canceled.set()
raise
slack._event_task_shutdown_drain_timeout = 0.01
task = asyncio.create_task(_handler())
slack._event_tasks.add(task)
task.add_done_callback(slack._handle_event_task_done)
await asyncio.wait_for(started.wait(), timeout=1)
await slack._async_close()
await asyncio.wait_for(canceled.wait(), timeout=1)
self.assertTrue(task.cancelled())
self.assertEqual(slack._event_tasks, set())
async def test_slack_connect_message_then_app_mention_is_handled_once(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = []
class _WebClient:
async def conversations_info(self, channel):
return {"channel": {"id": channel, "is_ext_shared": True}}
async def _on_message(_context, text):
received.append(text)
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
message_payload = {
"event_id": "evt-slack-connect-message-first",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> please help",
"ts": "1710000000.000370",
},
}
app_mention_payload = {
"event_id": "evt-slack-connect-app-mention-second",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "app_mention",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> please help",
"ts": "1710000000.000370",
},
}
await slack._handle_event(message_payload)
await slack._handle_event(app_mention_payload)
self.assertEqual(received, ["<@U_BOT> please help"])
async def test_slack_connect_app_mention_then_message_is_handled_once(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test", require_mention=True))
received = []
class _WebClient:
async def conversations_info(self, channel):
return {"channel": {"id": channel, "is_ext_shared": True}}
async def _on_message(_context, text):
received.append(text)
slack.web_client = _WebClient()
slack.register_callbacks(on_message=_on_message)
app_mention_payload = {
"event_id": "evt-slack-connect-app-mention-first",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "app_mention",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> please help",
"ts": "1710000000.000380",
},
}
message_payload = {
"event_id": "evt-slack-connect-message-second",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C_CONNECT",
"user": "U123",
"text": "<@U_BOT> please help",
"ts": "1710000000.000380",
},
}
await slack._handle_event(app_mention_payload)
await slack._handle_event(message_payload)
self.assertEqual(received, ["<@U_BOT> please help"])
async def test_dm_preserves_non_bot_mentions(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
async def _on_message(_context, text):
received["text"] = text
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-dm-mention-preserve-other",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "D123",
"user": "U123",
"text": "<@U_BOT> summarize what <@U_OTHER> said",
"ts": "1710000000.000400",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "<@U_BOT> summarize what <@U_OTHER> said"})
async def test_channel_message_with_other_mentions_is_not_skipped(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
async def _on_message(_context, text):
received["text"] = text
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-channel-other-mention",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C123",
"user": "U123",
"text": "please ask <@U_OTHER> to check",
"ts": "1710000000.000500",
},
}
await slack._handle_event(payload)
self.assertEqual(received, {"text": "please ask <@U_OTHER> to check"})
async def test_channel_message_with_bot_mention_mid_text_is_skipped(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {"called": False}
async def _on_message(_context, _text):
received["called"] = True
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-channel-bot-mention-middle",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "message",
"channel": "C123",
"user": "U123",
"text": "hello <@U_BOT> please help",
"ts": "1710000000.000550",
},
}
await slack._handle_event(payload)
self.assertFalse(received["called"])
async def test_app_mention_preserves_non_bot_mentions(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
received = {}
async def _on_message(context, text):
received["text"] = text
received["normalized_user_text"] = (context.platform_specific or {}).get(
"normalized_user_text"
)
slack.register_callbacks(on_message=_on_message)
payload = {
"event_id": "evt-app-mention-preserve-other",
"team_id": "T1",
"authorizations": [{"user_id": "U_BOT"}],
"event": {
"type": "app_mention",
"channel": "C123",
"user": "U123",
"text": "<@U_BOT> summarize what <@U_OTHER> said",
"ts": "1710000000.000600",
},
}
await slack._handle_event(payload)
self.assertEqual(
received,
{
"text": "<@U_BOT> summarize what <@U_OTHER> said",
"normalized_user_text": "summarize what <@U_OTHER> said",
},
)
class SlackReactionDmRecoveryTests(unittest.IsolatedAsyncioTestCase):
"""``reactions.add``/``remove`` reject a user id as ``channel``.
``chat.postMessage`` silently accepts one (it opens the DM for you), so a DM
context that carried the user id kept *sending* fine while every reaction ack
failed with ``channel_not_found`` and silently downgraded to an ack message.
"""
@staticmethod
def _slack_api_error(error: str):
return sys.modules["slack_sdk.errors"].SlackApiError(error, response={"error": error})
def _bot_with_store(self):
slack = SlackBot(SlackConfig(bot_token="xoxb-test"))
record = SimpleNamespace(dm_chat_id="")
updates = []
class _Store:
def get_user(self, user_id, platform=None):
return record
def update_user_fields(self, user_id, *, platform=None, **values):
updates.append((user_id, values["dm_chat_id"]))
slack.settings_manager = SimpleNamespace(get_store=lambda: _Store(), reload_from_disk=lambda: None)
return slack, record, updates
async def test_add_reaction_recovers_dm_channel_when_context_carries_user_id(self):
slack, record, updates = self._bot_with_store()
calls = []
class _WebClient:
async def reactions_add(self, **kwargs):
calls.append(kwargs["channel"])
if kwargs["channel"] != "D999":
raise SlackReactionDmRecoveryTests._slack_api_error("channel_not_found")
return {"ok": True}
async def conversations_open(self, users):
return {"ok": True, "channel": {"id": "D999"}}
slack.web_client = _WebClient()
# The broken shape: a DM whose channel_id was left as the user id.
context = MessageContext(user_id="U123", channel_id="U123", platform_specific={"is_dm": True})
ok = await slack.add_reaction(context, "1710000000.000010", "👀")
self.assertTrue(ok)
self.assertEqual(calls, ["U123", "D999"])
self.assertEqual(context.channel_id, "D999")
self.assertEqual(record.dm_chat_id, "D999")
self.assertEqual(updates, [("U123", "D999")])
async def test_add_reaction_treats_channel_equal_to_user_as_dm_without_is_dm_flag(self):
slack, _record, _updates = self._bot_with_store()
calls = []
class _WebClient:
async def reactions_add(self, **kwargs):
calls.append(kwargs["channel"])
if kwargs["channel"] != "D999":
raise SlackReactionDmRecoveryTests._slack_api_error("channel_not_found")
return {"ok": True}
async def conversations_open(self, users):
return {"ok": True, "channel": {"id": "D999"}}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="U123")
self.assertTrue(await slack.add_reaction(context, "1710000000.000010", "👀"))
self.assertEqual(calls, ["U123", "D999"])
async def test_add_reaction_does_not_recover_for_real_channel(self):
slack, _record, _updates = self._bot_with_store()
opened = []
class _WebClient:
async def reactions_add(self, **kwargs):
raise SlackReactionDmRecoveryTests._slack_api_error("channel_not_found")
async def conversations_open(self, users):
opened.append(users)
return {"ok": True, "channel": {"id": "D999"}}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="C123")
self.assertFalse(await slack.add_reaction(context, "1710000000.000010", "👀"))
self.assertEqual(opened, [])
self.assertEqual(context.channel_id, "C123")
async def test_remove_reaction_recovers_dm_channel(self):
slack, _record, _updates = self._bot_with_store()
calls = []
class _WebClient:
async def reactions_remove(self, **kwargs):
calls.append(kwargs["channel"])
if kwargs["channel"] != "D999":
raise SlackReactionDmRecoveryTests._slack_api_error("channel_not_found")
return {"ok": True}
async def conversations_open(self, users):
return {"ok": True, "channel": {"id": "D999"}}
slack.web_client = _WebClient()
context = MessageContext(user_id="U123", channel_id="U123", platform_specific={"is_dm": True})
self.assertTrue(await slack.remove_reaction(context, "1710000000.000010", "👌"))
self.assertEqual(calls, ["U123", "D999"])
self.assertEqual(context.channel_id, "D999")
if __name__ == "__main__":
unittest.main()