feat: prepare v0.3.0 library delivery

tests/test_mapped_line_join.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from importlib import import_module
+from importlib.metadata import version as distribution_version
 from typing import TYPE_CHECKING, cast
 
 import pytest
@@ -356,10 +357,14 @@ def test_empty_document_and_empty_rule_set_are_no_ops() -> None:
 
     assert transform("", ()) == ""
     assert transform("exam-\nple", ()) == "exam-\nple"
-    assert modifier.version == "2.0.0"
+    assert modifier.version == "2.0.1"
     assert dict(modifier.parameters)["rules"] == ()
 
 
+def test_installed_package_version_matches_delivery_candidate() -> None:
+    assert distribution_version("mdpolish") == "0.3.0"
+
+
 def test_parameters_preserve_rule_order_and_record_all_options() -> None:
     first = mapped_line_join((exact_rule(rule_id="first"), exact_rule(rule_id="second")))
     second = mapped_line_join((exact_rule(rule_id="second"), exact_rule(rule_id="first")))
@@ -530,20 +535,65 @@ def test_missing_requested_optional_backend_raises_without_fallback(monkeypatch:
         mapped_line_join((lexical_rule(),))
 
 
-@pytest.mark.parametrize(
-    ("backend", "available"),
-    [
-        (LexiconBackend.SPELLCHECKER, mapped_module._SpellChecker is not None),
-        (LexiconBackend.WORDFREQ, mapped_module._zipf_frequency is not None),
-    ],
-)
-def test_installed_optional_backend_constructs_or_is_reported_as_skipped(
-    backend: LexiconBackend,
-    available: bool,
+def test_spellchecker_case_sensitive_dictionary_is_rejected_before_backend_loading(
+    monkeypatch: MonkeyPatch,
 ) -> None:
-    if not available:
-        pytest.skip(f"optional backend is not installed: {backend.value}")
-    mapped_line_join((lexical_rule(backend=backend),))
+    monkeypatch.setattr(mapped_module, "_SpellChecker", None)
+    rule = lexical_rule(backend=LexiconBackend.SPELLCHECKER)
+
+    with pytest.raises(ModifierContractError, match=r"english\.lexical") as raised:
+        mapped_line_join((rule,))
+
+    message = str(raised.value)
+    assert "pyspellchecker" in message
+    assert "case_sensitive=False" in message
+    assert "lexical' extra" not in message
+
+
+def test_real_spellchecker_and_pyphen_transform_and_record_versions() -> None:
+    if mapped_module._SpellChecker is None or mapped_module._Pyphen is None:
+        pytest.skip("optional lexical backend is not installed")
+    rule = lexical_rule(
+        backend=LexiconBackend.SPELLCHECKER,
+        case_sensitive=False,
+        hyphenation_language="en_US",
+    )
+    modifier = mapped_line_join((rule,))
+    result = Pipeline((modifier,)).transform("an exam-\nple")
+
+    assert result.status is RunStatus.SUCCESS
+    assert result.output_markdown == "an example"
+    records = cast(tuple[tuple[tuple[str, object], ...], ...], dict(modifier.parameters)["rules"])
+    package_versions = dict(cast(tuple[tuple[str, str], ...], dict(records[0])["package_versions"]))
+    assert package_versions == {
+        "pyphen": distribution_version("pyphen"),
+        "pyspellchecker": distribution_version("pyspellchecker"),
+    }
+
+
+def test_real_pyphen_invalid_breakpoint_keeps_joined_candidate_out() -> None:
+    if mapped_module._SpellChecker is None or mapped_module._Pyphen is None:
+        pytest.skip("optional lexical backend is not installed")
+    rule = lexical_rule(
+        backend=LexiconBackend.SPELLCHECKER,
+        case_sensitive=False,
+        hyphenation_language="en_US",
+    )
+
+    assert transform("exa-\nmple", (rule,)) == "exa-\nmple"
+
+
+def test_real_wordfreq_transforms_and_records_version() -> None:
+    if mapped_module._zipf_frequency is None:
+        pytest.skip("optional frequency backend is not installed")
+    modifier = mapped_line_join((lexical_rule(),))
+    result = Pipeline((modifier,)).transform("an exam-\nple")
+
+    assert result.status is RunStatus.SUCCESS
+    assert result.output_markdown == "an example"
+    records = cast(tuple[tuple[tuple[str, object], ...], ...], dict(modifier.parameters)["rules"])
+    package_versions = dict(cast(tuple[tuple[str, str], ...], dict(records[0])["package_versions"]))
+    assert package_versions == {"wordfreq": distribution_version("wordfreq")}
 
 
 def test_successful_output_is_idempotent() -> None: