From ac40b38cadde55cc162eff9a071944133cd5fa4c Mon Sep 17 00:00:00 2001 From: Trenton Holmes <797416+stumpylog@users.noreply.github.com> Date: Tue, 18 Aug 2026 13:27:59 -0700 Subject: [PATCH] test(search): dedupe the resolve-and-assert boilerplate in test_registry.py Every test repeated the same 5-line make_ref/resolve/assert-not-None sequence before its one real assertion. Extract a registry fixture and a typed _resolve() helper so each test states one fact in one line. --- src/documents/tests/search/test_registry.py | 118 +++++++++----------- 1 file changed, 54 insertions(+), 64 deletions(-) diff --git a/src/documents/tests/search/test_registry.py b/src/documents/tests/search/test_registry.py index 266dd154a..f7e9aee6f 100644 --- a/src/documents/tests/search/test_registry.py +++ b/src/documents/tests/search/test_registry.py @@ -1,12 +1,30 @@ +import pytest from whoosh_compat import FieldKind +from whoosh_compat import FieldRegistry +from whoosh_compat.fields import ResolvedField from documents.search._fields import PUBLIC_FIELDS from documents.search._registry import get_field_registry +@pytest.fixture +def registry() -> FieldRegistry: + return get_field_registry(None) + + +def _resolve(registry: FieldRegistry, name: str) -> ResolvedField: + ref = registry.make_ref(name) + assert ref is not None, f"{name} is not a valid field ref" + resolved = registry.resolve(ref) + assert resolved is not None, f"{name} did not resolve" + return resolved + + class TestFieldRegistry: - def test_internal_id_fields_are_not_registered(self) -> None: - registry = get_field_registry(None) + def test_internal_id_fields_are_not_registered( + self, + registry: FieldRegistry, + ) -> None: for name in ( "tag_id", "owner_id", @@ -18,98 +36,70 @@ class TestFieldRegistry: ): assert name not in registry - def test_type_alias_resolves_to_document_type(self) -> None: - registry = get_field_registry(None) - ref = registry.make_ref("type") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None - assert resolved.spec.name == "document_type" + def test_type_alias_resolves_to_document_type( + self, + registry: FieldRegistry, + ) -> None: + assert _resolve(registry, "type").spec.name == "document_type" - def test_path_alias_resolves_to_storage_path(self) -> None: - registry = get_field_registry(None) - ref = registry.make_ref("path") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None - assert resolved.spec.name == "storage_path" + def test_path_alias_resolves_to_storage_path(self, registry: FieldRegistry) -> None: + assert _resolve(registry, "path").spec.name == "storage_path" - def test_notes_json_subpaths_resolve(self) -> None: - registry = get_field_registry(None) - ref = registry.make_ref("notes.user") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None + def test_notes_json_subpaths_resolve(self, registry: FieldRegistry) -> None: + resolved = _resolve(registry, "notes.user") assert resolved.spec.name == "notes" assert resolved.json_path == "user" assert resolved.is_subpath is True - def test_custom_fields_json_subpaths_resolve(self) -> None: - registry = get_field_registry(None) + def test_custom_fields_json_subpaths_resolve(self, registry: FieldRegistry) -> None: for raw in ("custom_fields.name", "custom_fields.value"): - ref = registry.make_ref(raw) - assert ref is not None - assert registry.resolve(ref) is not None + _resolve(registry, raw) - def test_unregistered_json_subpath_does_not_resolve(self) -> None: - registry = get_field_registry(None) + def test_unregistered_json_subpath_does_not_resolve( + self, + registry: FieldRegistry, + ) -> None: # An unregistered subpath is not even a valid FieldRef: make_ref # returns None for a dotted name whose subpath isn't registered # (it doesn't produce a ref for resolve() to then reject). assert registry.make_ref("notes.bogus") is None - def test_tag_is_comma_values(self) -> None: - registry = get_field_registry(None) - ref = registry.make_ref("tag") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None - assert resolved.spec.comma_values is True + def test_tag_is_comma_values(self, registry: FieldRegistry) -> None: + assert _resolve(registry, "tag").spec.comma_values is True - def test_created_is_date_kind(self) -> None: - registry = get_field_registry(None) - ref = registry.make_ref("created") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None + def test_created_is_date_kind(self, registry: FieldRegistry) -> None: + resolved = _resolve(registry, "created") assert resolved.spec.kind is FieldKind.DATE assert resolved.spec.date_only is True - def test_analyzer_lowercases_and_ascii_folds(self) -> None: + def test_analyzer_lowercases_and_ascii_folds(self, registry: FieldRegistry) -> None: # title uses the paperless_text analyzer: simple -> remove_long -> # lowercase -> ascii_fold [-> stemmer]. With no language configured # (None), no stemmer runs, so "Café" folds to the single token "cafe". - registry = get_field_registry(None) - ref = registry.make_ref("title") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None + resolved = _resolve(registry, "title") assert resolved.spec.analyzer is not None assert resolved.spec.analyzer("Café") == ["cafe"] - def test_checksum_analyzer_is_identity_single_token(self) -> None: + def test_checksum_analyzer_is_identity_single_token( + self, + registry: FieldRegistry, + ) -> None: # checksum uses the raw tokenizer at index time (no splitting). - registry = get_field_registry(None) - ref = registry.make_ref("checksum") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None + resolved = _resolve(registry, "checksum") + assert resolved.spec.analyzer is not None assert resolved.spec.analyzer("ABC-123") == ["ABC-123"] - def test_pattern_normalizer_is_ascii_fold_only_no_stemming(self) -> None: - registry = get_field_registry(None) - ref = registry.make_ref("title") - assert ref is not None - resolved = registry.resolve(ref) - assert resolved is not None + def test_pattern_normalizer_is_ascii_fold_only_no_stemming( + self, + registry: FieldRegistry, + ) -> None: + resolved = _resolve(registry, "title") assert resolved.spec.pattern_normalizer is not None # "running" must NOT be stemmed to "run" by the pattern normalizer, # only case/accent-folded — even with English stemming configured. registry_en = get_field_registry("en") - ref_en = registry_en.make_ref("title") - assert ref_en is not None - resolved_en = registry_en.resolve(ref_en) - assert resolved_en is not None + resolved_en = _resolve(registry_en, "title") + assert resolved_en.spec.pattern_normalizer is not None assert resolved_en.spec.pattern_normalizer("Running") == "running" def test_registry_is_cached_per_language(self) -> None: