1
import pytest
2
from langchain_core.language_models import BaseChatModel
3

4

5
@pytest.mark.integration
6
@pytest.mark.slow
7
async def test_real_model_connection(model: BaseChatModel) -> None:
8
    response = await model.ainvoke("只回复 OK")
9
    assert response.text.strip()

01
import os
02

03
import pytest
04
from langchain_core.language_models import BaseChatModel
05

06
pytestmark = pytest.mark.integration
07

08

09
@pytest.mark.skipif(
10
    not os.getenv("DEEPSEEK_API_KEY"),
11
    reason="没有配置 DeepSeek API Key",
12
)
13
async def test_real_model_connection(model: BaseChatModel) -> None:
14
    response = await model.ainvoke("只回复 OK")
15
    assert response.text.strip()

01
import pytest
02
from asgi_lifespan import LifespanManager
03
from fastapi import FastAPI
04
from httpx import ASGITransport, AsyncClient
05

06

07
@pytest.mark.api
08
async def test_health(app: FastAPI) -> None:
09
    async with LifespanManager(app) as manager:
10
        transport = ASGITransport(app=manager.app)
11

12
        async with AsyncClient(
13
            transport=transport,
14
            base_url="http://testserver",
15
        ) as client:
16
            response = await client.get("/api/v1/health")
17

18
    assert response.status_code == 200

01
from pathlib import Path
02

03
import pytest
04

05
from app.core.config_loader import ConfigError, load_config
06

07
VALID_CONFIG = """
08
[app]
09
name = "FastAPI LangChain Test"
10
environment = "test"
11
log_level = "WARNING"
12

13
[server]
14
host = "127.0.0.1"
15
port = 8000
16

17
[server.cors]
18
allow_origins = ["http://testserver"]
19
allow_methods = ["GET", "POST"]
20

21
[model]
22
provider = "fake"
23
name = "test-model"
24
base_url = "https://example.test"
25
temperature = {temperature}
26
timeout_seconds = 5
27
max_retries = 0
28

29
[langgraph]
30
recursion_limit = 10
31
checkpoint_backend = "memory"
32

33
[database]
34
pool_size = 1
35
pool_timeout_seconds = 5
36
"""
37

38

39
def write_config(tmp_path: Path, *, temperature: float = 0.1) -> Path:
40
    config_path = tmp_path / "config.toml"
41
    config_path.write_text(
42
        VALID_CONFIG.format(temperature=temperature),
43
        encoding="utf-8",
44
    )
45
    return config_path
46

47

48
def test_load_model_config(tmp_path: Path) -> None:
49
    config = load_config(write_config(tmp_path))
50

51
    assert config.model.name == "test-model"
52
    assert config.model.temperature == 0.1
53

54

55
def test_reject_invalid_temperature(tmp_path: Path) -> None:
56
    with pytest.raises(ConfigError, match=r"model\.temperature"):
57
        load_config(write_config(tmp_path, temperature=9))

01
import pytest
02

03
from app.core.settings import get_settings
04

05

06
def test_environment_overrides_toml(
07
    monkeypatch: pytest.MonkeyPatch,
08
) -> None:
09
    monkeypatch.setenv("MODEL__NAME", "environment-model")
10
    get_settings.cache_clear()
11

12
    try:
13
        settings = get_settings()
14
        assert settings.model.name == "environment-model"
15
    finally:
16
        get_settings.cache_clear()

1
from app.services.chat import ChatService
2

3

4
async def test_chat_service(chat_service: ChatService) -> None:
5
    await chat_service.answer("hello")

01
from langchain_core.language_models.fake_chat_models import (
02
    FakeMessagesListChatModel,
03
)
04
from langchain_core.messages import AIMessage
05

06

07
def create_fake_model() -> FakeMessagesListChatModel:
08
    return FakeMessagesListChatModel(
09
        responses=[AIMessage(content="固定测试回答")],
10
    )

01
from unittest.mock import patch
02

03
from pydantic import SecretStr
04

05
from app.agent.model import create_model
06
from app.core.settings import Settings
07

08

09
def test_model_factory_uses_settings(test_settings: Settings) -> None:
10
    settings = test_settings.model_copy(
11
        update={
12
            "model": test_settings.model.model_copy(
13
                update={"api_key": SecretStr("test-api-key")},
14
            ),
15
        },
16
    )
17

18
    with patch("app.agent.model.ChatOpenAI") as chat_openai:
19
        create_model(settings)
20

21
    call = chat_openai.call_args
22
    assert call is not None
23
    assert call.kwargs["model"] == "fake-model"
24
    assert call.kwargs["api_key"] == "test-api-key"
25
    assert call.kwargs["timeout"] == 5
26
    assert call.kwargs["max_retries"] == 0