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

style: fix linting and formatting issues

Browse Source 
- Run black formatter on all Python files
- Fix ruff linting issues:
  - Remove unused imports
  - Remove unused variables
  - Fix f-string without placeholders
- All 37 tests still pass
- Code quality improved for CI/CD compliance

🧹 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Fahad
2025-06-09 09:37:46 +04:00
parent fb5c04ea60
commit 5ccedcecd8
14 changed files with 376 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
tests/test_thinking_modes.py
View File

@@ -2,7 +2,6 @@
Tests for thinking_mode functionality across all tools
"""
import os
from unittest.mock import Mock, patch
import pytest
@@ -22,7 +21,7 @@ def setup_test_env():
class TestThinkingModes:
"""Test thinking modes across all tools"""
def test_default_thinking_modes(self):
"""Test that tools have correct default thinking modes"""
tools = [
@@ -31,35 +30,40 @@ class TestThinkingModes:
(ReviewCodeTool(), "medium"),
(DebugIssueTool(), "medium"),
]
for tool, expected_default in tools:
assert tool.get_default_thinking_mode() == expected_default, \
f"{tool.__class__.__name__} should default to {expected_default}"
assert (
tool.get_default_thinking_mode() == expected_default
), 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):
"""Test minimal thinking mode"""
mock_model = Mock()
mock_model.generate_content.return_value = Mock(
candidates=[Mock(content=Mock(parts=[Mock(text="Minimal thinking response")]))]
candidates=[
Mock(content=Mock(parts=[Mock(text="Minimal thinking response")]))
]
)
mock_create_model.return_value = mock_model
tool = AnalyzeTool()
result = await tool.execute({
"files": ["test.py"],
"question": "What is this?",
"thinking_mode": "minimal"
})
result = await tool.execute(
{
"files": ["test.py"],
"question": "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
assert result[0].text.startswith("Analysis:")
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_low(self, mock_create_model):
@@ -69,43 +73,44 @@ class TestThinkingModes:
candidates=[Mock(content=Mock(parts=[Mock(text="Low thinking response")]))]
)
mock_create_model.return_value = mock_model
tool = ReviewCodeTool()
result = await tool.execute({
"files": ["test.py"],
"thinking_mode": "low"
})
result = await tool.execute({"files": ["test.py"], "thinking_mode": "low"})
# 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"
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):
"""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")]))]
candidates=[
Mock(content=Mock(parts=[Mock(text="Medium thinking response")]))
]
)
mock_create_model.return_value = mock_model
tool = DebugIssueTool()
result = await tool.execute({
"error_description": "Test error",
# Not specifying thinking_mode, should use default (medium)
})
result = await tool.execute(
{
"error_description": "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"
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):
@@ -115,19 +120,21 @@ class TestThinkingModes:
candidates=[Mock(content=Mock(parts=[Mock(text="High thinking response")]))]
)
mock_create_model.return_value = mock_model
tool = AnalyzeTool()
result = await tool.execute({
"files": ["complex.py"],
"question": "Analyze architecture",
"thinking_mode": "high"
})
await tool.execute(
{
"files": ["complex.py"],
"question": "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"
@pytest.mark.asyncio
@patch("tools.base.BaseTool.create_model")
async def test_thinking_mode_max(self, mock_create_model):
@@ -137,47 +144,58 @@ class TestThinkingModes:
candidates=[Mock(content=Mock(parts=[Mock(text="Max thinking response")]))]
)
mock_create_model.return_value = mock_model
tool = ThinkDeeperTool()
result = await tool.execute({
"current_analysis": "Initial analysis",
# Not specifying thinking_mode, should use default (max)
})
result = await tool.execute(
{
"current_analysis": "Initial analysis",
# Not specifying thinking_mode, should use default (max)
}
)
# 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] == "max"
assert "Extended Analysis by Gemini" in result[0].text
def test_thinking_budget_mapping(self):
"""Test that thinking modes map to correct budget values"""
from tools.base import BaseTool
# Create a simple test tool
class TestTool(BaseTool):
def get_name(self): return "test"
def get_description(self): return "test"
def get_input_schema(self): return {}
def get_system_prompt(self): return "test"
def get_request_model(self): return None
async def prepare_prompt(self, request): return "test"
tool = TestTool()
def get_name(self):
return "test"
def get_description(self):
return "test"
def get_input_schema(self):
return {}
def get_system_prompt(self):
return "test"
def get_request_model(self):
return None
async def prepare_prompt(self, request):
return "test"
# Expected mappings
expected_budgets = {
"minimal": 128,
"low": 2048,
"medium": 8192,
"high": 16384,
"max": 32768
"max": 32768,
}
# Check each mode in create_model
for mode, expected_budget in expected_budgets.items():
# The budget mapping is inside create_model
# We can't easily test it without calling the method
# But we've verified the values are correct in the code
pass
pass