api-test-toolkit 0.2.0__tar.gz → 0.3.0__tar.gz

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-test-toolkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: AI 友好的 API 自动化测试工具包
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.31
@@ -19,3 +19,4 @@ Requires-Dist: responses>=0.25; extra == "dev"
 Requires-Dist: faker>=22.0; extra == "dev"
 Requires-Dist: ruff>=0.3; extra == "dev"
 Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: pymysql>=1.1; extra == "dev"

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta:__legacy__"
 
 [project]
 name = "api-test-toolkit"
-version = "0.2.0"
+version = "0.3.0"
 description = "AI 友好的 API 自动化测试工具包"
 requires-python = ">=3.11"
 dependencies = [
@@ -33,4 +33,5 @@ dev = [
     "faker>=22.0",
     "ruff>=0.3",
     "mypy>=1.8",
+    "pymysql>=1.1",
 ]

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/src/api_test_kit/client.py

@@ -9,7 +9,7 @@ from typing import Any
 import requests
 from requests.adapters import HTTPAdapter, Retry
 
-from api_test_kit.config import HarnessConfig
+from api_test_kit.config import DomainConfig, HarnessConfig
 
 logger = logging.getLogger(__name__)
 
@@ -83,6 +83,11 @@ class BaseClient:
         client = BaseClient(config)
         client.authenticate(BearerTokenProvider("xxx"))
         resp: ApiResponse = client.get("/api/v1/users")
+
+    从域名配置创建::
+
+        domain = config.get_domain("order")
+        client = BaseClient.from_domain(domain)
     """
 
     def __init__(self, config: HarnessConfig) -> None:
@@ -92,6 +97,20 @@ class BaseClient:
         self._token_provider: TokenProvider | None = None
         self._token: str | None = None
 
+    @classmethod
+    def from_domain(cls, domain: DomainConfig) -> BaseClient:
+        """从 ``DomainConfig`` 创建客户端（用于跨系统 E2E）。"""
+        config = HarnessConfig(
+            base_url=domain.base_url,
+            api_prefix=domain.api_prefix,
+            auth_type=domain.auth_type,
+            auth_header_name=domain.auth_header_name,
+            client_secret=domain.client_secret,
+            timeout=domain.timeout,
+            max_retries=domain.max_retries,
+        )
+        return cls(config)
+
     # ── 认证 ────────────────────────────────────────────────────
 
     def authenticate(self, provider: TokenProvider) -> None:

api_test_toolkit-0.3.0/src/api_test_kit/config.py

@@ -0,0 +1,185 @@
+"""通过 Pydantic Settings 实现的多环境配置。
+
+使用方法::
+
+    config = HarnessConfig.from_env("staging")
+    config.base_url  # -> "https://staging-api.example.com"
+
+多域名支持（E2E 跨系统调用）::
+
+    # config.staging.env 中配置：
+    #   DOMAIN_ORDER__BASE_URL=https://order-api.example.com
+    #   DOMAIN_INVENTORY__BASE_URL=https://inv-api.example.com
+
+    config.get_domain("order")      # -> DomainConfig(base_url="...")
+    config.list_domains()           # -> ["inventory", "order"]
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+# ── 域名配置 ──────────────────────────────────────────────
+
+
+@dataclass
+class DomainConfig:
+    """单个 API 域名的连接配置。
+
+    通过 ``DOMAIN_{NAME}__{KEY}`` 环境变量驱动。
+    """
+    name: str
+    base_url: str = ""
+    api_prefix: str = ""
+    auth_type: str = "bearer"
+    auth_header_name: str = "authorization"
+    client_secret: str | None = None
+    timeout: int = 30
+    max_retries: int = 3
+
+
+class HarnessConfig(BaseSettings):
+    """从环境文件或环境变量加载的应用配置。
+
+    优先级：环境变量 > 环境文件 > 默认值。
+    """
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+        frozen=True,
+    )
+
+    # --- 核心 ---
+    env_name: str = Field(default="dev", description="Environment name (dev/staging/prod)")
+    base_url: str = Field(default="http://localhost:8000", description="API base URL")
+    api_prefix: str = Field(default="/api/v1", description="API version prefix")
+
+    # --- 认证 ---
+    auth_type: Literal["none", "bearer", "api_key", "basic", "oauth2"] = Field(
+        default="bearer",
+    )
+    auth_header_name: str = Field(
+        default="authorization",
+        description="HTTP header name for the auth token "
+                    "(default: 'authorization' for bearer, 'x-api-key' for api_key)",
+    )
+    auth_token_url: str | None = Field(default=None, description="Token endpoint for OAuth2")
+    client_id: str | None = Field(default=None)
+    client_secret: str | None = Field(default=None, description="Also used as bearer token value")
+
+    # --- HTTP 客户端 ---
+    timeout: int = Field(default=30, ge=1, le=300)
+    max_retries: int = Field(default=3, ge=0, le=10)
+    retry_backoff: float = Field(default=1.0, ge=0.1)
+
+    # --- 日志 ---
+    log_level: str = Field(default="INFO", pattern=r"^(DEBUG|INFO|WARNING|ERROR)$")
+    log_requests: bool = Field(default=True)
+    log_responses: bool = Field(default=True)
+
+    # --- 派生 ---
+    @property
+    def api_url(self) -> str:
+        """完整的 API 基础 URL（base_url + api_prefix）。"""
+        return f"{self.base_url}{self.api_prefix}"
+
+    # ── 域名发现 ──────────────────────────────────────────
+
+    _domain_cache: dict[str, DomainConfig] | None = None
+
+    def get_domain(self, name: str) -> DomainConfig | None:
+        """按名称获取域名配置。
+
+        从环境变量读取 ``DOMAIN_{NAME}__{KEY}`` 模式的值::
+
+            config.get_domain("order")
+            # -> DomainConfig(name="order", base_url="https://order-api.example.com", ...)
+
+        如果未配置返回 ``None``。
+        """
+        prefix = f"DOMAIN_{name.upper()}__"
+        base_url = os.getenv(f"{prefix}BASE_URL")
+        if not base_url:
+            return None
+        return DomainConfig(
+            name=name.lower(),
+            base_url=base_url,
+            api_prefix=os.getenv(f"{prefix}API_PREFIX", ""),
+            auth_type=os.getenv(f"{prefix}AUTH_TYPE", "bearer"),
+            auth_header_name=os.getenv(f"{prefix}AUTH_HEADER_NAME", "authorization"),
+            client_secret=os.getenv(f"{prefix}CLIENT_SECRET"),
+            timeout=int(os.getenv(f"{prefix}TIMEOUT", "30")),
+            max_retries=int(os.getenv(f"{prefix}MAX_RETRIES", "3")),
+        )
+
+    def list_domains(self) -> list[str]:
+        """列出所有已配置的域名。"""
+        names: set[str] = set()
+        for key, val in os.environ.items():
+            if key.startswith("DOMAIN_") and "__" in key:
+                name = key.split("__")[0].replace("DOMAIN_", "").lower()
+                names.add(name)
+        return sorted(names)
+
+    # ── 数据库配置发现 ─────────────────────────────────────
+
+    def get_db_config(self, name: str) -> DatabaseConfig | None:
+        """按名称获取数据库配置。
+
+        从环境变量读取 ``DB_{NAME}__{KEY}`` 模式的值::
+
+            config.get_db_config("order")
+            # -> DatabaseConfig(name="order", engine="mysql", host="...")
+        """
+        from api_test_kit.db.config import DatabaseConfig
+
+        prefix = f"DB_{name.upper()}__"
+        engine = os.getenv(f"{prefix}ENGINE")
+        if not engine:
+            return None
+        return DatabaseConfig(
+            name=name.lower(),
+            engine=engine.lower(),
+            host=os.getenv(f"{prefix}HOST", "localhost"),
+            port=int(os.getenv(f"{prefix}PORT", "3306")),
+            user=os.getenv(f"{prefix}USER", "root"),
+            password=os.getenv(f"{prefix}PASSWORD", ""),
+            database=os.getenv(f"{prefix}DATABASE", name.lower()),
+        )
+
+    def list_db_configs(self) -> list[str]:
+        """列出所有已配置的数据库名称。"""
+        names: set[str] = set()
+        for key, val in os.environ.items():
+            if key.startswith("DB_") and "__" in key:
+                name = key.split("__")[0].replace("DB_", "").lower()
+                names.add(name)
+        return sorted(names)
+
+    @classmethod
+    def from_env(cls, env_name: str = "dev") -> HarnessConfig:
+        """加载指定环境的配置。
+
+        查找项目根目录下的 ``config.{env_name}.env``，
+        如果不存在则回退到 ``.env``。
+        """
+        project_root = cls._find_project_root()
+        env_file = project_root / f"config.{env_name}.env"
+        return cls(_env_file=str(env_file) if env_file.exists() else None)
+
+    @staticmethod
+    def _find_project_root() -> Path:
+        """从当前工作目录向上查找项目根目录（包含 pyproject.toml 的目录）。"""
+        start = Path.cwd()
+        for parent in [start] + list(start.parents):
+            if (parent / "pyproject.toml").exists():
+                return parent
+        return start

api_test_toolkit-0.3.0/src/api_test_kit/db/__init__.py

@@ -0,0 +1,8 @@
+"""数据库操作 — 多数据源连接、查询、写入、数据提取。"""
+from api_test_kit.db.config import DatabaseConfig
+from api_test_kit.db.database import Database
+
+__all__ = [
+    "DatabaseConfig",
+    "Database",
+]

api_test_toolkit-0.3.0/src/api_test_kit/db/config.py

@@ -0,0 +1,30 @@
+"""数据库连接配置。"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class DatabaseConfig:
+    """单个数据库的连接配置。
+
+    通过 ``DB_{NAME}__{KEY}`` 环境变量驱动。
+    """
+
+    name: str
+    engine: str = "mysql"  # mysql / postgresql / sqlite
+    host: str = "localhost"
+    port: int = 3306
+    user: str = "root"
+    password: str = ""
+    database: str = ""
+
+    @property
+    def is_sqlite(self) -> bool:
+        return self.engine == "sqlite"
+
+    @classmethod
+    def sqlite_in_memory(cls, name: str = "test") -> DatabaseConfig:
+        """创建一个内存 SQLite 配置（用于单元测试）。"""
+        return cls(name=name, engine="sqlite", database=":memory:")

api_test_toolkit-0.3.0/src/api_test_kit/db/database.py

@@ -0,0 +1,138 @@
+"""数据库操作封装 — 连接、查询、写入、数据提取。
+
+支持 MySQL、PostgreSQL、SQLite。MySQL 需要安装 ``pymysql``。
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from api_test_kit.db.config import DatabaseConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Database:
+    """数据库操作封装。
+
+    用法::
+
+        config = DatabaseConfig(name="order", engine="mysql",
+                                host="localhost", database="orders")
+        db = Database(config)
+        rows = db.query("SELECT * FROM orders WHERE id = %(id)s", {"id": 1})
+        affected = db.execute("UPDATE orders SET status = %(s)s", {"s": "shipped"})
+        val = db.extract("SELECT name FROM users WHERE id = %(id)s", "name", {"id": 1})
+    """
+
+    def __init__(self, config: DatabaseConfig) -> None:
+        self.config = config
+        self._conn: Any = None
+
+    # ── 连接 ──────────────────────────────────────────────
+
+    @property
+    def conn(self) -> Any:
+        """惰性获取数据库连接。"""
+        if self._conn is None:
+            self._conn = self._create_connection()
+            logger.info("[DB] 已连接: %s/%s", self.config.engine, self.config.database)
+        return self._conn
+
+    def _create_connection(self) -> Any:
+        cfg = self.config
+        if cfg.is_sqlite:
+            import sqlite3
+            conn = sqlite3.connect(cfg.database)
+            conn.row_factory = sqlite3.Row
+            return conn
+        elif cfg.engine == "mysql":
+            return self._connect_mysql(cfg)
+        elif cfg.engine == "postgresql":
+            return self._connect_postgres(cfg)
+        raise ValueError(f"不支持的数据库引擎: {cfg.engine}")
+
+    def _connect_mysql(self, cfg: DatabaseConfig) -> Any:
+        try:
+            import pymysql
+            import pymysql.cursors
+        except ImportError:
+            raise ImportError(
+                "MySQL 支持需要安装 pymysql: pip install pymysql"
+            )
+        return pymysql.connect(
+            host=cfg.host,
+            port=cfg.port,
+            user=cfg.user,
+            password=cfg.password,
+            database=cfg.database,
+            charset="utf8mb4",
+            cursorclass=pymysql.cursors.DictCursor,
+        )
+
+    def _connect_postgres(self, cfg: DatabaseConfig) -> Any:
+        try:
+            import psycopg2
+            import psycopg2.extras
+        except ImportError:
+            raise ImportError(
+                "PostgreSQL 支持需要安装 psycopg2: pip install psycopg2-binary"
+            )
+        return psycopg2.connect(
+            host=cfg.host,
+            port=cfg.port,
+            user=cfg.user,
+            password=cfg.password,
+            dbname=cfg.database,
+            cursor_factory=psycopg2.extras.RealDictCursor,
+        )
+
+    # ── 操作 ──────────────────────────────────────────────
+
+    def query(self, sql: str, params: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+        """执行查询，返回字典列表。"""
+        cursor = self.conn.cursor()
+        cursor.execute(sql, params or {})
+        rows = cursor.fetchall()
+        cols = [d[0] for d in cursor.description] if cursor.description else []
+        cursor.close()
+        result: list[dict[str, Any]] = []
+        for r in rows:
+            if isinstance(r, dict):
+                result.append(r)
+            elif hasattr(r, "keys"):
+                result.append({k: r[k] for k in r.keys()})
+            else:
+                result.append(dict(zip(cols, r)) if cols else {})
+        return result
+
+    def execute(self, sql: str, params: dict[str, Any] | None = None) -> int:
+        """执行写入（insert/update/delete），返回影响行数。"""
+        cursor = self.conn.cursor()
+        cursor.execute(sql, params or {})
+        self.conn.commit()
+        affected = cursor.rowcount
+        cursor.close()
+        return affected
+
+    def extract(self, sql: str, column: str, params: dict[str, Any] | None = None) -> Any:
+        """查询并提取某一列的值（用于 E2E 数据传递）。"""
+        rows = self.query(sql, params)
+        if rows:
+            return rows[0].get(column)
+        return None
+
+    def close(self) -> None:
+        """关闭数据库连接。"""
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+            logger.info("[DB] 已断开: %s/%s", self.config.engine, self.config.database)
+
+    # ── 上下文管理器 ───────────────────────────────────────
+
+    def __enter__(self) -> Database:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/src/api_test_kit/scaffold.py

@@ -50,6 +50,7 @@ TEMPLATE_FILES: list[str] = [
 
 EMPTY_DIRS: list[str] = [
     "tests/endpoints",
+    "tests/e2e",
     "reports",
 ]
 

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/src/api_test_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-test-toolkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: AI 友好的 API 自动化测试工具包
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.31
@@ -19,3 +19,4 @@ Requires-Dist: responses>=0.25; extra == "dev"
 Requires-Dist: faker>=22.0; extra == "dev"
 Requires-Dist: ruff>=0.3; extra == "dev"
 Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: pymysql>=1.1; extra == "dev"

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/src/api_test_toolkit.egg-info/SOURCES.txt

@@ -7,6 +7,9 @@ src/api_test_kit/client.py
 src/api_test_kit/config.py
 src/api_test_kit/logger.py
 src/api_test_kit/scaffold.py
+src/api_test_kit/db/__init__.py
+src/api_test_kit/db/config.py
+src/api_test_kit/db/database.py
 src/api_test_kit/e2e/__init__.py
 src/api_test_kit/e2e/context.py
 src/api_test_kit/e2e/helpers.py
@@ -21,6 +24,7 @@ src/api_test_kit/templates/pytest.ini
 src/api_test_kit/templates/scripts/new-endpoint.sh
 src/api_test_kit/templates/tests/__init__.py
 src/api_test_kit/templates/tests/conftest.py
+src/api_test_kit/templates/tests/e2e/__init__.py
 src/api_test_toolkit.egg-info/PKG-INFO
 src/api_test_toolkit.egg-info/SOURCES.txt
 src/api_test_toolkit.egg-info/dependency_links.txt
@@ -29,6 +33,8 @@ src/api_test_toolkit.egg-info/requires.txt
 src/api_test_toolkit.egg-info/top_level.txt
 tests/test_assertions.py
 tests/test_client.py
+tests/test_config.py
+tests/test_db.py
 tests/test_e2e_context.py
 tests/test_e2e_scenario.py
 tests/test_e2e_step.py

{api_test_toolkit-0.2.0 → api_test_toolkit-0.3.0}/src/api_test_toolkit.egg-info/requires.txt

@@ -15,3 +15,4 @@ responses>=0.25
 faker>=22.0
 ruff>=0.3
 mypy>=1.8
+pymysql>=1.1

api_test_toolkit-0.3.0/tests/test_config.py

@@ -0,0 +1,56 @@
+"""配置模块单元测试。"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from api_test_kit.config import DomainConfig, HarnessConfig
+
+
+class TestDomainConfig:
+    """DomainConfig — 多域名配置。"""
+
+    def test_get_domain_exists(self) -> None:
+        os.environ["DOMAIN_ORDER__BASE_URL"] = "https://order.test.com"
+        os.environ["DOMAIN_ORDER__API_PREFIX"] = "/api/v2"
+        try:
+            c = HarnessConfig()
+            d = c.get_domain("order")
+            assert d is not None
+            assert d.base_url == "https://order.test.com"
+            assert d.api_prefix == "/api/v2"
+            assert d.name == "order"
+        finally:
+            del os.environ["DOMAIN_ORDER__BASE_URL"]
+            del os.environ["DOMAIN_ORDER__API_PREFIX"]
+
+    def test_get_domain_missing(self) -> None:
+        c = HarnessConfig()
+        assert c.get_domain("nonexistent") is None
+
+    def test_list_domains(self) -> None:
+        os.environ["DOMAIN_A__BASE_URL"] = "https://a.test.com"
+        os.environ["DOMAIN_B__BASE_URL"] = "https://b.test.com"
+        try:
+            c = HarnessConfig()
+            domains = c.list_domains()
+            assert "a" in domains
+            assert "b" in domains
+        finally:
+            del os.environ["DOMAIN_A__BASE_URL"]
+            del os.environ["DOMAIN_B__BASE_URL"]
+
+    def test_get_db_config(self) -> None:
+        os.environ["DB_ORDER__ENGINE"] = "mysql"
+        os.environ["DB_ORDER__HOST"] = "order-db.test.com"
+        try:
+            c = HarnessConfig()
+            dbc = c.get_db_config("order")
+            assert dbc is not None
+            assert dbc.engine == "mysql"
+            assert dbc.host == "order-db.test.com"
+            assert dbc.port == 3306
+        finally:
+            del os.environ["DB_ORDER__ENGINE"]
+            del os.environ["DB_ORDER__HOST"]

api_test_toolkit-0.3.0/tests/test_db.py

@@ -0,0 +1,108 @@
+"""Database 单元测试（使用 SQLite，无需外部数据库）。"""
+from __future__ import annotations
+
+import pytest
+
+from api_test_kit.db.config import DatabaseConfig
+from api_test_kit.db.database import Database
+
+
+@pytest.fixture
+def db() -> Database:
+    """创建内存 SQLite 数据库并初始化测试表。"""
+    config = DatabaseConfig.sqlite_in_memory()
+    database = Database(config)
+    database.execute(
+        "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"
+    )
+    database.execute(
+        "INSERT INTO users (name, email) VALUES (:name, :email)",
+        {"name": "Alice", "email": "alice@test.com"},
+    )
+    database.execute(
+        "INSERT INTO users (name, email) VALUES (:name, :email)",
+        {"name": "Bob", "email": "bob@test.com"},
+    )
+    return database
+
+
+class TestDatabase:
+    """Database — 数据库操作封装。"""
+
+    def test_query_returns_dicts(self, db: Database) -> None:
+        rows = db.query("SELECT * FROM users ORDER BY id")
+        assert len(rows) == 2
+        assert rows[0]["name"] == "Alice"
+        assert rows[0]["email"] == "alice@test.com"
+
+    def test_query_with_params(self, db: Database) -> None:
+        rows = db.query(
+            "SELECT * FROM users WHERE name = :name",
+            {"name": "Bob"},
+        )
+        assert len(rows) == 1
+        assert rows[0]["email"] == "bob@test.com"
+
+    def test_execute_insert(self, db: Database) -> None:
+        affected = db.execute(
+            "INSERT INTO users (name, email) VALUES (:name, :email)",
+            {"name": "Charlie", "email": "charlie@test.com"},
+        )
+        assert affected == 1
+        rows = db.query("SELECT * FROM users")
+        assert len(rows) == 3
+
+    def test_execute_update(self, db: Database) -> None:
+        affected = db.execute(
+            "UPDATE users SET email = :email WHERE name = :name",
+            {"email": "alice@new.com", "name": "Alice"},
+        )
+        assert affected == 1
+        row = db.query("SELECT * FROM users WHERE name = 'Alice'")
+        assert row[0]["email"] == "alice@new.com"
+
+    def test_execute_delete(self, db: Database) -> None:
+        affected = db.execute("DELETE FROM users WHERE name = :name", {"name": "Alice"})
+        assert affected == 1
+        rows = db.query("SELECT * FROM users")
+        assert len(rows) == 1
+
+    def test_extract_column_value(self, db: Database) -> None:
+        val = db.extract(
+            "SELECT email FROM users WHERE name = :name",
+            "email",
+            {"name": "Alice"},
+        )
+        assert val == "alice@test.com"
+
+    def test_extract_returns_none_for_missing(self, db: Database) -> None:
+        val = db.extract(
+            "SELECT email FROM users WHERE name = :name",
+            "email",
+            {"name": "Nonexistent"},
+        )
+        assert val is None
+
+    def test_context_manager(self) -> None:
+        config = DatabaseConfig.sqlite_in_memory()
+        with Database(config) as db:
+            db.execute("CREATE TABLE t (x INTEGER)")
+            db.execute("INSERT INTO t VALUES (42)")
+            rows = db.query("SELECT * FROM t")
+            assert rows[0]["x"] == 42
+        # 退出上下文后连接应关闭
+        assert db._conn is None
+
+    def test_config_sqlite_in_memory(self) -> None:
+        config = DatabaseConfig.sqlite_in_memory("testdb")
+        assert config.name == "testdb"
+        assert config.engine == "sqlite"
+        assert config.database == ":memory:"
+        assert config.is_sqlite is True
+
+    def test_config_mysql_defaults(self) -> None:
+        config = DatabaseConfig(name="order", engine="mysql", host="db.example.com")
+        assert config.host == "db.example.com"
+        assert config.port == 3306
+        assert config.user == "root"
+        assert config.is_sqlite is False

api_test_toolkit-0.2.0/src/api_test_kit/config.py

@@ -1,82 +0,0 @@
-"""通过 Pydantic Settings 实现的多环境配置。
-
-使用方法::
-
-    config = HarnessConfig.from_env("staging")
-    config.base_url  # -> "https://staging-api.example.com"
-"""
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Literal
-
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class HarnessConfig(BaseSettings):
-    """从环境文件或环境变量加载的应用配置。
-
-    优先级：环境变量 > 环境文件 > 默认值。
-    """
-
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        extra="ignore",
-        frozen=True,
-    )
-
-    # --- 核心 ---
-    env_name: str = Field(default="dev", description="Environment name (dev/staging/prod)")
-    base_url: str = Field(default="http://localhost:8000", description="API base URL")
-    api_prefix: str = Field(default="/api/v1", description="API version prefix")
-
-    # --- 认证 ---
-    auth_type: Literal["none", "bearer", "api_key", "basic", "oauth2"] = Field(
-        default="bearer",
-    )
-    auth_header_name: str = Field(
-        default="authorization",
-        description="HTTP header name for the auth token "
-                    "(default: 'authorization' for bearer, 'x-api-key' for api_key)",
-    )
-    auth_token_url: str | None = Field(default=None, description="Token endpoint for OAuth2")
-    client_id: str | None = Field(default=None)
-    client_secret: str | None = Field(default=None, description="Also used as bearer token value")
-
-    # --- HTTP 客户端 ---
-    timeout: int = Field(default=30, ge=1, le=300)
-    max_retries: int = Field(default=3, ge=0, le=10)
-    retry_backoff: float = Field(default=1.0, ge=0.1)
-
-    # --- 日志 ---
-    log_level: str = Field(default="INFO", pattern=r"^(DEBUG|INFO|WARNING|ERROR)$")
-    log_requests: bool = Field(default=True)
-    log_responses: bool = Field(default=True)
-
-    # --- 派生 ---
-    @property
-    def api_url(self) -> str:
-        """完整的 API 基础 URL（base_url + api_prefix）。"""
-        return f"{self.base_url}{self.api_prefix}"
-
-    @classmethod
-    def from_env(cls, env_name: str = "dev") -> HarnessConfig:
-        """加载指定环境的配置。
-
-        查找项目根目录下的 ``config.{env_name}.env``，
-        如果不存在则回退到 ``.env``。
-        """
-        project_root = cls._find_project_root()
-        env_file = project_root / f"config.{env_name}.env"
-        return cls(_env_file=str(env_file) if env_file.exists() else None)
-
-    @staticmethod
-    def _find_project_root() -> Path:
-        """从当前工作目录向上查找项目根目录（包含 pyproject.toml 的目录）。"""
-        start = Path.cwd()
-        for parent in [start] + list(start.parents):
-            if (parent / "pyproject.toml").exists():
-                return parent
-        return start