105 lines
4.3 KiB
Python
105 lines
4.3 KiB
Python
import json
|
|
import signal
|
|
import unittest
|
|
from urllib.error import HTTPError
|
|
from unittest.mock import Mock, patch
|
|
|
|
from fgai.graylog_mcp import GraylogMcpClient, _hard_timeout
|
|
|
|
|
|
class _Response:
|
|
def __init__(self, body: dict[str, object], session: str = "session-1") -> None:
|
|
self.body = body
|
|
self.headers = {"Mcp-Session-Id": session}
|
|
|
|
def read(self) -> bytes:
|
|
return json.dumps(self.body).encode("utf-8")
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *_args):
|
|
return False
|
|
|
|
|
|
class GraylogMcpTests(unittest.TestCase):
|
|
def test_accepts_raw_or_copied_basic_credentials(self):
|
|
raw = GraylogMcpClient("http://graylog/api/mcp", "raw-token")._authorization_header()
|
|
encoded = raw.removeprefix("Basic ")
|
|
self.assertEqual(GraylogMcpClient("http://graylog/api/mcp", encoded)._authorization_header(), raw)
|
|
self.assertEqual(GraylogMcpClient("http://graylog/api/mcp", raw)._authorization_header(), raw)
|
|
|
|
def test_probe_initializes_and_lists_tools(self):
|
|
responses = iter([
|
|
_Response({"result": {"serverInfo": {"version": "7.1.6"}}}),
|
|
_Response({}),
|
|
_Response({"result": {"tools": [{"name": "search_messages"}, {"name": "aggregate_messages"}]}}),
|
|
])
|
|
with patch("fgai.graylog_mcp.GraylogMcpClient._open", side_effect=responses):
|
|
status = GraylogMcpClient("http://graylog/api/mcp", "raw-token").probe()
|
|
self.assertEqual(status["status"], "connected")
|
|
self.assertIn("search_messages", status["tools"])
|
|
|
|
def test_probe_keeps_existing_session_unless_forced(self):
|
|
responses = iter([
|
|
_Response({"result": {"serverInfo": {"version": "7.1.6"}}}, session="session-1"),
|
|
_Response({}, session="session-1"),
|
|
_Response({"result": {"tools": []}}, session="session-1"),
|
|
])
|
|
client = GraylogMcpClient("http://graylog/api/mcp", "raw-token")
|
|
client.session_id = "existing-session"
|
|
|
|
with patch("fgai.graylog_mcp.GraylogMcpClient._open", side_effect=responses):
|
|
client.probe()
|
|
|
|
self.assertEqual(client.session_id, "session-1")
|
|
|
|
def test_call_tool_reinitializes_after_stale_session_error(self):
|
|
responses = iter([
|
|
HTTPError("http://graylog/api/mcp", 404, "stale session", {}, None),
|
|
_Response({"result": {"serverInfo": {"version": "7.1.6"}}}, session="session-2"),
|
|
_Response({}, session="session-2"),
|
|
_Response({"result": {"tools": [{"name": "search_messages"}]}}, session="session-2"),
|
|
_Response({"result": {"content": []}}, session="session-2"),
|
|
])
|
|
client = GraylogMcpClient("http://graylog/api/mcp", "raw-token")
|
|
client.session_id = "old-session"
|
|
|
|
with patch("fgai.graylog_mcp.GraylogMcpClient._open", side_effect=responses):
|
|
result = client.call_tool("search_messages", {"query": "*"})
|
|
|
|
self.assertEqual(result["result"]["content"], [])
|
|
self.assertEqual(client.session_id, "session-2")
|
|
|
|
def test_default_open_bypasses_environment_proxies(self):
|
|
client = GraylogMcpClient("http://graylog/api/mcp", "raw-token")
|
|
req = object()
|
|
opener = Mock()
|
|
opener.open.return_value = "response"
|
|
|
|
with patch("fgai.graylog_mcp.request.build_opener", return_value=opener) as build_opener:
|
|
result = client._open(req, None)
|
|
|
|
self.assertEqual(result, "response")
|
|
self.assertEqual(opener.open.call_args.kwargs["timeout"], 15)
|
|
self.assertEqual(build_opener.call_args.args[0].proxies, {})
|
|
|
|
def test_hard_timeout_preserves_outer_timer_remaining_time(self):
|
|
previous_handler = signal.getsignal(signal.SIGALRM)
|
|
previous_timer = signal.getitimer(signal.ITIMER_REAL)
|
|
try:
|
|
signal.setitimer(signal.ITIMER_REAL, 20)
|
|
with patch("fgai.graylog_mcp.time.monotonic", side_effect=[100.0, 103.0]):
|
|
with _hard_timeout(5):
|
|
pass
|
|
remaining = signal.getitimer(signal.ITIMER_REAL)[0]
|
|
self.assertGreater(remaining, 16)
|
|
self.assertLessEqual(remaining, 17.5)
|
|
finally:
|
|
signal.setitimer(signal.ITIMER_REAL, previous_timer[0], previous_timer[1])
|
|
signal.signal(signal.SIGALRM, previous_handler)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|