test: isolate global CONSTANTS collection mutations in conftest

The autouse fixture only snapshotted scalar config attrs, so tests that
mutate a global collection (e.g. CONSTANTS.titles) relied on manual,
non-exception-safe cleanup. If such a test failed before its cleanup ran,
the mutation leaked into later tests — reintroducing the order-dependence
the fixture was meant to eliminate.

Snapshot and restore the collection managers (SetManager / TupleManager /
RegexTupleManager) too, via a small type-aware clone (deepcopy can't
round-trip RegexTupleManager's compiled patterns), and reset the lazy
_pst cache so it recomputes from the restored collections. The manual
cleanup in test_can_change_global_constants is now redundant and removed.

Verified order-independence across randomized seeds and via an injected
test that mutates a global collection then fails before cleanup: the
following test still sees pristine config.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: derek73

tests/conftest.py

@@ -2,7 +2,9 @@
 
 import pytest
 
-from nameparser.config import CONSTANTS
+from nameparser.config import CONSTANTS, SetManager, TupleManager
+
+ConfigCollection = SetManager | TupleManager
 
 # Scalar (non-collection) config attributes that individual tests mutate on the
 # global CONSTANTS singleton. Several tests change these without restoring them;
@@ -19,6 +21,36 @@
     "force_mixed_case_capitalization",
 )
 
+# Collection config attributes (the SetManager / TupleManager constants). Tests
+# that customize the global CONSTANTS — e.g. adding or removing a title — mutate
+# these in place, so a shallow snapshot of the reference would not protect later
+# tests. We snapshot independent copies and restore them, making collection
+# mutations order-independent too.
+_COLLECTION_CONFIG_ATTRS = (
+    "prefixes",
+    "suffix_acronyms",
+    "suffix_not_acronyms",
+    "titles",
+    "first_name_titles",
+    "conjunctions",
+    "capitalization_exceptions",
+    "regexes",
+)
+
+
+def _clone_config_collection(value: ConfigCollection) -> ConfigCollection:
+    """Return an independent copy of a config collection manager.
+
+    ``copy.deepcopy`` is not used because ``RegexTupleManager`` carries compiled
+    patterns that its ``__reduce__`` cannot round-trip. Rebuilding from the
+    manager's own contents copies the container while sharing the (immutable)
+    elements, which is all the snapshot needs.
+    """
+    if isinstance(value, SetManager):
+        return SetManager(set(value))
+    # TupleManager / RegexTupleManager are dict subclasses.
+    return type(value)(dict(value))
+
 
 @pytest.fixture(autouse=True, params=['', None], ids=['default', 'none'])
 def empty_attribute_default(request: pytest.FixtureRequest) -> Iterator[str | None]:
@@ -27,12 +59,22 @@ def empty_attribute_default(request: pytest.FixtureRequest) -> Iterator[str | No
     Reproduces the original tests.py __main__ block, which ran the whole suite
     twice — once with the default ('') and once with None — as a regression
     check that the three parsing code paths agree. The surrounding snapshot of
-    the scalar CONSTANTS attributes restores any global config a test mutates,
-    so tests do not leak state into one another (the original relied on
-    unittest's alphabetical method ordering to mask such leaks).
+    both the scalar and the collection CONSTANTS attributes restores any global
+    config a test mutates, so tests do not leak state into one another (the
+    original relied on unittest's alphabetical method ordering to mask such
+    leaks).
     """
-    snapshot = {attr: getattr(CONSTANTS, attr) for attr in _SCALAR_CONFIG_ATTRS}
+    scalar_snapshot = {attr: getattr(CONSTANTS, attr) for attr in _SCALAR_CONFIG_ATTRS}
+    collection_snapshot = {
+        attr: _clone_config_collection(getattr(CONSTANTS, attr))
+        for attr in _COLLECTION_CONFIG_ATTRS
+    }
     CONSTANTS.empty_attribute_default = request.param
     yield request.param
-    for attr, value in snapshot.items():
+    for attr, value in scalar_snapshot.items():
+        setattr(CONSTANTS, attr, value)
+    for attr, value in collection_snapshot.items():
         setattr(CONSTANTS, attr, value)
+    # Invalidate the lazily-built suffixes/prefixes/titles cache so it is
+    # recomputed from the restored collections rather than a mutated one.
+    CONSTANTS._pst = None

tests/test_constants.py

@@ -52,8 +52,8 @@ def test_can_change_global_constants(self) -> None:
         self.assertEqual('hon' in hn2.C.titles, False)
         self.assertEqual(hn.has_own_config, False)
         self.assertEqual(hn2.has_own_config, False)
-        # clean up so we don't mess up other tests
-        hn.C.titles.add('hon')
+        # No manual cleanup needed: the autouse fixture in conftest.py snapshots
+        # and restores the global CONSTANTS collections around every test.
 
     def test_remove_multiple_arguments(self) -> None:
         hn = HumanName("Ms Hon Solo", constants=None)