nene2-python 1.8.0__tar.gz → 1.8.1__tar.gz

{nene2_python-1.8.0 → nene2_python-1.8.1}/CHANGELOG.md

@@ -5,6 +5,21 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ---
 
+## [1.8.1] — 2026-05-20
+
+FT25〜FT28 フィールドトライアル — RequestId ヘルパー・structlog ログレベル・ThrottleMiddleware 改善。
+
+### Added
+- `nene2.middleware.get_request_id()` — FastAPI `Depends` で注入できる request ID ヘルパー関数 (FT25)
+- `setup_logging()` に `log_level: str = "INFO"` パラメータを追加し `AppSettings.log_level` との統合が容易に (FT26)
+- `ThrottleMiddleware` に `path_limits: dict[str, int] | None` パラメータを追加し、パスごとに異なるレート制限を設定可能に (FT28)
+- Field trial reports: `docs/field-trials/2026-05-field-trial-25.md` 〜 `docs/field-trials/2026-05-field-trial-28.md`
+
+### Fixed
+- `ThrottleMiddleware` — ウィンドウ経過後も `_counts` に古いエントリが残り続ける問題を修正（定期クリーンアップを実装）(FT27)
+
+---
+
 ## [1.8.0] — 2026-05-20
 
 FT18〜FT23 フィールドトライアル — ログテスト・Problem Details・ThrottleMiddleware・ドメイン例外・HealthCheck・RequestSizeLimit の各改善。

{nene2_python-1.8.0 → nene2_python-1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nene2-python
-Version: 1.8.0
+Version: 1.8.1
 Summary: NENE2 Python — minimal API framework following NENE2's design philosophy
 Project-URL: Homepage, https://github.com/hideyukiMORI/nene2-python
 Project-URL: Repository, https://github.com/hideyukiMORI/nene2-python

nene2_python-1.8.1/docs/field-trials/2026-05-field-trial-24.md

@@ -0,0 +1,89 @@
+# FT24: AppSettings 実運用検証
+
+**日付**: 2026-05-20
+**テーマ**: `AppSettings` を使った環境変数ベースの設定管理パターンの実運用検証
+**FT アプリ**: `/home/xi/docker/nene2-python-FT/ft24-app-settings/`
+
+---
+
+## 目的
+
+`nene2.config.AppSettings` を実際のアプリに組み込み、
+環境変数から設定を読み込んでミドルウェアを設定するパターンを検証する。
+
+---
+
+## 実施内容
+
+`AppSettings` の各フィールドを使って以下を設定:
+- `ErrorHandlerMiddleware(debug=settings.app_debug)`
+- `RequestSizeLimitMiddleware(max_bytes=settings.max_body_size)`
+- `ThrottleMiddleware(limit=settings.throttle_limit, window=settings.throttle_window)` (conditional)
+- `SecurityHeadersMiddleware` (conditional)
+
+---
+
+## テスト結果
+
+### test_app.py（正常系・機能確認）
+| テスト | 結果 |
+|---|---|
+| test_health_endpoint_returns_env | PASS |
+| test_debug_false_by_default | PASS |
+| test_settings_loaded_from_env_vars | PASS |
+| test_throttle_disabled_via_settings | PASS |
+| test_max_body_size_from_settings | PASS |
+| test_db_url_sqlite_default | PASS |
+| test_db_url_mysql_format | PASS |
+
+### test_friction.py（摩擦点確認）
+| テスト | 結果 | 摩擦 |
+|---|---|---|
+| test_list_fields_not_parseable_from_env_string | PASS | あり（ドキュメント） |
+| test_no_log_level_setting | PASS | あり |
+| test_no_middleware_factory_helper | PASS | あり（設計上の判断） |
+
+---
+
+## 発見した摩擦点
+
+### FT24-F1: list[str] フィールドを環境変数で設定する方法がドキュメントにない
+
+**概要**: `cors_origins`、`bearer_tokens`、`api_keys` は `list[str]` 型だが、
+環境変数から設定するには JSON 形式 (`["a","b"]`) が必要。
+単純な `"token1,token2"` ではパースされない。
+
+**判断**: pydantic-settings の標準動作のため、リファレンスドキュメントに記載する。
+
+---
+
+### FT24-F2: ログレベルの設定フィールドがない
+
+**概要**: `app_debug: bool` しかなく、`INFO`/`WARNING`/`ERROR` の粒度制御ができない。
+
+**影響**: ステージング環境で `INFO` ログを出しつつ、本番では `WARNING` に絞りたいが、
+現在は `app_debug=true` でしか詳細ログを出す方法がない。
+
+**期待する解決策**: `log_level: str = "INFO"` フィールドを追加。
+
+---
+
+### FT24-F3: AppSettings からミドルウェアを自動設定するヘルパーがない
+
+**概要**: AppSettings の設定値をミドルウェアに適用するには、
+毎回条件分岐付きのボイラープレートを手書きする必要がある。
+
+**判断**: `configure_middleware(app, settings)` ヘルパーは「薄い HTTP 層」の設計哲学に反し、
+フレームワークの主張が強くなりすぎる。FT アプリ側でパターンを提示する対応が適切。
+今回はドキュメント追加のみ。
+
+---
+
+## まとめ
+
+`AppSettings` は環境変数から型安全に設定を読み込む機能として正しく動作する。
+実運用での摩擦は:
+
+1. **list[str] 環境変数の書き方がわかりにくい** → ドキュメント追加対応
+2. **log_level フィールドがない** → Issue 化・修正対象
+3. **ミドルウェア自動設定ヘルパーがない** → 設計上の判断で修正しない

nene2_python-1.8.1/docs/field-trials/2026-05-field-trial-25.md

@@ -0,0 +1,82 @@
+# FT25: RequestIdMiddleware 実運用検証
+
+**日付**: 2026-05-20
+**テーマ**: `RequestIdMiddleware` のリクエスト ID 生成・伝播・ContextVar 統合の実運用検証
+**FT アプリ**: `/home/xi/docker/nene2-python-FT/ft25-request-id/`
+
+---
+
+## 目的
+
+`nene2.middleware.RequestIdMiddleware` と `request_id_var` を使って、
+リクエスト ID を生成・伝播するパターンを検証する。
+
+---
+
+## 実施内容
+
+- `/api/echo` エンドポイントで `request_id_var.get()` を返す
+- クライアント提供の有効 UUID v4 の伝播確認
+- 無効な ID が新しい UUID に置き換えられることを確認
+
+---
+
+## テスト結果
+
+### test_app.py（正常系・機能確認）
+| テスト | 結果 |
+|---|---|
+| test_response_includes_x_request_id_header | PASS |
+| test_request_id_is_available_in_handler | PASS |
+| test_client_supplied_valid_uuid_is_preserved | PASS |
+| test_client_supplied_invalid_id_is_replaced | PASS |
+| test_each_request_gets_unique_id | PASS |
+
+### test_friction.py（摩擦点確認）
+| テスト | 結果 | 摩擦 |
+|---|---|---|
+| test_request_id_not_accessible_from_middleware_stack | PASS | あり（ドキュメント） |
+| test_no_helper_to_get_request_id_from_header_in_handler | PASS | あり |
+| test_request_id_contextvars_isolation_per_request | PASS | なし（正しい動作） |
+
+---
+
+## 発見した摩擦点
+
+### FT25-F1: ミドルウェア順序依存がドキュメントに明記されていない
+
+**概要**: `request_id_var` はミドルウェアの実行順序に依存するが、
+これがドキュメントに明記されていない。
+`RequestIdMiddleware` より先に実行されるミドルウェアでは `request_id_var.get()` が空になる。
+
+**判断**: ミドルウェア追加順のドキュメント化で対応（how-to に記載）。
+
+---
+
+### FT25-F2: FastAPI Depends 用の get_request_id() ヘルパーがない
+
+**概要**: `request_id_var.get()` で直接取得できるが、
+FastAPI の依存性注入パターンと統合するヘルパーがない。
+
+```python
+# 各プロジェクトで毎回書く必要がある
+async def get_request_id() -> str:
+    return request_id_var.get()
+
+@app.get("/")
+async def handler(request_id: str = Depends(get_request_id)):
+    ...
+```
+
+**期待する解決策**: `nene2.middleware` から `get_request_id` を直接インポートできると便利。
+
+---
+
+## まとめ
+
+`RequestIdMiddleware` の基本機能（UUID v4 生成・検証・ContextVar 伝播・レスポンスヘッダー付与）は
+問題なく動作する。
+
+摩擦点:
+1. **ミドルウェア順序依存のドキュメント不備** → how-to に追記
+2. **`get_request_id()` Depends ヘルパーがない** → Issue 化・修正対象

nene2_python-1.8.1/docs/field-trials/2026-05-field-trial-26.md

@@ -0,0 +1,73 @@
+# FT26: nene2.log structlog 統合検証
+
+**日付**: 2026-05-20
+**テーマ**: `setup_logging()` と `AppSettings.log_level` の連携検証
+**FT アプリ**: `/home/xi/docker/nene2-python-FT/ft26-logging/`
+
+---
+
+## 目的
+
+`nene2.log.setup_logging()` を実際のアプリで使い、
+`AppSettings.log_level`（FT24 で追加）との統合フローを検証する。
+
+---
+
+## 実施内容
+
+- `setup_logging()` の `local` / `production` 環境での動作確認
+- `RequestLoggingMiddleware` と structlog の連携確認
+- `AppSettings.log_level` を `setup_logging()` に渡す方法の検証
+
+---
+
+## テスト結果
+
+### test_app.py（正常系・機能確認）
+| テスト | 結果 |
+|---|---|
+| test_log_test_endpoint_returns_200 | PASS |
+| test_request_logging_middleware_logs_request | PASS |
+| test_log_levels_endpoint_returns_200 | PASS |
+| test_setup_logging_local_env | PASS |
+| test_setup_logging_production_env | PASS |
+
+### test_friction.py（摩擦点確認）
+| テスト | 結果 | 摩擦 |
+|---|---|---|
+| test_setup_logging_does_not_accept_log_level_param | PASS | あり |
+| test_setup_logging_hardcodes_info_level | PASS | あり |
+| test_no_way_to_integrate_app_settings_log_level_with_setup_logging | PASS | あり（ボイラープレート） |
+
+---
+
+## 発見した摩擦点
+
+### FT26-F1: setup_logging() が log_level を受け取れない
+
+**概要**: FT24 で `AppSettings.log_level` が追加されたが、
+`setup_logging()` はそれを受け取るパラメータを持たない。
+`setup_logging()` は常に `logging.INFO` をハードコードするため、
+`AppSettings.log_level = "DEBUG"` を設定しても反映されない。
+
+```python
+# 現状: ボイラープレートが必要
+settings = AppSettings(log_level="DEBUG")
+setup_logging(app_env=settings.app_env)
+logging.getLogger().setLevel(settings.log_level)  # ← 別途必要
+
+# 期待する使い方
+setup_logging(app_env=settings.app_env, log_level=settings.log_level)
+```
+
+**期待する解決策**: `setup_logging(app_env="local", log_level="INFO")` のように
+`log_level` パラメータを追加して `AppSettings` と統合しやすくする。
+
+---
+
+## まとめ
+
+`setup_logging()` の基本機能（ConsoleRenderer / JSONRenderer の切り替え）は問題なく動作する。
+
+摩擦点:
+1. **`setup_logging()` に `log_level` パラメータがない** → `AppSettings.log_level` との統合時にボイラープレートが必要 → Issue 化・修正対象

nene2_python-1.8.1/docs/field-trials/2026-05-field-trial-27.md

@@ -0,0 +1,66 @@
+# FT27: ThrottleMiddleware 長時間運用検証
+
+**日付**: 2026-05-20
+**テーマ**: `ThrottleMiddleware` の長時間稼働時のメモリ蓄積問題を検証
+**FT アプリ**: `/home/xi/docker/nene2-python-FT/ft27-throttle-cleanup/`
+
+---
+
+## 目的
+
+`ThrottleMiddleware` の `_counts` ディクショナリに古いエントリが蓄積する問題（Issue #223）を実証し、
+修正方針を検討する。
+
+---
+
+## 実施内容
+
+- 複数 IP からのリクエストシミュレーション
+- ウィンドウ経過後のエントリ残存を確認
+- クリーンアップ機能の有無を検証
+
+---
+
+## テスト結果
+
+### test_app.py（正常系・機能確認）
+| テスト | 結果 |
+|---|---|
+| test_ping_returns_200 | PASS |
+| test_rate_limit_headers_present | PASS |
+| test_rate_limit_exceeded_returns_429 | PASS |
+| test_different_ips_have_separate_counters | PASS |
+
+### test_friction.py（摩擦点確認）
+| テスト | 結果 | 摩擦 |
+|---|---|---|
+| test_stale_entries_accumulate_in_memory | PASS | あり（バグ） |
+| test_no_cleanup_method_exists_on_throttle_middleware | PASS | あり |
+
+---
+
+## 発見した摩擦点
+
+### FT27-F1: 古いエントリが _counts から削除されない（Issue #223）
+
+**概要**: 異なるクライアント IP からリクエストが来るたびに `_counts` にエントリが追加されるが、
+ウィンドウ期間が過ぎても古いエントリは削除されない。
+長時間稼働・多数の異なるクライアントが存在する環境ではメモリが際限なく増加する。
+
+**確認した動作**:
+```python
+# 10 IP のエントリを作成 → window (1秒) 経過後も 10 エントリが残る
+# 新しい IP のリクエスト後も 11 エントリ (10 古い + 1 新しい)
+```
+
+**修正方針**: `_check_rate()` 内で定期的にクリーンアップを実施する。
+`_last_cleanup` タイムスタンプを持ち、`window` 秒経過したときに期限切れエントリを一括削除する。
+
+---
+
+## まとめ
+
+`ThrottleMiddleware` の基本機能は正常に動作する。
+
+摩擦点:
+1. **古いエントリのメモリ蓄積** → Issue #223 として登録済み、修正対象

nene2_python-1.8.1/docs/field-trials/2026-05-field-trial-28.md

@@ -0,0 +1,54 @@
+# FT28: ThrottleMiddleware パスごとのレート制限検証
+
+**日付**: 2026-05-20
+**テーマ**: `ThrottleMiddleware` のパスごとのレート制限（Issue #222）
+**FT アプリ**: `/home/xi/docker/nene2-python-FT/ft28-path-throttle/`
+
+---
+
+## 目的
+
+重いエンドポイントだけ厳しいレート制限をかけたい実運用ニーズを検証する。
+
+---
+
+## 実施内容
+
+- `path_limits` パラメータの不在を確認
+- 現状では全エンドポイントで同じ `limit`/`window` しか設定できないことを実証
+
+---
+
+## テスト結果
+
+### test_friction.py（摩擦点確認）
+| テスト | 結果 | 摩擦 |
+|---|---|---|
+| test_throttle_middleware_does_not_support_path_limits | PASS | あり |
+| test_workaround_requires_multiple_middlewares | PASS | あり |
+
+---
+
+## 発見した摩擦点
+
+### FT28-F1: ThrottleMiddleware がパスごとのレート制限をサポートしない（Issue #222）
+
+**概要**: 全エンドポイントで同じ `limit`/`window` しか設定できない。
+`/api/expensive` だけ `limit=10` にして残りは `limit=100` にする、という設定ができない。
+
+**期待する使い方**:
+```python
+app.add_middleware(
+    ThrottleMiddleware,
+    limit=100,
+    window=60,
+    path_limits={"/api/expensive": 10, "/api/search": 30},
+)
+```
+
+---
+
+## まとめ
+
+摩擦点:
+1. **`path_limits` 未対応** → Issue #222 として登録済み、修正対象

{nene2_python-1.8.0 → nene2_python-1.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nene2-python"
-version = "1.8.0"
+version = "1.8.1"
 description = "NENE2 Python — minimal API framework following NENE2's design philosophy"
 readme = "README.md"
 license = {text = "MIT"}

{nene2_python-1.8.0 → nene2_python-1.8.1}/src/nene2/config/settings.py

@@ -12,6 +12,7 @@ class AppSettings(BaseSettings):
     app_env: str = "local"
     app_debug: bool = False
     app_name: str = "nene2-python"
+    log_level: str = "INFO"
     security_headers_enabled: bool = True
     max_body_size: int = 1_048_576  # 1 MiB
     throttle_enabled: bool = True
@@ -50,6 +51,15 @@ class AppSettings(BaseSettings):
             raise ValueError(f"app_env must be one of {allowed}")
         return v
 
+    @field_validator("log_level")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        allowed = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+        upper = v.upper()
+        if upper not in allowed:
+            raise ValueError(f"log_level must be one of {allowed}")
+        return upper
+
     @field_validator("db_adapter")
     @classmethod
     def validate_adapter(cls, v: str) -> str:

{nene2_python-1.8.0 → nene2_python-1.8.1}/src/nene2/log/setup.py

@@ -51,7 +51,7 @@ def configure_for_testing() -> None:
     root.setLevel(logging.DEBUG)
 
 
-def setup_logging(app_env: str = "local") -> None:
+def setup_logging(app_env: str = "local", log_level: str = "INFO") -> None:
     shared_processors: list[structlog.types.Processor] = [
         structlog.stdlib.add_log_level,
         structlog.stdlib.add_logger_name,
@@ -86,4 +86,4 @@ def setup_logging(app_env: str = "local") -> None:
     root = logging.getLogger()
     root.handlers.clear()
     root.addHandler(handler)
-    root.setLevel(logging.INFO)
+    root.setLevel(getattr(logging, log_level.upper(), logging.INFO))

{nene2_python-1.8.0 → nene2_python-1.8.1}/src/nene2/middleware/__init__.py

@@ -2,7 +2,7 @@
 
 from .domain_exception import DomainExceptionHandlerProtocol, SimpleDomainHandler
 from .error_handler import ErrorHandlerMiddleware
-from .request_id import RequestIdMiddleware, request_id_var
+from .request_id import RequestIdMiddleware, get_request_id, request_id_var
 from .request_logging import RequestLoggingMiddleware
 from .request_size_limit import RequestSizeLimitMiddleware
 from .security_headers import SecurityHeadersMiddleware
@@ -13,6 +13,7 @@ __all__ = [
     "SimpleDomainHandler",
     "ErrorHandlerMiddleware",
     "RequestIdMiddleware",
+    "get_request_id",
     "RequestLoggingMiddleware",
     "RequestSizeLimitMiddleware",
     "SecurityHeadersMiddleware",

{nene2_python-1.8.0 → nene2_python-1.8.1}/src/nene2/middleware/request_id.py

@@ -30,6 +30,24 @@ def _validated_request_id(value: str | None) -> str:
     return str(uuid.uuid4())
 
 
+def get_request_id() -> str:
+    """FastAPI ``Depends``-compatible helper that returns the current request ID.
+
+    Use this in route handlers to inject the request ID via dependency injection::
+
+        from nene2.middleware import get_request_id
+
+
+        @app.get("/")
+        async def handler(request_id: str = Depends(get_request_id)) -> JSONResponse:
+            return JSONResponse({"request_id": request_id})
+
+    Returns an empty string when called outside of a request context
+    (e.g., in tests without :class:`RequestIdMiddleware`).
+    """
+    return request_id_var.get()
+
+
 class RequestIdMiddleware(BaseHTTPMiddleware):
     """Generate or forward X-Request-Id and expose it via contextvars.
 

{nene2_python-1.8.0 → nene2_python-1.8.1}/src/nene2/middleware/throttle.py

@@ -42,14 +42,19 @@ class ThrottleMiddleware(BaseHTTPMiddleware):
     ``X-RateLimit-Reset`` headers to every response so clients can monitor
     their quota.  On 429, also adds ``Retry-After``.
 
-    Use ``exclude_paths`` to bypass rate limiting for health checks and API docs::
+    Use ``path_limits`` to apply stricter limits on specific paths::
 
         app.add_middleware(
             ThrottleMiddleware,
-            limit=60,
+            limit=100,
             window=60,
+            path_limits={"/api/expensive": 10, "/api/search": 30},
             exclude_paths=["/health", "/docs", "/openapi.json"],
         )
+
+    Path-limited endpoints are tracked independently from the global counter
+    (the key includes the path, so ``/api/expensive`` quota is separate from
+    the default quota for other paths).
     """
 
     def __init__(
@@ -58,14 +63,17 @@ class ThrottleMiddleware(BaseHTTPMiddleware):
         *,
         limit: int = _DEFAULT_LIMIT,
         window: int = _DEFAULT_WINDOW,
+        path_limits: dict[str, int] | None = None,
         exclude_paths: list[str] | None = None,
     ) -> None:
         super().__init__(app)  # type: ignore[arg-type]
         self._limit = limit
         self._window = window
+        self._path_limits: dict[str, int] = path_limits or {}
         self._exclude_paths = set(exclude_paths or [])
         self._counts: dict[str, tuple[int, float]] = {}
         self._lock = threading.Lock()
+        self._last_cleanup: float = 0.0
 
     def _client_key(self, request: Request) -> str:
         forwarded = request.headers.get("X-Forwarded-For")
@@ -73,10 +81,20 @@ class ThrottleMiddleware(BaseHTTPMiddleware):
             return forwarded.split(",")[0].strip()
         return request.client.host if request.client else "unknown"
 
-    def _check_rate(self, key: str) -> _RateInfo:
+    def _evict_stale(self, now: float) -> None:
+        if now - self._last_cleanup < self._window:
+            return
+        self._last_cleanup = now
+        cutoff = now - self._window
+        stale = [k for k, (_, ws) in self._counts.items() if ws < cutoff]
+        for k in stale:
+            del self._counts[k]
+
+    def _check_rate(self, key: str, limit: int) -> _RateInfo:
         now = time.monotonic()
         wall_now = int(time.time())
         with self._lock:
+            self._evict_stale(now)
             count, window_start = self._counts.get(key, (0, now))
             if now - window_start >= self._window:
                 count, window_start = 0, now
@@ -85,24 +103,31 @@ class ThrottleMiddleware(BaseHTTPMiddleware):
             elapsed = int(now - window_start)
             retry_after = max(0, self._window - elapsed)
             reset_at = wall_now + retry_after
-            remaining = max(0, self._limit - count)
+            remaining = max(0, limit - count)
         return _RateInfo(
-            allowed=count <= self._limit,
+            allowed=count <= limit,
             remaining=remaining,
             retry_after=retry_after,
             reset_at=reset_at,
         )
 
-    def _apply_rate_headers(self, response: Response, info: _RateInfo) -> None:
-        response.headers["X-RateLimit-Limit"] = str(self._limit)
+    def _apply_rate_headers(self, response: Response, info: _RateInfo, limit: int) -> None:
+        response.headers["X-RateLimit-Limit"] = str(limit)
         response.headers["X-RateLimit-Remaining"] = str(info.remaining)
         response.headers["X-RateLimit-Reset"] = str(info.reset_at)
 
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
-        if request.url.path in self._exclude_paths:
+        path = request.url.path
+        if path in self._exclude_paths:
             return await call_next(request)
-        key = self._client_key(request)
-        info = self._check_rate(key)
+        client = self._client_key(request)
+        if path in self._path_limits:
+            effective_limit = self._path_limits[path]
+            key = f"{client}:{path}"
+        else:
+            effective_limit = self._limit
+            key = client
+        info = self._check_rate(key, effective_limit)
         if not info.allowed:
             error_response = problem_details_response(
                 "too-many-requests",
@@ -111,8 +136,8 @@ class ThrottleMiddleware(BaseHTTPMiddleware):
                 f"Rate limit exceeded. Retry after {info.retry_after} seconds.",
             )
             error_response.headers["Retry-After"] = str(info.retry_after)
-            self._apply_rate_headers(error_response, info)
+            self._apply_rate_headers(error_response, info, effective_limit)
             return error_response
         response = await call_next(request)
-        self._apply_rate_headers(response, info)
+        self._apply_rate_headers(response, info, effective_limit)
         return response

nene2_python-1.8.1/tests/nene2/config/test_settings.py

@@ -0,0 +1,54 @@
+"""Tests for AppSettings."""
+
+import pytest
+from pydantic import ValidationError
+
+from nene2.config import AppSettings
+
+
+def test_default_log_level_is_info() -> None:
+    settings = AppSettings()
+    assert settings.log_level == "INFO"
+
+
+def test_log_level_is_normalized_to_uppercase() -> None:
+    settings = AppSettings(log_level="debug")
+    assert settings.log_level == "DEBUG"
+
+
+def test_log_level_accepts_all_standard_levels() -> None:
+    for level in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"):
+        settings = AppSettings(log_level=level)
+        assert settings.log_level == level
+
+
+def test_invalid_log_level_raises_validation_error() -> None:
+    with pytest.raises(ValidationError):
+        AppSettings(log_level="TRACE")
+
+
+def test_default_app_env_is_local() -> None:
+    settings = AppSettings()
+    assert settings.app_env == "local"
+
+
+def test_invalid_app_env_raises_validation_error() -> None:
+    with pytest.raises(ValidationError):
+        AppSettings(app_env="staging")
+
+
+def test_db_url_sqlite_by_default() -> None:
+    settings = AppSettings()
+    assert settings.db_url.startswith("sqlite:///")
+
+
+def test_db_url_mysql_format() -> None:
+    settings = AppSettings(
+        db_adapter="mysql",
+        db_user="root",
+        db_name="mydb",
+        db_host="localhost",
+        db_port=3306,
+    )
+    assert "mysql+pymysql://" in settings.db_url
+    assert "mydb" in settings.db_url