torbjorn/my-pal-mcp-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP major refactor and features

Browse Source
This commit is contained in:
Fahad
2025-06-12 07:14:59 +04:00
parent e06a6fd1fc
commit 2a067a7f4e
46 changed files with 2960 additions and 1011 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
tests/test_thinking_modes.py
View File

@@ -3,6 +3,7 @@ Tests for thinking_mode functionality across all tools
"""
from unittest.mock import Mock, patch
from tests.mock_helpers import create_mock_provider
import pytest
@@ -37,28 +38,35 @@ class TestThinkingModes:
), f"{tool.__class__.__name__} should default to {expected_default}"
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_minimal(self, mock_create_model):
@patch("tools.base.BaseTool.get_model_provider")
async def test_thinking_mode_minimal(self, mock_get_provider):
"""Test minimal thinking mode"""
mock_model = Mock()
mock_model.generate_content.return_value = Mock(
candidates=[Mock(content=Mock(parts=[Mock(text="Minimal thinking response")]))]
mock_provider = create_mock_provider()
mock_provider.get_provider_type.return_value = Mock(value="google")
mock_provider.supports_thinking_mode.return_value = True
mock_provider.generate_content.return_value = Mock(
content="Minimal thinking response",
usage={},
model_name="gemini-2.0-flash-exp",
metadata={}
)
mock_create_model.return_value = mock_model
mock_get_provider.return_value = mock_provider
tool = AnalyzeTool()
result = await tool.execute(
{
"files": ["/absolute/path/test.py"],
"question": "What is this?",
"prompt": "What is this?",
"thinking_mode": "minimal",
}
)
# Verify create_model was called with correct thinking_mode
mock_create_model.assert_called_once()
args = mock_create_model.call_args[0]
assert args[2] == "minimal" # thinking_mode parameter
mock_get_provider.assert_called_once()
# Verify generate_content was called with thinking_mode
mock_provider.generate_content.assert_called_once()
call_kwargs = mock_provider.generate_content.call_args[1]
assert call_kwargs.get("thinking_mode") == "minimal" or (not mock_provider.supports_thinking_mode.return_value and call_kwargs.get("thinking_mode") is None) # thinking_mode parameter
# Parse JSON response
import json
@@ -68,102 +76,130 @@ class TestThinkingModes:
assert response_data["content"].startswith("Analysis:")
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_low(self, mock_create_model):
@patch("tools.base.BaseTool.get_model_provider")
async def test_thinking_mode_low(self, mock_get_provider):
"""Test low thinking mode"""
mock_model = Mock()
mock_model.generate_content.return_value = Mock(
candidates=[Mock(content=Mock(parts=[Mock(text="Low thinking response")]))]
mock_provider = create_mock_provider()
mock_provider.get_provider_type.return_value = Mock(value="google")
mock_provider.supports_thinking_mode.return_value = True
mock_provider.generate_content.return_value = Mock(
content="Low thinking response",
usage={},
model_name="gemini-2.0-flash-exp",
metadata={}
)
mock_create_model.return_value = mock_model
mock_get_provider.return_value = mock_provider
tool = CodeReviewTool()
result = await tool.execute(
{
"files": ["/absolute/path/test.py"],
"thinking_mode": "low",
"context": "Test code review for validation purposes",
"prompt": "Test code review for validation purposes",
}
)
# Verify create_model was called with correct thinking_mode
mock_create_model.assert_called_once()
args = mock_create_model.call_args[0]
assert args[2] == "low"
mock_get_provider.assert_called_once()
# Verify generate_content was called with thinking_mode
mock_provider.generate_content.assert_called_once()
call_kwargs = mock_provider.generate_content.call_args[1]
assert call_kwargs.get("thinking_mode") == "low" or (not mock_provider.supports_thinking_mode.return_value and call_kwargs.get("thinking_mode") is None)
assert "Code Review" in result[0].text
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_medium(self, mock_create_model):
@patch("tools.base.BaseTool.get_model_provider")
async def test_thinking_mode_medium(self, mock_get_provider):
"""Test medium thinking mode (default for most tools)"""
mock_model = Mock()
mock_model.generate_content.return_value = Mock(
candidates=[Mock(content=Mock(parts=[Mock(text="Medium thinking response")]))]
mock_provider = create_mock_provider()
mock_provider.get_provider_type.return_value = Mock(value="google")
mock_provider.supports_thinking_mode.return_value = True
mock_provider.generate_content.return_value = Mock(
content="Medium thinking response",
usage={},
model_name="gemini-2.0-flash-exp",
metadata={}
)
mock_create_model.return_value = mock_model
mock_get_provider.return_value = mock_provider
tool = DebugIssueTool()
result = await tool.execute(
{
"error_description": "Test error",
"prompt": "Test error",
# Not specifying thinking_mode, should use default (medium)
}
)
# Verify create_model was called with default thinking_mode
mock_create_model.assert_called_once()
args = mock_create_model.call_args[0]
assert args[2] == "medium"
mock_get_provider.assert_called_once()
# Verify generate_content was called with thinking_mode
mock_provider.generate_content.assert_called_once()
call_kwargs = mock_provider.generate_content.call_args[1]
assert call_kwargs.get("thinking_mode") == "medium" or (not mock_provider.supports_thinking_mode.return_value and call_kwargs.get("thinking_mode") is None)
assert "Debug Analysis" in result[0].text
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_high(self, mock_create_model):
@patch("tools.base.BaseTool.get_model_provider")
async def test_thinking_mode_high(self, mock_get_provider):
"""Test high thinking mode"""
mock_model = Mock()
mock_model.generate_content.return_value = Mock(
candidates=[Mock(content=Mock(parts=[Mock(text="High thinking response")]))]
mock_provider = create_mock_provider()
mock_provider.get_provider_type.return_value = Mock(value="google")
mock_provider.supports_thinking_mode.return_value = True
mock_provider.generate_content.return_value = Mock(
content="High thinking response",
usage={},
model_name="gemini-2.0-flash-exp",
metadata={}
)
mock_create_model.return_value = mock_model
mock_get_provider.return_value = mock_provider
tool = AnalyzeTool()
await tool.execute(
{
"files": ["/absolute/path/complex.py"],
"question": "Analyze architecture",
"prompt": "Analyze architecture",
"thinking_mode": "high",
}
)
# Verify create_model was called with correct thinking_mode
mock_create_model.assert_called_once()
args = mock_create_model.call_args[0]
assert args[2] == "high"
mock_get_provider.assert_called_once()
# Verify generate_content was called with thinking_mode
mock_provider.generate_content.assert_called_once()
call_kwargs = mock_provider.generate_content.call_args[1]
assert call_kwargs.get("thinking_mode") == "high" or (not mock_provider.supports_thinking_mode.return_value and call_kwargs.get("thinking_mode") is None)
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_max(self, mock_create_model):
@patch("tools.base.BaseTool.get_model_provider")
async def test_thinking_mode_max(self, mock_get_provider):
"""Test max thinking mode (default for thinkdeep)"""
mock_model = Mock()
mock_model.generate_content.return_value = Mock(
candidates=[Mock(content=Mock(parts=[Mock(text="Max thinking response")]))]
mock_provider = create_mock_provider()
mock_provider.get_provider_type.return_value = Mock(value="google")
mock_provider.supports_thinking_mode.return_value = True
mock_provider.generate_content.return_value = Mock(
content="Max thinking response",
usage={},
model_name="gemini-2.0-flash-exp",
metadata={}
)
mock_create_model.return_value = mock_model
mock_get_provider.return_value = mock_provider
tool = ThinkDeepTool()
result = await tool.execute(
{
"current_analysis": "Initial analysis",
"prompt": "Initial analysis",
# Not specifying thinking_mode, should use default (high)
}
)
# Verify create_model was called with default thinking_mode
mock_create_model.assert_called_once()
args = mock_create_model.call_args[0]
assert args[2] == "high"
mock_get_provider.assert_called_once()
# Verify generate_content was called with thinking_mode
mock_provider.generate_content.assert_called_once()
call_kwargs = mock_provider.generate_content.call_args[1]
assert call_kwargs.get("thinking_mode") == "high" or (not mock_provider.supports_thinking_mode.return_value and call_kwargs.get("thinking_mode") is None)
assert "Extended Analysis by Gemini" in result[0].text