test: reorganize core suite into explicit domain files

tests/library/test_library_client_extractors.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from auditui.library import LibraryClient
+
+
+@dataclass(slots=True)
+class MockClient:
+    """Client double that records writes and serves configurable responses."""
+
+    put_calls: list[tuple[str, dict]] = field(default_factory=list)
+    post_calls: list[tuple[str, dict]] = field(default_factory=list)
+    _post_response: dict = field(default_factory=dict)
+    raise_on_put: bool = False
+
+    def put(self, path: str, body: dict) -> dict:
+        """Record put payload or raise when configured."""
+        if self.raise_on_put:
+            raise RuntimeError("put failed")
+        self.put_calls.append((path, body))
+        return {}
+
+    def post(self, path: str, body: dict) -> dict:
+        """Record post payload and return configured response."""
+        self.post_calls.append((path, body))
+        return self._post_response
+
+    def get(self, path: str, **kwargs: dict) -> dict:
+        """Return empty data for extractor-focused tests."""
+        del path, kwargs
+        return {}
+
+
+def build_item(
+    *,
+    title: str | None = None,
+    product_title: str | None = None,
+    authors: list[dict] | None = None,
+    runtime_min: int | None = None,
+    listening_status: dict | None = None,
+    percent_complete: int | float | None = None,
+    asin: str | None = None,
+) -> dict:
+    """Construct synthetic library items for extractor and finish tests."""
+    item: dict = {}
+    if title is not None:
+        item["title"] = title
+    if percent_complete is not None:
+        item["percent_complete"] = percent_complete
+    if listening_status is not None:
+        item["listening_status"] = listening_status
+    if asin is not None:
+        item["asin"] = asin
+    product: dict = {}
+    if product_title is not None:
+        product["title"] = product_title
+    if runtime_min is not None:
+        product["runtime_length"] = {"min": runtime_min}
+    if authors is not None:
+        product["authors"] = authors
+    if asin is not None:
+        product["asin"] = asin
+    if product:
+        item["product"] = product
+    if runtime_min is not None:
+        item["runtime_length_min"] = runtime_min
+    return item
+
+
+def test_extract_title_prefers_product_title() -> None:
+    """Ensure product title has precedence over outer item title."""
+    library = LibraryClient(MockClient())  # type: ignore[arg-type]
+    assert (
+        library.extract_title(build_item(title="Outer", product_title="Inner"))
+        == "Inner"
+    )
+
+
+def test_extract_title_falls_back_to_asin() -> None:
+    """Ensure title fallback uses product ASIN when no title exists."""
+    library = LibraryClient(MockClient())  # type: ignore[arg-type]
+    assert library.extract_title({"product": {"asin": "A1"}}) == "A1"
+
+
+def test_extract_authors_joins_names() -> None:
+    """Ensure author dictionaries are converted to a readable list."""
+    library = LibraryClient(MockClient())  # type: ignore[arg-type]
+    item = build_item(authors=[{"name": "A"}, {"name": "B"}])
+    assert library.extract_authors(item) == "A, B"
+
+
+def test_extract_runtime_minutes_handles_dict_and_number() -> None:
+    """Ensure runtime extraction supports dict and numeric payloads."""
+    library = LibraryClient(MockClient())  # type: ignore[arg-type]
+    assert library.extract_runtime_minutes(build_item(runtime_min=12)) == 12
+    assert library.extract_runtime_minutes({"runtime_length": 42}) == 42
+
+
+def test_extract_progress_info_prefers_listening_status_when_needed() -> None:
+    """Ensure progress can be sourced from listening_status when top-level is absent."""
+    library = LibraryClient(MockClient())  # type: ignore[arg-type]
+    item = build_item(listening_status={"percent_complete": 25.0})
+    assert library.extract_progress_info(item) == 25.0
+
+
+def test_extract_asin_prefers_item_then_product() -> None:
+    """Ensure ASIN extraction works from both item and product fields."""
+    library = LibraryClient(MockClient())  # type: ignore[arg-type]
+    assert library.extract_asin(build_item(asin="ASIN1")) == "ASIN1"
+    assert library.extract_asin({"product": {"asin": "ASIN2"}}) == "ASIN2"

tests/library/test_library_client_progress_updates.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from auditui.library import LibraryClient
+
+
+@dataclass(slots=True)
+class ProgressClient:
+    """Client double for position and finished-state API methods."""
+
+    get_responses: dict[str, dict] = field(default_factory=dict)
+    put_calls: list[tuple[str, dict]] = field(default_factory=list)
+    post_response: dict = field(default_factory=dict)
+    fail_put: bool = False
+
+    def get(self, path: str, **kwargs: object) -> dict:
+        """Return preconfigured payloads by API path."""
+        del kwargs
+        return self.get_responses.get(path, {})
+
+    def put(self, path: str, body: dict) -> dict:
+        """Record payloads or raise to exercise error handling."""
+        if self.fail_put:
+            raise OSError("write failed")
+        self.put_calls.append((path, body))
+        return {}
+
+    def post(self, path: str, body: dict) -> dict:
+        """Return licenserequest response for ACR extraction."""
+        del path, body
+        return self.post_response
+
+
+def test_is_finished_true_from_percent_complete() -> None:
+    """Ensure 100 percent completion is treated as finished."""
+    library = LibraryClient(ProgressClient())  # type: ignore[arg-type]
+    assert library.is_finished({"percent_complete": 100}) is True
+
+
+def test_get_last_position_reads_matching_annotation() -> None:
+    """Ensure last position is read in seconds from matching annotation."""
+    client = ProgressClient(
+        get_responses={
+            "1.0/annotations/lastpositions": {
+                "asin_last_position_heard_annots": [
+                    {"asin": "X", "last_position_heard": {"position_ms": 9000}}
+                ]
+            }
+        }
+    )
+    library = LibraryClient(client)  # type: ignore[arg-type]
+    assert library.get_last_position("X") == 9.0
+
+
+def test_get_last_position_returns_none_for_missing_state() -> None:
+    """Ensure DoesNotExist status is surfaced as no saved position."""
+    client = ProgressClient(
+        get_responses={
+            "1.0/annotations/lastpositions": {
+                "asin_last_position_heard_annots": [
+                    {"asin": "X", "last_position_heard": {"status": "DoesNotExist"}}
+                ]
+            }
+        }
+    )
+    library = LibraryClient(client)  # type: ignore[arg-type]
+    assert library.get_last_position("X") is None
+
+
+def test_save_last_position_validates_non_positive_values() -> None:
+    """Ensure save_last_position short-circuits on non-positive input."""
+    library = LibraryClient(ProgressClient())  # type: ignore[arg-type]
+    assert library.save_last_position("A", 0) is False
+
+
+def test_update_position_writes_version_when_available() -> None:
+    """Ensure version is included in payload when metadata provides it."""
+    client = ProgressClient(
+        get_responses={
+            "1.0/content/A/metadata": {
+                "content_metadata": {
+                    "content_reference": {"acr": "token", "version": "2"}
+                }
+            }
+        }
+    )
+    library = LibraryClient(client)  # type: ignore[arg-type]
+    assert library._update_position("A", 5.5) is True
+    path, body = client.put_calls[0]
+    assert path == "1.0/lastpositions/A"
+    assert body["position_ms"] == 5500
+    assert body["version"] == "2"
+
+
+def test_mark_as_finished_updates_item_in_place() -> None:
+    """Ensure successful finish update mutates local item flags."""
+    client = ProgressClient(post_response={"content_license": {"acr": "token"}})
+    library = LibraryClient(client)  # type: ignore[arg-type]
+    item = {"runtime_length_min": 1, "listening_status": {}}
+    assert library.mark_as_finished("ASIN", item) is True
+    assert item["is_finished"] is True
+    assert item["listening_status"]["is_finished"] is True

tests/library/test_library_search_filters.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from auditui.library import build_search_text, filter_items
+
+
+class SearchLibrary:
+    """Simple search extraction adapter for build_search_text tests."""
+
+    def extract_title(self, item: dict) -> str:
+        """Return a title value from a synthetic item."""
+        return item.get("t", "")
+
+    def extract_authors(self, item: dict) -> str:
+        """Return an author value from a synthetic item."""
+        return item.get("a", "")
+
+
+def test_build_search_text_uses_library_client_when_present() -> None:
+    """Ensure search text delegates to library extractor methods."""
+    item = {"t": "The Book", "a": "The Author"}
+    assert build_search_text(item, SearchLibrary()) == "the book the author"
+
+
+def test_filter_items_returns_input_when_filter_empty() -> None:
+    """Ensure empty filter bypasses per-item search callback evaluation."""
+    items = [{"k": 1}, {"k": 2}]
+    assert filter_items(items, "", lambda _item: "ignored") == items
+
+
+def test_filter_items_matches_case_insensitively() -> None:
+    """Ensure search matching is case-insensitive across computed text."""
+    items = [{"name": "Alpha"}, {"name": "Beta"}]
+    result = filter_items(items, "BETA", lambda item: item["name"].lower())
+    assert result == [items[1]]

tests/library/test_library_table_formatting.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, cast
+
+from auditui.constants import AUTHOR_NAME_MAX_LENGTH
+from auditui.library import (
+    create_progress_sort_key,
+    create_title_sort_key,
+    filter_unfinished_items,
+    format_item_as_row,
+    truncate_author_name,
+)
+
+
+class StubLibrary:
+    """Library facade exposing only helpers needed by table formatting code."""
+
+    def extract_title(self, item: dict) -> str:
+        """Return synthetic title value."""
+        return item.get("title", "")
+
+    def extract_authors(self, item: dict) -> str:
+        """Return synthetic authors value."""
+        return item.get("authors", "")
+
+    def extract_runtime_minutes(self, item: dict) -> int | None:
+        """Return synthetic minute duration."""
+        return item.get("minutes")
+
+    def format_duration(
+        self, value: int | None, unit: str = "minutes", default_none: str | None = None
+    ) -> str | None:
+        """Render runtime in compact minute format for tests."""
+        del unit
+        return default_none if value is None else f"{value}m"
+
+    def extract_progress_info(self, item: dict) -> float | None:
+        """Return synthetic progress percentage value."""
+        return item.get("percent")
+
+    def extract_asin(self, item: dict) -> str | None:
+        """Return synthetic ASIN value."""
+        return item.get("asin")
+
+    def is_finished(self, item: dict) -> bool:
+        """Return synthetic finished flag from the item."""
+        return bool(item.get("finished"))
+
+
+@dataclass(slots=True)
+class StubDownloads:
+    """Download cache adapter exposing just is_cached."""
+
+    cached: set[str]
+
+    def is_cached(self, asin: str) -> bool:
+        """Return whether an ASIN is cached."""
+        return asin in self.cached
+
+
+def test_create_title_sort_key_normalizes_accents() -> None:
+    """Ensure title sorting removes accents before case-fold compare."""
+    key_fn, _ = create_title_sort_key()
+    assert key_fn(["Ecole"]) == key_fn(["École"])
+
+
+def test_create_progress_sort_key_parses_percent_strings() -> None:
+    """Ensure progress sorting converts percentages and handles invalid values."""
+    key_fn, _ = create_progress_sort_key()
+    assert key_fn(["0", "0", "0", "42.5%", ""]) == 42.5
+    assert key_fn(["0", "0", "0", "bad", ""]) == 0.0
+
+
+def test_truncate_author_name_clamps_long_values() -> None:
+    """Ensure very long author strings are shortened with ellipsis."""
+    long_name = "A" * (AUTHOR_NAME_MAX_LENGTH + 5)
+    out = truncate_author_name(long_name)
+    assert out.endswith("...")
+    assert len(out) <= AUTHOR_NAME_MAX_LENGTH
+
+
+def test_format_item_as_row_marks_downloaded_titles() -> None:
+    """Ensure downloaded ASINs are shown with a checkmark in table rows."""
+    item = {
+        "title": "Title",
+        "authors": "Author",
+        "minutes": 90,
+        "percent": 12.34,
+        "asin": "A1",
+    }
+    row = format_item_as_row(item, StubLibrary(), cast(Any, StubDownloads({"A1"})))
+    assert row == ("Title", "Author", "90m", "12.3%", "✓")
+
+
+def test_filter_unfinished_items_keeps_only_incomplete() -> None:
+    """Ensure unfinished filter excludes items marked as finished."""
+    items = [{"id": 1, "finished": False}, {"id": 2, "finished": True}]
+    assert filter_unfinished_items(items, StubLibrary()) == [items[0]]