llm-tool-cli 0.2.0__py3-none-any.whl

llm_tool_cli/core/tests/test_context.py

@@ -0,0 +1,152 @@
+from contextvars import Context
+
+import pytest
+
+from llm_tool_cli.core.context import ContextValue
+from llm_tool_cli.core.errors import ContextValueAlreadySet, ContextValueNotSet
+
+
+class TestContextValue:
+    def test_get__missing_value_identifies_binding(self) -> None:
+        value = ContextValue[str]("workspace")
+
+        with pytest.raises(ContextValueNotSet) as caught:
+            value.get()
+
+        assert caught.value.details == {"name": "workspace"}
+        assert not value.is_set()
+
+    @pytest.mark.parametrize("initial", [None, False, 0, "", "  café 日本語  ", []])
+    def test_initialize__preserves_value_in_current_context(self, initial: object) -> None:
+        value = ContextValue[object]("setting")
+        execution = Context()
+
+        execution.run(value.initialize, initial)
+
+        assert execution.run(value.is_set)
+        assert execution.run(value.get) == initial
+        assert not value.is_set()
+
+    @pytest.mark.parametrize(
+        ("initial", "replacement"),
+        [("first", "second"), ("first", "first"), (None, None), (None, "second")],
+    )
+    def test_initialize__rejects_reassignment_and_preserves_value(
+        self, initial: str | None, replacement: str | None
+    ) -> None:
+        value = ContextValue[str | None]("setting")
+        execution = Context()
+        execution.run(value.initialize, initial)
+
+        with pytest.raises(ContextValueAlreadySet) as caught:
+            execution.run(value.initialize, replacement)
+
+        assert caught.value.details == {"name": "setting"}
+        assert execution.run(value.get) == initial
+
+    def test_initialize__rejects_assignment_during_scope(self) -> None:
+        value = ContextValue[str]("setting")
+
+        with value.scope("temporary"):
+            with pytest.raises(ContextValueAlreadySet):
+                value.initialize("replacement")
+
+            assert value.get() == "temporary"
+
+        execution = Context()
+        execution.run(value.initialize, "permanent")
+        assert execution.run(value.get) == "permanent"
+
+    def test_scope__binds_on_entry_and_restores_unset_state(self) -> None:
+        value = ContextValue[str]("setting")
+        scope = value.scope("temporary")
+        assert not value.is_set()
+
+        with scope:
+            assert value.is_set()
+            assert value.get() == "temporary"
+
+        assert not value.is_set()
+        with pytest.raises(ContextValueNotSet):
+            value.get()
+
+    def test_scope__restores_initialized_value(self) -> None:
+        value = ContextValue[str]("setting")
+        execution = Context()
+        execution.run(value.initialize, "initial")
+
+        def override() -> None:
+            with value.scope("temporary"):
+                assert value.get() == "temporary"
+
+            assert value.get() == "initial"
+
+        execution.run(override)
+        assert not value.is_set()
+
+    @pytest.mark.parametrize("outer", [None, "outer"])
+    def test_scope__nested_scopes_restore_previous_values(self, outer: str | None) -> None:
+        value = ContextValue[str | None]("operation")
+
+        with value.scope(outer):
+            with value.scope("middle"):
+                with value.scope(None):
+                    assert value.is_set()
+                    assert value.get() is None
+
+                assert value.get() == "middle"
+
+            assert value.is_set()
+            assert value.get() == outer
+
+        assert not value.is_set()
+
+    @pytest.mark.parametrize("error", [ValueError("failure"), SystemExit(1)])
+    def test_scope__restores_previous_value_after_exception(self, error: BaseException) -> None:
+        value = ContextValue[str]("setting")
+
+        with value.scope("outer"):
+            with pytest.raises(type(error)) as caught:
+                with value.scope("inner"):
+                    raise error
+
+            assert caught.value == error
+            assert value.get() == "outer"
+
+        assert not value.is_set()
+
+    def test_scope__restores_unset_state_after_exception(self) -> None:
+        value = ContextValue[str]("setting")
+
+        with pytest.raises(ValueError):
+            with value.scope("temporary"):
+                raise ValueError("failure")
+
+        assert not value.is_set()
+        with pytest.raises(ContextValueNotSet):
+            value.get()
+
+    def test_scope__same_name_does_not_share_bindings(self) -> None:
+        first = ContextValue[str]("setting")
+        second = ContextValue[str]("setting")
+
+        with first.scope("first"):
+            assert not second.is_set()
+            with second.scope("second"):
+                assert first.get() == "first"
+                assert second.get() == "second"
+
+            assert first.get() == "first"
+            assert not second.is_set()
+
+        assert not first.is_set()
+
+    def test_scope__preserves_object_mutations(self) -> None:
+        value = ContextValue[list[str]]("cache")
+        original: list[str] = []
+
+        with value.scope(original):
+            value.get().append("loaded")
+            assert original == ["loaded"]
+
+        assert original == ["loaded"]

llm_tool_cli/core/tests/test_entities.py

@@ -0,0 +1,65 @@
+import pydantic
+import pytest
+
+from llm_tool_cli.core.entities import BaseEntity
+
+
+class _NestedEntity(BaseEntity):
+    values: list[int]
+
+
+class _SampleEntity(BaseEntity):
+    name: str
+    nested: _NestedEntity
+
+
+class TestBaseEntity:
+    def test_model_config__strips_strings(self) -> None:
+        entity = _SampleEntity(name="  value  ", nested=_NestedEntity(values=[]))
+
+        assert entity.name == "value"
+
+    def test_model_config__forbids_extra_fields(self) -> None:
+        with pytest.raises(pydantic.ValidationError):
+            _SampleEntity.model_validate({"name": "value", "nested": {"values": []}, "extra": True})
+
+    def test_model_config__is_frozen(self) -> None:
+        entity = _SampleEntity(name="value", nested=_NestedEntity(values=[]))
+
+        with pytest.raises(pydantic.ValidationError):
+            setattr(entity, "name", "changed")
+
+    @pytest.mark.parametrize("changes", [{}, {"name": "after"}])
+    def test_replace__returns_deep_copy_with_changes(self, changes: dict[str, object]) -> None:
+        entity = _SampleEntity(name="before", nested=_NestedEntity(values=[1]))
+
+        replaced = entity.replace(**changes)
+        replaced.nested.values.append(2)
+
+        assert entity.name == "before"
+        assert entity.nested.values == [1]
+        assert replaced.name == changes.get("name", "before")
+        assert replaced.nested.values == [1, 2]
+
+    def test_replace__does_not_normalize_trusted_changes(self) -> None:
+        entity = _SampleEntity(name="before", nested=_NestedEntity(values=[]))
+
+        assert entity.replace(name="  after  ").name == "  after  "
+
+    def test_to_json__serializes_entity(self) -> None:
+        entity = _SampleEntity(name="value", nested=_NestedEntity(values=[1, 2]))
+
+        assert (
+            entity.to_json()
+            == '{\n  "name": "value",\n  "nested": {\n    "values": [\n      1,\n      2\n    ]\n  }\n}'
+        )
+
+    def test_from_json__deserializes_and_validates_entity(self) -> None:
+        entity = _SampleEntity.from_json('{"name": "  value  ", "nested": {"values": [1]}}')
+
+        assert entity == _SampleEntity(name="value", nested=_NestedEntity(values=[1]))
+
+    @pytest.mark.parametrize("json_data", ["{", '{"name": "value", "nested": {"values": ["invalid"]}}'])
+    def test_from_json__rejects_invalid_input(self, json_data: str) -> None:
+        with pytest.raises(pydantic.ValidationError):
+            _SampleEntity.from_json(json_data)

llm_tool_cli/core/tests/test_errors.py

@@ -0,0 +1,211 @@
+from pathlib import Path
+from types import MappingProxyType
+from typing import ClassVar
+
+import pytest
+
+from llm_tool_cli.core.entities import ExitCode
+from llm_tool_cli.core.errors import (
+    EnvironmentError,
+    EnvironmentErrors,
+    EnvironmentErrorsProxy,
+    InternalError,
+    exit_code_for_errors,
+)
+
+
+class BrokenState(InternalError):
+    message_template: ClassVar[str] = "Broken {thing}"
+
+
+class TestInternalError:
+    @pytest.mark.parametrize("message", [None, "", "operation failed"])
+    def test_init__message_fallback(self, message: str | None) -> None:
+        error = InternalError(message)
+        expected = "InternalError" if message is None else message
+
+        assert error.message == expected
+        assert str(error) == expected
+        assert error.args == (expected,)
+
+    def test_init__formats_template_from_details(self) -> None:
+        details: dict[str, object] = {"thing": "state {literal}"}
+        error = BrokenState(details=MappingProxyType(details))
+
+        assert error.details == details
+        assert error.message == "Broken state {literal}"
+        assert str(error) == error.message
+        assert error.args == (error.message,)
+
+    @pytest.mark.parametrize("message", ["", "literal {thing}", "{"])
+    def test_init__explicit_message_overrides_template(self, message: str) -> None:
+        error = BrokenState(message)
+
+        assert error.message == message
+        assert str(error) == message
+        assert error.args == (message,)
+
+    @pytest.mark.parametrize("template", ["Invalid state", ""])
+    def test_init__constant_template_without_details(self, template: str) -> None:
+        class InvalidState(InternalError):
+            message_template: ClassVar[str] = template
+
+        error = InvalidState()
+
+        assert error.message == template
+        assert error.details == {}
+
+    def test_init__missing_template_context_raises(self) -> None:
+        with pytest.raises(KeyError, match="thing"):
+            BrokenState()
+
+    @pytest.mark.parametrize("details", [None, {}])
+    def test_init__empty_details_are_independent(self, details: dict[str, object] | None) -> None:
+        first = InternalError(details=details)
+        second = InternalError(details=details)
+        first.details["path"] = "config.toml"
+
+        assert not second.details
+        if details is not None:
+            assert not details
+
+    def test_init__copies_mapping(self) -> None:
+        details: dict[str, object] = {"path": "original.toml"}
+        error = InternalError(details=MappingProxyType(details))
+        details["path"] = "changed.toml"
+        details["extra"] = True
+
+        assert error.details == {"path": "original.toml"}
+
+    def test_init__nested_values_remain_shared(self) -> None:
+        items = ["original"]
+        error = InternalError(details={"items": items})
+        items.append("added")
+
+        assert error.details["items"] == ["original", "added"]
+
+    def test_message__uses_exception_arguments(self) -> None:
+        error = InternalError("original")
+        error.args = ("updated",)
+
+        assert error.message == str(error) == "updated"
+
+
+class ResourceUnavailable(EnvironmentError):
+    code: str = "resource_unavailable"
+    message: str = "Resource {error.path}: {error.reason}"
+    path: Path
+    reason: str
+
+
+class ReportedProblem(ResourceUnavailable):
+    cli_exit_code: ClassVar[ExitCode] = ExitCode.success
+
+
+class ArgumentRejected(ResourceUnavailable):
+    cli_exit_code: ClassVar[ExitCode] = ExitCode.invalid_arguments
+
+
+class ConfigurationRejected(ResourceUnavailable):
+    cli_exit_code: ClassVar[ExitCode] = ExitCode.configuration_error
+
+
+class TestEnvironmentError:
+    @pytest.mark.parametrize("error_type", [ResourceUnavailable, ReportedProblem])
+    def test_cli_exit_code__is_not_serialized(self, error_type: type[ResourceUnavailable]) -> None:
+        error = error_type(path=Path("resource.txt"), reason="denied")
+
+        assert "cli_exit_code" not in error.model_dump()
+        assert "cli_exit_code" not in error.as_record()
+        assert error_type.from_json(error.to_json()).cli_exit_code == error.cli_exit_code
+
+    def test_format_message__substitutes_typed_context(self) -> None:
+        error = ResourceUnavailable(path=Path("resource.txt"), reason="access denied")
+
+        assert error.format_message() == "Resource resource.txt: access denied"
+
+    def test_format_message__uses_normalized_context(self) -> None:
+        error = ResourceUnavailable(
+            path=Path("resource.txt"),
+            message="  Resource {error.path}: {error.reason}\n",
+            reason="  café\n  {literal}\n",
+        )
+
+        assert error.format_message() == "Resource resource.txt: café\n  {literal}"
+
+    def test_as_record__serializes_context_without_template_fields(self) -> None:
+        error = ResourceUnavailable(
+            path=Path("resource.txt"), reason="access denied", ways_to_fix=["Check {error.path}"]
+        )
+
+        assert error.as_record() == {
+            "type": "error",
+            "code": "resource_unavailable",
+            "message": "Resource resource.txt: access denied",
+            "path": "resource.txt",
+            "reason": "access denied",
+        }
+
+    def test_with_cause__keeps_debugging_context_private(self) -> None:
+        cause = PermissionError("access denied")
+        error = ResourceUnavailable(path=Path("resource.txt"), reason=str(cause))
+        original_record = error.as_record()
+
+        returned = error.with_cause(cause)
+
+        assert returned == error
+        assert error.cause == cause
+        assert error.as_record() == original_record
+        assert "cause" not in error.model_dump_json()
+
+    def test_cause__without_original_exception(self) -> None:
+        error = ResourceUnavailable(path=Path("resource.txt"), reason="not configured")
+
+        assert error.cause is None
+
+
+class TestExitCodeForErrors:
+    @pytest.mark.parametrize(
+        ("error_types", "expected"),
+        [
+            ([], 0),
+            ([ReportedProblem, ReportedProblem], 0),
+            ([ResourceUnavailable], 3),
+            ([ArgumentRejected], 1),
+            ([ConfigurationRejected], 2),
+            ([ReportedProblem, ArgumentRejected], 1),
+            ([ArgumentRejected, ConfigurationRejected], 2),
+            ([ConfigurationRejected, ArgumentRejected], 2),
+            ([ArgumentRejected, ConfigurationRejected, ResourceUnavailable, ReportedProblem], 3),
+            ([ReportedProblem, ResourceUnavailable, ConfigurationRejected, ArgumentRejected], 3),
+        ],
+    )
+    def test_highest_code_without_changing_errors(
+        self, error_types: list[type[ResourceUnavailable]], expected: int
+    ) -> None:
+        errors: EnvironmentErrors = [
+            error_type(path=Path(f"resource-{index}.txt"), reason="denied")
+            for index, error_type in enumerate(error_types)
+        ]
+        records = [error.as_record() for error in errors]
+
+        result = exit_code_for_errors(errors)
+
+        assert result == expected
+        assert [error.as_record() for error in errors] == records
+
+
+class TestEnvironmentErrorsProxy:
+    @pytest.mark.parametrize("reasons", [[], ["unavailable", "access denied"]])
+    def test_init__retains_original_error_list(self, reasons: list[str]) -> None:
+        errors: EnvironmentErrors = [
+            ResourceUnavailable(path=Path("resource.txt"), reason=reason) for reason in reasons
+        ]
+
+        proxy = EnvironmentErrorsProxy(errors)
+
+        assert proxy.details == {"errors": errors}
+
+        errors.append(ResourceUnavailable(path=Path("other.txt"), reason="missing"))
+
+        assert proxy.details == {"errors": errors}

llm_tool_cli/core/tests/test_result.py

@@ -0,0 +1,256 @@
+import pytest
+
+from llm_tool_cli.core.errors import EnvironmentError, EnvironmentErrors, InternalError
+from llm_tool_cli.core.result import Err, Ok, Result, UnwrapErrError, UnwrapError, unwrap_to_error
+
+
+class ExpectedFailure(EnvironmentError):
+    code: str = "expected_failure"
+    message: str = "Expected failure"
+
+
+class SpecificFailure(ExpectedFailure):
+    code: str = "specific_failure"
+
+
+class OtherFailure(EnvironmentError):
+    code: str = "other_failure"
+    message: str = "Other failure"
+
+
+class TestUnwrapError:
+    def test_errors__preserves_list_values_and_order(self) -> None:
+        failures: EnvironmentErrors = [SpecificFailure(), OtherFailure()]
+        exception = UnwrapError(error=failures)
+
+        recovered = exception.errors
+
+        assert recovered == [SpecificFailure(), OtherFailure()]
+        recovered.append(ExpectedFailure())
+        assert failures == [SpecificFailure(), OtherFailure(), ExpectedFailure()]
+
+    def test_errors__accepts_empty_list(self) -> None:
+        assert UnwrapError(error=[]).errors == []
+
+    def test_errors__reads_current_details_payload(self) -> None:
+        exception = UnwrapError(error=[ExpectedFailure()])
+        exception.details["error"] = [OtherFailure()]
+
+        assert exception.errors == [OtherFailure()]
+
+    @pytest.mark.parametrize(
+        "payload",
+        [
+            None,
+            "unexpected payload",
+            ExpectedFailure(),
+            (ExpectedFailure(),),
+            iter([ExpectedFailure()]),
+            [ExpectedFailure(), "unexpected payload"],
+        ],
+    )
+    def test_errors__rejects_malformed_payload(self, payload: object) -> None:
+        exception = UnwrapError(error=[])
+        exception.details["error"] = payload
+
+        with pytest.raises(UnwrapError) as caught:
+            _ = exception.errors
+
+        assert caught.value == exception
+        assert caught.value.details == {"error": payload}
+
+    def test_errors__rejects_missing_payload(self) -> None:
+        exception = UnwrapError(error=[])
+        del exception.details["error"]
+
+        with pytest.raises(UnwrapError) as caught:
+            _ = exception.errors
+
+        assert caught.value == exception
+        assert caught.value.details == {}
+
+
+class TestResult:
+    @pytest.mark.parametrize("errors", [[], [ExpectedFailure()], [ExpectedFailure(), OtherFailure()]])
+    def test_is_err__without_type_accepts_any_error_list(self, errors: EnvironmentErrors) -> None:
+        result: Result[int] = Err(errors)
+
+        assert result.is_err()
+        assert result.is_err(None)
+        assert result.unwrap_err() == errors
+
+    @pytest.mark.parametrize("value", [None, 1])
+    def test_is_err__success_never_matches(self, value: int | None) -> None:
+        result: Result[int | None] = Ok(value)
+
+        assert not result.is_err()
+        assert not result.is_err(ExpectedFailure)
+        assert result.unwrap() == value
+
+    @pytest.mark.parametrize(
+        "errors",
+        [[ExpectedFailure()], [SpecificFailure()], [ExpectedFailure(), SpecificFailure()]],
+    )
+    def test_is_err__matches_all_errors_including_subclasses(self, errors: EnvironmentErrors) -> None:
+        result: Result[int] = Err(errors)
+
+        assert result.is_err(ExpectedFailure)
+        assert result.unwrap_err() == errors
+
+    @pytest.mark.parametrize(
+        "errors",
+        [[OtherFailure()], [ExpectedFailure(), OtherFailure()], [OtherFailure(), ExpectedFailure()]],
+    )
+    def test_is_err__rejects_unmatched_and_mixed_errors(self, errors: EnvironmentErrors) -> None:
+        result: Result[int] = Err(errors)
+
+        assert result.is_err()
+        assert not result.is_err(ExpectedFailure)
+        assert result.unwrap_err() == errors
+
+    def test_is_err__empty_error_list_does_not_match_type(self) -> None:
+        result: Result[int] = Err([])
+
+        assert result.is_err()
+        assert not result.is_err(ExpectedFailure)
+
+    def test_unwrap__none_is_a_success_value(self) -> None:
+        result: Result[None] = Ok(None)
+
+        assert result.is_ok()
+        assert result.unwrap() is None
+
+    def test_ok__exposes_success_value(self) -> None:
+        result: Result[int] = Ok(2)
+
+        assert result.is_ok()
+        assert not result.is_err()
+        assert result.ok() == 2
+        assert result.err() is None
+        assert result.unwrap() == 2
+        assert result.unwrap_or(3) == 2
+
+    def test_ok__maps_success_value(self) -> None:
+        result: Result[int] = Ok(2)
+
+        mapped = result.map(lambda value: value + 1)
+        mapped_error = result.map_err(lambda errors: pytest.fail("must not transform errors on success"))
+
+        assert mapped.unwrap() == 3
+        assert mapped_error.unwrap() == 2
+
+    def test_ok__unwrap_err_raises_internal_error(self) -> None:
+        result: Result[int] = Ok(2)
+
+        with pytest.raises(UnwrapErrError) as exc_info:
+            result.unwrap_err()
+
+        assert exc_info.value.details == {"value": 2}
+        assert exc_info.value.message == str(exc_info.value)
+
+    def test_err__exposes_error_value(self) -> None:
+        errors: EnvironmentErrors = [ExpectedFailure(), OtherFailure()]
+        result: Result[int] = Err(errors)
+
+        assert not result.is_ok()
+        assert result.is_err()
+        assert result.ok() is None
+        assert result.err() == errors
+        assert result.unwrap_or(3) == 3
+
+    def test_err__maps_error_value(self) -> None:
+        result: Result[int] = Err([ExpectedFailure()])
+
+        mapped = result.map(lambda value: pytest.fail("must not transform a value on failure"))
+        mapped_error = result.map_err(lambda errors: [*errors, OtherFailure()])
+
+        assert mapped.err() == [ExpectedFailure()]
+        assert mapped_error.err() == [ExpectedFailure(), OtherFailure()]
+        assert result.err() == [ExpectedFailure()]
+
+    def test_err__unwrap_raises_internal_error_with_error_value(self) -> None:
+        errors: EnvironmentErrors = [ExpectedFailure(), OtherFailure()]
+        result: Result[int] = Err(errors)
+
+        with pytest.raises(UnwrapError) as exc_info:
+            result.unwrap()
+
+        assert exc_info.value.details == {"error": errors}
+        assert exc_info.value.message == str(exc_info.value)
+
+
+class TestOk:
+    def test_returns_success_result(self) -> None:
+        assert Ok("value").unwrap() == "value"
+
+
+class TestErr:
+    def test_returns_error_result(self) -> None:
+        errors: EnvironmentErrors = [ExpectedFailure(), OtherFailure()]
+
+        assert Err(errors).unwrap_err() == errors
+
+
+class TestUnwrapToError:
+    def test_short_circuits_composition_without_losing_errors(self) -> None:
+        calls = []
+
+        @unwrap_to_error
+        def composed() -> Result[str]:
+            calls.append("before")
+            result: Result[str] = Err([ExpectedFailure(), OtherFailure()])
+            value = result.unwrap()
+            calls.append("after")
+            return Ok(value)
+
+        assert composed().unwrap_err() == [ExpectedFailure(), OtherFailure()]
+        assert calls == ["before"]
+
+    def test_does_not_hide_unwrap_err_misuse(self) -> None:
+        @unwrap_to_error
+        def composed() -> Result[str]:
+            Ok("value").unwrap_err()
+            return Ok("unreachable")
+
+        with pytest.raises(UnwrapErrError):
+            composed()
+
+    @pytest.mark.parametrize("errors", [[], [ExpectedFailure(), SpecificFailure(), OtherFailure()]])
+    def test_converts_unwrap_error_to_error_result(self, errors: EnvironmentErrors) -> None:
+        @unwrap_to_error
+        def composed() -> Result[str]:
+            return Err(errors).unwrap()
+
+        result = composed()
+
+        assert result.is_err()
+        assert result.unwrap_err() == errors
+
+    def test_malformed_unwrap_payload_remains_an_exception(self) -> None:
+        exception = UnwrapError(error=[])
+        exception.details["error"] = [ExpectedFailure(), "unexpected payload"]
+
+        @unwrap_to_error
+        def composed() -> Result[str]:
+            raise exception
+
+        with pytest.raises(UnwrapError) as caught:
+            composed()
+
+        assert caught.value == exception
+
+    def test_preserves_success_result(self) -> None:
+        @unwrap_to_error
+        def composed() -> Result[str]:
+            return Ok("value")
+
+        assert composed().unwrap() == "value"
+
+    @pytest.mark.parametrize("error", [RuntimeError("boom"), InternalError("technical failure")])
+    def test_does_not_hide_arbitrary_exceptions(self, error: Exception) -> None:
+        @unwrap_to_error
+        def composed() -> Result[str]:
+            raise error
+
+        with pytest.raises(type(error)):
+            composed()