Pin the ja adapter against a stub so coverage sees it (#272)

The adapter's guard stack ran only in the extra-gated integration
tests, which the coverage-bearing CI job never executes -- so
codecov/patch read locales/ja.py at 55% while ja-extra proved it
green. A stubbed namedivider module exercises every branch in the
plain suite, including the two defensive paths the real 0.4.x
library cannot reach, plus the gbdt selection. Also pins the two
remaining uncovered new lines: parser_for's base type check and
Segmentation's confidence TYPE error.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: derek73

tests/v2/test_locales.py

@@ -3,6 +3,8 @@
 import functools
 import importlib.util
 import re
+import sys
+import types
 from collections.abc import Callable, Iterable
 from types import ModuleType
 
@@ -215,6 +217,79 @@ def test_ja_segmenter_without_extra_raises_helpfully() -> None:
         locales.ja_segmenter()
 
 
+class _FakeDivided:
+    """The shape of namedivider's DividedName, minus namedivider —
+    lets the adapter's guard stack run in the plain (no-extra) suite,
+    including the two defensive branches the real 0.4.x library can
+    never reach (reconstruction failure, an empty side)."""
+
+    def __init__(self, family: str, given: str, score: float) -> None:
+        self.family, self.given, self.score = family, given, score
+
+
+def _fake_namedivider(monkeypatch: pytest.MonkeyPatch,
+                      divide: "Callable[[str], _FakeDivided]") -> list[str]:
+    """Install a stub namedivider module and return the gbdt-call log
+    (empty unless GBDTNameDivider was constructed)."""
+    constructed: list[str] = []
+
+    class _Basic:
+        def __init__(self) -> None:
+            constructed.append("basic")
+
+        def divide_name(self, text: str) -> _FakeDivided:
+            return divide(text)
+
+    class _GBDT(_Basic):
+        def __init__(self) -> None:
+            constructed.append("gbdt")
+
+    stub = types.ModuleType("namedivider")
+    stub.BasicNameDivider = _Basic  # type: ignore[attr-defined]
+    stub.GBDTNameDivider = _GBDT  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "namedivider", stub)
+    return constructed
+
+
+def test_ja_adapter_guard_stack_against_a_stub(
+        monkeypatch: pytest.MonkeyPatch) -> None:
+    # The adapter's whole contract without the extra: this is what the
+    # coverage-bearing CI job sees, so the guards are pinned here and
+    # not only behind the nameparser[ja] integration tests.
+    divide = _fake_namedivider(
+        monkeypatch, lambda text: _FakeDivided(text[:2], text[2:], 0.5))
+    seg = locales.ja_segmenter()
+    assert divide == ["basic"]
+    answer = seg("山田太郎")
+    assert answer is not None
+    assert answer.splits == (2,) and answer.confidence == 0.5
+    assert seg("김민준") is None            # outside the repertoire
+    assert seg("林") is None                # namedivider raises below 2
+
+
+def test_ja_adapter_defensive_branches_against_a_stub(
+        monkeypatch: pytest.MonkeyPatch) -> None:
+    # reconstruction failure -> decline; an empty side -> the stated
+    # "confidently undivided" opinion; an out-of-range score -> clamped
+    # so Segmentation's [0, 1] validation cannot raise mid-parse
+    _fake_namedivider(
+        monkeypatch, lambda text: _FakeDivided("外", "れ", 0.5))
+    assert locales.ja_segmenter()("山田太郎") is None
+    _fake_namedivider(
+        monkeypatch, lambda text: _FakeDivided(text, "", 1.0000001))
+    whole = locales.ja_segmenter()("山田太郎")
+    assert whole is not None
+    assert whole.splits == () and whole.confidence == 1.0
+
+
+def test_ja_adapter_gbdt_flag_selects_the_gbdt_divider(
+        monkeypatch: pytest.MonkeyPatch) -> None:
+    divide = _fake_namedivider(
+        monkeypatch, lambda text: _FakeDivided(text[:1], text[1:], 1.0))
+    locales.ja_segmenter(gbdt=True)
+    assert divide == ["gbdt"]
+
+
 def test_ja_ranges_stay_in_sync_with_vocab() -> None:
     # the twin of the zh pin above: ja.py hand-copies the three
     # Japanese-repertoire scripts' spans for DEVIATES and for the

tests/v2/test_parser.py

@@ -634,6 +634,11 @@ def seg(text: str) -> Segmentation | None:
     assert p.segmenter is seg
 
 
+def test_parser_for_rejects_a_non_parser_base() -> None:
+    with pytest.raises(TypeError, match="base must be a Parser"):
+        parser_for(locales.get("zh"), base=5)  # type: ignore[arg-type]
+
+
 def test_parser_for_takes_a_segmenter_keyword() -> None:
     def seg(text: str) -> Segmentation | None:
         return None

tests/v2/test_types.py

@@ -87,6 +87,9 @@ def test_segmentation_validates_splits() -> None:
         Segmentation(("2",))  # type: ignore[arg-type]
     with pytest.raises(ValueError, match="confidence"):
         Segmentation((2,), confidence=1.5)
+    # wrong TYPE is the TypeError branch, distinct from the range check
+    with pytest.raises(TypeError, match="confidence"):
+        Segmentation((2,), confidence="high")  # type: ignore[arg-type]
 
 
 def test_segmentation_rejects_mappings_and_non_iterables() -> None: