chore: update dependencies and enhance testing configuration

- Added `httpx` as a dependency for improved HTTP handling in tests.
- Configured pytest to specify test paths and set asyncio mode to auto for better test execution.

Author: knqiufan

agent/pyproject.toml

@@ -24,9 +24,14 @@ memory = [
 dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.24",
+    "httpx>=0.28",
     "ruff>=0.8",
 ]
 
 [tool.ruff]
 line-length = 100
 target-version = "py311"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

agent/tests/__init__.py

@@ -0,0 +1,14 @@
+"""Shared test fixtures for the MisakaX Agent Sidecar."""
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    """Async HTTP client for testing FastAPI endpoints."""
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as ac:
+        yield ac

agent/tests/conftest.py

@@ -0,0 +1,25 @@
+"""Tests for the application configuration."""
+
+from app.config import Settings
+
+
+def test_default_settings():
+    settings = Settings()
+    assert settings.host == "127.0.0.1"
+    assert settings.port == 9527
+    assert settings.log_level == "info"
+    assert settings.db_path == ""
+
+
+def test_settings_env_prefix(monkeypatch):
+    monkeypatch.setenv("MISAKA_PORT", "8080")
+    monkeypatch.setenv("MISAKA_LOG_LEVEL", "debug")
+    settings = Settings()
+    assert settings.port == 8080
+    assert settings.log_level == "debug"
+
+
+def test_settings_custom_db_path(monkeypatch):
+    monkeypatch.setenv("MISAKA_DB_PATH", "/tmp/test.db")
+    settings = Settings()
+    assert settings.db_path == "/tmp/test.db"

agent/tests/test_config.py

@@ -0,0 +1,27 @@
+"""Tests for the health check endpoint."""
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_health_check_returns_ok(client):
+    response = await client.get("/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"
+    assert data["service"] == "misaka-agent"
+
+
+@pytest.mark.asyncio
+async def test_health_check_is_get_only(client):
+    response = await client.post("/health")
+    assert response.status_code == 405
+
+
+@pytest.mark.asyncio
+async def test_openapi_schema_accessible(client):
+    response = await client.get("/openapi.json")
+    assert response.status_code == 200
+    schema = response.json()
+    assert schema["info"]["title"] == "MisakaX Agent"
+    assert schema["info"]["version"] == "0.1.0"

agent/tests/test_health.py

@@ -6,7 +6,10 @@ pub mod config;
 pub mod crypto;
 pub mod db;
 pub mod services;
+#[cfg(not(feature = "test-private"))]
 mod sidecar;
+#[cfg(feature = "test-private")]
+pub mod sidecar;
 
 use config::AppConfig;
 use services::llm::StreamRegistry;

src-tauri/src/lib.rs

@@ -1,6 +1,11 @@
 use std::process::{Child, Command};
 use std::time::Duration;
 
+/// 构建健康检查 URL
+pub fn health_check_url(port: u16) -> String {
+    format!("http://127.0.0.1:{}/health", port)
+}
+
 /// Manages the Python Agent Sidecar process lifecycle.
 pub struct SidecarManager {
     child: Option<Child>,
@@ -9,8 +14,7 @@ pub struct SidecarManager {
 impl SidecarManager {
     /// Spawn the Python sidecar and wait for its health check.
     pub fn start(agent_dir: &str, port: u16) -> Result<Self, String> {
-        // Check if already running
-        if Self::health_check(port) {
+        if Self::is_healthy(port) {
             tracing::info!("Python Sidecar already running on port {}", port);
             return Ok(Self { child: None });
         }
@@ -36,16 +40,14 @@ impl SidecarManager {
                 )
             })?;
 
-        // Wait for health check (max 10 seconds)
         for _ in 0..20 {
             std::thread::sleep(Duration::from_millis(500));
-            if Self::health_check(port) {
+            if Self::is_healthy(port) {
                 tracing::info!("Python Sidecar ready on port {}", port);
                 return Ok(Self { child: Some(child) });
             }
         }
 
-        // Timeout — kill the process and return error
         let _ = child.kill();
         let _ = child.wait();
         Err(format!(
@@ -54,9 +56,9 @@ impl SidecarManager {
         ))
     }
 
-    fn health_check(port: u16) -> bool {
+    fn is_healthy(port: u16) -> bool {
         reqwest::blocking::Client::new()
-            .get(format!("http://127.0.0.1:{}/health", port))
+            .get(health_check_url(port))
             .timeout(Duration::from_secs(2))
             .send()
             .map(|r| r.status().is_success())

src-tauri/src/sidecar.rs

@@ -0,0 +1,186 @@
+use misaka_x_lib::crypto;
+use misaka_x_lib::db::models::CreateCustomModel;
+use misaka_x_lib::db::repository::{CustomModelRepo, RouterConfigRepo};
+use misaka_x_lib::services::llm::registry::{ModelInfo, ModelRegistry};
+use rusqlite::Connection;
+
+fn setup_test_db() -> Connection {
+    let conn = Connection::open_in_memory().unwrap();
+    conn.execute_batch("PRAGMA foreign_keys=ON;").unwrap();
+    misaka_x_lib::db::migrations::run_migrations(&conn).unwrap();
+    conn
+}
+
+fn insert_router_config(conn: &Connection, id: &str, provider: &str) {
+    let encrypted = crypto::encrypt("sk-test-key-fake-12345678").unwrap();
+    RouterConfigRepo::insert(
+        conn, id, "Test Provider", provider, &encrypted,
+        None, None, None, true, None,
+    )
+    .unwrap();
+}
+
+// ─── CustomModelRepo tests ───────────────────────────────────────────
+
+#[test]
+fn test_insert_custom_model() {
+    let conn = setup_test_db();
+    insert_router_config(&conn, "rc-1", "openai");
+
+    let model = CreateCustomModel {
+        model_id: "ft-gpt-4o".to_string(),
+        display_name: "Fine-tuned GPT-4o".to_string(),
+        supports_vision: true,
+        supports_thinking: false,
+        max_tokens: Some(4096),
+        context_window: Some(128000),
+    };
+
+    CustomModelRepo::insert(&conn, "cm-1", "rc-1", &model).unwrap();
+
+    let models = ModelRegistry::available_models(&conn, "rc-1", "openai").unwrap();
+    let custom: Vec<_> = models.iter().filter(|m| m.is_custom).collect();
+    assert_eq!(custom.len(), 1);
+    assert_eq!(custom[0].model_id, "ft-gpt-4o");
+    assert_eq!(custom[0].display_name, "Fine-tuned GPT-4o");
+    assert!(custom[0].supports_vision);
+    assert!(!custom[0].supports_thinking);
+    assert_eq!(custom[0].max_tokens, Some(4096));
+    assert_eq!(custom[0].context_window, Some(128000));
+}
+
+#[test]
+fn test_insert_custom_model_minimal() {
+    let conn = setup_test_db();
+    insert_router_config(&conn, "rc-1", "openai");
+
+    let model = CreateCustomModel {
+        model_id: "my-model".to_string(),
+        display_name: "My Model".to_string(),
+        supports_vision: false,
+        supports_thinking: false,
+        max_tokens: None,
+        context_window: None,
+    };
+
+    CustomModelRepo::insert(&conn, "cm-1", "rc-1", &model).unwrap();
+
+    let models = ModelRegistry::available_models(&conn, "rc-1", "openai").unwrap();
+    let custom: Vec<_> = models.iter().filter(|m| m.is_custom).collect();
+    assert_eq!(custom.len(), 1);
+    assert_eq!(custom[0].max_tokens, None);
+    assert_eq!(custom[0].context_window, None);
+}
+
+#[test]
+fn test_delete_custom_model() {
+    let conn = setup_test_db();
+    insert_router_config(&conn, "rc-1", "openai");
+
+    let model = CreateCustomModel {
+        model_id: "to-delete".to_string(),
+        display_name: "Delete Me".to_string(),
+        supports_vision: false,
+        supports_thinking: false,
+        max_tokens: None,
+        context_window: None,
+    };
+
+    CustomModelRepo::insert(&conn, "cm-del", "rc-1", &model).unwrap();
+    CustomModelRepo::delete(&conn, "cm-del").unwrap();
+
+    let models = ModelRegistry::available_models(&conn, "rc-1", "openai").unwrap();
+    let custom_count = models.iter().filter(|m| m.is_custom).count();
+    assert_eq!(custom_count, 0);
+}
+
+#[test]
+fn test_delete_custom_model_not_found() {
+    let conn = setup_test_db();
+    let result = CustomModelRepo::delete(&conn, "nonexistent");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_custom_models_unique_constraint() {
+    let conn = setup_test_db();
+    insert_router_config(&conn, "rc-1", "openai");
+
+    let model = CreateCustomModel {
+        model_id: "duplicate".to_string(),
+        display_name: "First".to_string(),
+        supports_vision: false,
+        supports_thinking: false,
+        max_tokens: None,
+        context_window: None,
+    };
+
+    CustomModelRepo::insert(&conn, "cm-1", "rc-1", &model).unwrap();
+
+    let model2 = CreateCustomModel {
+        model_id: "duplicate".to_string(),
+        display_name: "Second".to_string(),
+        supports_vision: false,
+        supports_thinking: false,
+        max_tokens: None,
+        context_window: None,
+    };
+
+    let result = CustomModelRepo::insert(&conn, "cm-2", "rc-1", &model2);
+    assert!(result.is_err(), "Should fail on duplicate (router_config_id, model_id)");
+}
+
+#[test]
+fn test_multiple_custom_models_per_provider() {
+    let conn = setup_test_db();
+    insert_router_config(&conn, "rc-1", "openai");
+
+    for i in 0..5 {
+        let model = CreateCustomModel {
+            model_id: format!("model-{}", i),
+            display_name: format!("Model {}", i),
+            supports_vision: false,
+            supports_thinking: false,
+            max_tokens: None,
+            context_window: None,
+        };
+        CustomModelRepo::insert(&conn, &format!("cm-{}", i), "rc-1", &model).unwrap();
+    }
+
+    let models = ModelRegistry::available_models(&conn, "rc-1", "openai").unwrap();
+    let custom_count = models.iter().filter(|m| m.is_custom).count();
+    assert_eq!(custom_count, 5);
+}
+
+// ─── ModelInfo structure tests ───────────────────────────────────────
+
+#[test]
+fn test_model_info_serialize() {
+    let info = ModelInfo::builtin("gpt-4o", "GPT-4o", true, false);
+    let json = serde_json::to_string(&info).unwrap();
+    assert!(json.contains("\"model_id\":\"gpt-4o\""));
+    assert!(json.contains("\"display_name\":\"GPT-4o\""));
+    assert!(json.contains("\"supports_vision\":true"));
+    assert!(json.contains("\"supports_thinking\":false"));
+    assert!(json.contains("\"is_custom\":false"));
+}
+
+#[test]
+fn test_model_info_deserialize() {
+    let json = r#"{
+        "model_id": "custom-1",
+        "display_name": "Custom Model",
+        "supports_vision": true,
+        "supports_thinking": true,
+        "is_custom": true,
+        "max_tokens": 8192,
+        "context_window": null
+    }"#;
+    let info: ModelInfo = serde_json::from_str(json).unwrap();
+    assert_eq!(info.model_id, "custom-1");
+    assert!(info.supports_vision);
+    assert!(info.supports_thinking);
+    assert!(info.is_custom);
+    assert_eq!(info.max_tokens, Some(8192));
+    assert!(info.context_window.is_none());
+}