feat: 添加 CI/CD 和单元测试

- 添加 GitHub Actions CI 工作流 (.github/workflows/ci.yml)
- 后端: pytest 测试框架 + 13 个测试用例 (auth, models, health)
- 前端: vitest 测试框架 + 9 个测试用例 (utils, stores)
- 添加 ruff 代码检查配置
- 更新架构文档迁移计划

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: MKY508

.github/workflows/ci.yml

@@ -0,0 +1,98 @@
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  # 后端测试
+  backend:
+    name: Backend (Python)
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/api
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: "pip"
+          cache-dependency-path: apps/api/pyproject.toml
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Lint with Ruff
+        run: |
+          ruff check .
+          ruff format --check .
+
+      - name: Type check with mypy
+        run: mypy app --ignore-missing-imports
+        continue-on-error: true
+
+      - name: Run tests
+        run: pytest tests/ -v --cov=app --cov-report=xml
+        env:
+          DATABASE_URL: sqlite+aiosqlite:///./test.db
+          JWT_SECRET_KEY: test-secret-key-for-ci
+          ENCRYPTION_KEY: dGVzdC1lbmNyeXB0aW9uLWtleS0zMmJ5dGVz
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v4
+        with:
+          file: apps/api/coverage.xml
+          flags: backend
+        continue-on-error: true
+
+  # 前端测试
+  frontend:
+    name: Frontend (Next.js)
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/web
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+          cache-dependency-path: apps/web/package-lock.json
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Type check
+        run: npm run type-check
+
+      - name: Run tests
+        run: npm run test --if-present
+
+      - name: Build
+        run: npm run build
+        env:
+          NEXT_PUBLIC_API_URL: http://localhost:8000
+
+  # 所有检查通过
+  ci-success:
+    name: CI Success
+    needs: [backend, frontend]
+    runs-on: ubuntu-latest
+    steps:
+      - name: All checks passed
+        run: echo "✅ All CI checks passed!"

apps/api/pyproject.toml

@@ -43,6 +43,17 @@ dependencies = [
     "structlog>=24.1.0",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.1.0",
+    "httpx>=0.27.0",
+    "aiosqlite>=0.20.0",
+    "ruff>=0.4.0",
+    "mypy>=1.10.0",
+]
+
 [project.scripts]
 querygpt-api = "app.main:run"
 
@@ -52,3 +63,19 @@ packages = ["app"]
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+ignore = ["E501"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["app"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "-v --tb=short"

apps/api/pytest.ini

@@ -0,0 +1,9 @@
+[pytest]
+asyncio_mode = auto
+testpaths = tests
+python_files = test_*.py
+python_functions = test_*
+addopts = -v --tb=short
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::UserWarning

apps/api/tests/__init__.py

@@ -0,0 +1 @@
+"""QueryGPT API Tests"""

apps/api/tests/conftest.py

@@ -0,0 +1,83 @@
+"""Pytest fixtures for API tests"""
+import asyncio
+from collections.abc import AsyncGenerator, Generator
+
+import pytest
+from fastapi.testclient import TestClient
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+
+from app.db.tables import Base
+from app.main import app
+from app.db import get_db
+from app.core.security import create_access_token
+
+# 测试数据库 URL
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
+
+
+@pytest.fixture(scope="session")
+def event_loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
+    """Create event loop for async tests"""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+@pytest.fixture(scope="function")
+async def async_engine():
+    """Create async engine for each test"""
+    engine = create_async_engine(
+        TEST_DATABASE_URL,
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield engine
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+    await engine.dispose()
+
+
+@pytest.fixture(scope="function")
+async def db_session(async_engine) -> AsyncGenerator[AsyncSession, None]:
+    """Create database session for each test"""
+    async_session = sessionmaker(
+        async_engine, class_=AsyncSession, expire_on_commit=False
+    )
+    async with async_session() as session:
+        yield session
+
+
+@pytest.fixture(scope="function")
+async def client(db_session: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
+    """Create test client with overridden database"""
+    async def override_get_db():
+        yield db_session
+
+    app.dependency_overrides[get_db] = override_get_db
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test"
+    ) as ac:
+        yield ac
+
+    app.dependency_overrides.clear()
+
+
+@pytest.fixture
+def sync_client() -> Generator[TestClient, None, None]:
+    """Sync test client for simple tests"""
+    with TestClient(app) as c:
+        yield c
+
+
+@pytest.fixture
+def auth_headers() -> dict[str, str]:
+    """Generate auth headers with test token"""
+    token = create_access_token(data={"sub": "test@example.com", "user_id": "test-user-id"})
+    return {"Authorization": f"Bearer {token}"}

apps/api/tests/test_auth.py

@@ -0,0 +1,128 @@
+"""Authentication API tests"""
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.asyncio
+async def test_register_user(client: AsyncClient):
+    """Test user registration"""
+    response = await client.post(
+        "/api/v1/auth/register",
+        json={
+            "email": "test@example.com",
+            "password": "testpassword123",
+            "display_name": "Test User",
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["code"] == 0
+    assert data["data"]["email"] == "test@example.com"
+
+
+@pytest.mark.asyncio
+async def test_register_duplicate_email(client: AsyncClient):
+    """Test registration with duplicate email fails"""
+    # First registration
+    await client.post(
+        "/api/v1/auth/register",
+        json={
+            "email": "duplicate@example.com",
+            "password": "testpassword123",
+        },
+    )
+    # Second registration with same email
+    response = await client.post(
+        "/api/v1/auth/register",
+        json={
+            "email": "duplicate@example.com",
+            "password": "testpassword123",
+        },
+    )
+    assert response.status_code == 400
+
+
+@pytest.mark.asyncio
+async def test_login_success(client: AsyncClient):
+    """Test successful login"""
+    # Register first
+    await client.post(
+        "/api/v1/auth/register",
+        json={
+            "email": "login@example.com",
+            "password": "testpassword123",
+        },
+    )
+    # Login
+    response = await client.post(
+        "/api/v1/auth/login",
+        data={
+            "username": "login@example.com",
+            "password": "testpassword123",
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "access_token" in data
+    assert data["token_type"] == "bearer"
+
+
+@pytest.mark.asyncio
+async def test_login_wrong_password(client: AsyncClient):
+    """Test login with wrong password fails"""
+    # Register first
+    await client.post(
+        "/api/v1/auth/register",
+        json={
+            "email": "wrongpw@example.com",
+            "password": "correctpassword",
+        },
+    )
+    # Login with wrong password
+    response = await client.post(
+        "/api/v1/auth/login",
+        data={
+            "username": "wrongpw@example.com",
+            "password": "wrongpassword",
+        },
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_get_current_user(client: AsyncClient):
+    """Test getting current user info"""
+    # Register and login
+    await client.post(
+        "/api/v1/auth/register",
+        json={
+            "email": "me@example.com",
+            "password": "testpassword123",
+            "display_name": "Me User",
+        },
+    )
+    login_response = await client.post(
+        "/api/v1/auth/login",
+        data={
+            "username": "me@example.com",
+            "password": "testpassword123",
+        },
+    )
+    token = login_response.json()["access_token"]
+
+    # Get current user
+    response = await client.get(
+        "/api/v1/auth/me",
+        headers={"Authorization": f"Bearer {token}"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["data"]["email"] == "me@example.com"
+    assert data["data"]["display_name"] == "Me User"
+
+
+@pytest.mark.asyncio
+async def test_unauthorized_access(client: AsyncClient):
+    """Test accessing protected endpoint without token"""
+    response = await client.get("/api/v1/auth/me")
+    assert response.status_code == 401

apps/api/tests/test_health.py

@@ -0,0 +1,19 @@
+"""Health check endpoint tests"""
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.asyncio
+async def test_health_check(client: AsyncClient):
+    """Test health check endpoint returns OK"""
+    response = await client.get("/api/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"
+
+
+@pytest.mark.asyncio
+async def test_root_redirect(client: AsyncClient):
+    """Test root redirects to docs"""
+    response = await client.get("/", follow_redirects=False)
+    assert response.status_code in [200, 307, 302]