danweiyuan-eapi 0.1.0__tar.gz

danweiyuan_eapi-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: danweiyuan-eapi
+Version: 0.1.0
+Summary: Lightweight FastAPI infrastructure — exceptions, database, config, security, cache, pagination
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: bcrypt>=4.0.0
+Requires-Dist: redis>=5.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"
+Requires-Dist: aiosqlite>=0.20.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"

danweiyuan_eapi-0.1.0/README.md

@@ -0,0 +1,20 @@
+# danweiyuan-eapi
+
+Lightweight FastAPI infrastructure package for shared use across projects.
+
+## Install
+
+```bash
+pip install danweiyuan-eapi
+```
+
+## Modules
+
+- `config` — BaseSettings with required fields (database_url, redis_url, secret_key)
+- `exceptions` — AppError hierarchy + FastAPI exception handlers
+- `database` — Async SQLAlchemy engine/session factory + Base + TimestampMixin
+- `dependencies` — `get_db()` FastAPI dependency
+- `security` — JWT create/verify + bcrypt hash/verify (stateless)
+- `cache` — Async Redis connection manager
+- `response` — Unified API response helpers
+- `pagination` — PaginationParams + paginate helper

danweiyuan_eapi-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "danweiyuan-eapi"
+version = "0.1.0"
+description = "Lightweight FastAPI infrastructure — exceptions, database, config, security, cache, pagination"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+dependencies = [
+    "fastapi>=0.100.0",
+    "sqlalchemy[asyncio]>=2.0.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+    "python-jose[cryptography]>=3.3.0",
+    "bcrypt>=4.0.0",
+    "redis>=5.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+    "httpx>=0.27.0",
+    "aiosqlite>=0.20.0",
+    "ruff>=0.6.0",
+]
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "N", "UP", "B", "SIM", "RUF"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["danweiyuan_eapi"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

danweiyuan_eapi-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/__init__.py

@@ -0,0 +1,14 @@
+"""danweiyuan-eapi — Lightweight FastAPI infrastructure.
+
+Modules:
+    config        — BaseSettings with required fields
+    exceptions    — AppError hierarchy + FastAPI exception handlers
+    database      — Async SQLAlchemy engine/session factory + Base + TimestampMixin
+    dependencies  — get_db() FastAPI dependency factory
+    security      — JWT + bcrypt helpers (stateless)
+    cache         — Async Redis connection manager
+    response      — Unified API response helpers
+    pagination    — PaginationParams + paginate helper
+"""
+
+__version__ = "0.1.0"

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/cache.py

@@ -0,0 +1,30 @@
+"""Async Redis connection manager."""
+
+import redis.asyncio as aioredis
+
+_redis_url: str | None = None
+_redis: aioredis.Redis | None = None
+
+
+def configure(redis_url: str) -> None:
+    """Set the Redis connection URL."""
+    global _redis_url
+    _redis_url = redis_url
+
+
+async def get_redis() -> aioredis.Redis:
+    """Get or create the shared async Redis connection."""
+    if _redis_url is None:
+        raise RuntimeError("danweiyuan_eapi.cache not configured — call cache.configure(redis_url) first")
+    global _redis
+    if _redis is None:
+        _redis = aioredis.from_url(_redis_url, decode_responses=True)
+    return _redis
+
+
+async def close_redis() -> None:
+    """Close the Redis connection. Safe to call even if not connected."""
+    global _redis
+    if _redis is not None:
+        await _redis.close()
+        _redis = None

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/config.py

@@ -0,0 +1,23 @@
+"""Base Pydantic Settings class for FastAPI projects."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings as PydanticBaseSettings
+from pydantic_settings import SettingsConfigDict
+
+
+class BaseSettings(PydanticBaseSettings):
+    """Base settings — subclass and add project-specific fields."""
+
+    database_url: str
+    redis_url: str
+    secret_key: str
+    jwt_algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    debug: bool = False
+    allowed_origins: list[str] = Field(default_factory=list)
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/database.py

@@ -0,0 +1,42 @@
+"""Async SQLAlchemy engine and session factory, declarative Base, and TimestampMixin."""
+
+from datetime import datetime
+
+from sqlalchemy import func
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class Base(DeclarativeBase):
+    """Declarative base class for all ORM models."""
+
+    pass
+
+
+class TimestampMixin:
+    """Mixin that adds created_at and updated_at columns."""
+
+    created_at: Mapped[datetime] = mapped_column(server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(server_default=func.now(), onupdate=func.now())
+
+
+def create_async_engine_factory(
+    database_url: str,
+    pool_size: int = 5,
+    max_overflow: int = 10,
+    echo: bool = False,
+) -> AsyncEngine:
+    """Create an async SQLAlchemy engine."""
+    if database_url.startswith("sqlite"):
+        return create_async_engine(database_url, echo=echo)
+    return create_async_engine(
+        database_url,
+        pool_size=pool_size,
+        max_overflow=max_overflow,
+        echo=echo,
+    )
+
+
+def create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
+    """Create an async session factory bound to the given engine."""
+    return async_sessionmaker(engine, expire_on_commit=False)

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/dependencies.py

@@ -0,0 +1,16 @@
+"""FastAPI dependency factories."""
+
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+
+def create_get_db(session_factory: async_sessionmaker[AsyncSession]):
+    """Create a get_db FastAPI dependency bound to a session factory."""
+
+    async def get_db() -> AsyncGenerator[AsyncSession]:
+        """Yield a database session, automatically closed after the request."""
+        async with session_factory() as session:
+            yield session
+
+    return get_db

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/exceptions.py

@@ -0,0 +1,75 @@
+"""AppError exception hierarchy and FastAPI exception handler registration."""
+
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+
+class AppError(Exception):
+    """Base class for all application-level errors."""
+
+    def __init__(self, message: str, code: str = "UNKNOWN_ERROR") -> None:
+        self.message = message
+        self.code = code
+
+
+class NotFoundError(AppError):
+    """Resource not found."""
+
+    def __init__(self, resource: str) -> None:
+        super().__init__(message=f"{resource}不存在", code="NOT_FOUND")
+
+
+class BusinessError(AppError):
+    """Business rule validation failure."""
+
+    pass
+
+
+class PermissionDeniedError(AppError):
+    """Insufficient permissions."""
+
+    def __init__(self) -> None:
+        super().__init__(message="权限不足", code="PERMISSION_DENIED")
+
+
+class AuthenticationError(AppError):
+    """Authentication failed or missing."""
+
+    def __init__(self) -> None:
+        super().__init__(message="认证失败", code="AUTHENTICATION_FAILED")
+
+
+def register_exception_handlers(app: FastAPI) -> None:
+    """Register exception-to-HTTP-response handlers on a FastAPI app."""
+
+    @app.exception_handler(NotFoundError)
+    async def not_found_handler(request: Request, exc: NotFoundError) -> JSONResponse:
+        """Handle NotFoundError → 404."""
+        return JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content={"code": exc.code, "message": exc.message},
+        )
+
+    @app.exception_handler(BusinessError)
+    async def business_error_handler(request: Request, exc: BusinessError) -> JSONResponse:
+        """Handle BusinessError → 422."""
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={"code": exc.code, "message": exc.message},
+        )
+
+    @app.exception_handler(PermissionDeniedError)
+    async def permission_denied_handler(request: Request, exc: PermissionDeniedError) -> JSONResponse:
+        """Handle PermissionDeniedError → 403."""
+        return JSONResponse(
+            status_code=status.HTTP_403_FORBIDDEN,
+            content={"code": exc.code, "message": exc.message},
+        )
+
+    @app.exception_handler(AuthenticationError)
+    async def auth_error_handler(request: Request, exc: AuthenticationError) -> JSONResponse:
+        """Handle AuthenticationError → 401."""
+        return JSONResponse(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            content={"code": exc.code, "message": exc.message},
+        )

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/pagination.py

@@ -0,0 +1,25 @@
+"""Pagination utilities."""
+
+from typing import NamedTuple
+
+from pydantic import BaseModel, Field
+
+
+class PaginationParams(BaseModel):
+    """Query parameters for paginated endpoints."""
+
+    page: int = Field(default=1, ge=1, description="Page number (1-based)")
+    page_size: int = Field(default=20, ge=1, le=100, description="Items per page")
+
+
+class OffsetLimit(NamedTuple):
+    """Result of paginate() — ready for SQL OFFSET / LIMIT."""
+
+    offset: int
+    limit: int
+
+
+def paginate(page: int, page_size: int) -> OffsetLimit:
+    """Calculate SQL offset and limit from 1-based page and page_size."""
+    offset = (max(page, 1) - 1) * page_size
+    return OffsetLimit(offset=offset, limit=page_size)

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/response.py

@@ -0,0 +1,19 @@
+"""Unified API response helpers."""
+
+import time
+from typing import Any
+
+
+def success(data: Any = None, message: str = "success") -> dict:
+    """Return a 200 OK response envelope."""
+    return {"code": 200, "message": message, "data": data, "timestamp": int(time.time())}
+
+
+def fail(code: int = 400, message: str = "fail") -> dict:
+    """Return an error response envelope."""
+    return {"code": code, "message": message, "data": None, "timestamp": int(time.time())}
+
+
+def paginated(items: list, total: int, page: int, page_size: int) -> dict:
+    """Return a 200 OK envelope containing paginated list metadata."""
+    return success(data={"items": items, "total": total, "page": page, "page_size": page_size})

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi/security.py

@@ -0,0 +1,48 @@
+"""JWT token creation/verification and bcrypt password hashing.
+
+All helpers are stateless — pass secrets and algorithm as parameters.
+"""
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import bcrypt
+from jose import JWTError, jwt
+
+
+def hash_password(password: str) -> str:
+    """Return a bcrypt hash of *password*."""
+    password_bytes = password.encode("utf-8")
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(password_bytes, salt)
+    return hashed.decode("utf-8")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    """Return True if *plain* matches *hashed*."""
+    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
+
+
+def create_token(
+    data: dict[str, Any],
+    secret: str,
+    expires_minutes: int,
+    algorithm: str = "HS256",
+) -> str:
+    """Encode *data* as a signed JWT with the given expiration."""
+    to_encode = data.copy()
+    expire = datetime.now(UTC) + timedelta(minutes=expires_minutes)
+    to_encode["exp"] = expire
+    return jwt.encode(to_encode, secret, algorithm=algorithm)
+
+
+def decode_token(
+    token: str,
+    secret: str,
+    algorithm: str = "HS256",
+) -> dict[str, Any] | None:
+    """Decode and verify *token*. Returns None if invalid/expired."""
+    try:
+        return jwt.decode(token, secret, algorithms=[algorithm])
+    except JWTError:
+        return None

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: danweiyuan-eapi
+Version: 0.1.0
+Summary: Lightweight FastAPI infrastructure — exceptions, database, config, security, cache, pagination
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: bcrypt>=4.0.0
+Requires-Dist: redis>=5.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"
+Requires-Dist: aiosqlite>=0.20.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+README.md
+pyproject.toml
+src/danweiyuan_eapi/__init__.py
+src/danweiyuan_eapi/cache.py
+src/danweiyuan_eapi/config.py
+src/danweiyuan_eapi/database.py
+src/danweiyuan_eapi/dependencies.py
+src/danweiyuan_eapi/exceptions.py
+src/danweiyuan_eapi/pagination.py
+src/danweiyuan_eapi/response.py
+src/danweiyuan_eapi/security.py
+src/danweiyuan_eapi.egg-info/PKG-INFO
+src/danweiyuan_eapi.egg-info/SOURCES.txt
+src/danweiyuan_eapi.egg-info/dependency_links.txt
+src/danweiyuan_eapi.egg-info/requires.txt
+src/danweiyuan_eapi.egg-info/top_level.txt
+tests/test_cache.py
+tests/test_config.py
+tests/test_database.py
+tests/test_dependencies.py
+tests/test_exceptions.py
+tests/test_pagination.py
+tests/test_response.py
+tests/test_security.py

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi.egg-info/requires.txt

@@ -0,0 +1,14 @@
+fastapi>=0.100.0
+sqlalchemy[asyncio]>=2.0.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+python-jose[cryptography]>=3.3.0
+bcrypt>=4.0.0
+redis>=5.0.0
+
+[dev]
+pytest>=8.0.0
+pytest-asyncio>=0.24.0
+httpx>=0.27.0
+aiosqlite>=0.20.0
+ruff>=0.6.0

danweiyuan_eapi-0.1.0/src/danweiyuan_eapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+danweiyuan_eapi

danweiyuan_eapi-0.1.0/tests/test_cache.py

@@ -0,0 +1,28 @@
+"""Tests for danweiyuan_eapi.cache."""
+
+import pytest
+
+import danweiyuan_eapi.cache as cache_mod
+from danweiyuan_eapi.cache import close_redis, configure, get_redis
+
+
+class TestCacheConfiguration:
+    @pytest.fixture(autouse=True)
+    async def cleanup(self):
+        yield
+        cache_mod._redis_url = None
+        cache_mod._redis = None
+
+    async def test_get_redis_without_configure_raises(self):
+        cache_mod._redis_url = None
+        cache_mod._redis = None
+        with pytest.raises(RuntimeError, match="not configured"):
+            await get_redis()
+
+    async def test_configure_sets_url(self):
+        configure("redis://localhost:6379/15")
+        assert cache_mod._redis_url == "redis://localhost:6379/15"
+
+    async def test_close_redis_is_safe_when_not_connected(self):
+        cache_mod._redis = None
+        await close_redis()  # should not raise

danweiyuan_eapi-0.1.0/tests/test_config.py

@@ -0,0 +1,65 @@
+"""Tests for danweiyuan_eapi.config."""
+
+import pytest
+
+from danweiyuan_eapi.config import BaseSettings
+
+
+class TestBaseSettings:
+    def test_required_fields_raise_without_env(self, monkeypatch):
+        monkeypatch.delenv("DATABASE_URL", raising=False)
+        monkeypatch.delenv("REDIS_URL", raising=False)
+        monkeypatch.delenv("SECRET_KEY", raising=False)
+        with pytest.raises(ValueError):
+            BaseSettings()
+
+    def test_construct_with_all_required(self, monkeypatch):
+        monkeypatch.setenv("DATABASE_URL", "postgresql+asyncpg://u:p@localhost/db")
+        monkeypatch.setenv("REDIS_URL", "redis://localhost:6379/0")
+        monkeypatch.setenv("SECRET_KEY", "test-secret")
+        s = BaseSettings()
+        assert s.database_url == "postgresql+asyncpg://u:p@localhost/db"
+        assert s.redis_url == "redis://localhost:6379/0"
+        assert s.secret_key == "test-secret"
+
+    def test_debug_defaults_false(self, monkeypatch):
+        monkeypatch.setenv("DATABASE_URL", "postgresql+asyncpg://u:p@localhost/db")
+        monkeypatch.setenv("REDIS_URL", "redis://localhost:6379/0")
+        monkeypatch.setenv("SECRET_KEY", "s")
+        s = BaseSettings()
+        assert s.debug is False
+
+    def test_allowed_origins_defaults_empty(self, monkeypatch):
+        monkeypatch.setenv("DATABASE_URL", "postgresql+asyncpg://u:p@localhost/db")
+        monkeypatch.setenv("REDIS_URL", "redis://localhost:6379/0")
+        monkeypatch.setenv("SECRET_KEY", "s")
+        s = BaseSettings()
+        assert s.allowed_origins == []
+
+    def test_allowed_origins_from_env(self, monkeypatch):
+        monkeypatch.setenv("DATABASE_URL", "postgresql+asyncpg://u:p@localhost/db")
+        monkeypatch.setenv("REDIS_URL", "redis://localhost:6379/0")
+        monkeypatch.setenv("SECRET_KEY", "s")
+        monkeypatch.setenv("ALLOWED_ORIGINS", '["http://localhost:5173","http://example.com"]')
+        s = BaseSettings()
+        assert s.allowed_origins == ["http://localhost:5173", "http://example.com"]
+
+    def test_subclass_adds_fields(self, monkeypatch):
+        monkeypatch.setenv("DATABASE_URL", "postgresql+asyncpg://u:p@localhost/db")
+        monkeypatch.setenv("REDIS_URL", "redis://localhost:6379/0")
+        monkeypatch.setenv("SECRET_KEY", "s")
+        monkeypatch.setenv("CUSTOM_FIELD", "hello")
+
+        class MySettings(BaseSettings):
+            custom_field: str = "default"
+
+        s = MySettings()
+        assert s.custom_field == "hello"
+
+    def test_jwt_defaults(self, monkeypatch):
+        monkeypatch.setenv("DATABASE_URL", "postgresql+asyncpg://u:p@localhost/db")
+        monkeypatch.setenv("REDIS_URL", "redis://localhost:6379/0")
+        monkeypatch.setenv("SECRET_KEY", "s")
+        s = BaseSettings()
+        assert s.jwt_algorithm == "HS256"
+        assert s.access_token_expire_minutes == 30

danweiyuan_eapi-0.1.0/tests/test_database.py

@@ -0,0 +1,42 @@
+"""Tests for danweiyuan_eapi.database."""
+
+import pytest
+from sqlalchemy import String, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
+
+from danweiyuan_eapi.database import Base, TimestampMixin, create_async_engine_factory, create_session_factory
+
+
+class FakeModel(Base, TimestampMixin):
+    __tablename__ = "fake_items"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(50))
+
+
+class TestDatabaseFactory:
+    @pytest.fixture()
+    async def session(self):
+        engine = create_async_engine_factory("sqlite+aiosqlite:///:memory:")
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        session_factory = create_session_factory(engine)
+        async with session_factory() as session:
+            yield session
+        await engine.dispose()
+
+    async def test_insert_and_query(self, session: AsyncSession):
+        item = FakeModel(id=1, name="test-item")
+        session.add(item)
+        await session.commit()
+        result = await session.execute(select(FakeModel).where(FakeModel.id == 1))
+        found = result.scalar_one()
+        assert found.name == "test-item"
+
+    async def test_timestamp_mixin_has_columns(self):
+        assert hasattr(FakeModel, "created_at")
+        assert hasattr(FakeModel, "updated_at")
+
+    async def test_base_is_declarative(self):
+        assert hasattr(Base, "metadata")
+        assert "fake_items" in Base.metadata.tables

danweiyuan_eapi-0.1.0/tests/test_dependencies.py

@@ -0,0 +1,70 @@
+"""Tests for danweiyuan_eapi.dependencies."""
+
+import pytest
+from fastapi import Depends, FastAPI
+from fastapi.testclient import TestClient
+from sqlalchemy import String, select
+from sqlalchemy.orm import Mapped, mapped_column
+
+from danweiyuan_eapi.database import Base, create_async_engine_factory, create_session_factory
+from danweiyuan_eapi.dependencies import create_get_db
+
+
+class Item(Base):
+    __tablename__ = "dep_test_items"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(50))
+
+
+class TestGetDb:
+    @pytest.fixture()
+    def app(self, tmp_path):
+        db_path = tmp_path / "test.db"
+        engine = create_async_engine_factory(f"sqlite+aiosqlite:///{db_path}")
+        session_factory = create_session_factory(engine)
+        get_db = create_get_db(session_factory)
+
+        from collections.abc import AsyncGenerator
+        from contextlib import asynccontextmanager
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+            async with engine.begin() as conn:
+                await conn.run_sync(Base.metadata.create_all)
+            yield
+            await engine.dispose()
+
+        app = FastAPI(lifespan=lifespan)
+
+        @app.post("/items")
+        async def create_item(session=Depends(get_db)):  # noqa: B008
+            item = Item(id=1, name="test")
+            session.add(item)
+            await session.commit()
+            return {"id": 1}
+
+        @app.get("/items/{item_id}")
+        async def get_item(item_id: int, session=Depends(get_db)):  # noqa: B008
+            result = await session.execute(select(Item).where(Item.id == item_id))
+            item = result.scalar_one_or_none()
+            if item is None:
+                return {"error": "not found"}
+            return {"id": item.id, "name": item.name}
+
+        return app
+
+    @pytest.fixture()
+    def client(self, app):
+        with TestClient(app) as c:
+            yield c
+
+    def test_create_and_get_via_dependency(self, client):
+        resp = client.post("/items")
+        assert resp.status_code == 200
+        resp = client.get("/items/1")
+        assert resp.status_code == 200
+        assert resp.json() == {"id": 1, "name": "test"}
+
+    def test_get_nonexistent_returns_not_found(self, client):
+        resp = client.get("/items/999")
+        assert resp.json() == {"error": "not found"}

danweiyuan_eapi-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,93 @@
+"""Tests for danweiyuan_eapi.exceptions."""
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from danweiyuan_eapi.exceptions import (
+    AppError,
+    AuthenticationError,
+    BusinessError,
+    NotFoundError,
+    PermissionDeniedError,
+    register_exception_handlers,
+)
+
+
+class TestAppErrorHierarchy:
+    def test_app_error_defaults(self):
+        err = AppError(message="something broke")
+        assert err.message == "something broke"
+        assert err.code == "UNKNOWN_ERROR"
+
+    def test_app_error_custom_code(self):
+        err = AppError(message="oops", code="CUSTOM")
+        assert err.code == "CUSTOM"
+
+    def test_not_found_error(self):
+        err = NotFoundError("用户")
+        assert err.message == "用户不存在"
+        assert err.code == "NOT_FOUND"
+        assert isinstance(err, AppError)
+
+    def test_business_error(self):
+        err = BusinessError(message="余额不足", code="INSUFFICIENT_BALANCE")
+        assert err.message == "余额不足"
+        assert isinstance(err, AppError)
+
+    def test_permission_denied_error(self):
+        err = PermissionDeniedError()
+        assert err.message == "权限不足"
+        assert err.code == "PERMISSION_DENIED"
+
+    def test_authentication_error(self):
+        err = AuthenticationError()
+        assert err.message == "认证失败"
+        assert err.code == "AUTHENTICATION_FAILED"
+
+
+class TestExceptionHandlers:
+    @pytest.fixture()
+    def app(self):
+        app = FastAPI()
+        register_exception_handlers(app)
+
+        @app.get("/not-found")
+        async def raise_not_found():
+            raise NotFoundError("订单")
+
+        @app.get("/business-error")
+        async def raise_business():
+            raise BusinessError(message="余额不足", code="INSUFFICIENT_BALANCE")
+
+        @app.get("/forbidden")
+        async def raise_forbidden():
+            raise PermissionDeniedError()
+
+        @app.get("/unauthorized")
+        async def raise_auth():
+            raise AuthenticationError()
+
+        return app
+
+    @pytest.fixture()
+    def client(self, app):
+        return TestClient(app)
+
+    def test_not_found_returns_404(self, client):
+        resp = client.get("/not-found")
+        assert resp.status_code == 404
+        assert resp.json() == {"code": "NOT_FOUND", "message": "订单不存在"}
+
+    def test_business_error_returns_422(self, client):
+        resp = client.get("/business-error")
+        assert resp.status_code == 422
+        assert resp.json() == {"code": "INSUFFICIENT_BALANCE", "message": "余额不足"}
+
+    def test_permission_denied_returns_403(self, client):
+        resp = client.get("/forbidden")
+        assert resp.status_code == 403
+
+    def test_authentication_error_returns_401(self, client):
+        resp = client.get("/unauthorized")
+        assert resp.status_code == 401

danweiyuan_eapi-0.1.0/tests/test_pagination.py

@@ -0,0 +1,38 @@
+"""Tests for danweiyuan_eapi.pagination."""
+
+import pytest
+
+from danweiyuan_eapi.pagination import OffsetLimit, PaginationParams, paginate
+
+
+class TestPaginate:
+    def test_first_page(self):
+        assert paginate(1, 20) == OffsetLimit(offset=0, limit=20)
+
+    def test_third_page(self):
+        assert paginate(3, 10) == OffsetLimit(offset=20, limit=10)
+
+    def test_page_zero_treated_as_one(self):
+        assert paginate(0, 20) == OffsetLimit(offset=0, limit=20)
+
+    def test_negative_page_treated_as_one(self):
+        assert paginate(-5, 20) == OffsetLimit(offset=0, limit=20)
+
+
+class TestPaginationParams:
+    def test_defaults(self):
+        params = PaginationParams()
+        assert params.page == 1
+        assert params.page_size == 20
+
+    def test_custom_values(self):
+        params = PaginationParams(page=3, page_size=50)
+        assert params.page == 3
+
+    def test_page_min_is_one(self):
+        with pytest.raises(ValueError):
+            PaginationParams(page=0)
+
+    def test_page_size_max_is_100(self):
+        with pytest.raises(ValueError):
+            PaginationParams(page_size=101)

danweiyuan_eapi-0.1.0/tests/test_response.py

@@ -0,0 +1,43 @@
+"""Tests for danweiyuan_eapi.response."""
+
+from danweiyuan_eapi.response import fail, paginated, success
+
+
+class TestSuccess:
+    def test_default_message(self):
+        result = success(data={"id": 1})
+        assert result["code"] == 200
+        assert result["message"] == "success"
+        assert result["data"] == {"id": 1}
+        assert "timestamp" in result
+
+    def test_custom_message(self):
+        result = success(data=None, message="created")
+        assert result["message"] == "created"
+
+    def test_no_data(self):
+        result = success()
+        assert result["data"] is None
+
+
+class TestFail:
+    def test_default_values(self):
+        result = fail()
+        assert result["code"] == 400
+        assert result["message"] == "fail"
+
+    def test_custom_code_and_message(self):
+        result = fail(code=500, message="internal error")
+        assert result["code"] == 500
+
+
+class TestPaginated:
+    def test_paginated_structure(self):
+        items = [{"id": 1}, {"id": 2}]
+        result = paginated(items=items, total=50, page=1, page_size=20)
+        assert result["code"] == 200
+        data = result["data"]
+        assert data["items"] == items
+        assert data["total"] == 50
+        assert data["page"] == 1
+        assert data["page_size"] == 20

danweiyuan_eapi-0.1.0/tests/test_security.py

@@ -0,0 +1,51 @@
+"""Tests for danweiyuan_eapi.security."""
+
+from danweiyuan_eapi.security import create_token, decode_token, hash_password, verify_password
+
+
+class TestPasswordHashing:
+    def test_hash_returns_bcrypt_string(self):
+        hashed = hash_password("secret123")
+        assert hashed.startswith("$2b$")
+
+    def test_verify_correct_password(self):
+        hashed = hash_password("mypassword")
+        assert verify_password("mypassword", hashed) is True
+
+    def test_verify_wrong_password(self):
+        hashed = hash_password("mypassword")
+        assert verify_password("wrongpassword", hashed) is False
+
+    def test_different_hashes_for_same_password(self):
+        h1 = hash_password("same")
+        h2 = hash_password("same")
+        assert h1 != h2
+
+
+class TestJWTTokens:
+    SECRET = "test-secret-key-for-unit-tests"
+
+    def test_create_and_decode_token(self):
+        data = {"sub": "42", "username": "alice"}
+        token = create_token(data, secret=self.SECRET, expires_minutes=30)
+        payload = decode_token(token, secret=self.SECRET)
+        assert payload is not None
+        assert payload["sub"] == "42"
+        assert payload["username"] == "alice"
+
+    def test_decode_with_wrong_secret_returns_none(self):
+        token = create_token({"sub": "1"}, secret=self.SECRET, expires_minutes=30)
+        assert decode_token(token, secret="wrong-secret") is None
+
+    def test_expired_token_returns_none(self):
+        token = create_token({"sub": "1"}, secret=self.SECRET, expires_minutes=-1)
+        assert decode_token(token, secret=self.SECRET) is None
+
+    def test_invalid_token_string_returns_none(self):
+        assert decode_token("not-a-jwt", secret=self.SECRET) is None
+
+    def test_create_does_not_mutate_input(self):
+        data = {"sub": "1"}
+        original = data.copy()
+        create_token(data, secret=self.SECRET, expires_minutes=30)
+        assert data == original