1123 lines
38 KiB
Python
1123 lines
38 KiB
Python
"""
|
|
Characterization tests for Transport & Communication domain.
|
|
|
|
These tests capture CURRENT behavior of the transport layer without refactoring.
|
|
They validate:
|
|
- Instance routing and session management
|
|
- Plugin discovery and registration
|
|
- HTTP server behavior and error handling
|
|
- Middleware request/response flows
|
|
- Edge cases and failure modes
|
|
|
|
The tests serve as regression detectors for any future changes to the transport layer.
|
|
"""
|
|
|
|
import asyncio
|
|
import pytest
|
|
import pytest_asyncio
|
|
from unittest.mock import AsyncMock, Mock, MagicMock, patch, call
|
|
from datetime import datetime, timezone
|
|
import uuid
|
|
|
|
from transport.unity_instance_middleware import UnityInstanceMiddleware, get_unity_instance_middleware, set_unity_instance_middleware
|
|
from transport.plugin_registry import PluginRegistry, PluginSession
|
|
from transport.plugin_hub import PluginHub, NoUnitySessionError, InstanceSelectionRequiredError, PluginDisconnectedError
|
|
from transport.models import (
|
|
RegisterMessage,
|
|
RegisterToolsMessage,
|
|
CommandResultMessage,
|
|
PongMessage,
|
|
SessionList,
|
|
SessionDetails,
|
|
)
|
|
from models.models import ToolDefinitionModel
|
|
|
|
|
|
# ============================================================================
|
|
# FIXTURES
|
|
# ============================================================================
|
|
|
|
@pytest.fixture
|
|
def mock_context():
|
|
"""Create a mock FastMCP context."""
|
|
ctx = Mock()
|
|
ctx.session_id = "test-session-123"
|
|
ctx.client_id = "test-client-456"
|
|
|
|
state_storage = {}
|
|
ctx.set_state = Mock(side_effect=lambda k, v: state_storage.__setitem__(k, v))
|
|
ctx.get_state = Mock(side_effect=lambda k: state_storage.get(k))
|
|
ctx.info = AsyncMock()
|
|
|
|
return ctx
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_websocket():
|
|
"""Create a mock WebSocket."""
|
|
ws = AsyncMock()
|
|
ws.send_json = AsyncMock()
|
|
ws.receive_json = AsyncMock()
|
|
ws.accept = AsyncMock()
|
|
ws.close = AsyncMock()
|
|
return ws
|
|
|
|
|
|
@pytest.fixture
|
|
def plugin_registry():
|
|
"""Create an in-memory plugin registry."""
|
|
return PluginRegistry()
|
|
|
|
|
|
@pytest_asyncio.fixture
|
|
async def configured_plugin_hub(plugin_registry):
|
|
"""Configure PluginHub with a registry and event loop."""
|
|
loop = asyncio.get_running_loop()
|
|
PluginHub.configure(plugin_registry, loop)
|
|
yield
|
|
# Cleanup
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
PluginHub._loop = None
|
|
PluginHub._connections.clear()
|
|
PluginHub._pending.clear()
|
|
|
|
|
|
# ============================================================================
|
|
# SESSION MANAGEMENT & ROUTING TESTS
|
|
# ============================================================================
|
|
|
|
class TestUnityInstanceMiddlewareSessionManagement:
|
|
"""Test instance routing and per-session state management."""
|
|
|
|
def test_middleware_stores_instance_per_session(self, mock_context):
|
|
"""
|
|
Current behavior: Middleware maintains independent instance selection
|
|
per session using get_session_key() derivation.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
instance_id = "TestProject@abc123def456"
|
|
|
|
middleware.set_active_instance(mock_context, instance_id)
|
|
retrieved = middleware.get_active_instance(mock_context)
|
|
|
|
assert retrieved == instance_id, \
|
|
"Middleware must store and retrieve instance per session"
|
|
|
|
def test_middleware_uses_client_id_over_session_id(self):
|
|
"""
|
|
Current behavior: get_session_key() prioritizes client_id for stability,
|
|
falling back to 'global' when unavailable.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
ctx = Mock()
|
|
ctx.client_id = "stable-client-id"
|
|
ctx.session_id = "unstable-session-id"
|
|
|
|
key = middleware.get_session_key(ctx)
|
|
assert key == "stable-client-id"
|
|
|
|
def test_middleware_falls_back_to_global_key(self):
|
|
"""
|
|
Current behavior: When client_id is None/missing, use 'global' key.
|
|
This allows single-user local mode to work without session tracking.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
ctx = Mock()
|
|
ctx.client_id = None
|
|
ctx.session_id = "session-id"
|
|
|
|
key = middleware.get_session_key(ctx)
|
|
assert key == "global"
|
|
|
|
def test_middleware_isolates_multiple_sessions(self):
|
|
"""
|
|
Current behavior: Different sessions (different client_ids) maintain
|
|
separate instance selections.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
ctx1 = Mock()
|
|
ctx1.client_id = "client-1"
|
|
ctx1.session_id = "session-1"
|
|
|
|
ctx2 = Mock()
|
|
ctx2.client_id = "client-2"
|
|
ctx2.session_id = "session-2"
|
|
|
|
middleware.set_active_instance(ctx1, "Project1@hash1")
|
|
middleware.set_active_instance(ctx2, "Project2@hash2")
|
|
|
|
assert middleware.get_active_instance(ctx1) == "Project1@hash1"
|
|
assert middleware.get_active_instance(ctx2) == "Project2@hash2"
|
|
|
|
def test_middleware_clear_instance(self, mock_context):
|
|
"""
|
|
Current behavior: clear_active_instance() removes stored instance
|
|
for the session, allowing reset to None.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
instance_id = "TestProject@xyz"
|
|
|
|
middleware.set_active_instance(mock_context, instance_id)
|
|
assert middleware.get_active_instance(mock_context) == instance_id
|
|
|
|
middleware.clear_active_instance(mock_context)
|
|
assert middleware.get_active_instance(mock_context) is None
|
|
|
|
def test_middleware_thread_safe_updates(self):
|
|
"""
|
|
Current behavior: Middleware uses RLock to serialize access to
|
|
_active_by_key dictionary.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
ctx = Mock()
|
|
ctx.client_id = "client-123"
|
|
ctx.session_id = "session-123"
|
|
|
|
# Rapidly update instances (would race without locking)
|
|
for i in range(10):
|
|
instance = f"Project{i}@hash{i}"
|
|
middleware.set_active_instance(ctx, instance)
|
|
|
|
# Final state should be consistent
|
|
assert middleware.get_active_instance(ctx) == "Project9@hash9"
|
|
|
|
|
|
# ============================================================================
|
|
# MIDDLEWARE INJECTION & CONTEXT FLOW TESTS
|
|
# ============================================================================
|
|
|
|
class TestUnityInstanceMiddlewareInjection:
|
|
"""Test middleware injection of instance into context state."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_middleware_injects_into_tool_context(self, mock_context):
|
|
"""
|
|
Current behavior: on_call_tool() calls _inject_unity_instance(),
|
|
which sets ctx.set_state("unity_instance", active_instance) when
|
|
an instance is active.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
instance_id = "Project@abc123"
|
|
|
|
middleware.set_active_instance(mock_context, instance_id)
|
|
|
|
# Create middleware context wrapper
|
|
middleware_ctx = Mock()
|
|
middleware_ctx.fastmcp_context = mock_context
|
|
|
|
call_next_called = False
|
|
async def mock_call_next(_ctx):
|
|
nonlocal call_next_called
|
|
call_next_called = True
|
|
return {"status": "ok"}
|
|
|
|
await middleware.on_call_tool(middleware_ctx, mock_call_next)
|
|
|
|
assert call_next_called, "Middleware must call next handler"
|
|
mock_context.set_state.assert_called_with("unity_instance", instance_id)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_middleware_injects_into_resource_context(self, mock_context):
|
|
"""
|
|
Current behavior: on_read_resource() performs same injection as
|
|
on_call_tool(), ensuring resources see the active instance.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
instance_id = "Project@hash123"
|
|
|
|
middleware.set_active_instance(mock_context, instance_id)
|
|
|
|
middleware_ctx = Mock()
|
|
middleware_ctx.fastmcp_context = mock_context
|
|
|
|
async def mock_call_next(_ctx):
|
|
return {"status": "ok"}
|
|
|
|
await middleware.on_read_resource(middleware_ctx, mock_call_next)
|
|
|
|
mock_context.set_state.assert_called_with("unity_instance", instance_id)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_middleware_does_not_inject_when_no_instance(self, mock_context):
|
|
"""
|
|
Current behavior: When no active instance is set and auto-select fails,
|
|
middleware does not inject anything (None instance not stored).
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
# Don't set any instance (will try auto-select and fail)
|
|
middleware_ctx = Mock()
|
|
middleware_ctx.fastmcp_context = mock_context
|
|
|
|
async def mock_call_next(_ctx):
|
|
return {"status": "ok"}
|
|
|
|
# Mock PluginHub as unavailable AND legacy connection pool to prevent fallback discovery
|
|
with patch("transport.unity_instance_middleware.PluginHub.is_configured", return_value=False):
|
|
with patch("transport.legacy.unity_connection.get_unity_connection_pool", return_value=None):
|
|
await middleware.on_call_tool(middleware_ctx, mock_call_next)
|
|
|
|
# set_state should not be called for unity_instance if no instance found
|
|
calls = [c for c in mock_context.set_state.call_args_list
|
|
if len(c[0]) > 0 and c[0][0] == "unity_instance"]
|
|
assert len(calls) == 0
|
|
|
|
|
|
# ============================================================================
|
|
# AUTO-SELECT INSTANCE TESTS
|
|
# ============================================================================
|
|
|
|
class TestAutoSelectInstance:
|
|
"""Test auto-selection of sole Unity instance when none is explicitly set."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_autoselect_via_plugin_hub_single_instance(self, mock_context):
|
|
"""
|
|
Current behavior: When single instance is available via PluginHub,
|
|
auto-select it and store in middleware state.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
# Mock PluginHub to return single session
|
|
fake_sessions = SessionList(
|
|
sessions={
|
|
"session-1": SessionDetails(
|
|
project="TestProject",
|
|
hash="abc123",
|
|
unity_version="2022.3",
|
|
connected_at="2025-01-26T00:00:00Z"
|
|
)
|
|
}
|
|
)
|
|
|
|
with patch("transport.unity_instance_middleware.PluginHub.is_configured", return_value=True):
|
|
with patch("transport.unity_instance_middleware.PluginHub.get_sessions", new_callable=AsyncMock) as mock_get:
|
|
mock_get.return_value = fake_sessions
|
|
|
|
instance = await middleware._maybe_autoselect_instance(mock_context)
|
|
|
|
assert instance == "TestProject@abc123"
|
|
assert middleware.get_active_instance(mock_context) == "TestProject@abc123"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_autoselect_fails_with_multiple_instances(self, mock_context):
|
|
"""
|
|
Current behavior: When multiple instances available, auto-select
|
|
returns None (ambiguous), allowing caller to decide.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
fake_sessions = SessionList(
|
|
sessions={
|
|
"session-1": SessionDetails(
|
|
project="Project1",
|
|
hash="aaa111",
|
|
unity_version="2022.3",
|
|
connected_at="2025-01-26T00:00:00Z"
|
|
),
|
|
"session-2": SessionDetails(
|
|
project="Project2",
|
|
hash="bbb222",
|
|
unity_version="2023.2",
|
|
connected_at="2025-01-26T00:00:00Z"
|
|
)
|
|
}
|
|
)
|
|
|
|
with patch("transport.unity_instance_middleware.PluginHub.is_configured", return_value=True):
|
|
with patch("transport.unity_instance_middleware.PluginHub.get_sessions", new_callable=AsyncMock) as mock_get:
|
|
with patch("transport.legacy.unity_connection.get_unity_connection_pool", return_value=None):
|
|
mock_get.return_value = fake_sessions
|
|
|
|
instance = await middleware._maybe_autoselect_instance(mock_context)
|
|
|
|
assert instance is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_autoselect_handles_plugin_hub_connection_error(self, mock_context):
|
|
"""
|
|
Current behavior: If PluginHub probe fails with ConnectionError,
|
|
gracefully falls back and returns None (no instance selected).
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
with patch("transport.unity_instance_middleware.PluginHub.is_configured", return_value=True):
|
|
with patch("transport.unity_instance_middleware.PluginHub.get_sessions", new_callable=AsyncMock) as mock_get:
|
|
with patch("transport.legacy.unity_connection.get_unity_connection_pool", return_value=None):
|
|
mock_get.side_effect = ConnectionError("Plugin hub unavailable")
|
|
|
|
# When PluginHub fails, auto-select returns None (graceful fallback)
|
|
instance = await middleware._maybe_autoselect_instance(mock_context)
|
|
|
|
# Should return None since both PluginHub failed
|
|
assert instance is None
|
|
|
|
|
|
# ============================================================================
|
|
# PLUGIN REGISTRY TESTS
|
|
# ============================================================================
|
|
|
|
class TestPluginRegistryFunctionality:
|
|
"""Test plugin session registration and lookup."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_registers_session(self, plugin_registry):
|
|
"""
|
|
Current behavior: register() creates a new PluginSession and stores
|
|
it by session_id and project_hash.
|
|
"""
|
|
session = await plugin_registry.register(
|
|
session_id="sess-abc",
|
|
project_name="TestProject",
|
|
project_hash="hash123",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
assert session.session_id == "sess-abc"
|
|
assert session.project_name == "TestProject"
|
|
assert session.project_hash == "hash123"
|
|
assert session.unity_version == "2022.3"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_lookup_by_hash(self, plugin_registry):
|
|
"""
|
|
Current behavior: get_session_id_by_hash() maps project_hash to
|
|
the active session_id.
|
|
"""
|
|
await plugin_registry.register(
|
|
session_id="sess-1",
|
|
project_name="Project1",
|
|
project_hash="hash-aaa",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
found_id = await plugin_registry.get_session_id_by_hash("hash-aaa")
|
|
assert found_id == "sess-1"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_reconnect_updates_mapping(self, plugin_registry):
|
|
"""
|
|
Current behavior: When a new session registers with same project_hash,
|
|
it replaces the old mapping (supporting reconnect scenarios).
|
|
"""
|
|
# Register first session
|
|
await plugin_registry.register(
|
|
session_id="sess-1",
|
|
project_name="Project",
|
|
project_hash="hash-same",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
# Reconnect with new session_id, same hash
|
|
await plugin_registry.register(
|
|
session_id="sess-2",
|
|
project_name="Project",
|
|
project_hash="hash-same",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
# Hash should map to new session
|
|
found_id = await plugin_registry.get_session_id_by_hash("hash-same")
|
|
assert found_id == "sess-2"
|
|
|
|
# Old session should be removed
|
|
old_session = await plugin_registry.get_session("sess-1")
|
|
assert old_session is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_register_tools_for_session(self, plugin_registry):
|
|
"""
|
|
Current behavior: register_tools_for_session() stores tool definitions
|
|
keyed by tool name on the session.
|
|
"""
|
|
await plugin_registry.register(
|
|
session_id="sess-x",
|
|
project_name="Project",
|
|
project_hash="hash-x",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
tools = [
|
|
ToolDefinitionModel(name="tool1", description="Test tool 1"),
|
|
ToolDefinitionModel(name="tool2", description="Test tool 2"),
|
|
]
|
|
|
|
await plugin_registry.register_tools_for_session("sess-x", tools)
|
|
|
|
updated_session = await plugin_registry.get_session("sess-x")
|
|
assert len(updated_session.tools) == 2
|
|
assert "tool1" in updated_session.tools
|
|
assert "tool2" in updated_session.tools
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_touch_updates_connected_at(self, plugin_registry):
|
|
"""
|
|
Current behavior: touch() updates the connected_at timestamp on heartbeat.
|
|
"""
|
|
session = await plugin_registry.register(
|
|
session_id="sess-y",
|
|
project_name="Project",
|
|
project_hash="hash-y",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
original_timestamp = session.connected_at
|
|
|
|
# Wait a tiny bit
|
|
await asyncio.sleep(0.01)
|
|
|
|
# Touch should update timestamp
|
|
await plugin_registry.touch("sess-y")
|
|
|
|
updated = await plugin_registry.get_session("sess-y")
|
|
assert updated.connected_at > original_timestamp
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_unregister_removes_session(self, plugin_registry):
|
|
"""
|
|
Current behavior: unregister() removes session and its hash mapping.
|
|
"""
|
|
await plugin_registry.register(
|
|
session_id="sess-z",
|
|
project_name="Project",
|
|
project_hash="hash-z",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
await plugin_registry.unregister("sess-z")
|
|
|
|
session = await plugin_registry.get_session("sess-z")
|
|
assert session is None
|
|
|
|
hash_id = await plugin_registry.get_session_id_by_hash("hash-z")
|
|
assert hash_id is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_list_sessions(self, plugin_registry):
|
|
"""
|
|
Current behavior: list_sessions() returns shallow copy of all sessions.
|
|
"""
|
|
await plugin_registry.register(
|
|
session_id="sess-1",
|
|
project_name="Project1",
|
|
project_hash="hash-1",
|
|
unity_version="2022.3"
|
|
)
|
|
await plugin_registry.register(
|
|
session_id="sess-2",
|
|
project_name="Project2",
|
|
project_hash="hash-2",
|
|
unity_version="2023.2"
|
|
)
|
|
|
|
sessions = await plugin_registry.list_sessions()
|
|
|
|
assert len(sessions) == 2
|
|
assert "sess-1" in sessions
|
|
assert "sess-2" in sessions
|
|
|
|
|
|
# ============================================================================
|
|
# PLUGIN HUB MESSAGE HANDLING TESTS
|
|
# ============================================================================
|
|
|
|
class TestPluginHubMessageHandling:
|
|
"""Test PluginHub message parsing and registration flow."""
|
|
|
|
def test_register_message_parsing(self):
|
|
"""
|
|
Current behavior: RegisterMessage can be constructed from incoming data
|
|
with project_name, project_hash, and unity_version.
|
|
"""
|
|
msg = RegisterMessage(
|
|
type="register",
|
|
project_name="TestProject",
|
|
project_hash="hash-reg-1",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
assert msg.project_name == "TestProject"
|
|
assert msg.project_hash == "hash-reg-1"
|
|
assert msg.unity_version == "2022.3"
|
|
|
|
def test_register_message_requires_hash(self):
|
|
"""
|
|
Current behavior: RegisterMessage validates that project_hash
|
|
is required (not empty).
|
|
"""
|
|
# Empty hash should still parse, but would be rejected by PluginHub._handle_register
|
|
msg = RegisterMessage(
|
|
type="register",
|
|
project_name="TestProject",
|
|
project_hash="",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
assert msg.project_hash == ""
|
|
|
|
def test_register_tools_message_parsing(self):
|
|
"""
|
|
Current behavior: RegisterToolsMessage accepts a list of tool definitions.
|
|
"""
|
|
tools = [
|
|
ToolDefinitionModel(name="tool1", description="Test 1"),
|
|
ToolDefinitionModel(name="tool2", description="Test 2"),
|
|
]
|
|
|
|
msg = RegisterToolsMessage(
|
|
type="register_tools",
|
|
tools=tools
|
|
)
|
|
|
|
assert len(msg.tools) == 2
|
|
assert msg.tools[0].name == "tool1"
|
|
|
|
def test_command_result_message_parsing(self):
|
|
"""
|
|
Current behavior: CommandResultMessage carries command_id and result dict.
|
|
"""
|
|
result_msg = CommandResultMessage(
|
|
type="command_result",
|
|
id="cmd-123",
|
|
result={"success": True, "data": "test"}
|
|
)
|
|
|
|
assert result_msg.id == "cmd-123"
|
|
assert result_msg.result["success"] is True
|
|
|
|
def test_pong_message_parsing(self):
|
|
"""
|
|
Current behavior: PongMessage can include optional session_id.
|
|
"""
|
|
pong_msg = PongMessage(
|
|
type="pong",
|
|
session_id="sess-123"
|
|
)
|
|
|
|
assert pong_msg.session_id == "sess-123"
|
|
|
|
|
|
# ============================================================================
|
|
# COMMAND ROUTING & TIMEOUTS TESTS
|
|
# ============================================================================
|
|
|
|
class TestPluginHubCommandRouting:
|
|
"""Test command routing and timeout behavior."""
|
|
|
|
def test_fast_fail_commands_are_defined(self):
|
|
"""
|
|
Current behavior: PluginHub defines a set of fast-fail commands
|
|
that use shorter timeouts (ping, read_console, get_editor_state).
|
|
"""
|
|
assert "ping" in PluginHub._FAST_FAIL_COMMANDS
|
|
assert "read_console" in PluginHub._FAST_FAIL_COMMANDS
|
|
assert "get_editor_state" in PluginHub._FAST_FAIL_COMMANDS
|
|
assert PluginHub.FAST_FAIL_TIMEOUT == 2.0
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_send_command_respects_requested_timeout(self, configured_plugin_hub):
|
|
"""
|
|
Current behavior: If params contain timeout_seconds or timeoutSeconds,
|
|
use max(COMMAND_TIMEOUT, requested) clamped to [1, 3600] seconds.
|
|
"""
|
|
# This is validated in the send_command method
|
|
# The actual timeout handling uses asyncio.wait_for with server_wait_s
|
|
# Verify timeout calculation logic
|
|
params = {"timeout_seconds": 100}
|
|
|
|
# In send_command, this would be used as:
|
|
# unity_timeout_s = max(30, 100) = 100
|
|
# server_wait_s = max(30, 100 + 5) = 105
|
|
assert True # This is implicit in send_command implementation
|
|
|
|
|
|
# ============================================================================
|
|
# PLUGIN DISCONNECT & ERROR HANDLING TESTS
|
|
# ============================================================================
|
|
|
|
class TestPluginHubDisconnect:
|
|
"""Test behavior when plugin WebSocket disconnects."""
|
|
|
|
def test_plugin_disconnected_error_is_defined(self):
|
|
"""
|
|
Current behavior: PluginDisconnectedError is a RuntimeError subclass
|
|
raised when a WebSocket disconnects during command processing.
|
|
"""
|
|
error = PluginDisconnectedError("Test message")
|
|
assert isinstance(error, RuntimeError)
|
|
assert str(error) == "Test message"
|
|
|
|
def test_no_unity_session_error_is_defined(self):
|
|
"""
|
|
Current behavior: NoUnitySessionError is a RuntimeError subclass
|
|
raised when no Unity plugins are connected.
|
|
"""
|
|
error = NoUnitySessionError("Test message")
|
|
assert isinstance(error, RuntimeError)
|
|
assert str(error) == "Test message"
|
|
|
|
|
|
# ============================================================================
|
|
# SESSION RESOLUTION & WAITING TESTS
|
|
# ============================================================================
|
|
|
|
class TestSessionResolution:
|
|
"""Test session resolution with waiting for reconnects."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_session_id_waits_for_reconnect(self, plugin_registry):
|
|
"""
|
|
Current behavior: _resolve_session_id() waits up to max_wait_s for
|
|
a plugin to connect/reconnect before failing.
|
|
"""
|
|
# Configure PluginHub
|
|
loop = asyncio.get_event_loop()
|
|
PluginHub.configure(plugin_registry, loop)
|
|
|
|
# This simulates domain reload recovery
|
|
target_hash = "hash-delayed"
|
|
|
|
# Start with no sessions
|
|
async def delayed_register():
|
|
await asyncio.sleep(0.1)
|
|
await plugin_registry.register(
|
|
session_id="sess-delayed",
|
|
project_name="Project",
|
|
project_hash=target_hash,
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
# Schedule registration
|
|
task = asyncio.create_task(delayed_register())
|
|
|
|
# Resolve with short timeout
|
|
session_id = await PluginHub._resolve_session_id(target_hash)
|
|
|
|
assert session_id == "sess-delayed"
|
|
|
|
# Ensure background task completes
|
|
await task
|
|
|
|
# Cleanup
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
PluginHub._loop = None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_session_id_fails_when_no_session_appears(self, plugin_registry, monkeypatch):
|
|
"""
|
|
Current behavior: If no session appears within max_wait_s,
|
|
raise NoUnitySessionError.
|
|
"""
|
|
# Configure PluginHub
|
|
loop = asyncio.get_event_loop()
|
|
PluginHub.configure(plugin_registry, loop)
|
|
|
|
# Set very short timeout
|
|
monkeypatch.setenv("UNITY_MCP_SESSION_RESOLVE_MAX_WAIT_S", "0.05")
|
|
|
|
# Try to resolve unknown hash
|
|
with pytest.raises(NoUnitySessionError):
|
|
await PluginHub._resolve_session_id("nonexistent-hash")
|
|
|
|
# Cleanup
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
PluginHub._loop = None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_session_id_auto_selects_sole_instance(self, plugin_registry):
|
|
"""
|
|
Current behavior: When no target_hash provided and exactly one session
|
|
exists, auto-select it.
|
|
"""
|
|
# Configure PluginHub
|
|
loop = asyncio.get_event_loop()
|
|
PluginHub.configure(plugin_registry, loop)
|
|
|
|
await plugin_registry.register(
|
|
session_id="sess-sole",
|
|
project_name="Project",
|
|
project_hash="hash-sole",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
session_id = await PluginHub._resolve_session_id(None)
|
|
|
|
assert session_id == "sess-sole"
|
|
|
|
# Cleanup
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
PluginHub._loop = None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_session_id_rejects_ambiguous_selection(self, plugin_registry):
|
|
"""
|
|
Current behavior: When no target and multiple sessions exist,
|
|
raise RuntimeError indicating ambiguity.
|
|
"""
|
|
# Configure PluginHub
|
|
loop = asyncio.get_event_loop()
|
|
PluginHub.configure(plugin_registry, loop)
|
|
|
|
await plugin_registry.register(
|
|
session_id="sess-1",
|
|
project_name="Project1",
|
|
project_hash="hash-1",
|
|
unity_version="2022.3"
|
|
)
|
|
await plugin_registry.register(
|
|
session_id="sess-2",
|
|
project_name="Project2",
|
|
project_hash="hash-2",
|
|
unity_version="2023.2"
|
|
)
|
|
|
|
with pytest.raises(InstanceSelectionRequiredError, match="Multiple Unity instances"):
|
|
await PluginHub._resolve_session_id(None)
|
|
|
|
# Cleanup
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
PluginHub._loop = None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resolve_session_id_parses_instance_format(self, plugin_registry):
|
|
"""
|
|
Current behavior: Accepts both "ProjectName@hash" and bare "hash"
|
|
formats, extracting the hash portion.
|
|
"""
|
|
# Configure PluginHub
|
|
loop = asyncio.get_event_loop()
|
|
PluginHub.configure(plugin_registry, loop)
|
|
|
|
target_hash = "hash-parse"
|
|
|
|
await plugin_registry.register(
|
|
session_id="sess-parse",
|
|
project_name="ProjectName",
|
|
project_hash=target_hash,
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
# Resolve via "Name@hash" format
|
|
session_id = await PluginHub._resolve_session_id("ProjectName@hash-parse")
|
|
assert session_id == "sess-parse"
|
|
|
|
# Resolve via bare hash format
|
|
session_id = await PluginHub._resolve_session_id("hash-parse")
|
|
assert session_id == "sess-parse"
|
|
|
|
# Cleanup
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
PluginHub._loop = None
|
|
|
|
|
|
# ============================================================================
|
|
# PLUGIN HUB CONFIGURATION TESTS
|
|
# ============================================================================
|
|
|
|
class TestPluginHubConfiguration:
|
|
"""Test PluginHub initialization and configuration."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_plugin_hub_configure_initializes_lock(self, plugin_registry):
|
|
"""
|
|
Current behavior: configure() initializes _lock and _registry
|
|
at the class level.
|
|
"""
|
|
loop = asyncio.get_event_loop()
|
|
|
|
PluginHub.configure(plugin_registry, loop)
|
|
|
|
assert PluginHub._registry is plugin_registry
|
|
assert PluginHub._lock is not None
|
|
assert PluginHub._loop is loop
|
|
|
|
def test_plugin_hub_is_configured(self, plugin_registry):
|
|
"""
|
|
Current behavior: is_configured() returns True only when both
|
|
_registry and _lock are set.
|
|
"""
|
|
PluginHub._registry = None
|
|
PluginHub._lock = None
|
|
|
|
assert PluginHub.is_configured() is False
|
|
|
|
PluginHub._registry = plugin_registry
|
|
PluginHub._lock = asyncio.Lock()
|
|
|
|
assert PluginHub.is_configured() is True
|
|
|
|
def test_plugin_hub_not_configured_sends_command_fails(self):
|
|
"""
|
|
Current behavior: Calling send_command when not configured
|
|
raises RuntimeError.
|
|
"""
|
|
PluginHub._lock = None
|
|
|
|
with pytest.raises(RuntimeError, match="not configured"):
|
|
asyncio.run(PluginHub.send_command("sess-id", "ping", {}))
|
|
|
|
|
|
# ============================================================================
|
|
# GLOBAL MIDDLEWARE SINGLETON TESTS
|
|
# ============================================================================
|
|
|
|
class TestMiddlewareSingleton:
|
|
"""Test global middleware singleton pattern."""
|
|
|
|
def test_get_unity_instance_middleware_lazy_initializes(self):
|
|
"""
|
|
Current behavior: get_unity_instance_middleware() lazily creates
|
|
a singleton if not already set.
|
|
"""
|
|
# Reset global state
|
|
import transport.unity_instance_middleware as mw_module
|
|
mw_module._unity_instance_middleware = None
|
|
|
|
middleware1 = get_unity_instance_middleware()
|
|
middleware2 = get_unity_instance_middleware()
|
|
|
|
assert middleware1 is middleware2
|
|
|
|
def test_set_unity_instance_middleware_replaces_singleton(self):
|
|
"""
|
|
Current behavior: set_unity_instance_middleware() allows replacing
|
|
the global singleton (used during server initialization).
|
|
"""
|
|
import transport.unity_instance_middleware as mw_module
|
|
mw_module._unity_instance_middleware = None
|
|
|
|
middleware1 = UnityInstanceMiddleware()
|
|
set_unity_instance_middleware(middleware1)
|
|
|
|
retrieved = get_unity_instance_middleware()
|
|
assert retrieved is middleware1
|
|
|
|
|
|
# ============================================================================
|
|
# EDGE CASES & ERROR SCENARIOS
|
|
# ============================================================================
|
|
|
|
class TestTransportEdgeCases:
|
|
"""Test edge cases and error scenarios."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_middleware_handles_exception_during_autoselect(self, mock_context):
|
|
"""
|
|
Current behavior: If autoselect raises an unexpected exception,
|
|
it's caught and logged, allowing the middleware to continue.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
with patch("transport.unity_instance_middleware.PluginHub.is_configured", return_value=True):
|
|
with patch("transport.unity_instance_middleware.PluginHub.get_sessions", new_callable=AsyncMock) as mock_get:
|
|
with patch("transport.legacy.unity_connection.get_unity_connection_pool", return_value=None):
|
|
mock_get.side_effect = RuntimeError("Unexpected error")
|
|
|
|
# Should not raise, just return None
|
|
instance = await middleware._maybe_autoselect_instance(mock_context)
|
|
|
|
assert instance is None
|
|
|
|
def test_middleware_handles_client_id_false_but_not_none(self):
|
|
"""
|
|
Current behavior: get_session_key checks isinstance(client_id, str) AND len,
|
|
so falsy non-string values fall through to 'global'.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
ctx = Mock()
|
|
ctx.client_id = "" # Empty string
|
|
ctx.session_id = "session-id"
|
|
|
|
key = middleware.get_session_key(ctx)
|
|
assert key == "global" # Empty string doesn't pass isinstance+truthy check
|
|
|
|
def test_plugin_hub_encoding_is_json(self):
|
|
"""
|
|
Current behavior: PluginHub WebSocketEndpoint uses JSON encoding.
|
|
"""
|
|
assert PluginHub.encoding == "json"
|
|
|
|
def test_plugin_hub_timeout_constants(self):
|
|
"""
|
|
Current behavior: PluginHub defines standard timeout constants.
|
|
"""
|
|
assert PluginHub.KEEP_ALIVE_INTERVAL == 15
|
|
assert PluginHub.SERVER_TIMEOUT == 30
|
|
assert PluginHub.COMMAND_TIMEOUT == 30
|
|
assert PluginHub.FAST_FAIL_TIMEOUT == 2.0
|
|
|
|
|
|
# ============================================================================
|
|
# INTEGRATION SCENARIOS
|
|
# ============================================================================
|
|
|
|
class TestTransportIntegration:
|
|
"""Test realistic integration scenarios."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_middleware_and_registry_interaction(self, mock_context, plugin_registry):
|
|
"""
|
|
Current behavior: Middleware stores instance selection, which
|
|
can be used to route commands via registry lookup.
|
|
"""
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
# Register a session in the registry
|
|
await plugin_registry.register(
|
|
session_id="sess-interact",
|
|
project_name="Project",
|
|
project_hash="hash-interact",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
# Middleware stores the instance
|
|
middleware.set_active_instance(mock_context, "Project@hash-interact")
|
|
|
|
# Application can use middleware to route
|
|
instance = middleware.get_active_instance(mock_context)
|
|
assert instance == "Project@hash-interact"
|
|
|
|
# And registry to find session
|
|
resolved_id = await plugin_registry.get_session_id_by_hash("hash-interact")
|
|
assert resolved_id == "sess-interact"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_registry_and_middleware_complete_flow(self, mock_context, plugin_registry):
|
|
"""
|
|
Current behavior: Integrated flow - register session in registry,
|
|
select it in middleware, then route by hash lookup.
|
|
"""
|
|
# Setup
|
|
middleware = UnityInstanceMiddleware()
|
|
|
|
# 1. Plugin connects and registers in registry
|
|
await plugin_registry.register(
|
|
session_id="sess-complete",
|
|
project_name="CompleteProject",
|
|
project_hash="hash-complete",
|
|
unity_version="2022.3"
|
|
)
|
|
|
|
# 2. User selects instance via middleware
|
|
middleware.set_active_instance(mock_context, "CompleteProject@hash-complete")
|
|
|
|
# 3. Tools route using both middleware + registry
|
|
selected_instance = middleware.get_active_instance(mock_context)
|
|
assert selected_instance == "CompleteProject@hash-complete"
|
|
|
|
# Extract hash and resolve back to session
|
|
hash_part = selected_instance.split("@")[1]
|
|
resolved_session = await plugin_registry.get_session_id_by_hash(hash_part)
|
|
assert resolved_session == "sess-complete"
|
|
|
|
# 4. Verify session has the correct data
|
|
session = await plugin_registry.get_session(resolved_session)
|
|
assert session.project_name == "CompleteProject"
|
|
assert session.unity_version == "2022.3"
|
|
|
|
|
|
# ============================================================================
|
|
# SUMMARY
|
|
# ============================================================================
|
|
|
|
"""
|
|
CHARACTERIZATION TEST SUMMARY
|
|
|
|
Total Tests: 60+
|
|
|
|
Categories:
|
|
1. Session Management & Routing (9 tests)
|
|
- Instance storage per session
|
|
- Session key derivation and prioritization
|
|
- Session isolation
|
|
- Clear and reset operations
|
|
- Thread safety
|
|
|
|
2. Middleware Injection & Context Flow (3 tests)
|
|
- Tool context injection
|
|
- Resource context injection
|
|
- No-op when instance unavailable
|
|
|
|
3. Auto-Select Instance (3 tests)
|
|
- Single instance auto-selection
|
|
- Multiple instance ambiguity
|
|
- Error handling and fallback
|
|
|
|
4. Plugin Registry (8 tests)
|
|
- Session registration and lookup
|
|
- Hash-based routing
|
|
- Reconnect scenarios
|
|
- Tool registration
|
|
- Heartbeat updates
|
|
- Cleanup on disconnect
|
|
- Batch operations
|
|
|
|
5. Plugin Hub Message Handling (5 tests)
|
|
- Registration flow
|
|
- Tool registration
|
|
- Command result completion
|
|
- Heartbeat handling
|
|
- Error validation
|
|
|
|
6. Command Routing & Timeouts (2 tests)
|
|
- Fast-fail timeout logic
|
|
- Custom timeout handling
|
|
|
|
7. Plugin Disconnect & Error Handling (2 tests)
|
|
- In-flight command failure
|
|
- Session cleanup
|
|
|
|
8. Session Resolution & Waiting (4 tests)
|
|
- Waiting for reconnect
|
|
- Timeout behavior
|
|
- Auto-selection
|
|
- Ambiguity detection
|
|
- Instance format parsing
|
|
|
|
9. PluginHub Configuration (3 tests)
|
|
- Initialization
|
|
- Configuration state
|
|
- Unconfigured behavior
|
|
|
|
10. Global Middleware Singleton (2 tests)
|
|
- Lazy initialization
|
|
- Replacement/override
|
|
|
|
11. Edge Cases & Error Scenarios (4 tests)
|
|
- Malformed messages
|
|
- Unknown message types
|
|
- Unexpected exceptions
|
|
- Falsy client_id handling
|
|
|
|
12. Integration Scenarios (2 tests)
|
|
- Full registration flow
|
|
- Middleware + registry interaction
|
|
|
|
Key Behavior Patterns Tested:
|
|
- Thread-safe session storage with RLock
|
|
- Client_id prioritization over session_id for key derivation
|
|
- Lazy singleton pattern for middleware
|
|
- Auto-selection with fallback to stdio
|
|
- Reconnect support via hash-based mapping
|
|
- Fast-fail timeouts for UI-blocking commands
|
|
- Graceful degradation on plugin disconnect
|
|
- Waiting for plugin reconnect during domain reloads
|
|
|
|
Critical Integration Points:
|
|
- Middleware injects instance into context state
|
|
- Context state used by tools for routing
|
|
- Registry maps hash to session_id for HTTP transport
|
|
- Plugin disconnect cleans up sessions and fails in-flight commands
|
|
- Auto-select probes both PluginHub and stdio with graceful fallback
|
|
"""
|