# In mcp_server/__init__.py

@with_monitoring("my_new_tool")
async def my_new_tool_impl(param1: str, param2: int = 10) -> Dict[str, Any]:
    """Implementation function with monitoring."""
    try:
        # Your business logic here
        result = f"Processed {param1} with {param2}"
        
        return {
            "result": result,
            "status": "✅ Success",
            "timestamp": time.time()
        }
        
    except Exception as e:
        raise MCPError(f"Tool failed: {str(e)}")

@mcp.tool()
async def my_new_tool(param1: str, param2: int = 10) -> Dict[str, Any]:
    """User-facing tool function."""
    result: Dict[str, Any] = await my_new_tool_impl(param1, param2)
    return result

# In tests/test_my_tool.py

import pytest
from mcp_server import my_new_tool_impl, MCPError

@pytest.mark.asyncio
async def test_my_new_tool_success():
    """Test successful tool execution."""
    result = await my_new_tool_impl("test", 5)
    
    assert result["status"] == "✅ Success"
    assert "test" in result["result"]
    assert result["timestamp"] > 0

@pytest.mark.asyncio
async def test_my_new_tool_error_handling():
    """Test error handling."""
    with pytest.raises(MCPError):
        await my_new_tool_impl("", -1)  # Invalid inputs

def validate_input(param: str) -> str:
    """Validate and sanitize inputs."""
    if not param or len(param.strip()) == 0:
        raise MCPError("Parameter cannot be empty")
    
    # Remove potentially dangerous characters
    sanitized = re.sub(r'[<>"]', '', param.strip())
    return sanitized

async def secure_file_operation(file_path: str) -> Dict[str, Any]:
    """Always use validate_path for file operations."""
    try:
        validated_path = validate_path(file_path)
        # Safe to proceed with validated_path
        return {"path": str(validated_path)}
    except Exception as e:
        raise MCPError(f"Invalid path: {str(e)}")

import pytest
from unittest.mock import patch, AsyncMock
from mcp_server import tool_function_impl, MCPError

class TestMyTool:
    """Test suite for my_tool functionality."""
    
    @pytest.mark.asyncio
    async def test_happy_path(self):
        """Test normal operation."""
        # Setup
        # Execute  
        # Assert
        
    @pytest.mark.asyncio
    async def test_error_conditions(self):
        """Test error handling."""
        # Test various error scenarios
        
    @pytest.mark.asyncio  
    async def test_edge_cases(self):
        """Test boundary conditions."""
        # Test edge cases and limits

@patch('mcp_server.subprocess.run')
@pytest.mark.asyncio
async def test_command_execution(mock_run):
    """Test command execution with mocked subprocess."""
    # Mock the subprocess.run call
    mock_run.return_value.returncode = 0
    mock_run.return_value.stdout = "success"
    mock_run.return_value.stderr = ""
    
    result = await run_command_impl(["echo", "test"])
    assert result["success"] is True

@pytest.mark.asyncio
async def test_async_operations():
    """Test asynchronous operations properly."""
    # Use await for async functions
    result = await async_function()
    
    # Use AsyncMock for async mocks
    with patch('mcp_server.async_dep', new_callable=AsyncMock) as mock:
        mock.return_value = "mocked"
        result = await function_using_async_dep()
        mock.assert_called_once()

# Add benchmark for new tools
import time

@with_monitoring("performance_test")
async def benchmark_my_tool():
    """Benchmark tool performance."""
    start = time.time()
    
    # Run tool multiple times
    for _ in range(100):
        await my_new_tool_impl("test", 10)
    
    duration = time.time() - start
    return {
        "tool": "my_new_tool",
        "iterations": 100,
        "total_duration": duration,
        "avg_duration": duration / 100
    }

import tracemalloc

async def test_memory_usage():
    """Test memory usage of tools."""
    tracemalloc.start()
    
    # Run your tool
    await my_new_tool_impl("test", 10)
    
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    
    assert peak < 10 * 1024 * 1024  # Less than 10MB

@pytest.mark.asyncio
async def test_path_traversal_prevention():
    """Test directory traversal attack prevention."""
    dangerous_paths = [
        "../../../etc/passwd",
        "/etc/passwd", 
        "\\..\\..\\windows\\system32"
    ]
    
    for path in dangerous_paths:
        with pytest.raises(MCPError, match="outside allowed directory"):
            await read_file_impl(path)

@patch('mcp_server.RATE_LIMITER')
@pytest.mark.asyncio
async def test_rate_limiting(mock_limiter):
    """Test rate limiting behavior."""
    mock_limiter.hit.return_value = False  # Simulate rate limit exceeded
    
    with pytest.raises(RateLimitExceeded):
        await my_tool_impl("test")