mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
1202 lines
37 KiB
Python
1202 lines
37 KiB
Python
"""Test tool compatibility functionality."""
|
|
|
|
import pytest
|
|
from unittest.mock import MagicMock
|
|
from typing import List
|
|
from nodupe.core.tool_system.compatibility import ToolCompatibility
|
|
from nodupe.core.tool_system.compatibility import ToolCompatibilityError
|
|
from nodupe.core.tool_system.base import Tool
|
|
|
|
|
|
class TestToolCompatibility:
|
|
"""Test tool compatibility core functionality."""
|
|
|
|
def test_tool_compatibility_initialization(self):
|
|
"""Test tool compatibility initialization."""
|
|
compatibility = ToolCompatibility()
|
|
assert compatibility is not None
|
|
assert isinstance(compatibility, ToolCompatibility)
|
|
|
|
# Test that it has expected attributes
|
|
assert hasattr(compatibility, 'check_compatibility')
|
|
assert hasattr(compatibility, 'get_compatibility_report')
|
|
assert hasattr(compatibility, 'initialize')
|
|
assert hasattr(compatibility, 'shutdown')
|
|
|
|
def test_tool_compatibility_with_container(self):
|
|
"""Test tool compatibility with dependency container."""
|
|
from nodupe.core.container import ServiceContainer
|
|
|
|
compatibility = ToolCompatibility()
|
|
container = ServiceContainer()
|
|
|
|
# Initialize compatibility with container
|
|
compatibility.initialize(container)
|
|
assert compatibility.container is container
|
|
|
|
def test_tool_compatibility_lifecycle(self):
|
|
"""Test tool compatibility lifecycle operations."""
|
|
from nodupe.core.container import ServiceContainer
|
|
|
|
compatibility = ToolCompatibility()
|
|
container = ServiceContainer()
|
|
|
|
# Test initialization
|
|
compatibility.initialize(container)
|
|
assert compatibility.container is container
|
|
|
|
# Test shutdown
|
|
compatibility.shutdown()
|
|
assert compatibility.container is None
|
|
|
|
# Test re-initialization
|
|
compatibility.initialize(container)
|
|
assert compatibility.container is container
|
|
|
|
|
|
class TestToolCompatibilityOperations:
|
|
"""Test tool compatibility operations."""
|
|
|
|
def test_check_compatibility(self):
|
|
"""Test checking tool compatibility."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "test_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(test_tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
# Verify report structure
|
|
assert "compatible" in report
|
|
assert "issues" in report
|
|
assert "warnings" in report
|
|
|
|
def test_get_compatibility_report(self):
|
|
"""Test getting compatibility report."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "test_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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()
|
|
|
|
# Get compatibility report
|
|
report = compatibility.get_compatibility_report(test_tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
# Verify report structure
|
|
assert "tool_name" in report
|
|
assert "tool_version" in report
|
|
assert "compatibility_status" in report
|
|
assert "compatibility_issues" in report
|
|
assert "compatibility_warnings" in report
|
|
|
|
def test_check_compatible_tool(self):
|
|
"""Test checking compatible tool."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a compatible test tool
|
|
class CompatibleTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "compatible_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
compatible_tool = CompatibleTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(compatible_tool)
|
|
assert report["compatible"] is True
|
|
assert len(report["issues"]) == 0
|
|
|
|
def test_check_incompatible_tool(self):
|
|
"""Test checking incompatible tool."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create an incompatible test tool
|
|
class IncompatibleTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "incompatible_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["nonexistent>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
incompatible_tool = IncompatibleTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(incompatible_tool)
|
|
assert report["compatible"] is False
|
|
assert len(report["issues"]) > 0
|
|
|
|
|
|
class TestToolCompatibilityEdgeCases:
|
|
"""Test tool compatibility edge cases."""
|
|
|
|
def test_check_tool_with_no_dependencies(self):
|
|
"""Test checking tool with no dependencies."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool with no dependencies
|
|
class NoDepsTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "no_deps_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return []
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
no_deps_tool = NoDepsTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(no_deps_tool)
|
|
assert report is not None
|
|
assert report["compatible"] is True
|
|
|
|
def test_check_tool_with_empty_name(self):
|
|
"""Test checking tool with empty name."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool with empty name
|
|
class EmptyNameTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return ""
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return []
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
empty_name_tool = EmptyNameTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(empty_name_tool)
|
|
assert report is not None
|
|
assert report["compatible"] is False
|
|
assert len(report["issues"]) > 0
|
|
|
|
def test_check_tool_with_invalid_version(self):
|
|
"""Test checking tool with invalid version."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool with invalid version
|
|
class InvalidVersionTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "invalid_version_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "invalid_version"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return []
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
invalid_version_tool = InvalidVersionTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(invalid_version_tool)
|
|
assert report is not None
|
|
assert report["compatible"] is False
|
|
assert len(report["issues"]) > 0
|
|
|
|
def test_check_tool_with_missing_methods(self):
|
|
"""Test checking tool with missing required methods."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool missing required methods
|
|
class IncompleteTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "incomplete_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return []
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
# 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()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(incomplete_tool)
|
|
assert report is not None
|
|
assert report["compatible"] is False
|
|
assert len(report["issues"]) > 0
|
|
|
|
|
|
class TestToolCompatibilityPerformance:
|
|
"""Test tool compatibility performance."""
|
|
|
|
def test_mass_tool_compatibility_checking(self):
|
|
"""Test mass tool compatibility checking."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create many test tools
|
|
tools = []
|
|
for i in range(10):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return f"test_tool_{i}"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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)
|
|
|
|
# Check compatibility for all tools
|
|
for tool in tools:
|
|
report = compatibility.check_compatibility(tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
def test_tool_compatibility_performance(self):
|
|
"""Test tool compatibility performance."""
|
|
import time
|
|
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create many test tools
|
|
tools = []
|
|
for i in range(50):
|
|
class TestTool(Tool):
|
|
"""Test tool implementation."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return f"perf_tool_{i}"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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)
|
|
|
|
# Test compatibility checking performance
|
|
start_time = time.time()
|
|
for tool in tools:
|
|
compatibility.check_compatibility(tool)
|
|
compatibility_time = time.time() - start_time
|
|
|
|
# Should be fast operation
|
|
assert compatibility_time < 1.0
|
|
|
|
|
|
class TestToolCompatibilityIntegration:
|
|
"""Test tool compatibility integration scenarios."""
|
|
|
|
def test_compatibility_with_registry(self):
|
|
"""Test compatibility integration with registry."""
|
|
from nodupe.core.tool_system.registry import ToolRegistry
|
|
|
|
compatibility = ToolCompatibility()
|
|
registry = ToolRegistry()
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "test_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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 compatibility
|
|
report = compatibility.check_compatibility(test_tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
def test_compatibility_with_loader(self):
|
|
"""Test compatibility integration with loader."""
|
|
from nodupe.core.tool_system.loader import ToolLoader
|
|
from nodupe.core.tool_system.registry import ToolRegistry
|
|
|
|
compatibility = ToolCompatibility()
|
|
registry = ToolRegistry()
|
|
loader = ToolLoader(registry)
|
|
|
|
# Create a test tool
|
|
class TestTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "test_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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()
|
|
|
|
# Load tool
|
|
loaded_tool = loader.load_tool(test_tool)
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(loaded_tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
|
|
class TestToolCompatibilityErrorHandling:
|
|
"""Test tool compatibility error handling."""
|
|
|
|
def test_check_compatibility_with_invalid_tool(self):
|
|
"""Test checking compatibility with invalid tool."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create an invalid tool (not inheriting from Tool)
|
|
class InvalidTool:
|
|
"""Test helper class."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the invalid tool."""
|
|
self.name = "invalid_tool"
|
|
|
|
invalid_tool = InvalidTool()
|
|
|
|
# Check compatibility
|
|
with pytest.raises(ToolCompatibilityError):
|
|
compatibility.check_compatibility(invalid_tool)
|
|
|
|
def test_check_compatibility_with_none_tool(self):
|
|
"""Test checking compatibility with None tool."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Check compatibility with None
|
|
with pytest.raises(ToolCompatibilityError):
|
|
compatibility.check_compatibility(None)
|
|
|
|
def test_check_compatibility_with_missing_attributes(self):
|
|
"""Test checking compatibility with tool missing attributes."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool missing required attributes
|
|
class IncompleteTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
# Missing name, version, 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"
|
|
|
|
incomplete_tool = IncompleteTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(incomplete_tool)
|
|
assert report is not None
|
|
assert report["compatible"] is False
|
|
assert len(report["issues"]) > 0
|
|
|
|
|
|
class TestToolCompatibilityAdvanced:
|
|
"""Test advanced tool compatibility functionality."""
|
|
|
|
def test_compatibility_with_complex_dependencies(self):
|
|
"""Test compatibility with complex dependencies."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool with complex dependencies
|
|
class ComplexDepsTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "complex_deps_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return [
|
|
"core>=1.0.0",
|
|
"utils>=2.0.0",
|
|
"network>=1.5.0",
|
|
"ml>=3.0.0"
|
|
]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
complex_deps_tool = ComplexDepsTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(complex_deps_tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
# Verify dependencies are checked
|
|
assert len(report["issues"]) > 0 or len(report["warnings"]) > 0
|
|
|
|
def test_compatibility_with_version_constraints(self):
|
|
"""Test compatibility with version constraints."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool with version constraints
|
|
class VersionConstrainedTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "version_constrained_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return [
|
|
"core>=1.0.0,<2.0.0",
|
|
"utils>=2.0.0,<=3.0.0"
|
|
]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
version_constrained_tool = VersionConstrainedTool()
|
|
|
|
# Check compatibility
|
|
report = compatibility.check_compatibility(version_constrained_tool)
|
|
assert report is not None
|
|
assert isinstance(report, dict)
|
|
|
|
def test_compatibility_with_conditional_checking(self):
|
|
"""Test compatibility with conditional checking."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create tools with different compatibility profiles
|
|
tools = []
|
|
|
|
# Compatible tool
|
|
class CompatibleTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "compatible_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
# Incompatible tool
|
|
class IncompatibleTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "incompatible_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["nonexistent>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
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"
|
|
|
|
tools.append(CompatibleTool())
|
|
tools.append(IncompatibleTool())
|
|
|
|
# Check compatibility for all tools
|
|
results = []
|
|
for tool in tools:
|
|
report = compatibility.check_compatibility(tool)
|
|
results.append(report)
|
|
|
|
# Verify different results
|
|
assert results[0]["compatible"] is True
|
|
assert results[1]["compatible"] is False
|
|
|
|
def test_compatibility_with_dynamic_dependency_management(self):
|
|
"""Test compatibility with dynamic dependency management."""
|
|
compatibility = ToolCompatibility()
|
|
|
|
# Create a tool with dynamic dependencies
|
|
class DynamicDepsTool(Tool):
|
|
"""Test tool implementation for compatibility testing."""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "dynamic_deps_tool"
|
|
|
|
@property
|
|
def version(self) -> str:
|
|
"""Get the tool version."""
|
|
return "1.0.0"
|
|
|
|
@property
|
|
def dependencies(self) -> List[str]:
|
|
"""Get the tool dependencies."""
|
|
return ["core>=1.0.0"]
|
|
|
|
def __init__(self):
|
|
"""Initialize the test tool."""
|
|
self.initialized = False
|
|
self.dynamic_dependencies = []
|
|
|
|
def initialize(self, container):
|
|
"""Initialize the tool with the container."""
|
|
self.initialized = True
|
|
# Add dynamic dependencies during initialization
|
|
self.dynamic_dependencies = ["utils>=2.0.0", "network>=1.0.0"]
|
|
|
|
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"
|
|
|
|
dynamic_deps_tool = DynamicDepsTool()
|
|
|
|
# Check compatibility before initialization
|
|
report1 = compatibility.check_compatibility(dynamic_deps_tool)
|
|
assert report1 is not None
|
|
|
|
# Initialize tool
|
|
dynamic_deps_tool.initialize(MagicMock())
|
|
|
|
# Check compatibility after initialization
|
|
report2 = compatibility.check_compatibility(dynamic_deps_tool)
|
|
assert report2 is not None
|
|
|
|
# Compare reports
|
|
assert report1 != report2
|