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

fix: remove unused imports and clean up code in various files

Browse Source
This commit is contained in:
OhMyApps
2025-06-23 23:24:38 +02:00
parent f8e559ebb2
commit 3368830f05
7 changed files with 27 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test_simulation_files/api_endpoints.py
View File

@@ -1,8 +1,9 @@
#!/usr/bin/env python3
from flask import Flask, request, jsonify
import os
import subprocess
import requests
from flask import Flask, jsonify, request
app = Flask(__name__)

1
test_simulation_files/auth_manager.py
View File

@@ -2,7 +2,6 @@
import hashlib
import pickle
import sqlite3
from flask import request, session
class AuthenticationManager:

26
tests/test_integration_utf8.py
View File

@@ -175,19 +175,19 @@ from typing import Dict, Optional
class GestionnairePreferences:
"""Gestionnaire des préférences utilisateur avec support UTF-8."""
def __init__(self):
self.données = {}
self.historique = []
def définir_préférence(self, clé: str, valeur) -> bool:
"""
Définit une préférence utilisateur.
Args:
clé: Identifiant de la préférence
valeur: Valeur à enregistrer
Returns:
True si la préférence a été définie avec succès
"""
@@ -202,18 +202,18 @@ class GestionnairePreferences:
except Exception as e:
print(f"Error setting preference: {e}")
return False
def obtenir_préférence(self, clé: str) -> Optional:
"""Récupère une préférence par sa clé."""
return self.données.get(clé)
def exporter_données(self) -> str:
"""Exporte les données en JSON UTF-8."""
return json.dumps(self.données, ensure_ascii=False, indent=2)
# Configuration par défaut avec caractères UTF-8
CONFIG_DÉFAUT = {
"langue": "français",
"langue": "français",
"région": "France",
"thème": "sombre",
"notifications": "activées"
@@ -222,11 +222,11 @@ CONFIG_DÉFAUT = {
def créer_gestionnaire() -> GestionnairePreferences:
"""Crée une instance du gestionnaire."""
gestionnaire = GestionnairePreferences()
# Application de la configuration par défaut
for clé, valeur in CONFIG_DÉFAUT.items():
gestionnaire.définir_préférence(clé, valeur)
return gestionnaire
if __name__ == "__main__":
@@ -243,7 +243,7 @@ if __name__ == "__main__":
try:
# Test reading
with open(temp_file, "r", encoding="utf-8") as f:
with open(temp_file, encoding="utf-8") as f:
read_content = f.read()
# Checks
@@ -293,7 +293,7 @@ The architectural analysis of the project has been **successfully** completed. H
### 🎯 Achieved Goals
- ✅ Complete code review
- ✅ Identification of performance issues
- ✅ Identification of performance issues
- ✅ Improvement recommendations generated
### 📊 Analyzed Metrics
@@ -312,14 +312,14 @@ No critical issues detected.
1. **Query performance**: Optimization needed
2. **Memory management**: Potential leaks detected
#### 🟡 Medium
#### 🟡 Medium
1. **Documentation**: Some functions lack comments
2. **Unit tests**: Coverage to be improved
### 🚀 Priority Recommendations
1. **DB Optimization**: Implement Redis cache
2. **Refactoring**: Separate responsibilities
2. **Refactoring**: Separate responsibilities
3. **Documentation**: Add missing docstrings
4. **Tests**: Increase coverage to 90%+

15
tests/test_provider_utf8.py
View File

@@ -10,9 +10,8 @@ from unittest.mock import Mock, patch
import pytest
from providers.base import ModelProvider, ProviderType
from providers.base import ProviderType
from providers.gemini import GeminiModelProvider
from providers.openai_compatible import OpenAICompatibleProvider
from providers.openai_provider import OpenAIModelProvider
@@ -98,13 +97,11 @@ class TestProviderUTF8Encoding(unittest.TestCase):
mock_client = Mock()
mock_client.chat.completions.create.return_value = mock_response
mock_openai_class.return_value = mock_client
# Test OpenAI provider
mock_openai_class.return_value = mock_client # Test OpenAI provider
provider = OpenAIModelProvider(api_key="test-key")
# Test with UTF-8 logging
with patch("logging.info") as mock_logging:
with patch("logging.info"):
response = provider.generate_content(
prompt="Generate Python code to process data",
model_name="gpt-4",
@@ -329,8 +326,7 @@ class TestLocaleModelIntegration(unittest.TestCase):
def test_system_prompt_enhancement_french(self):
"""Test system prompt enhancement with French locale."""
os.environ["LOCALE"] = "fr-FR"
provider = OpenAIModelProvider(api_key="test")
base_prompt = "You are a helpful coding assistant."
OpenAIModelProvider(api_key="test")
# Simulate language instruction
tool = DummyToolForLocaleTest()
instruction = tool.get_language_instruction()
@@ -339,8 +335,7 @@ class TestLocaleModelIntegration(unittest.TestCase):
def test_system_prompt_enhancement_multiple_locales(self):
"""Test enhancement with different locales."""
provider = OpenAIModelProvider(api_key="test")
base_prompt = "You are a helpful assistant."
OpenAIModelProvider(api_key="test")
locales = ["fr-FR", "es-ES", "de-DE", "it-IT", "pt-BR", "ja-JP", "zh-CN"]
for locale in locales:
os.environ["LOCALE"] = locale

21
tests/test_utf8_localization.py
View File

@@ -16,8 +16,6 @@ import tempfile
import unittest
from unittest.mock import AsyncMock, Mock, patch
import pytest
from tools.chat import ChatTool
from tools.codereview import CodeReviewTool
from tools.shared.base_tool import BaseTool
@@ -209,14 +207,13 @@ class TestUTF8Localization(unittest.TestCase):
# Created by: Lead Developer
# Creation date: December 15, 2024
def process_data(preferences, parameters):
'''
def process_data(preferences, parameters): '''
Processes data according to user preferences.
Args:
preferences: User preferences dictionary
parameters: Configuration parameters
Returns:
Processing result
'''
@@ -239,7 +236,7 @@ def generate_report():
try:
# Read file
with open(temp_file, "r", encoding="utf-8") as f:
with open(temp_file, encoding="utf-8") as f:
read_content = f.read()
# Checks
@@ -361,15 +358,13 @@ class TestLocalizationIntegration(unittest.TestCase):
"relevant_files": ["/test/example.py"],
"model": "test-model",
}
)
# Checks
) # Checks
self.assertIsNotNone(result)
self.assertEqual(len(result), 1)
# Parse JSON response - should be valid UTF-8
response_text = result[0].text
response_data = json.loads(response_text)
json.loads(response_text) # Validate JSON format
# Check that language instruction was used
mock_provider.generate_content.assert_called()
@@ -391,9 +386,7 @@ class TestLocalizationIntegration(unittest.TestCase):
# Spanish
os.environ["LOCALE"] = "es-ES"
instruction_es = tool.get_language_instruction()
self.assertIn("es-ES", instruction_es)
# Chinese
self.assertIn("es-ES", instruction_es) # Chinese
os.environ["LOCALE"] = "zh-CN"
instruction_zh = tool.get_language_instruction()
self.assertIn("zh-CN", instruction_zh)

416
tests/test_utf8_localization_fixed.py
View File

@@ -1,416 +0,0 @@
"""
Unit tests to validate UTF-8 localization and encoding
of French characters.
These tests check:
1. Language instruction generation according to LOCALE
2. UTF-8 encoding with json.dumps(ensure_ascii=False)
3. French characters and emojis are displayed correctly
4. MCP tools return localized content
"""
import asyncio
import json
import os
import tempfile
import unittest
from unittest.mock import AsyncMock, Mock, patch
import pytest
from tools.chat import ChatTool
from tools.codereview import CodeReviewTool
from tools.shared.base_tool import BaseTool
class TestTool(BaseTool):
"""Concrete implementation of BaseTool for testing."""
def __init__(self):
super().__init__()
def get_name(self) -> str:
return "test_tool"
def get_description(self) -> str:
return "A test tool for localization testing"
def get_input_schema(self) -> dict:
return {"type": "object", "properties": {}}
def get_system_prompt(self) -> str:
return "You are a test assistant."
def get_request_model(self):
return dict # Simple dict for testing
async def prepare_prompt(self, request) -> str:
return "Test prompt"
async def execute(self, arguments: dict) -> list:
return [Mock(text="test response")]
class TestUTF8Localization(unittest.TestCase):
"""Tests for UTF-8 localization and French character encoding."""
def setUp(self):
"""Test setup."""
self.original_locale = os.getenv("LOCALE")
def tearDown(self):
"""Cleanup after tests."""
if self.original_locale is not None:
os.environ["LOCALE"] = self.original_locale
else:
os.environ.pop("LOCALE", None)
def test_language_instruction_generation_french(self):
"""Test language instruction generation for French."""
# Set LOCALE to French
os.environ["LOCALE"] = "fr-FR"
# Test get_language_instruction method
tool = TestTool()
instruction = tool.get_language_instruction()
# Checks
self.assertIsInstance(instruction, str)
self.assertIn("fr-FR", instruction)
self.assertTrue(instruction.endswith("\n\n"))
def test_language_instruction_generation_english(self):
"""Test language instruction generation for English."""
# Set LOCALE to English
os.environ["LOCALE"] = "en-US"
tool = TestTool()
instruction = tool.get_language_instruction()
# Checks
self.assertIsInstance(instruction, str)
self.assertIn("en-US", instruction)
self.assertTrue(instruction.endswith("\n\n"))
def test_language_instruction_empty_locale(self):
"""Test with empty LOCALE."""
# Set LOCALE to empty
os.environ["LOCALE"] = ""
tool = TestTool()
instruction = tool.get_language_instruction()
# Should return empty string
self.assertEqual(instruction, "")
def test_language_instruction_no_locale(self):
"""Test with no LOCALE variable set."""
# Remove LOCALE
os.environ.pop("LOCALE", None)
tool = TestTool()
instruction = tool.get_language_instruction()
# Should return empty string
self.assertEqual(instruction, "")
def test_json_dumps_utf8_encoding(self):
"""Test that json.dumps uses ensure_ascii=False for UTF-8."""
# Test data with French characters and emojis
test_data = {
"status": "succès",
"message": "Tâche terminée avec succès",
"details": {
"créé": "2024-01-01",
"développeur": "Jean Dupont",
"préférences": ["français", "développement"],
"emojis": "🔴 🟠 🟡 🟢 ✅ ❌",
},
}
# Test with ensure_ascii=False (correct)
json_correct = json.dumps(test_data, ensure_ascii=False, indent=2)
# Check that UTF-8 characters are preserved
self.assertIn("succès", json_correct)
self.assertIn("terminée", json_correct)
self.assertIn("créé", json_correct)
self.assertIn("développeur", json_correct)
self.assertIn("préférences", json_correct)
self.assertIn("français", json_correct)
self.assertIn("développement", json_correct)
self.assertIn("🔴", json_correct)
self.assertIn("🟢", json_correct)
self.assertIn("✅", json_correct)
# Check that characters are NOT escaped
self.assertNotIn("\\u", json_correct)
self.assertNotIn("\\ud83d", json_correct)
def test_json_dumps_ascii_encoding_comparison(self):
"""Test comparison between ensure_ascii=True and False."""
test_data = {"message": "Développement réussi! 🎉"}
# With ensure_ascii=True (old, incorrect behavior)
json_escaped = json.dumps(test_data, ensure_ascii=True)
# With ensure_ascii=False (new, correct behavior)
json_utf8 = json.dumps(test_data, ensure_ascii=False)
# Checks
self.assertIn("\\u", json_escaped) # Characters are escaped
self.assertNotIn("é", json_escaped) # UTF-8 characters are escaped
self.assertNotIn("\\u", json_utf8) # No escaped characters
self.assertIn("é", json_utf8) # UTF-8 characters preserved
self.assertIn("🎉", json_utf8) # Emojis preserved
@patch("tools.shared.base_tool.BaseTool.get_model_provider")
async def test_chat_tool_french_response(self, mock_get_provider):
"""Test that the chat tool returns a response in French."""
# Set to French
os.environ["LOCALE"] = "fr-FR"
# Mock provider
mock_provider = Mock()
mock_provider.get_provider_type.return_value = Mock(value="test")
mock_provider.generate_content = AsyncMock(
return_value=Mock(
content="Bonjour! Je peux vous aider avec vos tâches.",
usage={},
model_name="test-model",
metadata={},
)
)
mock_get_provider.return_value = mock_provider
# Test chat tool
chat_tool = ChatTool()
result = await chat_tool.execute({"prompt": "Peux-tu m'aider?", "model": "test-model"})
# Checks
self.assertIsNotNone(result)
self.assertEqual(len(result), 1)
# Parse JSON response
response_data = json.loads(result[0].text)
# Check that response contains content
self.assertIn("status", response_data)
# Check that language instruction was added
mock_provider.generate_content.assert_called_once()
def test_french_characters_in_file_content(self):
"""Test reading and writing files with French characters."""
# Test content with French characters
test_content = """
# System configuration
# Created by: Lead Developer
# Creation date: December 15, 2024
def process_data(preferences, parameters):
'''
Processes data according to user preferences.
Args:
preferences: User preferences dictionary
parameters: Configuration parameters
Returns:
Processing result
'''
return "Processing completed successfully! ✅"
# Helper functions
def generate_report():
'''Generates a summary report.'''
return {
"status": "success",
"data": "Report generated",
"emojis": "📊 📈 📉"
}
"""
# Test writing and reading
with tempfile.NamedTemporaryFile(mode="w+", encoding="utf-8", delete=False) as f:
f.write(test_content)
temp_file = f.name
try:
# Read file
with open(temp_file, "r", encoding="utf-8") as f:
read_content = f.read()
# Checks
self.assertEqual(read_content, test_content)
self.assertIn("Lead Developer", read_content)
self.assertIn("Creation", read_content)
self.assertIn("preferences", read_content)
self.assertIn("parameters", read_content)
self.assertIn("completed", read_content)
self.assertIn("successfully", read_content)
self.assertIn("✅", read_content)
self.assertIn("success", read_content)
self.assertIn("generated", read_content)
self.assertIn("📊", read_content)
finally:
# Cleanup
os.unlink(temp_file)
def test_unicode_normalization(self):
"""Test Unicode normalization for accented characters."""
# Test with different Unicode encodings
test_cases = [
"café", # e + acute accent combined
"café", # e with precomposed acute accent
"naïf", # i + diaeresis
"coeur", # oe ligature
"été", # e + acute accent
]
for text in test_cases:
# Test that json.dumps preserves characters
json_output = json.dumps({"text": text}, ensure_ascii=False)
self.assertIn(text, json_output)
# Parse and check
parsed = json.loads(json_output)
self.assertEqual(parsed["text"], text)
def test_emoji_preservation(self):
"""Test emoji preservation in JSON encoding."""
# Emojis used in Zen MCP tools
emojis = [
"🔴", # Critical
"🟠", # High
"🟡", # Medium
"🟢", # Low
"✅", # Success
"❌", # Error
"⚠️", # Warning
"📊", # Charts
"🎉", # Celebration
"🚀", # Rocket
"🇫🇷", # French flag
]
test_data = {"emojis": emojis, "message": " ".join(emojis)}
# Test with ensure_ascii=False
json_output = json.dumps(test_data, ensure_ascii=False)
# Checks
for emoji in emojis:
self.assertIn(emoji, json_output)
# No escaped characters
self.assertNotIn("\\u", json_output)
# Test parsing
parsed = json.loads(json_output)
self.assertEqual(parsed["emojis"], emojis)
self.assertEqual(parsed["message"], " ".join(emojis))
class TestLocalizationIntegration(unittest.TestCase):
"""Integration tests for localization with real tools."""
def setUp(self):
"""Integration test setup."""
self.original_locale = os.getenv("LOCALE")
def tearDown(self):
"""Cleanup after integration tests."""
if self.original_locale is not None:
os.environ["LOCALE"] = self.original_locale
else:
os.environ.pop("LOCALE", None)
@patch("tools.shared.base_tool.BaseTool.get_model_provider")
async def test_codereview_tool_french_locale(self, mock_get_provider):
"""Test that the codereview tool uses French localization."""
# Set to French
os.environ["LOCALE"] = "fr-FR"
# Mock provider with French response
mock_provider = Mock()
mock_provider.get_provider_type.return_value = Mock(value="test")
mock_provider.generate_content = AsyncMock(
return_value=Mock(
content=json.dumps(
{"status": "analysis_complete", "raw_analysis": "Code review completed. 🟢"}, ensure_ascii=False
),
usage={},
model_name="test-model",
metadata={},
)
)
mock_get_provider.return_value = mock_provider
# Test codereview tool
codereview_tool = CodeReviewTool()
result = await codereview_tool.execute(
{
"step": "Source code review",
"step_number": 1,
"total_steps": 1,
"next_step_required": False,
"findings": "Python code analysis",
"relevant_files": ["/test/example.py"],
"model": "test-model",
}
)
# Checks
self.assertIsNotNone(result)
self.assertEqual(len(result), 1)
# Parse JSON response - should be valid UTF-8
response_text = result[0].text
response_data = json.loads(response_text)
# Check that language instruction was used
mock_provider.generate_content.assert_called()
def test_multiple_locales_switching(self):
"""Test switching locales during execution."""
tool = TestTool()
# French
os.environ["LOCALE"] = "fr-FR"
instruction_fr = tool.get_language_instruction()
self.assertIn("fr-FR", instruction_fr)
# English
os.environ["LOCALE"] = "en-US"
instruction_en = tool.get_language_instruction()
self.assertIn("en-US", instruction_en)
# Spanish
os.environ["LOCALE"] = "es-ES"
instruction_es = tool.get_language_instruction()
self.assertIn("es-ES", instruction_es)
# Chinese
os.environ["LOCALE"] = "zh-CN"
instruction_zh = tool.get_language_instruction()
self.assertIn("zh-CN", instruction_zh)
# Check that all instructions are different
instructions = [instruction_fr, instruction_en, instruction_es, instruction_zh]
for i, inst1 in enumerate(instructions):
for j, inst2 in enumerate(instructions):
if i != j:
self.assertNotEqual(inst1, inst2)
# Helper function to run async tests
def run_async_test(test_func):
"""Helper to run async test functions."""
return asyncio.run(test_func())
if __name__ == "__main__":
unittest.main(verbosity=2)

1
tests/test_workflow_utf8.py
View File

@@ -5,7 +5,6 @@ and the generation of properly encoded JSON responses.
import json
import os
import tempfile
import unittest
from unittest.mock import Mock, patch