浅念
134 lines
4.5 KiB
Python
134 lines
4.5 KiB
Python
"""Shared pytest fixtures for the yunke-server test suite."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import AsyncIterator, Awaitable, Callable
|
|
|
|
import pytest
|
|
from httpx import ASGITransport, AsyncClient
|
|
from sqlalchemy.ext.asyncio import (
|
|
AsyncSession,
|
|
async_sessionmaker,
|
|
create_async_engine,
|
|
)
|
|
from sqlalchemy.pool import StaticPool
|
|
|
|
from app.api import deps
|
|
from app.api.main import app
|
|
from app.config import get_settings
|
|
from app.db.base import Base
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def reset_settings_cache():
|
|
"""Ensure each test starts with a fresh Settings cache.
|
|
|
|
Tests that mutate env vars and call `get_settings()` must also clear the
|
|
`lru_cache` themselves; this fixture is a safety net that runs after every
|
|
test so a cached `Settings` from one test never leaks into the next.
|
|
"""
|
|
yield
|
|
get_settings.cache_clear()
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _disable_request_throttle(monkeypatch):
|
|
"""Zero out the conservative request-pace settings for the test suite.
|
|
|
|
Production defaults (``request_min_interval=1.0``, ``request_jitter=0.8``)
|
|
would make every mocked request sleep ~1-1.8s and balloon the suite's
|
|
runtime. In tests we want the *behaviour* (header stealth, backoff, cap)
|
|
without the wall-clock cost, so we pin the throttle env vars to 0. The
|
|
defaults themselves are still asserted directly via ``Settings`` field
|
|
introspection in ``test_config.py``. The cache is cleared on either side
|
|
so the zeroed env is picked up the first time a test reads settings.
|
|
"""
|
|
get_settings.cache_clear()
|
|
monkeypatch.setenv("REQUEST_MIN_INTERVAL", "0")
|
|
monkeypatch.setenv("REQUEST_JITTER", "0")
|
|
yield
|
|
get_settings.cache_clear()
|
|
|
|
|
|
@pytest.fixture
|
|
async def make_client() -> AsyncIterator[
|
|
Callable[[Callable[[AsyncSession], Awaitable[None]]], Awaitable[AsyncClient]]
|
|
]:
|
|
"""Factory yielding an ``AsyncClient`` over a seeded in-memory SQLite DB.
|
|
|
|
Mirrors the override pattern established in ``tests/test_api_customer.py``
|
|
(``StaticPool`` + single in-memory connection + ``get_session`` dependency
|
|
override) but lets each test supply its own seed coroutine so the read-API
|
|
test files don't each re-~40-line the boilerplate.
|
|
|
|
Usage::
|
|
|
|
async def test_x(make_client):
|
|
async def seed(session):
|
|
session.add(Department(dept_id="d1", ...))
|
|
await session.commit()
|
|
|
|
client = await make_client(seed)
|
|
r = await client.get("/api/departments")
|
|
...
|
|
|
|
The factory owns the engine + client lifetime: both are torn down
|
|
(``aclose`` / ``dispose``) and the dependency override cleared when the
|
|
test exits.
|
|
"""
|
|
|
|
created: list[tuple[AsyncClient, object]] = []
|
|
|
|
async def _factory(
|
|
seed: Callable[[AsyncSession], Awaitable[None]],
|
|
) -> AsyncClient:
|
|
engine = create_async_engine(
|
|
"sqlite+aiosqlite:///:memory:",
|
|
poolclass=StaticPool,
|
|
connect_args={"check_same_thread": False},
|
|
)
|
|
async with engine.begin() as conn:
|
|
await conn.run_sync(Base.metadata.create_all)
|
|
|
|
SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
|
|
async with SessionLocal() as session:
|
|
await seed(session)
|
|
|
|
async def _override_session() -> AsyncIterator[AsyncSession]:
|
|
async with SessionLocal() as s:
|
|
yield s
|
|
|
|
app.dependency_overrides[deps.get_session] = _override_session
|
|
client = AsyncClient(
|
|
transport=ASGITransport(app=app), base_url="http://test"
|
|
)
|
|
created.append((client, engine))
|
|
return client
|
|
|
|
try:
|
|
yield _factory
|
|
finally:
|
|
for client, engine in created:
|
|
await client.aclose()
|
|
await engine.dispose()
|
|
app.dependency_overrides.clear()
|
|
|
|
|
|
@pytest.fixture
|
|
async def make_session() -> AsyncIterator[AsyncSession]:
|
|
"""独立内存 SQLite AsyncSession(不挂 API 依赖)——存储层/管理域测试用。
|
|
|
|
与 make_client 共用 StaticPool 单连接模式;每个测试独享全新 schema。
|
|
"""
|
|
engine = create_async_engine(
|
|
"sqlite+aiosqlite:///:memory:",
|
|
poolclass=StaticPool,
|
|
connect_args={"check_same_thread": False},
|
|
)
|
|
async with engine.begin() as conn:
|
|
await conn.run_sync(Base.metadata.create_all)
|
|
SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
|
|
async with SessionLocal() as s:
|
|
yield s
|
|
await engine.dispose()
|