auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/llms/test_remove_functionality.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+测试脚本：验证删除模型功能是否正常工作
+"""
+
+import sys
+import tempfile
+import json
+from pathlib import Path
+
+# 添加项目根目录到 sys.path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from autocoder.common.llms.manager import LLMManager
+
+
+def test_remove_functionality():
+    """测试删除模型功能"""
+    print("=== 测试删除模型功能 ===\n")
+    
+    # 使用临时目录避免影响用户配置
+    with tempfile.TemporaryDirectory() as temp_dir:
+        models_json = Path(temp_dir) / "models.json"
+        print(f"使用临时目录: {temp_dir}")
+        
+        # 1. 初始化 LLMManager
+        print("\n1. 初始化 LLMManager...")
+        manager = LLMManager(str(models_json))
+        print(f"   ✓ 初始化完成，当前模型数量: {len(manager.get_all_models())}")
+        
+        # 2. 添加一些测试模型
+        print("\n2. 添加测试模型...")
+        test_models = [
+            {
+                "name": "test/model1",
+                "model_name": "test-model-1",
+                "model_type": "saas/openai",
+                "base_url": "https://test1.api.com/v1",
+                "description": "测试模型1"
+            },
+            {
+                "name": "test/model2",
+                "model_name": "test-model-2",
+                "model_type": "saas/openai",
+                "base_url": "https://test2.api.com/v1",
+                "description": "测试模型2",
+                "api_key": "test-key-123"
+            }
+        ]
+        
+        manager.add_models(test_models)  # type: ignore
+        total_models = len(manager.get_all_models())
+        print(f"   ✓ 添加了 {len(test_models)} 个测试模型")
+        print(f"   ✓ 当前总模型数量: {total_models}")
+        
+        # 验证模型已添加
+        for model_data in test_models:
+            if manager.check_model_exists(model_data["name"]):
+                print(f"   ✓ 模型 {model_data['name']} 已成功添加")
+                if "api_key" in model_data:
+                    has_key = manager.has_key(model_data["name"])
+                    print(f"     - API 密钥状态: {'✓ 已配置' if has_key else '✗ 未配置'}")
+            else:
+                print(f"   ✗ 模型 {model_data['name']} 添加失败")
+        
+        # 3. 测试删除自定义模型
+        print("\n3. 测试删除自定义模型...")
+        model_to_remove = "test/model1"
+        
+        print(f"   删除前模型数量: {len(manager.get_all_models())}")
+        result = manager.remove_model(model_to_remove)
+        
+        if result:
+            print(f"   ✓ 成功删除模型: {model_to_remove}")
+            print(f"   ✓ 删除后模型数量: {len(manager.get_all_models())}")
+            
+            # 验证模型确实被删除了
+            if not manager.check_model_exists(model_to_remove):
+                print(f"   ✓ 确认模型 {model_to_remove} 已不存在")
+            else:
+                print(f"   ✗ 错误：模型 {model_to_remove} 仍然存在")
+        else:
+            print(f"   ✗ 删除模型失败: {model_to_remove}")
+        
+        # 4. 测试删除带有 API 密钥的模型
+        print("\n4. 测试删除带有 API 密钥的模型...")
+        model_with_key = "test/model2"
+        
+        print(f"   删除前密钥状态: {'✓ 已配置' if manager.has_key(model_with_key) else '✗ 未配置'}")
+        result = manager.remove_model(model_with_key)
+        
+        if result:
+            print(f"   ✓ 成功删除带密钥的模型: {model_with_key}")
+            
+            # 验证模型和密钥都被删除了
+            if not manager.check_model_exists(model_with_key):
+                print(f"   ✓ 确认模型 {model_with_key} 已不存在")
+            else:
+                print(f"   ✗ 错误：模型 {model_with_key} 仍然存在")
+        else:
+            print(f"   ✗ 删除带密钥的模型失败: {model_with_key}")
+        
+        # 5. 测试删除默认模型（应该失败）
+        print("\n5. 测试删除默认模型（应该失败）...")
+        default_model = "deepseek/v3"
+        
+        result = manager.remove_model(default_model)
+        if not result:
+            print(f"   ✓ 正确：无法删除默认模型 {default_model}")
+            
+            # 验证默认模型仍然存在
+            if manager.check_model_exists(default_model):
+                print(f"   ✓ 确认默认模型 {default_model} 仍然存在")
+            else:
+                print(f"   ✗ 错误：默认模型 {default_model} 被意外删除")
+        else:
+            print(f"   ✗ 错误：成功删除了默认模型 {default_model}（这不应该发生）")
+        
+        # 6. 测试删除不存在的模型
+        print("\n6. 测试删除不存在的模型...")
+        nonexistent_model = "non/existent"
+        
+        result = manager.remove_model(nonexistent_model)
+        if not result:
+            print(f"   ✓ 正确：无法删除不存在的模型 {nonexistent_model}")
+        else:
+            print(f"   ✗ 错误：声称成功删除了不存在的模型 {nonexistent_model}")
+        
+        # 7. 最终验证
+        print("\n7. 最终验证...")
+        final_models = manager.get_all_models()
+        custom_models = [name for name in final_models.keys() if name.startswith("test/")]
+        
+        print(f"   ✓ 最终模型总数: {len(final_models)}")
+        print(f"   ✓ 剩余测试模型数量: {len(custom_models)}")
+        
+        if len(custom_models) == 0:
+            print("   ✓ 所有测试模型已成功清理")
+        else:
+            print(f"   ⚠️  仍有测试模型未清理: {custom_models}")
+        
+        # 检查默认模型是否完整
+        default_models = ["deepseek/v3", "deepseek/r1", "ark/deepseek-v3-250324"]
+        missing_defaults = [name for name in default_models if not manager.check_model_exists(name)]
+        
+        if not missing_defaults:
+            print("   ✓ 所有默认模型都完整保留")
+        else:
+            print(f"   ✗ 缺失的默认模型: {missing_defaults}")
+    
+    print("\n=== 删除功能测试完成 ===")
+
+
+def test_models_command_integration():
+    """测试与 models_command 的集成"""
+    print("\n=== 测试与 models_command 的集成 ===\n")
+    
+    # 这部分可以通过模拟 handle_models_command 函数来测试
+    # 但为了简单起见，我们只提供使用示例
+    print("使用示例：")
+    print("1. 添加模型：/models /add_model name=test/demo base_url=https://demo.com/v1")
+    print("2. 列出模型：/models /list")
+    print("3. 删除模型：/models /remove test/demo")
+    print("4. 验证删除：/models /list")
+    
+    print("\n预期行为：")
+    print("- 自定义模型应该能被成功删除")
+    print("- 删除后模型不应该出现在列表中")
+    print("- 默认模型不能被删除")
+    print("- 删除不存在的模型应该显示错误消息")
+
+
+if __name__ == "__main__":
+    try:
+        test_remove_functionality()
+        test_models_command_integration()
+        print("\n🎉 所有测试完成！删除功能工作正常。")
+    except Exception as e:
+        print(f"\n❌ 测试过程中出现错误: {e}")
+        import traceback
+        traceback.print_exc() 

autocoder/common/llms/tests/__init__.py

@@ -0,0 +1 @@
+# 测试模块 

autocoder/common/llms/tests/test_manager.py

@@ -0,0 +1,330 @@
+import unittest
+import tempfile
+import json
+from pathlib import Path
+from typing import List, Dict, Any
+from unittest.mock import patch, MagicMock
+
+from ..manager import LLMManager
+from ..schema import LLMModel
+
+
+class TestLLMManager(unittest.TestCase):
+    """LLMManager 单元测试"""
+    
+    def setUp(self):
+        """设置测试环境"""
+        # 创建临时目录和文件
+        self.temp_dir = tempfile.mkdtemp()
+        self.models_json = Path(self.temp_dir) / "models.json"
+        self.models_json.parent.mkdir(parents=True, exist_ok=True)
+        
+        # 创建测试用的模型配置
+        self.test_models = [
+            {
+                "name": "test/model1",
+                "model_name": "test-model-1",
+                "model_type": "saas/openai",
+                "base_url": "https://test.api.com/v1",
+                "context_window": 32768,
+                "max_output_tokens": 4096
+            }
+        ]
+        
+        # 写入测试配置
+        with open(self.models_json, 'w') as f:
+            json.dump(self.test_models, f)
+        
+        # 创建管理器实例，使用临时目录
+        self.manager = LLMManager(str(self.models_json))
+    
+    def tearDown(self):
+        """清理测试环境"""
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+    
+    def test_get_model(self):
+        """测试获取模型"""
+        # 获取存在的模型
+        model = self.manager.get_model("test/model1")
+        self.assertIsInstance(model, LLMModel)
+        self.assertIsNotNone(model)
+        if model:  # Type guard
+            self.assertEqual(model.name, "test/model1")
+            self.assertEqual(model.model_name, "test-model-1")
+        
+        # 获取不存在的模型
+        model = self.manager.get_model("non/existent")
+        self.assertIsNone(model)
+    
+    def test_get_all_models(self):
+        """测试获取所有模型"""
+        models = self.manager.get_all_models()
+        self.assertIsInstance(models, dict)
+        self.assertGreater(len(models), 0)
+        
+        # 应该包含测试模型
+        self.assertIn("test/model1", models)
+        
+        # 应该包含一些默认模型
+        self.assertIn("deepseek/v3", models)
+    
+    def test_add_models(self):
+        """测试添加模型"""
+        new_models = [{
+            "name": "test/model2",
+            "model_name": "test-model-2",
+            "model_type": "saas/openai",
+            "base_url": "https://test2.api.com/v1",
+            "context_window": 65536
+        }]
+        
+        self.manager.add_models(new_models)  # type: ignore
+        
+        # 验证模型已添加
+        model = self.manager.get_model("test/model2")
+        self.assertIsNotNone(model)
+        if model:  # Type guard
+            self.assertEqual(model.name, "test/model2")
+            self.assertEqual(model.context_window, 65536)
+    
+    def test_has_key(self):
+        """测试密钥检查"""
+        # 没有密钥的模型
+        self.assertFalse(self.manager.has_key("test/model1"))
+        
+        # 使用 manager 的 update_model_with_api_key 方法来保存密钥
+        result = self.manager.update_model_with_api_key("test/model1", "test-api-key")
+        self.assertTrue(result)
+        
+        # 现在应该有密钥了
+        self.assertTrue(self.manager.has_key("test/model1"))
+    
+    def test_update_price(self):
+        """测试价格更新"""
+        # 更新输入价格
+        result = self.manager.update_input_price("test/model1", 1.5)
+        self.assertTrue(result)
+        
+        model = self.manager.get_model("test/model1")
+        self.assertIsNotNone(model)
+        if model:
+            self.assertEqual(model.input_price, 1.5)
+        
+        # 更新输出价格
+        result = self.manager.update_output_price("test/model1", 3.0)
+        self.assertTrue(result)
+        
+        model = self.manager.get_model("test/model1")
+        self.assertIsNotNone(model)
+        if model:
+            self.assertEqual(model.output_price, 3.0)
+        
+        # 同时更新
+        result = self.manager.update_price("test/model1", input_price=2.0, output_price=4.0)
+        self.assertTrue(result)
+        
+        model = self.manager.get_model("test/model1")
+        self.assertIsNotNone(model)
+        if model:
+            self.assertEqual(model.input_price, 2.0)
+            self.assertEqual(model.output_price, 4.0)
+    
+    def test_cost_estimate(self):
+        """测试成本估算"""
+        # 设置价格
+        self.manager.update_price("test/model1", input_price=1.0, output_price=2.0)
+        
+        # 估算成本
+        cost = self.manager.get_cost_estimate("test/model1", 
+                                            input_tokens=1_000_000,
+                                            output_tokens=500_000)
+        
+        # 验证计算：1M * $1 + 0.5M * $2 = $2.0
+        self.assertEqual(cost, 2.0)
+        
+        # 测试不存在的模型
+        cost = self.manager.get_cost_estimate("non/existent", 
+                                            input_tokens=1000,
+                                            output_tokens=500)
+        self.assertIsNone(cost)
+    
+    def test_check_model_exists(self):
+        """测试模型存在性检查"""
+        self.assertTrue(self.manager.check_model_exists("test/model1"))
+        self.assertFalse(self.manager.check_model_exists("non/existent"))
+        
+        # 测试默认模型
+        self.assertTrue(self.manager.check_model_exists("deepseek/v3"))
+    
+    def test_update_model(self):
+        """测试更新模型信息"""
+        # 更新模型描述
+        result = self.manager.update_model("test/model1", {
+            "description": "Updated test model",
+            "input_price": 2.5
+        })
+        
+        self.assertIsNotNone(result)
+        
+        # 验证更新
+        model = self.manager.get_model("test/model1")
+        self.assertIsNotNone(model)
+        if model:
+            self.assertEqual(model.description, "Updated test model")
+            self.assertEqual(model.input_price, 2.5)
+        
+        # 测试更新不存在的模型
+        result = self.manager.update_model("non/existent", {"description": "test"})
+        self.assertIsNone(result)
+    
+    def test_get_model_info_compatibility(self):
+        """测试兼容性接口"""
+        # lite 模式应该返回模型信息
+        model_info = self.manager.get_model_info("test/model1", "lite")
+        self.assertIsNotNone(model_info)
+        self.assertIsInstance(model_info, dict)
+        if model_info:
+            self.assertEqual(model_info["name"], "test/model1")
+        
+        # pro 模式应该返回 None
+        model_info = self.manager.get_model_info("test/model1", "pro")
+        self.assertIsNone(model_info)
+        
+        # 不存在的模型应该返回 None
+        model_info = self.manager.get_model_info("non/existent", "lite")
+        self.assertIsNone(model_info)
+    
+    @patch('autocoder.common.llms.factory.byzerllm.SimpleByzerLLM')
+    def test_get_single_llm_lite(self, mock_llm_class):
+        """测试 lite 模式下获取 LLM 实例"""
+        # 准备模拟对象
+        mock_instance = MagicMock()
+        mock_llm_class.return_value = mock_instance
+        
+        # 添加带密钥的模型
+        model_with_key = {
+            "name": "test/model_key",
+            "model_name": "test-model-key",
+            "model_type": "saas/openai",
+            "base_url": "https://test.api.com/v1",
+            "api_key": "test-key-123"
+        }
+        self.manager.add_models([model_with_key])
+        
+        # 获取 LLM 实例
+        result = self.manager.get_single_llm("test/model_key", "lite")
+        
+        # 验证调用
+        self.assertIsNotNone(result)
+        mock_llm_class.assert_called_once_with(default_model_name="test/model_key")
+        mock_instance.deploy.assert_called_once()
+        
+        # 验证 deploy 参数
+        call_args = mock_instance.deploy.call_args
+        self.assertEqual(call_args[1]['udf_name'], "test/model_key")
+        self.assertEqual(call_args[1]['pretrained_model_type'], "saas/openai")
+    
+    def test_get_single_llm_no_key(self):
+        """测试没有密钥的模型获取 LLM 实例"""
+        # 尝试获取没有密钥的模型，现在应该抛出 ValueError
+        with self.assertRaises(ValueError) as context:
+            self.manager.get_single_llm("test/model1", "lite")
+        
+        error_message = str(context.exception)
+        self.assertIn("Failed to create LLM instance", error_message)
+        self.assertIn("test/model1", error_message)
+        self.assertIn("has no API key configured", error_message)
+    
+    def test_get_single_llm_multiple_models(self):
+        """测试多个模型名称的处理"""
+        # 添加带密钥的模型
+        model_with_key = {
+            "name": "test/model_key",
+            "model_name": "test-model-key",
+            "model_type": "saas/openai",
+            "base_url": "https://test.api.com/v1",
+            "api_key": "test-key-123"
+        }
+        self.manager.add_models([model_with_key])
+        
+        # 测试多个模型名称，第一个没有密钥，第二个有密钥
+        with patch('autocoder.common.llms.factory.byzerllm.SimpleByzerLLM') as mock_llm_class:
+            mock_instance = MagicMock()
+            mock_llm_class.return_value = mock_instance
+            
+            result = self.manager.get_single_llm("test/model1,test/model_key", "lite")
+            
+            # 应该跳过第一个模型，使用第二个模型
+            self.assertIsNotNone(result)
+            mock_llm_class.assert_called_once_with(default_model_name="test/model_key")
+    
+    def test_remove_model(self):
+        """测试删除模型"""
+        # 添加一个自定义模型
+        custom_model = {
+            "name": "test/removable",
+            "model_name": "test-removable",
+            "model_type": "saas/openai",
+            "base_url": "https://test.com/v1"
+        }
+        self.manager.add_models([custom_model])  # type: ignore
+        
+        # 验证模型已添加
+        self.assertTrue(self.manager.check_model_exists("test/removable"))
+        
+        # 删除模型
+        result = self.manager.remove_model("test/removable")
+        self.assertTrue(result)
+        
+        # 验证模型已被删除
+        self.assertFalse(self.manager.check_model_exists("test/removable"))
+    
+    def test_remove_default_model(self):
+        """测试删除默认模型（应该失败）"""
+        # 尝试删除默认模型
+        result = self.manager.remove_model("deepseek/v3")
+        self.assertFalse(result)
+        
+        # 验证默认模型仍然存在
+        self.assertTrue(self.manager.check_model_exists("deepseek/v3"))
+    
+    def test_remove_nonexistent_model(self):
+        """测试删除不存在的模型"""
+        result = self.manager.remove_model("non/existent")
+        self.assertFalse(result)
+    
+    def test_get_single_llm_detailed_error(self):
+        """测试 get_single_llm 在失败时抛出详细错误信息"""
+        # 尝试获取不存在的模型
+        with self.assertRaises(ValueError) as context:
+            self.manager.get_single_llm("non/existent", "lite")
+        
+        error_message = str(context.exception)
+        self.assertIn("Failed to create LLM instance", error_message)
+        self.assertIn("non/existent", error_message)
+        self.assertIn("Model 'non/existent' not found", error_message)
+        
+        # 尝试获取存在但没有密钥的模型
+        with self.assertRaises(ValueError) as context:
+            self.manager.get_single_llm("test/model1", "lite")
+        
+        error_message = str(context.exception)
+        self.assertIn("Failed to create LLM instance", error_message)
+        self.assertIn("test/model1", error_message)
+        self.assertIn("has no API key configured", error_message)
+        
+        # 尝试获取多个模型，都不可用
+        with self.assertRaises(ValueError) as context:
+            self.manager.get_single_llm("non/existent1,test/model1,non/existent2", "lite")
+        
+        error_message = str(context.exception)
+        self.assertIn("Failed to create LLM instance", error_message)
+        self.assertIn("non/existent1,test/model1,non/existent2", error_message)
+        self.assertIn("Model 'non/existent1' not found", error_message)
+        self.assertIn("Model 'test/model1': Model test/model1 has no API key configured", error_message)
+        self.assertIn("Model 'non/existent2' not found", error_message)
+
+
+if __name__ == '__main__':
+    unittest.main()