266 lines
9.2 KiB
Python
266 lines
9.2 KiB
Python
"""Tests for plugin-registered Slack Block Kit action handlers.
|
|
|
|
Covers:
|
|
* ``PluginContext.register_slack_action_handler`` validation + queuing
|
|
* ``PluginManager.get_slack_action_handlers`` accessor
|
|
* ``SlackAdapter.connect`` wiring those handlers into the AsyncApp
|
|
* Defensive wrapping: a plugin handler that raises does NOT take down
|
|
the gateway and Slack still gets an ack.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Ensure the repo root is importable when this test runs directly
|
|
# ---------------------------------------------------------------------------
|
|
_repo = str(Path(__file__).resolve().parents[2])
|
|
if _repo not in sys.path:
|
|
sys.path.insert(0, _repo)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Mock slack-bolt so SlackAdapter can be imported even without the package
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _ensure_slack_mock() -> None:
|
|
if "slack_bolt" in sys.modules and hasattr(sys.modules["slack_bolt"], "__file__"):
|
|
return
|
|
slack_bolt = MagicMock()
|
|
slack_bolt.async_app.AsyncApp = MagicMock
|
|
slack_bolt.adapter.socket_mode.async_handler.AsyncSocketModeHandler = MagicMock
|
|
|
|
slack_sdk = MagicMock()
|
|
slack_sdk.web.async_client.AsyncWebClient = MagicMock
|
|
|
|
for name, mod in [
|
|
("slack_bolt", slack_bolt),
|
|
("slack_bolt.async_app", slack_bolt.async_app),
|
|
("slack_bolt.adapter", slack_bolt.adapter),
|
|
("slack_bolt.adapter.socket_mode", slack_bolt.adapter.socket_mode),
|
|
("slack_bolt.adapter.socket_mode.async_handler",
|
|
slack_bolt.adapter.socket_mode.async_handler),
|
|
("slack_sdk", slack_sdk),
|
|
("slack_sdk.web", slack_sdk.web),
|
|
("slack_sdk.web.async_client", slack_sdk.web.async_client),
|
|
]:
|
|
sys.modules.setdefault(name, mod)
|
|
sys.modules.setdefault("aiohttp", MagicMock())
|
|
|
|
|
|
_ensure_slack_mock()
|
|
|
|
import plugins.platforms.slack.adapter as _slack_mod # noqa: E402
|
|
_slack_mod.SLACK_AVAILABLE = True
|
|
|
|
from gateway.config import PlatformConfig # noqa: E402
|
|
from plugins.platforms.slack.adapter import SlackAdapter # noqa: E402
|
|
|
|
from hermes_cli.plugins import ( # noqa: E402
|
|
PluginContext,
|
|
PluginManager,
|
|
PluginManifest,
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# PluginContext.register_slack_action_handler — input validation + queuing
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _make_ctx(name: str = "test_plugin") -> tuple[PluginManager, PluginContext]:
|
|
"""Build a fresh PluginManager + PluginContext bound to it."""
|
|
mgr = PluginManager()
|
|
manifest = PluginManifest(
|
|
name=name,
|
|
version="0.1.0",
|
|
description="test",
|
|
)
|
|
ctx = PluginContext(manifest=manifest, manager=mgr)
|
|
return mgr, ctx
|
|
|
|
|
|
class TestRegisterSlackActionHandlerAPI:
|
|
"""Behaviour of ctx.register_slack_action_handler()."""
|
|
|
|
def test_string_action_id_is_queued(self):
|
|
mgr, ctx = _make_ctx()
|
|
|
|
async def cb(ack, body, action): # pragma: no cover - never called here
|
|
await ack()
|
|
|
|
ctx.register_slack_action_handler("inbox_sweep_approve", cb)
|
|
|
|
handlers = mgr.get_slack_action_handlers()
|
|
assert len(handlers) == 1
|
|
action_id, callback, plugin_name = handlers[0]
|
|
assert action_id == "inbox_sweep_approve"
|
|
assert callback is cb
|
|
assert plugin_name == "test_plugin"
|
|
|
|
def test_regex_action_id_is_accepted(self):
|
|
"""slack_bolt accepts re.Pattern matchers — so should the plugin API."""
|
|
import re as _re
|
|
mgr, ctx = _make_ctx()
|
|
|
|
async def cb(ack, body, action): # pragma: no cover
|
|
await ack()
|
|
|
|
pat = _re.compile(r"^inbox_sweep_.*$")
|
|
ctx.register_slack_action_handler(pat, cb)
|
|
handlers = mgr.get_slack_action_handlers()
|
|
assert handlers[0][0] is pat
|
|
|
|
def test_constraint_dict_action_id_is_accepted(self):
|
|
"""slack_bolt also accepts {"action_id": ..., "block_id": ...} dicts."""
|
|
mgr, ctx = _make_ctx()
|
|
|
|
async def cb(ack, body, action): # pragma: no cover
|
|
await ack()
|
|
|
|
constraint = {"action_id": "approve", "block_id": "row_3"}
|
|
ctx.register_slack_action_handler(constraint, cb)
|
|
handlers = mgr.get_slack_action_handlers()
|
|
assert handlers[0][0] == constraint
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# SlackAdapter.connect wires plugin-registered handlers into AsyncApp
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _connect_with_recording_app(
|
|
adapter: SlackAdapter,
|
|
*,
|
|
plugin_handlers: list,
|
|
) -> tuple[bool, list]:
|
|
"""Run adapter.connect() with mocks and return (result, registered_actions).
|
|
|
|
Captures every action_id passed to ``app.action()`` so tests can
|
|
assert that built-in handlers AND plugin-supplied handlers were
|
|
wired up.
|
|
"""
|
|
registered_actions: list = [] # list of (action_id, callback)
|
|
|
|
def mock_action(action_id):
|
|
def decorator(fn):
|
|
registered_actions.append((action_id, fn))
|
|
return fn
|
|
return decorator
|
|
|
|
def mock_event(_event_type):
|
|
def decorator(fn):
|
|
return fn
|
|
return decorator
|
|
|
|
def mock_command(_cmd):
|
|
def decorator(fn):
|
|
return fn
|
|
return decorator
|
|
|
|
mock_app = MagicMock()
|
|
mock_app.event = mock_event
|
|
mock_app.command = mock_command
|
|
mock_app.action = mock_action
|
|
mock_app.client = AsyncMock()
|
|
|
|
mock_web_client = AsyncMock()
|
|
mock_web_client.auth_test = AsyncMock(return_value={
|
|
"user_id": "U_BOT",
|
|
"user": "testbot",
|
|
"team_id": "T_FAKE",
|
|
"team": "FakeTeam",
|
|
})
|
|
|
|
fake_mgr = MagicMock()
|
|
fake_mgr.get_slack_action_handlers.return_value = plugin_handlers
|
|
|
|
with patch.object(_slack_mod, "AsyncApp", return_value=mock_app), \
|
|
patch.object(_slack_mod, "AsyncWebClient", return_value=mock_web_client), \
|
|
patch.object(_slack_mod, "AsyncSocketModeHandler", return_value=MagicMock()), \
|
|
patch.dict(os.environ, {"SLACK_APP_TOKEN": "xapp-fake"}), \
|
|
patch("gateway.status.acquire_scoped_lock", return_value=(True, None)), \
|
|
patch("gateway.status.release_scoped_lock"), \
|
|
patch("hermes_cli.plugins.get_plugin_manager", return_value=fake_mgr), \
|
|
patch("asyncio.create_task"):
|
|
result = asyncio.run(adapter.connect())
|
|
|
|
return result, registered_actions
|
|
|
|
|
|
class TestSlackAdapterPluginActionWiring:
|
|
"""connect() must register plugin-supplied action handlers on AsyncApp."""
|
|
|
|
|
|
def test_no_plugin_handlers_does_not_break_connect(self):
|
|
"""An empty plugin handler list is the common case — must be a no-op."""
|
|
config = PlatformConfig(enabled=True, token="xoxb-fake")
|
|
adapter = SlackAdapter(config)
|
|
|
|
result, registered = _connect_with_recording_app(
|
|
adapter, plugin_handlers=[],
|
|
)
|
|
assert result is True
|
|
# Built-ins still wired
|
|
action_ids = [aid for aid, _cb in registered]
|
|
assert "hermes_approve_once" in action_ids
|
|
|
|
|
|
def test_plugin_loader_failure_does_not_break_connect(self):
|
|
"""If get_plugin_manager() blows up, connect() must still succeed.
|
|
|
|
Defensive belt-and-suspenders: the gateway should not refuse to
|
|
start because the plugin layer is unhealthy.
|
|
"""
|
|
config = PlatformConfig(enabled=True, token="xoxb-fake")
|
|
adapter = SlackAdapter(config)
|
|
|
|
registered_actions: list = []
|
|
|
|
def mock_action(action_id):
|
|
def decorator(fn):
|
|
registered_actions.append((action_id, fn))
|
|
return fn
|
|
return decorator
|
|
|
|
def _noop(_):
|
|
def decorator(fn): return fn
|
|
return decorator
|
|
|
|
mock_app = MagicMock()
|
|
mock_app.event = _noop
|
|
mock_app.command = _noop
|
|
mock_app.action = mock_action
|
|
mock_app.client = AsyncMock()
|
|
|
|
mock_web_client = AsyncMock()
|
|
mock_web_client.auth_test = AsyncMock(return_value={
|
|
"user_id": "U_BOT",
|
|
"user": "testbot",
|
|
"team_id": "T_FAKE",
|
|
"team": "FakeTeam",
|
|
})
|
|
|
|
with patch.object(_slack_mod, "AsyncApp", return_value=mock_app), \
|
|
patch.object(_slack_mod, "AsyncWebClient", return_value=mock_web_client), \
|
|
patch.object(_slack_mod, "AsyncSocketModeHandler", return_value=MagicMock()), \
|
|
patch.dict(os.environ, {"SLACK_APP_TOKEN": "xapp-fake"}), \
|
|
patch("gateway.status.acquire_scoped_lock", return_value=(True, None)), \
|
|
patch("gateway.status.release_scoped_lock"), \
|
|
patch("hermes_cli.plugins.get_plugin_manager",
|
|
side_effect=RuntimeError("plugins broken")), \
|
|
patch("asyncio.create_task"):
|
|
result = asyncio.run(adapter.connect())
|
|
|
|
assert result is True
|
|
# Built-ins still wired even when plugin loader failed.
|
|
action_ids = [aid for aid, _cb in registered_actions]
|
|
assert "hermes_approve_once" in action_ids
|