"""
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 - this is sufficient for auto-select to fail
with patch("transport.unity_instance_middleware.PluginHub.is_configured", return_value=False):
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:
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:
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:
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
"""
