feat(backend): 数字员工平台 B1+B2 批次实现

B1: 项目脚手架 + 数据模型 + 租户管理
- Task 1.1: FastAPI 项目脚手架、SQLite + async SQLAlchemy
- Task 1.2: 7 个数据模型 (Tenant, TenantConfig, DigitalEmployee, Conversation, Message, KnowledgeBase, Document)
- Task 1.3: 租户 CRUD API + LLM 配置(含 API Key AES 加密)

B2: 数字员工配置 + LLM Provider 抽象层
- Task 2.1: 数字员工 CRUD API(关联知识库)
- Task 2.2: BaseLLMProvider 抽象接口 + OpenAI/Qwen Provider
- Task 2.3: Provider 动态实例化 + test-provider 端点

验证: 26 个测试全部通过

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
rootandClaude Opus 4.7 committed 2026-05-06 11:29:48 +08:00
1 parent 44c37420af
commit c62156af53
37 files changed
+4419 -1

No files matched your search

View File
Whitespace-only changes.
+46
View File
@@ -0,0 +1,46 @@
import asyncio
from typing import AsyncGenerator
import pytest
import pytest_asyncio
from httpx import ASGITransport, AsyncClient
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from app.api.deps import get_db
from app.database import Base
from app.main import app
TEST_DB_URL = "sqlite+aiosqlite:///:memory:"
test_engine = create_async_engine(TEST_DB_URL, echo=False)
TestSession = async_sessionmaker(test_engine, class_=AsyncSession, expire_on_commit=False)
@pytest.fixture(scope="session")
def event_loop():
loop = asyncio.new_event_loop()
yield loop
loop.close()
@pytest_asyncio.fixture(scope="function")
async def setup_db():
async with test_engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
yield
async with test_engine.begin() as conn:
await conn.run_sync(Base.metadata.drop_all)
async def override_get_db() -> AsyncGenerator[AsyncSession, None]:
async with TestSession() as session:
yield session
@pytest_asyncio.fixture
async def client(setup_db) -> AsyncGenerator[AsyncClient, None]:
app.dependency_overrides[get_db] = override_get_db
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://test") as c:
yield c
app.dependency_overrides.clear()
+188
View File
@@ -0,0 +1,188 @@
import pytest
from httpx import AsyncClient
@pytest.mark.asyncio
async def test_create_employee(client: AsyncClient):
"""创建数字员工"""
# 先创建租户
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "Employee Test", "slug": "employee-test"},
)
tenant_id = tenant_resp.json()["id"]
response = await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "客服助手",
"role": "customer_service",
"system_prompt": "你是一个专业的客服助手。",
"greeting": "你好,有什么可以帮助您的?",
"temperature": 0.7,
"max_context_messages": 20,
"knowledge_base_ids": [],
},
)
assert response.status_code == 201
data = response.json()
assert data["name"] == "客服助手"
assert data["role"] == "customer_service"
assert data["status"] == "active"
assert "id" in data
@pytest.mark.asyncio
async def test_create_employee_with_knowledge_bases(client: AsyncClient):
"""创建数字员工时关联知识库"""
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "KB Test", "slug": "kb-test"},
)
tenant_id = tenant_resp.json()["id"]
# 创建知识库
from app.models import KnowledgeBase
from tests.conftest import TestSession
async with TestSession() as session:
kb1 = KnowledgeBase(tenant_id=tenant_id, name="产品文档")
kb2 = KnowledgeBase(tenant_id=tenant_id, name="FAQ")
session.add_all([kb1, kb2])
await session.commit()
kb1_id = kb1.id
kb2_id = kb2.id
response = await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "智能客服",
"role": "customer_service",
"system_prompt": "你是一个智能客服。",
"knowledge_base_ids": [kb1_id, kb2_id],
},
)
assert response.status_code == 201
data = response.json()
assert len(data["knowledge_base_ids"]) == 2
@pytest.mark.asyncio
async def test_list_employees(client: AsyncClient):
"""列出数字员工"""
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "List Test", "slug": "list-test"},
)
tenant_id = tenant_resp.json()["id"]
await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "员工A",
"role": "sales",
"system_prompt": "销售助手",
},
)
await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "员工B",
"role": "support",
"system_prompt": "支持助手",
},
)
response = await client.get(f"/api/v1/employees?tenant_id={tenant_id}")
assert response.status_code == 200
data = response.json()
assert len(data) >= 2
@pytest.mark.asyncio
async def test_get_employee(client: AsyncClient):
"""获取单个数字员工"""
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "Get Emp Test", "slug": "get-emp-test"},
)
tenant_id = tenant_resp.json()["id"]
create_resp = await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "测试员工",
"role": "test",
"system_prompt": "测试",
},
)
employee_id = create_resp.json()["id"]
response = await client.get(f"/api/v1/employees/{employee_id}")
assert response.status_code == 200
assert response.json()["name"] == "测试员工"
@pytest.mark.asyncio
async def test_update_employee(client: AsyncClient):
"""更新数字员工"""
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "Update Emp Test", "slug": "update-emp-test"},
)
tenant_id = tenant_resp.json()["id"]
create_resp = await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "旧名称",
"role": "old_role",
"system_prompt": "旧提示词",
},
)
employee_id = create_resp.json()["id"]
response = await client.patch(
f"/api/v1/employees/{employee_id}",
json={
"name": "新名称",
"temperature": 0.5,
},
)
assert response.status_code == 200
data = response.json()
assert data["name"] == "新名称"
assert data["temperature"] == 0.5
@pytest.mark.asyncio
async def test_delete_employee(client: AsyncClient):
"""删除数字员工"""
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "Delete Emp Test", "slug": "delete-emp-test"},
)
tenant_id = tenant_resp.json()["id"]
create_resp = await client.post(
"/api/v1/employees",
json={
"tenant_id": tenant_id,
"name": "待删除",
"role": "temp",
"system_prompt": "临时",
},
)
employee_id = create_resp.json()["id"]
response = await client.delete(f"/api/v1/employees/{employee_id}")
assert response.status_code == 204
get_resp = await client.get(f"/api/v1/employees/{employee_id}")
assert get_resp.status_code == 404
+9
View File
@@ -0,0 +1,9 @@
import pytest
from httpx import AsyncClient
@pytest.mark.asyncio
async def test_health_check(client: AsyncClient):
response = await client.get("/health")
assert response.status_code == 200
assert response.json() == {"status": "ok"}
+1 -1
View File
@@ -14,7 +14,7 @@ from tests.conftest import test_engine
@pytest.mark.asyncio
async def test_all_tables_created():
async def test_all_tables_created(setup_db):
expected_tables = {
"tenants",
"tenant_configs",
+196
View File
@@ -0,0 +1,196 @@
"""LLM Provider 抽象层测试"""
import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from app.providers.base import LLMMessage, LLMResponse
@pytest.mark.asyncio
async def test_base_provider_interface():
"""验证 BaseLLMProvider 接口定义"""
from app.providers.base import BaseLLMProvider
# 接口应该定义 chat, chat_stream, embed 方法
assert hasattr(BaseLLMProvider, "chat")
assert hasattr(BaseLLMProvider, "chat_stream")
assert hasattr(BaseLLMProvider, "embed")
@pytest.mark.asyncio
async def test_llm_message_dataclass():
"""验证 LLMMessage 数据类"""
msg = LLMMessage(role="user", content="Hello")
assert msg.role == "user"
assert msg.content == "Hello"
@pytest.mark.asyncio
async def test_llm_response_dataclass():
"""验证 LLMResponse 数据类"""
resp = LLMResponse(content="Hi there!", model="gpt-4", usage={"total_tokens": 10})
assert resp.content == "Hi there!"
assert resp.model == "gpt-4"
assert resp.usage["total_tokens"] == 10
@pytest.mark.asyncio
async def test_openai_provider_chat():
"""测试 OpenAI Provider chat 方法(mock)"""
from app.providers.openai_provider import OpenAIProvider
provider = OpenAIProvider(api_key="sk-test", model="gpt-4")
with patch.object(provider, "client") as mock_client:
mock_response = MagicMock()
mock_response.choices = [MagicMock(message=MagicMock(content="Test response"))]
mock_response.usage = MagicMock(total_tokens=100, prompt_tokens=50, completion_tokens=50)
mock_response.model = "gpt-4"
mock_client.chat.completions.create = AsyncMock(return_value=mock_response)
result = await provider.chat([LLMMessage(role="user", content="Hi")])
assert result.content == "Test response"
assert result.model == "gpt-4"
@pytest.mark.asyncio
async def test_openai_provider_chat_stream():
"""测试 OpenAI Provider chat_stream 方法(mock)"""
from app.providers.openai_provider import OpenAIProvider
provider = OpenAIProvider(api_key="sk-test", model="gpt-4")
async def mock_stream():
class MockChunk:
choices = [MagicMock(delta=MagicMock(content="token"))]
yield MockChunk()
yield MockChunk()
with patch.object(provider, "client") as mock_client:
mock_client.chat.completions.create = AsyncMock(return_value=mock_stream())
tokens = []
async for chunk in provider.chat_stream([LLMMessage(role="user", content="Hi")]):
tokens.append(chunk)
assert len(tokens) >= 1
@pytest.mark.asyncio
async def test_openai_provider_embed():
"""测试 OpenAI Provider embed 方法(mock)"""
from app.providers.openai_provider import OpenAIProvider
provider = OpenAIProvider(api_key="sk-test", model="text-embedding-3-small")
with patch.object(provider, "client") as mock_client:
mock_response = MagicMock()
mock_response.data = [MagicMock(embedding=[0.1, 0.2, 0.3])]
mock_response.usage = MagicMock(total_tokens=10)
mock_client.embeddings.create = AsyncMock(return_value=mock_response)
result = await provider.embed(["Hello world"])
assert len(result) == 1
assert len(result[0]) == 3
@pytest.mark.asyncio
async def test_qwen_provider_chat():
"""测试 Qwen Provider chat 方法(mock,兼容 OpenAI SDK)"""
from app.providers.qwen_provider import QwenProvider
provider = QwenProvider(
api_key="sk-qwen-test",
model="qwen-turbo",
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
with patch.object(provider, "client") as mock_client:
mock_response = MagicMock()
mock_response.choices = [MagicMock(message=MagicMock(content="Qwen response"))]
mock_response.usage = MagicMock(total_tokens=80)
mock_client.chat.completions.create = AsyncMock(return_value=mock_response)
result = await provider.chat([LLMMessage(role="user", content="你好")])
assert result.content == "Qwen response"
@pytest.mark.asyncio
async def test_provider_registry():
"""测试 Provider 注册表"""
from app.providers import get_provider
# 根据 provider 类型返回正确的实例
openai_provider = get_provider("openai", api_key="sk-test", model="gpt-4")
assert openai_provider.__class__.__name__ == "OpenAIProvider"
qwen_provider = get_provider("qwen", api_key="sk-qwen", model="qwen-turbo")
assert qwen_provider.__class__.__name__ == "QwenProvider"
@pytest.mark.asyncio
async def test_provider_registry_invalid():
"""测试 Provider 注册表无效类型"""
from app.providers import get_provider
with pytest.raises(ValueError, match="Unknown provider"):
get_provider("invalid_provider", api_key="sk-test", model="model")
# ============= Task 2.3: Provider 集成到租户配置 =============
@pytest.mark.asyncio
async def test_get_provider_for_tenant(client: AsyncClient):
"""测试根据租户配置获取 Provider"""
from app.services.tenant_service import get_provider_for_tenant
from tests.conftest import TestSession
# 创建租户并配置
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "Provider Test", "slug": "provider-test"},
)
tenant_id = tenant_resp.json()["id"]
await client.put(
f"/api/v1/tenants/{tenant_id}/config",
json={
"llm_provider": "openai",
"llm_api_key": "sk-test-provider-key",
"llm_model": "gpt-4o",
},
)
# 获取 Provider
async with TestSession() as session:
provider = await get_provider_for_tenant(session, tenant_id)
assert provider.__class__.__name__ == "OpenAIProvider"
assert provider.model == "gpt-4o"
@pytest.mark.asyncio
async def test_test_provider_endpoint(client: AsyncClient):
"""测试 Provider 测试端点"""
# 创建租户并配置
tenant_resp = await client.post(
"/api/v1/tenants",
json={"name": "Provider Endpoint Test", "slug": "provider-endpoint-test"},
)
tenant_id = tenant_resp.json()["id"]
await client.put(
f"/api/v1/tenants/{tenant_id}/config",
json={
"llm_provider": "openai",
"llm_api_key": "sk-test-endpoint",
"llm_model": "gpt-4",
},
)
# 测试 Provider
response = await client.post(f"/api/v1/tenants/{tenant_id}/test-provider")
assert response.status_code == 200
data = response.json()
assert data["provider"] == "openai"
assert data["model"] == "gpt-4"
assert "status" in data
+127
View File
@@ -0,0 +1,127 @@
import pytest
from httpx import AsyncClient
from app.models import Tenant
@pytest.mark.asyncio
async def test_create_tenant(client: AsyncClient):
response = await client.post(
"/api/v1/tenants",
json={"name": "Test Company", "slug": "test-company"},
)
assert response.status_code == 201
data = response.json()
assert data["name"] == "Test Company"
assert data["slug"] == "test-company"
assert "id" in data
@pytest.mark.asyncio
async def test_list_tenants(client: AsyncClient):
await client.post("/api/v1/tenants", json={"name": "A", "slug": "a"})
await client.post("/api/v1/tenants", json={"name": "B", "slug": "b"})
response = await client.get("/api/v1/tenants")
assert response.status_code == 200
data = response.json()
assert len(data) >= 2
@pytest.mark.asyncio
async def test_get_tenant(client: AsyncClient):
create_resp = await client.post(
"/api/v1/tenants",
json={"name": "Get Test", "slug": "get-test"},
)
tenant_id = create_resp.json()["id"]
response = await client.get(f"/api/v1/tenants/{tenant_id}")
assert response.status_code == 200
assert response.json()["name"] == "Get Test"
@pytest.mark.asyncio
async def test_update_tenant(client: AsyncClient):
create_resp = await client.post(
"/api/v1/tenants",
json={"name": "Old Name", "slug": "old-slug"},
)
tenant_id = create_resp.json()["id"]
response = await client.patch(
f"/api/v1/tenants/{tenant_id}",
json={"name": "New Name"},
)
assert response.status_code == 200
assert response.json()["name"] == "New Name"
@pytest.mark.asyncio
async def test_delete_tenant(client: AsyncClient):
create_resp = await client.post(
"/api/v1/tenants",
json={"name": "To Delete", "slug": "to-delete"},
)
tenant_id = create_resp.json()["id"]
response = await client.delete(f"/api/v1/tenants/{tenant_id}")
assert response.status_code == 204
get_resp = await client.get(f"/api/v1/tenants/{tenant_id}")
assert get_resp.status_code == 404
@pytest.mark.asyncio
async def test_update_tenant_config(client: AsyncClient):
create_resp = await client.post(
"/api/v1/tenants",
json={"name": "Config Test", "slug": "config-test"},
)
tenant_id = create_resp.json()["id"]
response = await client.put(
f"/api/v1/tenants/{tenant_id}/config",
json={
"llm_provider": "openai",
"llm_api_key": "sk-test-key-12345",
"llm_model": "gpt-4",
"llm_base_url": None,
},
)
assert response.status_code == 200
data = response.json()
assert data["llm_provider"] == "openai"
assert data["llm_model"] == "gpt-4"
assert "llm_api_key" not in data
@pytest.mark.asyncio
async def test_api_key_encrypted(client: AsyncClient):
from tests.conftest import TestSession
create_resp = await client.post(
"/api/v1/tenants",
json={"name": "Encrypt Test", "slug": "encrypt-test"},
)
tenant_id = create_resp.json()["id"]
await client.put(
f"/api/v1/tenants/{tenant_id}/config",
json={
"llm_provider": "openai",
"llm_api_key": "sk-secret-key-99999",
"llm_model": "gpt-4",
},
)
async with TestSession() as session:
from sqlalchemy import select
from app.models import TenantConfig
result = await session.execute(
select(TenantConfig).where(TenantConfig.tenant_id == tenant_id)
)
config = result.scalar_one()
assert config.llm_api_key != "sk-secret-key-99999"
assert len(config.llm_api_key) > 20