From 3368830f0500353462561bad5ca540dd7a175d17 Mon Sep 17 00:00:00 2001 From: OhMyApps <74984020+GiGiDKR@users.noreply.github.com> Date: Mon, 23 Jun 2025 23:24:38 +0200 Subject: [PATCH] fix: remove unused imports and clean up code in various files --- test_simulation_files/api_endpoints.py | 3 +- test_simulation_files/auth_manager.py | 1 - tests/test_integration_utf8.py | 26 +- tests/test_provider_utf8.py | 15 +- tests/test_utf8_localization.py | 21 +- tests/test_utf8_localization_fixed.py | 416 ------------------------- tests/test_workflow_utf8.py | 1 - 7 files changed, 27 insertions(+), 456 deletions(-) delete mode 100644 tests/test_utf8_localization_fixed.py diff --git a/test_simulation_files/api_endpoints.py b/test_simulation_files/api_endpoints.py index 3b8ed1a..a785985 100644 --- a/test_simulation_files/api_endpoints.py +++ b/test_simulation_files/api_endpoints.py @@ -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__) diff --git a/test_simulation_files/auth_manager.py b/test_simulation_files/auth_manager.py index 776881d..756a8da 100644 --- a/test_simulation_files/auth_manager.py +++ b/test_simulation_files/auth_manager.py @@ -2,7 +2,6 @@ import hashlib import pickle import sqlite3 -from flask import request, session class AuthenticationManager: diff --git a/tests/test_integration_utf8.py b/tests/test_integration_utf8.py index d6c28cd..ac1e7b9 100644 --- a/tests/test_integration_utf8.py +++ b/tests/test_integration_utf8.py @@ -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%+ diff --git a/tests/test_provider_utf8.py b/tests/test_provider_utf8.py index 0c3c8ee..cd66cb7 100644 --- a/tests/test_provider_utf8.py +++ b/tests/test_provider_utf8.py @@ -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 diff --git a/tests/test_utf8_localization.py b/tests/test_utf8_localization.py index d34f293..1d918b0 100644 --- a/tests/test_utf8_localization.py +++ b/tests/test_utf8_localization.py @@ -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) diff --git a/tests/test_utf8_localization_fixed.py b/tests/test_utf8_localization_fixed.py deleted file mode 100644 index d34f293..0000000 --- a/tests/test_utf8_localization_fixed.py +++ /dev/null @@ -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) diff --git a/tests/test_workflow_utf8.py b/tests/test_workflow_utf8.py index 9121c06..75a1770 100644 --- a/tests/test_workflow_utf8.py +++ b/tests/test_workflow_utf8.py @@ -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