第 2 周 练习骨架（只读展示）¶

"""Week 2 · M7 · w2_03_typing.py 的测试

用法：uv run pytest exercises/week2/test_w2_03_typing.py -q
注意：这里**只测运行时行为**。类型注解写得对不对，pytest 是看不出来的，
      所以本练习另有两条硬要求：
      1) VS Code 里 Pylance（`python.analysis.typeCheckingMode = "standard"`）零报错；
      2) `uvx ty check exercises/week2/w2_03_typing.py` 零错误。
      两条都做到，才算这个文件过关。
"""

import pytest
from w2_03_typing import (
    LAST_DURATIONS,
    MAX_STACK,
    ListRepository,
    Repository,
    Stack,
    describe_user,
    is_json,
    make_user,
    open_mode,
    pairwise,
    parse,
    timed,
)


def test_max_stack_is_a_constant() -> None:
    """Final 常量只是给类型检查器的约定，运行时就是个普通 int。"""
    assert MAX_STACK == 100


@pytest.mark.parametrize(
    "value",
    [None, True, 0, 1.5, "s", [], {}, [1, "a", None], {"a": {"b": [1, 2]}}],
)
def test_is_json_true(value: object) -> None:
    """能被 json.dumps 直接序列化的值都是 Json。"""
    assert is_json(value) is True


@pytest.mark.parametrize(
    "value",
    [{"a", "b"}, b"bytes", object(), {1: "a"}, [1, {2: 3}], {"a": object()}],
)
def test_is_json_false(value: object) -> None:
    """set/bytes/对象、以及非 str 键的 dict 都不是 Json。"""
    assert is_json(value) is False


def test_stack_push_pop_peek() -> None:
    """push 返回 self，所以能链式调用；pop 后长度减一。"""
    s: Stack[int] = Stack()
    assert s.is_empty() is True
    assert s.push(1).push(2) is s
    assert len(s) == 2
    assert s.peek() == 2
    assert len(s) == 2
    assert s.pop() == 2
    assert s.pop() == 1
    assert s.is_empty() is True


def test_stack_pop_empty_raises() -> None:
    """空栈弹出应抛 IndexError。"""
    s: Stack[str] = Stack()
    with pytest.raises(IndexError):
        s.pop()
    with pytest.raises(IndexError):
        s.peek()


@pytest.mark.parametrize(
    ("xs", "expected"),
    [
        ([1, 2, 3], [(1, 2), (2, 3)]),
        (["a"], []),
        ([], []),
        ((1, 2), [(1, 2)]),
    ],
)
def test_pairwise(xs: object, expected: object) -> None:
    """相邻配对；元组也是 Sequence，所以也能传。"""
    assert pairwise(xs) == expected  # type: ignore[arg-type]


def test_timed_keeps_metadata_and_result() -> None:
    """functools.wraps 保留名字和 docstring，返回值原样返回。"""

    @timed
    def add(a: int, b: int = 0) -> int:
        """加法。"""
        return a + b

    assert add.__name__ == "add"
    assert add.__doc__ == "加法。"
    assert add(1, 2) == 3
    assert add(1, b=5) == 6
    assert LAST_DURATIONS["add"] >= 0


def test_timed_lets_exceptions_through() -> None:
    """装饰器不能吞异常。"""

    @timed
    def boom() -> None:
        raise ValueError("炸了")

    with pytest.raises(ValueError, match="炸了"):
        boom()


def test_make_user_required_and_optional() -> None:
    """name 去空白；email 没传就不出现在字典里。"""
    assert make_user(name=" 小明 ", age=15) == {"name": "小明", "age": 15}
    user = make_user(name="a", age=1, email="a@b.com")
    assert user["email"] == "a@b.com"
    assert "email" not in make_user(name="a", age=1)


def test_make_user_rejects_negative_age() -> None:
    """age 为负要抛 ValueError。"""
    with pytest.raises(ValueError, match="age"):
        make_user(name="a", age=-1)


def test_describe_user() -> None:
    """NotRequired 的键要用 .get 取。"""
    assert describe_user({"name": "小明", "age": 15}) == "小明（15 岁）"
    assert (
        describe_user({"name": "a", "age": 1, "email": "x@y.z"}) == "a（1 岁，x@y.z）"
    )


def test_open_mode() -> None:
    """Literal 的两个合法值。"""
    assert open_mode("r") == "只读"
    assert open_mode("w") == "只写"


def test_open_mode_rejects_others() -> None:
    """运行时来的脏数据仍要拦（类型检查器管不到）。"""
    with pytest.raises(ValueError, match="不支持的模式"):
        open_mode("rb")  # type: ignore[arg-type]


def test_parse_overloads() -> None:
    """str -> int，bytes -> str。"""
    assert parse("42") == 42
    assert parse(b"hi") == "hi"


def test_parse_rejects_other_types() -> None:
    """别的类型抛 TypeError。"""
    with pytest.raises(TypeError):
        parse(1.5)  # type: ignore[call-overload]


def test_parse_bad_str_raises_value_error() -> None:
    """int("abc") 自然会抛 ValueError，不用自己转成别的异常。"""
    with pytest.raises(ValueError):
        parse("abc")


def test_list_repository_satisfies_protocol() -> None:
    """结构化子类型：没有继承 Repository，也是 Repository。"""
    repo: Repository[int] = ListRepository[int]()
    repo.add(1)
    repo.add(2)
    assert repo.list_all() == [1, 2]
    assert repo.get(0) == 1
    assert repo.get(9) is None
    assert isinstance(repo, Repository)


def test_list_all_returns_a_copy() -> None:
    """返回副本，外部改动不影响内部。"""
    repo = ListRepository[str]()
    repo.add("a")
    got = repo.list_all()
    got.append("b")
    assert repo.list_all() == ["a"]


def test_plain_object_is_not_a_repository() -> None:
    """@runtime_checkable 的 isinstance 只看方法名在不在。"""
    assert not isinstance(object(), Repository)

"""Week 2 · M8a · w2_04_pydantic_models.py 的测试

用法：uv run pytest exercises/week2/test_w2_04_pydantic_models.py -q
读法：每个测试名就是一条需求。先读测试，再去实现。
"""

from datetime import UTC, datetime, timedelta
from decimal import Decimal

import pytest
from pydantic import ValidationError
from w2_04_pydantic_models import (
    Address,
    Meeting,
    Money,
    Note,
    Profile,
    format_errors,
    parse_notes,
    promote,
)


def test_note_minimal() -> None:
    """只给 title 就能建出来：其他字段都有默认值。"""
    note = Note(title="标题")
    assert note.title == "标题"
    assert note.body == ""
    assert note.tags == []
    assert note.priority == "normal"


def test_note_created_at_is_aware_utc() -> None:
    """created_at 默认是"现在"，而且必须带时区（存库一律 UTC）。"""
    note = Note(title="t")
    assert note.created_at.tzinfo is not None
    assert abs((datetime.now(UTC) - note.created_at).total_seconds()) < 5


def test_note_strips_whitespace() -> None:
    """str_strip_whitespace=True：所有 str 字段自动去首尾空白。"""
    assert Note(title="  标题  ").title == "标题"


def test_note_title_too_short() -> None:
    """去空白后为空 -> min_length=1 失败。"""
    with pytest.raises(ValidationError) as exc_info:
        Note(title="   ")
    assert exc_info.value.errors()[0]["type"] == "string_too_short"


def test_note_title_too_long() -> None:
    """超过 100 字要报错。"""
    with pytest.raises(ValidationError):
        Note(title="字" * 101)


def test_note_tags_lowercase_and_dedup() -> None:
    """标签小写、去空白、按出现顺序去重。"""
    note = Note(title="t", tags=["Python", "python", " AI ", "ai", ""])
    assert note.tags == ["python", "ai"]


def test_note_too_many_tags() -> None:
    """标签最多 5 个（这个检查在去重之前）。"""
    with pytest.raises(ValidationError) as exc_info:
        Note(title="t", tags=["a", "b", "c", "d", "e", "f"])
    assert exc_info.value.errors()[0]["type"] == "too_long"


def test_note_lax_mode_coerces_int_like_str() -> None:
    """默认宽松模式：priority 是 Literal，写错的值要被拒绝。"""
    with pytest.raises(ValidationError):
        Note(title="t", priority="urgent")  # type: ignore[arg-type]


def test_note_forbids_extra_fields() -> None:
    """extra="forbid"：拼错的键名当场报错，而不是被悄悄忽略。"""
    with pytest.raises(ValidationError) as exc_info:
        Note(title="t", titel="打错了")  # type: ignore[call-arg]
    assert exc_info.value.errors()[0]["type"] == "extra_forbidden"


def test_mutable_default_is_not_shared() -> None:
    """陷阱题：Pydantic 会深拷贝默认值，所以两个实例不共享同一个列表。

    （和 dataclass 相反——dataclass 里 `tags: list = []` 直接是语法错误。）
    """
    a = Note(title="a")
    b = Note(title="b")
    a.tags.append("x")
    assert b.tags == []


def test_address_ok() -> None:
    """6 位邮编通过。"""
    addr = Address(city="北京", street="中关村 1 号", zipcode="100080")
    assert addr.zipcode == "100080"


@pytest.mark.parametrize("zipcode", ["1008", "1000800", "abcdef", ""])
def test_address_bad_zipcode(zipcode: str) -> None:
    """不是 6 位数字就报错。"""
    with pytest.raises(ValidationError):
        Address(city="北京", zipcode=zipcode)


def test_address_city_required_non_empty() -> None:
    """city 至少 1 个字。"""
    with pytest.raises(ValidationError):
        Address(city="", zipcode="100080")


def test_profile_nested_dict_becomes_model() -> None:
    """嵌套模型：传 dict 会被自动解析成 Address 实例。"""
    profile = Profile(
        name="小明", age=15, address={"city": "北京", "zipcode": "100080"}
    )
    assert isinstance(profile.address, Address)
    assert profile.address.city == "北京"
    assert profile.nickname is None


@pytest.mark.parametrize("age", [-1, 151])
def test_profile_age_out_of_range(age: int) -> None:
    """age 必须在 0–150。"""
    with pytest.raises(ValidationError):
        Profile(name="小明", age=age, address={"city": "北京", "zipcode": "100080"})


def test_meeting_ok() -> None:
    """start < end 正常。"""
    start = datetime(2026, 9, 14, 9, 0, tzinfo=UTC)
    meeting = Meeting(title="周会", start=start, end=start + timedelta(hours=1))
    assert meeting.end > meeting.start


def test_meeting_bad_order() -> None:
    """start >= end 时 model_validator 要拦住。"""
    start = datetime(2026, 9, 14, 9, 0, tzinfo=UTC)
    with pytest.raises(ValidationError) as exc_info:
        Meeting(title="周会", start=start, end=start)
    assert "start 必须早于 end" in str(exc_info.value)


def test_meeting_parses_iso_string() -> None:
    """datetime 字段接受 ISO 8601 字符串（这是 Pydantic 的解析能力）。"""
    meeting = Meeting(
        title="周会",
        start="2026-09-14T09:00:00+00:00",  # type: ignore[arg-type]
        end="2026-09-14T10:00:00+00:00",  # type: ignore[arg-type]
    )
    assert meeting.start.hour == 9


def test_money_ok() -> None:
    """严格模式下 Decimal 只接受 Decimal。"""
    money = Money(amount=Decimal("1.5"), currency="CNY")
    assert money.amount == Decimal("1.5")


def test_money_strict_rejects_str_amount() -> None:
    """strict=True：字符串 "1.5" 不再被悄悄转成 Decimal。"""
    with pytest.raises(ValidationError):
        Money(amount="1.5", currency="CNY")  # type: ignore[arg-type]


def test_money_rejects_bad_currency() -> None:
    """currency 必须是 3 位大写字母。"""
    with pytest.raises(ValidationError):
        Money(amount=Decimal("1"), currency="cny")


def test_money_rejects_non_positive_amount() -> None:
    """amount 必须大于 0。"""
    with pytest.raises(ValidationError):
        Money(amount=Decimal("0"), currency="CNY")


def test_format_errors() -> None:
    """errors() 的 loc 用 "." 连起来，前面带上第几条。"""
    with pytest.raises(ValidationError) as exc_info:
        Note(title="")
    messages = format_errors(exc_info.value, 0)
    assert len(messages) == 1
    assert messages[0].startswith("第 0 条 title: ")


def test_format_errors_nested_loc() -> None:
    """嵌套字段的 loc 是多段，比如 address.zipcode。"""
    with pytest.raises(ValidationError) as exc_info:
        Profile(name="小明", age=1, address={"city": "北京", "zipcode": "x"})
    messages = format_errors(exc_info.value, 3)
    assert any("address.zipcode" in m for m in messages)
    assert all(m.startswith("第 3 条 ") for m in messages)


def test_parse_notes_partial_success() -> None:
    """一条坏数据不能拖垮整批。"""
    notes, errors = parse_notes(
        [
            {"title": "好的"},
            {"title": ""},
            {"title": "也好的", "tags": ["A"]},
            {"title": "多字段", "oops": 1},
        ]
    )
    assert [n.title for n in notes] == ["好的", "也好的"]
    assert len(errors) == 2
    assert errors[0].startswith("第 1 条 ")
    assert errors[1].startswith("第 3 条 ")


def test_parse_notes_empty() -> None:
    """空输入返回两个空列表。"""
    assert parse_notes([]) == ([], [])


def test_promote_returns_copy() -> None:
    """model_copy(update=) 返回副本，原对象不变。"""
    note = Note(title="t")
    high = promote(note)
    assert high.priority == "high"
    assert note.priority == "normal"
    assert high is not note
    assert high.title == note.title

"""Week 2 · M8b · w2_05_pydantic_schema_settings.py 的测试

用法：uv run pytest exercises/week2/test_w2_05_pydantic_schema_settings.py -q
要点：Settings 的测试用 monkeypatch.setenv 造环境变量、monkeypatch.chdir 换工作目录，
      这样就不会依赖你机器上真实存在的 .env——测试必须可重复。
"""

from datetime import UTC, datetime
from decimal import Decimal
from pathlib import Path
from typing import Any

import pytest
from pydantic import ValidationError
from w2_05_pydantic_schema_settings import (
    ApiNote,
    Article,
    Click,
    Doc,
    KeyPress,
    Settings,
    describe_settings,
    dump_for_api,
    parse_event,
    parse_events,
    schema_summary,
    time_validation,
    validate_docs,
    validate_docs_one_by_one,
)

DOCS: list[dict[str, Any]] = [
    {"id": 1, "title": "a", "created_at": "2026-09-14T00:00:00Z"},
    {"id": 2, "title": "b", "created_at": "2026-09-15T00:00:00Z"},
]


def test_parse_event_click() -> None:
    """kind="click" 解析成 Click。"""
    event = parse_event({"kind": "click", "x": 1, "y": 2})
    assert isinstance(event, Click)
    assert (event.x, event.y) == (1, 2)


def test_parse_event_key() -> None:
    """kind="key" 解析成 KeyPress。"""
    event = parse_event({"kind": "key", "key": "a"})
    assert isinstance(event, KeyPress)
    assert event.key == "a"


def test_parse_event_unknown_kind() -> None:
    """判别字段不认识时，报错会直接指向 kind。"""
    with pytest.raises(ValidationError) as exc_info:
        parse_event({"kind": "scroll"})
    assert exc_info.value.errors()[0]["type"] == "union_tag_invalid"


def test_parse_event_missing_kind() -> None:
    """kind 缺失也要报错（这就是判别联合比"两个都试一遍"好的地方）。"""
    with pytest.raises(ValidationError):
        parse_event({"x": 1, "y": 2})


def test_parse_events_mixed() -> None:
    """一批混合事件。"""
    events = parse_events(
        [{"kind": "click", "x": 0, "y": 0}, {"kind": "key", "key": "b"}]
    )
    assert [type(e).__name__ for e in events] == ["Click", "KeyPress"]


def test_dump_for_api_json_mode() -> None:
    """mode="json"：datetime -> ISO 字符串，Decimal -> 字符串。"""
    note = ApiNote(
        title="t", createdAt=datetime(2026, 9, 14, tzinfo=UTC), price=Decimal("1.5")
    )
    dumped = dump_for_api(note)
    assert dumped["createdAt"] == "2026-09-14T00:00:00Z"
    assert dumped["price"] == "1.5"


def test_dump_for_api_excludes_none_and_uses_alias() -> None:
    """exclude_none=True 丢掉 None 字段；by_alias=True 用驼峰键名。"""
    note = ApiNote(
        title="t", created_at=datetime(2026, 9, 14, tzinfo=UTC), price=Decimal("2")
    )
    dumped = dump_for_api(note)
    assert "note_id" not in dumped
    assert "created_at" not in dumped
    assert dumped["summary"] == "t（2 元）"


def test_dump_for_api_result_is_json_serializable() -> None:
    """mode="json" 的意义就是结果能直接喂给 json.dumps。"""
    import json

    note = ApiNote(
        title="t", createdAt=datetime(2026, 9, 14, tzinfo=UTC), price=Decimal("1")
    )
    assert json.dumps(dump_for_api(note), ensure_ascii=False).startswith("{")


def test_schema_summary_required() -> None:
    """只有没有默认值的字段是必填。"""
    assert schema_summary(Article)["required"] == ["title"]


def test_schema_summary_simple_field() -> None:
    """description 和 default 都来自 Field(...)。"""
    fields = schema_summary(Article)["fields"]
    assert fields["title"] == {
        "type": "string",
        "description": "文章标题",
        "default": None,
    }
    assert fields["views"]["type"] == "integer"
    assert fields["views"]["default"] == 0


def test_schema_summary_optional_field_uses_any_of() -> None:
    """str | None 在 JSON Schema 里是 anyOf。"""
    fields = schema_summary(Article)["fields"]
    assert fields["author"]["type"] == "string|null"
    assert fields["author"]["description"] == "作者，可省略"


def test_schema_summary_list_field() -> None:
    """default_factory 的字段在 schema 里没有 default，所以取到 None。"""
    fields = schema_summary(Article)["fields"]
    assert fields["tags"]["type"] == "array"
    assert fields["tags"]["default"] is None


def test_schema_summary_covers_all_fields() -> None:
    """摘要要把每个字段都列出来。"""
    assert set(schema_summary(Article)["fields"]) == {
        "title",
        "views",
        "author",
        "tags",
    }


def test_settings_defaults(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
    """没有环境变量、没有 .env 时用默认值。"""
    monkeypatch.chdir(tmp_path)
    monkeypatch.delenv("KB_DB_PATH", raising=False)
    monkeypatch.delenv("KB_LOG_LEVEL", raising=False)
    settings = Settings()
    assert settings.db_path == Path("kb.db")
    assert settings.log_level == "INFO"


def test_settings_from_env(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
    """env_prefix="KB_"：db_path 读的是 KB_DB_PATH，并自动转成 Path。"""
    monkeypatch.chdir(tmp_path)
    monkeypatch.setenv("KB_DB_PATH", "data/kb.sqlite3")
    monkeypatch.setenv("KB_LOG_LEVEL", "DEBUG")
    settings = Settings()
    assert settings.db_path == Path("data/kb.sqlite3")
    assert settings.log_level == "DEBUG"


def test_settings_env_is_case_insensitive(
    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
    """环境变量名大小写不敏感。"""
    monkeypatch.chdir(tmp_path)
    monkeypatch.setenv("kb_log_level", "ERROR")
    assert Settings().log_level == "ERROR"


def test_settings_reads_dotenv(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
    """.env 也能读到（真实项目里 .env 不进 Git，仓库只放 .env.example）。"""
    (tmp_path / ".env").write_text("KB_LOG_LEVEL=WARNING\n", encoding="utf-8")
    monkeypatch.chdir(tmp_path)
    monkeypatch.delenv("KB_LOG_LEVEL", raising=False)
    assert Settings().log_level == "WARNING"


def test_settings_env_beats_dotenv(
    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
    """优先级：环境变量 > .env > 默认值。"""
    (tmp_path / ".env").write_text("KB_LOG_LEVEL=WARNING\n", encoding="utf-8")
    monkeypatch.chdir(tmp_path)
    monkeypatch.setenv("KB_LOG_LEVEL", "DEBUG")
    assert Settings().log_level == "DEBUG"


def test_settings_rejects_bad_level(
    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
    """Literal 会拦住写错的级别（比如小写的 info）。"""
    monkeypatch.chdir(tmp_path)
    monkeypatch.setenv("KB_LOG_LEVEL", "info")
    with pytest.raises(ValidationError):
        Settings()


def test_describe_settings(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
    """一句话描述配置。"""
    monkeypatch.chdir(tmp_path)
    monkeypatch.delenv("KB_DB_PATH", raising=False)
    monkeypatch.delenv("KB_LOG_LEVEL", raising=False)
    assert describe_settings(Settings()) == "db=kb.db level=INFO"


def test_validate_docs() -> None:
    """TypeAdapter 不用建模型也能校验 list[Doc]。"""
    docs = validate_docs(DOCS)
    assert [d.id for d in docs] == [1, 2]
    assert all(isinstance(d, Doc) for d in docs)
    assert docs[0].created_at == datetime(2026, 9, 14, tzinfo=UTC)


def test_validate_docs_same_as_loop() -> None:
    """两种方式结果必须一致（Pydantic 模型之间可以直接 == 比较）。"""
    assert validate_docs(DOCS) == validate_docs_one_by_one(DOCS)


def test_validate_docs_error_loc_has_index() -> None:
    """整批校验时，错误的 loc 第一段是出错的下标。"""
    bad = [DOCS[0], {"id": "x", "title": "b", "created_at": "2026-09-15T00:00:00Z"}]
    with pytest.raises(ValidationError) as exc_info:
        validate_docs(bad)
    assert exc_info.value.errors()[0]["loc"][0] == 1


def test_time_validation_returns_two_durations() -> None:
    """返回两个非负的秒数。"""
    adapter_seconds, loop_seconds = time_validation(DOCS * 10, repeat=2)
    assert adapter_seconds >= 0
    assert loop_seconds >= 0


def test_time_validation_rejects_bad_repeat() -> None:
    """repeat 必须为正。"""
    with pytest.raises(ValueError, match="repeat"):
        time_validation(DOCS, repeat=0)

"""Week 2 · M9 · w2_06_logging_config.py 的测试

用法：uv run pytest exercises/week2/test_w2_06_logging_config.py -q
要点：
- caplog 抓日志（它自己往根 logger 挂了 handler，所以 setup_logging 不能乱清 handler）
- tmp_path 给临时目录写日志文件与 TOML
- 每个测试跑完都把根 logger 恢复原样，否则测试之间会互相污染
"""

import json
import logging
import tomllib
from collections.abc import Iterator
from pathlib import Path

import pytest
from pydantic import ValidationError
from w2_06_logging_config import (
    AppConfig,
    JsonFormatter,
    divide,
    load_config,
    managed_handlers,
    resolve_setting,
    setup_logging,
)


@pytest.fixture(autouse=True)
def _isolate_root_logger() -> Iterator[None]:
    """每个测试前后把根 logger 的 handler 和级别恢复原样。"""
    root = logging.getLogger()
    old_handlers = root.handlers[:]
    old_level = root.level
    yield
    for handler in root.handlers[:]:
        if handler not in old_handlers:
            root.removeHandler(handler)
            handler.close()
    root.handlers[:] = old_handlers
    root.setLevel(old_level)


def _make_record(
    message: str = "a=%s", args: tuple[object, ...] = (1,)
) -> logging.LogRecord:
    """手工造一条 LogRecord，用来单测 Formatter。"""
    return logging.LogRecord(
        name="demo",
        level=logging.INFO,
        pathname=__file__,
        lineno=1,
        msg=message,
        args=args,
        exc_info=None,
    )


def test_json_formatter_keys() -> None:
    """四个固定的键，且 message 是套过参数的结果。"""
    line = JsonFormatter().format(_make_record())
    data = json.loads(line)
    assert set(data) == {"time", "level", "logger", "message"}
    assert data["level"] == "INFO"
    assert data["logger"] == "demo"
    assert data["message"] == "a=1"


def test_json_formatter_keeps_chinese() -> None:
    """ensure_ascii=False：中文不能变成 \\uXXXX。"""
    line = JsonFormatter().format(_make_record("你好 %s", ("小明",)))
    assert "你好 小明" in line
    assert json.loads(line)["message"] == "你好 小明"


def test_json_formatter_with_exception() -> None:
    """有异常信息时多一个 exc_info 键，里面带堆栈。"""
    try:
        raise ValueError("炸了")
    except ValueError:
        import sys

        record = _make_record("出错了", ())
        record.exc_info = sys.exc_info()
    data = json.loads(JsonFormatter().format(record))
    assert "exc_info" in data
    assert "ValueError" in data["exc_info"]
    assert "Traceback" in data["exc_info"]


def test_setup_logging_returns_root_and_sets_level() -> None:
    """返回根 logger，级别按参数设置（大小写不敏感）。"""
    root = setup_logging("debug")
    assert root is logging.getLogger()
    assert root.level == logging.DEBUG


def test_setup_logging_rejects_unknown_level() -> None:
    """不认识的级别要报错，而不是悄悄用 INFO。"""
    with pytest.raises(ValueError, match="未知日志级别"):
        setup_logging("VERBOSE")


def test_setup_logging_adds_one_console_handler() -> None:
    """不给 log_file 时只加一个控制台 handler。"""
    setup_logging("INFO")
    assert len(managed_handlers()) == 1


def test_setup_logging_is_idempotent(tmp_path: Path) -> None:
    """重复调用不重复加 handler——否则一条日志会打两遍。"""
    log_file = tmp_path / "logs" / "app.log"
    setup_logging("INFO", log_file)
    first = len(managed_handlers())
    setup_logging("INFO", log_file)
    setup_logging("DEBUG", log_file)
    assert first == 2
    assert len(managed_handlers()) == 2


def test_setup_logging_keeps_other_handlers(caplog: pytest.LogCaptureFixture) -> None:
    """只摘自己加的 handler：caplog 的 handler 必须活着。"""
    with caplog.at_level(logging.INFO):
        setup_logging("INFO")
        logging.getLogger("demo").info("还能抓到吗")
    assert "还能抓到吗" in caplog.text


def test_setup_logging_creates_parent_dir(tmp_path: Path) -> None:
    """父目录不存在也要能写。"""
    log_file = tmp_path / "deep" / "nested" / "app.log"
    setup_logging("INFO", log_file)
    logging.getLogger("demo").info("hi")
    assert log_file.exists()


def test_setup_logging_json_file(tmp_path: Path) -> None:
    """json=True 时文件里每行都是一条 JSON。"""
    log_file = tmp_path / "app.log"
    setup_logging("INFO", log_file, json=True)
    logging.getLogger("demo").warning("磁盘快满了 %d%%", 91)
    for handler in managed_handlers():
        handler.flush()
    lines = log_file.read_text(encoding="utf-8").splitlines()
    data = json.loads(lines[-1])
    assert data["level"] == "WARNING"
    assert data["message"] == "磁盘快满了 91%"


def test_setup_logging_plain_file(tmp_path: Path) -> None:
    """json=False 时是普通文本格式，至少能看到级别和消息。"""
    log_file = tmp_path / "app.log"
    setup_logging("INFO", log_file, json=False)
    logging.getLogger("demo").error("坏了")
    for handler in managed_handlers():
        handler.flush()
    text = log_file.read_text(encoding="utf-8")
    assert "ERROR" in text
    assert "坏了" in text


def test_divide_logs_info(caplog: pytest.LogCaptureFixture) -> None:
    """成功时打一条 INFO，参数用 %s 传（record.args 里能看到）。"""
    with caplog.at_level(logging.INFO, logger="w2_06_logging_config"):
        assert divide(6, 3) == 2.0
    assert len(caplog.records) == 1
    record = caplog.records[0]
    assert record.levelno == logging.INFO
    assert record.args == (6, 3, 2.0)
    assert "divide 6 / 3 = 2.0" in caplog.text


def test_divide_by_zero_logs_exception(caplog: pytest.LogCaptureFixture) -> None:
    """除零时返回 None，并且日志里带堆栈（logger.exception 而不是 error）。"""
    with caplog.at_level(logging.INFO, logger="w2_06_logging_config"):
        assert divide(1, 0) is None
    record = caplog.records[0]
    assert record.levelno == logging.ERROR
    assert record.exc_info is not None
    assert "ZeroDivisionError" in caplog.text
    assert "Traceback" in caplog.text


def test_load_config_defaults(tmp_path: Path) -> None:
    """只给 name，其余用默认值。"""
    path = tmp_path / "config.toml"
    path.write_text('name = "kb"\n', encoding="utf-8")
    config = load_config(path)
    assert config == AppConfig(name="kb")
    assert config.max_items == 100


def test_load_config_full(tmp_path: Path) -> None:
    """TOML 里的类型会被原样读出来（数字就是 int，不是字符串）。"""
    path = tmp_path / "config.toml"
    path.write_text('name = "kb"\nlevel = "DEBUG"\nmax_items = 5\n', encoding="utf-8")
    config = load_config(path)
    assert (config.level, config.max_items) == ("DEBUG", 5)


def test_load_config_missing_file(tmp_path: Path) -> None:
    """文件不存在就让 FileNotFoundError 抛出去。"""
    with pytest.raises(FileNotFoundError):
        load_config(tmp_path / "nope.toml")


def test_load_config_bad_toml(tmp_path: Path) -> None:
    """TOML 语法错误由 tomllib 报。"""
    path = tmp_path / "config.toml"
    path.write_text("name = \n", encoding="utf-8")
    with pytest.raises(tomllib.TOMLDecodeError):
        load_config(path)


def test_load_config_invalid_value(tmp_path: Path) -> None:
    """字段不合法由 Pydantic 报。"""
    path = tmp_path / "config.toml"
    path.write_text('name = "kb"\nmax_items = 0\n', encoding="utf-8")
    with pytest.raises(ValidationError):
        load_config(path)


def test_load_config_unknown_key(tmp_path: Path) -> None:
    """extra="forbid"：配置文件里写错的键名要报错。"""
    path = tmp_path / "config.toml"
    path.write_text('name = "kb"\nlevle = "DEBUG"\n', encoding="utf-8")
    with pytest.raises(ValidationError):
        load_config(path)


def test_resolve_setting_cli_wins(monkeypatch: pytest.MonkeyPatch) -> None:
    """命令行参数优先级最高。"""
    monkeypatch.setenv("KB_LOG_LEVEL", "WARNING")
    assert resolve_setting("DEBUG", "KB_LOG_LEVEL", "INFO") == "DEBUG"


def test_resolve_setting_env_then_default(monkeypatch: pytest.MonkeyPatch) -> None:
    """没有命令行参数时看环境变量，再没有就用默认值。"""
    monkeypatch.setenv("KB_LOG_LEVEL", "WARNING")
    assert resolve_setting(None, "KB_LOG_LEVEL", "INFO") == "WARNING"
    monkeypatch.delenv("KB_LOG_LEVEL")
    assert resolve_setting(None, "KB_LOG_LEVEL", "INFO") == "INFO"


def test_resolve_setting_empty_env_is_unset(monkeypatch: pytest.MonkeyPatch) -> None:
    """环境变量是空串等于没设。"""
    monkeypatch.setenv("KB_LOG_LEVEL", "")
    assert resolve_setting(None, "KB_LOG_LEVEL", "INFO") == "INFO"


def test_resolve_setting_empty_cli_counts(monkeypatch: pytest.MonkeyPatch) -> None:
    """命令行显式给空串，就用空串（None 才表示"没给"）。"""
    monkeypatch.setenv("KB_LOG_LEVEL", "WARNING")
    assert resolve_setting("", "KB_LOG_LEVEL", "INFO") == ""