test: fix all tests and enable full test suite

Author: firefox-669

.github/workflows/ci.yml

@@ -43,7 +43,7 @@ jobs:
     
     - name: Run tests
       run: |
-        pytest tests/ -v --tb=short || true
+        pytest tests/ -v --tb=short
     
     - name: Test CLI installation
       run: |

openspace_openhands_evolution/openspace_engine.py

@@ -159,33 +159,52 @@ async def search_skills(self, query: str, context: Dict) -> List[Dict]:
 
         return matched_skills[:10]  # 返回 top 10
 
-    async def evolve_skill(self, task, execution_trace: Dict, quality_score: float):
+    async def evolve_skill(self, skill_id=None, improvements=None, task=None, execution_trace: Dict=None, quality_score: float=None):
         """
         基于执行结果进化技能
         
         Args:
+            skill_id: 技能 ID (for backward compatibility with tests)
+            improvements: 改进列表 (for backward compatibility with tests)
             task: 任务对象
             execution_trace: 执行轨迹
             quality_score: 质量评分 (0-1)
             
         Returns:
             进化后的技能或 None
         """
-        # 记录执行历史到记忆存储
+        # Backward compatibility: if skill_id and improvements are provided, use old API
+        if skill_id is not None and improvements is not None:
+            if skill_id not in self.skill_registry:
+                return None
+            
+            skill = self.skill_registry[skill_id]
+            skill.version += 1
+            
+            if "improvements" not in skill.metadata:
+                skill.metadata["improvements"] = []
+            skill.metadata["improvements"].extend(improvements)
+            
+            return skill
+        
+        # New API: record to memory store
+        if task is None:
+            return None
+            
         project_id = getattr(task, 'project_id', 'unknown')
         if project_id not in self.memory_store:
             self.memory_store[project_id] = []
 
         memory_entry = {
             "task_id": getattr(task, 'id', 'unknown'),
             "timestamp": _now(),
-            "quality_score": quality_score,
-            "execution_trace": execution_trace,
+            "quality_score": quality_score or 0.5,
+            "execution_trace": execution_trace or {},
             "improvements": []
         }
 
         # 如果质量低于阈值，标记需要改进
-        if quality_score < 0.7:
+        if quality_score and quality_score < 0.7:
             memory_entry["needs_improvement"] = True
             memory_entry["improvements"].append({
                 "type": "quality_below_threshold",
@@ -198,31 +217,42 @@ async def evolve_skill(self, task, execution_trace: Dict, quality_score: float):
         # TODO: 在实际实现中，这里应该调用 LLM 分析失败原因并生成改进版本
         return None
 
-    async def fix_skill(self, failed_skill_id: str, error_context: Dict):
+    async def fix_skill(self, skill_id=None, error_context: Dict=None, failed_skill_id=None):
         """
         修复失败的技能
         
         Args:
-            failed_skill_id: 失败的技能 ID
+            skill_id: 技能 ID (for backward compatibility with tests)
             error_context: 错误上下文
+            failed_skill_id: 失败的技能 ID (alias for skill_id)
+            
+        Returns:
+            SkillCard: 修复后的技能对象
         """
-        if failed_skill_id not in self.skill_registry:
-            return
+        # Support both parameter names
+        actual_skill_id = skill_id or failed_skill_id
+        if not actual_skill_id:
+            return None
+            
+        if actual_skill_id not in self.skill_registry:
+            return None
 
-        skill = self.skill_registry[failed_skill_id]
+        skill = self.skill_registry[actual_skill_id]
 
         # 记录失败历史
         if "fix_history" not in skill.metadata:
             skill.metadata["fix_history"] = []
 
         skill.metadata["fix_history"].append({
             "timestamp": _now(),
-            "error": error_context.get("error", "Unknown"),
-            "context": error_context
+            "error": error_context.get("error", "Unknown") if error_context else "Unknown",
+            "context": error_context or {}
         })
 
         # TODO: 在实际实现中，这里应该分析错误并生成修复版本
-        print(f"⚠️  Skill {failed_skill_id} marked for fixing")
+        print(f"⚠️  Skill {actual_skill_id} marked for fixing")
+        
+        return skill
 
     async def get_project_skills(self, project_id: str) -> List[Dict]:
         """获取项目的所有技能"""
@@ -277,6 +307,30 @@ async def import_skills(self, project_id: str, skills: List[Dict]):
 
         print(f"✅ Imported {imported_count} skills to project {project_id}")
 
+    async def register_skill(self, skill_data: Dict):
+        """
+        注册单个技能（便捷方法）
+        
+        Args:
+            skill_data: 技能数据字典
+            
+        Returns:
+            SkillCard: 注册的技能对象
+        """
+        skill_id = skill_data.get('skill_id')
+        if not skill_id:
+            raise ValueError("skill_id is required")
+        
+        # 创建或更新技能
+        if skill_id in self.skill_registry:
+            skill = self.skill_registry[skill_id]
+            skill.version += 1
+        else:
+            skill = SkillCard.from_dict(skill_data)
+            self.skill_registry[skill_id] = skill
+        
+        return skill
+    
     async def capture_environment_fingerprint(self, project_id: str) -> Dict:
         """
         V-06: 捕获环境指纹

pytest.ini

@@ -11,5 +11,3 @@ addopts =
     -v
     --tb=short
     --strict-markers
-    --ignore-glob="*test_openspace_engine.py"
-    -k "not (test_monitor_execution or test_quality_calculation or test_trigger_alert or test_log_error or test_get_performance_report or test_get_status or test_init_orchestrator or test_init_with_custom_config or test_execute_task_structure or test_get_system_status or test_planning_layer or test_result_has)"

tests/conftest.py

@@ -0,0 +1,43 @@
+"""
+Shared test fixtures and utilities
+"""
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+
+
+class MockLLMProvider:
+    """Mock LLM provider for testing without API keys"""
+    
+    async def generate(self, prompt: str) -> str:
+        """Mock LLM generation"""
+        return '{"action": "test", "output": "mock response from LLM"}'
+    
+    async def analyze(self, text: str) -> dict:
+        """Mock analysis"""
+        return {
+            "confidence": 0.9,
+            "category": "test",
+            "intent": "code_generation"
+        }
+
+
+@pytest.fixture
+def mock_llm_config():
+    """Configuration with mock LLM"""
+    return {
+        'openspace': {
+            'registry_path': './test_data/skills',
+        },
+        'openhands': {
+            'model': 'mock-gpt-4',
+            'api_key': 'test-key',
+            'llm_provider': MockLLMProvider(),
+        },
+        'monitor': {
+            'quality_threshold': 0.8,
+            'enable_alerts': False,
+        },
+        'governance': {
+            'enabled': True,
+        }
+    }

tests/test_monitor.py

@@ -39,8 +39,8 @@ async def test_monitor_execution(self, monitor):
 
         assert isinstance(quality_metrics, dict)
         assert "overall_score" in quality_metrics
-        assert "base_score" in quality_metrics
         assert "confidence" in quality_metrics
+        assert "execution_time" in quality_metrics
 
     @pytest.mark.asyncio
     async def test_quality_calculation_success(self, monitor):
@@ -53,10 +53,10 @@ async def test_quality_calculation_success(self, monitor):
             }
         }
 
-        metrics = await monitor._calculate_quality_metrics(result)
+        metrics = monitor._calculate_quality_metrics(result)
 
         assert metrics["overall_score"] > 0.7  # Should be good quality
-        assert metrics["base_score"] == 1.0  # Success gives base score 1.0
+        assert metrics["success"] == True
 
     @pytest.mark.asyncio
     async def test_quality_calculation_failure(self, monitor):
@@ -70,37 +70,38 @@ async def test_quality_calculation_failure(self, monitor):
             }
         }
 
-        metrics = await monitor._calculate_quality_metrics(result)
+        metrics = monitor._calculate_quality_metrics(result)
 
         assert metrics["overall_score"] < 0.5  # Failed should have low score
-        assert metrics["base_score"] == 0.0  # Failure gives base score 0.0
+        assert metrics["success"] == False
 
     @pytest.mark.asyncio
     async def test_trigger_alert(self, monitor):
         """Test alert triggering"""
-        alert = await monitor._trigger_alert(
+        await monitor._trigger_alert(
             alert_type="quality_low",
             message="Quality score below threshold",
             severity="warning"
         )
 
-        assert isinstance(alert, dict)
+        assert len(monitor.alerts) > 0
+        alert = monitor.alerts[-1]
         assert alert["type"] == "quality_low"
         assert alert["severity"] == "warning"
         assert "timestamp" in alert
 
     @pytest.mark.asyncio
     async def test_log_error(self, monitor):
         """Test error logging"""
+        error = Exception("TestError")
         await monitor.log_error(
-            task_id="test-task-001",
-            error="TestError",
-            context={"detail": "Test error context"}
+            error=error,
+            context={"task_id": "test-task-001", "detail": "Test error context"}
         )
 
         assert len(monitor.error_log) > 0
-        assert monitor.error_log[-1]["task_id"] == "test-task-001"
-        assert monitor.error_log[-1]["error"] == "TestError"
+        assert monitor.error_log[-1]["error_type"] == "Exception"
+        assert monitor.error_log[-1]["error_message"] == "TestError"
 
     @pytest.mark.asyncio
     async def test_get_performance_report(self, monitor):
@@ -119,9 +120,9 @@ async def test_get_performance_report(self, monitor):
         report = await monitor.get_performance_report()
 
         assert isinstance(report, dict)
-        assert "total_executions" in report
-        assert "success_rate" in report
-        assert "average_quality" in report
+        assert "total_tasks" in report
+        assert "avg_quality" in report
+        assert "error_rate" in report
 
     @pytest.mark.asyncio
     async def test_get_status(self, monitor):
@@ -130,7 +131,7 @@ async def test_get_status(self, monitor):
 
         assert isinstance(status, dict)
         assert "status" in status
-        assert "errors_logged" in status
+        assert "errors_detected" in status
         assert "quality_threshold" in status