mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
1141 lines
37 KiB
Python
1141 lines
37 KiB
Python
"""Test tool lifecycle functionality."""
|
|
|
|
import pytest
|
|
from unittest.mock import MagicMock
|
|
from nodupe.core.tool_system.lifecycle import ToolLifecycleManager, ToolLifecycleError, ToolState
|
|
from nodupe.core.tool_system.registry import ToolRegistry
|
|
from nodupe.core.tool_system.base import Tool
|
|
|
|
|
|
class TestToolLifecycleManager:
|
|
"""Test tool lifecycle manager core functionality."""
|
|
|
|
def test_tool_lifecycle_manager_initialization(self):
|
|
"""Test tool lifecycle manager initialization."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
assert lifecycle_manager is not None
|
|
assert isinstance(lifecycle_manager, ToolLifecycleManager)
|
|
assert lifecycle_manager.registry is registry
|
|
|
|
# Test that it has expected attributes
|
|
assert hasattr(lifecycle_manager, 'initialize_tool')
|
|
assert hasattr(lifecycle_manager, 'shutdown_tool')
|
|
assert hasattr(lifecycle_manager, 'initialize_all_tools')
|
|
assert hasattr(lifecycle_manager, 'shutdown_all_tools')
|
|
assert hasattr(lifecycle_manager, 'get_tool_state')
|
|
assert hasattr(lifecycle_manager, 'is_tool_initialized')
|
|
assert hasattr(lifecycle_manager, 'is_tool_active')
|
|
assert hasattr(lifecycle_manager, 'get_active_tools')
|
|
assert hasattr(lifecycle_manager, 'get_tool_dependencies')
|
|
assert hasattr(lifecycle_manager, 'set_tool_dependencies')
|
|
assert hasattr(lifecycle_manager, 'initialize')
|
|
assert hasattr(lifecycle_manager, 'shutdown')
|
|
|
|
def test_tool_lifecycle_manager_with_container(self):
|
|
"""Test tool lifecycle manager with dependency container."""
|
|
from nodupe.core.container import ServiceContainer
|
|
|
|
registry = ToolRegistry()
|
|
container = ServiceContainer()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Initialize lifecycle manager with container
|
|
lifecycle_manager.initialize(container)
|
|
assert lifecycle_manager.container is container
|
|
|
|
def test_tool_lifecycle_manager_lifecycle(self):
|
|
"""Test tool lifecycle manager lifecycle operations."""
|
|
from nodupe.core.container import ServiceContainer
|
|
|
|
registry = ToolRegistry()
|
|
container = ServiceContainer()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Test initialization
|
|
lifecycle_manager.initialize(container)
|
|
assert lifecycle_manager.container is container
|
|
|
|
# Test shutdown
|
|
lifecycle_manager.shutdown()
|
|
assert lifecycle_manager.container is None
|
|
|
|
# Test re-initialization
|
|
lifecycle_manager.initialize(container)
|
|
assert lifecycle_manager.container is container
|
|
|
|
|
|
class TestToolState:
|
|
"""Test tool state functionality."""
|
|
|
|
def test_tool_state_enum(self):
|
|
"""Test tool state enum values."""
|
|
# Test that all expected states are present
|
|
assert hasattr(ToolState, 'UNINITIALIZED')
|
|
assert hasattr(ToolState, 'INITIALIZED')
|
|
assert hasattr(ToolState, 'ACTIVE')
|
|
assert hasattr(ToolState, 'FAILED')
|
|
|
|
# Test state values
|
|
assert ToolState.UNINITIALIZED.value == 0
|
|
assert ToolState.INITIALIZED.value == 1
|
|
assert ToolState.ACTIVE.value == 2
|
|
assert ToolState.FAILED.value == 3
|
|
|
|
|
|
class TestToolLifecycleOperations:
|
|
"""Test tool lifecycle operations."""
|
|
|
|
def test_initialize_tool(self):
|
|
"""Test initializing a tool."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Initialize tool
|
|
result = lifecycle_manager.initialize_tool("test_tool")
|
|
assert result is True
|
|
assert test_tool.initialized is True
|
|
|
|
# Check tool state
|
|
state = lifecycle_manager.get_tool_state("test_tool")
|
|
assert state == ToolState.INITIALIZED
|
|
|
|
def test_shutdown_tool(self):
|
|
"""Test shutting down a tool."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
self.shutdown_called = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
self.shutdown_called = True
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Initialize tool
|
|
lifecycle_manager.initialize_tool("test_tool")
|
|
assert test_tool.initialized is True
|
|
|
|
# Shutdown tool
|
|
result = lifecycle_manager.shutdown_tool("test_tool")
|
|
assert result is True
|
|
assert test_tool.shutdown_called is True
|
|
|
|
# Check tool state
|
|
state = lifecycle_manager.get_tool_state("test_tool")
|
|
assert state == ToolState.UNINITIALIZED
|
|
|
|
def test_initialize_all_tools(self):
|
|
"""Test initializing all tools."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create multiple test tools
|
|
tools = []
|
|
for i in range(3):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = f"test_tool_{i}"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
tools.append(test_tool)
|
|
registry.register(test_tool)
|
|
|
|
# Initialize all tools
|
|
result = lifecycle_manager.initialize_all_tools(MagicMock())
|
|
assert result is True
|
|
|
|
# Verify all tools are initialized
|
|
for tool in tools:
|
|
assert tool.initialized is True
|
|
state = lifecycle_manager.get_tool_state(tool.name)
|
|
assert state == ToolState.INITIALIZED
|
|
|
|
def test_shutdown_all_tools(self):
|
|
"""Test shutting down all tools."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create multiple test tools
|
|
tools = []
|
|
for i in range(3):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = f"test_tool_{i}"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
self.shutdown_called = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
self.shutdown_called = True
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
tools.append(test_tool)
|
|
registry.register(test_tool)
|
|
|
|
# Initialize all tools
|
|
lifecycle_manager.initialize_all_tools(MagicMock())
|
|
|
|
# Shutdown all tools
|
|
result = lifecycle_manager.shutdown_all_tools()
|
|
assert result is True
|
|
|
|
# Verify all tools are shutdown
|
|
for tool in tools:
|
|
assert tool.shutdown_called is True
|
|
state = lifecycle_manager.get_tool_state(tool.name)
|
|
assert state == ToolState.UNINITIALIZED
|
|
|
|
def test_get_tool_state(self):
|
|
"""Test getting tool state."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Check initial state
|
|
state = lifecycle_manager.get_tool_state("test_tool")
|
|
assert state == ToolState.UNINITIALIZED
|
|
|
|
# Initialize tool
|
|
lifecycle_manager.initialize_tool("test_tool")
|
|
|
|
# Check state after initialization
|
|
state = lifecycle_manager.get_tool_state("test_tool")
|
|
assert state == ToolState.INITIALIZED
|
|
|
|
def test_is_tool_initialized(self):
|
|
"""Test checking if tool is initialized."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Check before initialization
|
|
result = lifecycle_manager.is_tool_initialized("test_tool")
|
|
assert result is False
|
|
|
|
# Initialize tool
|
|
lifecycle_manager.initialize_tool("test_tool")
|
|
|
|
# Check after initialization
|
|
result = lifecycle_manager.is_tool_initialized("test_tool")
|
|
assert result is True
|
|
|
|
def test_is_tool_active(self):
|
|
"""Test checking if tool is active."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Check before initialization
|
|
result = lifecycle_manager.is_tool_active("test_tool")
|
|
assert result is False
|
|
|
|
# Initialize tool
|
|
lifecycle_manager.initialize_tool("test_tool")
|
|
|
|
# Check after initialization (should be active)
|
|
result = lifecycle_manager.is_tool_active("test_tool")
|
|
assert result is True
|
|
|
|
def test_get_active_tools(self):
|
|
"""Test getting active tools."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create multiple test tools
|
|
tools = []
|
|
for i in range(3):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = f"test_tool_{i}"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
tools.append(test_tool)
|
|
registry.register(test_tool)
|
|
|
|
# Initialize some tools
|
|
lifecycle_manager.initialize_tool("test_tool_0")
|
|
lifecycle_manager.initialize_tool("test_tool_2")
|
|
|
|
# Get active tools
|
|
active_tools = lifecycle_manager.get_active_tools()
|
|
assert len(active_tools) == 2
|
|
assert "test_tool_0" in active_tools
|
|
assert "test_tool_2" in active_tools
|
|
|
|
def test_get_tool_dependencies(self):
|
|
"""Test getting tool dependencies."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = ["dep1", "dep2"]
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Get tool dependencies
|
|
dependencies = lifecycle_manager.get_tool_dependencies("test_tool")
|
|
assert dependencies == ["dep1", "dep2"]
|
|
|
|
def test_set_tool_dependencies(self):
|
|
"""Test setting tool dependencies."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Set tool dependencies
|
|
lifecycle_manager.set_tool_dependencies(
|
|
"test_tool", ["new_dep1", "new_dep2"])
|
|
|
|
# Get tool dependencies
|
|
dependencies = lifecycle_manager.get_tool_dependencies("test_tool")
|
|
assert dependencies == ["new_dep1", "new_dep2"]
|
|
|
|
|
|
class TestToolLifecycleEdgeCases:
|
|
"""Test tool lifecycle edge cases."""
|
|
|
|
def test_initialize_nonexistent_tool(self):
|
|
"""Test initializing non-existent tool."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Try to initialize non-existent tool
|
|
result = lifecycle_manager.initialize_tool("nonexistent_tool")
|
|
assert result is False
|
|
|
|
def test_shutdown_nonexistent_tool(self):
|
|
"""Test shutting down non-existent tool."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Try to shutdown non-existent tool
|
|
result = lifecycle_manager.shutdown_tool("nonexistent_tool")
|
|
assert result is False
|
|
|
|
def test_initialize_tool_with_exception(self):
|
|
"""Test initializing tool that throws exception."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool that throws exception
|
|
class FailingTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "failing_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
raise Exception("Initialize failed")
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
failing_tool = FailingTool()
|
|
registry.register(failing_tool)
|
|
|
|
# Try to initialize tool
|
|
result = lifecycle_manager.initialize_tool("failing_tool")
|
|
assert result is False
|
|
|
|
# Check tool state
|
|
state = lifecycle_manager.get_tool_state("failing_tool")
|
|
assert state == ToolState.FAILED
|
|
|
|
def test_shutdown_tool_with_exception(self):
|
|
"""Test shutting down tool that throws exception."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool that throws exception in shutdown
|
|
class FailingTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "failing_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
raise Exception("Shutdown failed")
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
failing_tool = FailingTool()
|
|
registry.register(failing_tool)
|
|
|
|
# Initialize tool
|
|
lifecycle_manager.initialize_tool("failing_tool")
|
|
|
|
# Try to shutdown tool
|
|
result = lifecycle_manager.shutdown_tool("failing_tool")
|
|
assert result is False
|
|
|
|
# Check tool state
|
|
state = lifecycle_manager.get_tool_state("failing_tool")
|
|
assert state == ToolState.FAILED
|
|
|
|
|
|
class TestToolLifecyclePerformance:
|
|
"""Test tool lifecycle performance."""
|
|
|
|
def test_mass_tool_initialization(self):
|
|
"""Test mass tool initialization."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create many test tools
|
|
tools = []
|
|
for i in range(10):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = f"test_tool_{i}"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
tools.append(test_tool)
|
|
registry.register(test_tool)
|
|
|
|
# Initialize all tools
|
|
result = lifecycle_manager.initialize_all_tools(MagicMock())
|
|
assert result is True
|
|
|
|
# Verify all tools are initialized
|
|
for tool in tools:
|
|
assert tool.initialized is True
|
|
|
|
def test_tool_lifecycle_performance(self):
|
|
"""Test tool lifecycle performance."""
|
|
import time
|
|
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create many test tools
|
|
tools = []
|
|
for i in range(20):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = f"perf_tool_{i}"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
self.shutdown_called = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
self.shutdown_called = True
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
tools.append(test_tool)
|
|
registry.register(test_tool)
|
|
|
|
# Test initialization performance
|
|
start_time = time.time()
|
|
lifecycle_manager.initialize_all_tools(MagicMock())
|
|
init_time = time.time() - start_time
|
|
|
|
# Test shutdown performance
|
|
start_time = time.time()
|
|
lifecycle_manager.shutdown_all_tools()
|
|
shutdown_time = time.time() - start_time
|
|
|
|
# Should be fast operations
|
|
assert init_time < 1.0
|
|
assert shutdown_time < 0.5
|
|
|
|
|
|
class TestToolLifecycleIntegration:
|
|
"""Test tool lifecycle integration scenarios."""
|
|
|
|
def test_tool_lifecycle_with_registry(self):
|
|
"""Test tool lifecycle integration with registry."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
registry.register(test_tool)
|
|
|
|
# Initialize tool through lifecycle manager
|
|
lifecycle_manager.initialize_tool("test_tool")
|
|
|
|
# Verify tool is accessible through registry
|
|
retrieved = registry.get_tool("test_tool")
|
|
assert retrieved is test_tool
|
|
assert retrieved.initialized is True
|
|
|
|
def test_tool_lifecycle_with_loader(self):
|
|
"""Test tool lifecycle integration with loader."""
|
|
from nodupe.core.tool_system.loader import ToolLoader
|
|
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
loader = ToolLoader(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "test_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
self.shutdown_called = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
self.shutdown_called = True
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"test": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
test_tool = TestTool()
|
|
|
|
# Load tool
|
|
loaded_tool = loader.load_tool(test_tool)
|
|
|
|
# Initialize through lifecycle manager
|
|
lifecycle_manager.initialize_tool("test_tool")
|
|
assert test_tool.initialized is True
|
|
|
|
# Shutdown through lifecycle manager
|
|
lifecycle_manager.shutdown_tool("test_tool")
|
|
assert test_tool.shutdown_called is True
|
|
|
|
|
|
class TestToolLifecycleErrorHandling:
|
|
"""Test tool lifecycle error handling."""
|
|
|
|
def test_initialize_tool_with_missing_methods(self):
|
|
"""Test initializing tool with missing required methods."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create a tool missing required methods
|
|
class IncompleteTool(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "incomplete_tool"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
# Missing initialize and shutdown methods
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
incomplete_tool = IncompleteTool()
|
|
registry.register(incomplete_tool)
|
|
|
|
# Try to initialize tool
|
|
with pytest.raises(ToolLifecycleError):
|
|
lifecycle_manager.initialize_tool("incomplete_tool")
|
|
|
|
|
|
class TestToolLifecycleAdvanced:
|
|
"""Test advanced tool lifecycle functionality."""
|
|
|
|
def test_tool_lifecycle_with_dependencies(self):
|
|
"""Test tool lifecycle with dependencies."""
|
|
registry = ToolRegistry()
|
|
lifecycle_manager = ToolLifecycleManager(registry)
|
|
|
|
# Create test tools with dependencies
|
|
class ToolA(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "tool_a"
|
|
self.version = "1.0.0"
|
|
self.dependencies = []
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"feature_a": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
class ToolB(Tool):
|
|
"""Test tool implementation for lifecycle testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.name = "tool_b"
|
|
self.version = "1.0.0"
|
|
self.dependencies = ["tool_a"]
|
|
self.initialized = False
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
|
|
def shutdown(self):
|
|
"""Shutdown the tool."""
|
|
pass
|
|
|
|
def get_capabilities(self):
|
|
"""Get the tool capabilities."""
|
|
return {"feature_b": True}
|
|
|
|
@property
|
|
def api_methods(self):
|
|
"""Get the API methods."""
|
|
return {}
|
|
|
|
def run_standalone(self, args):
|
|
"""Run the tool in standalone mode."""
|
|
return 0
|
|
|
|
def describe_usage(self):
|
|
"""Describe how to use the tool."""
|
|
return "Test tool"
|
|
|
|
tool_a = ToolA()
|
|
tool_b = ToolB()
|
|
registry.register(tool_a)
|
|
registry.register(tool_b)
|
|
|
|
# Set dependencies
|
|
lifecycle_manager.set_tool_dependencies("tool_b", ["tool_a"])
|
|
|
|
# Initialize tools (should handle dependencies)
|
|
lifecycle_manager.initialize_tool("tool_a")
|
|
lifecycle_manager.initialize_tool("tool_b")
|
|
|
|
# Verify both tools are initialized
|
|
assert tool_a.initialized is True
|
|
assert tool_b.initialized is True
|