Keep only the lazy import test that is about this package.

Asserting that attribute access on a lazy name reaches the module
exercises the import machinery and not anything here, so it goes; the
import time it stood for is what the perf exercises already watch.

The localize regression moves to tests/compat, beside the module it
covers and out of the suite that syncs to the stdlib, which has no
_compat to localize for. What stays in the shared suite is that the
lazy modules go unloaded, now named for the declaration it reads.

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

Author: jaraco

tests/compat/test_localize.py

@@ -5,6 +5,7 @@
 
 import importlib.metadata as stdlib
 import pathlib
+import subprocess
 import sys
 import unittest
 import warnings
@@ -177,3 +178,38 @@ def metadata(self):
             warnings.simplefilter('always')
             assert localize.dist(hostile) is hostile
         assert not [str(warning.message) for warning in caught]
+
+
+class LazyAdaptersTests(unittest.TestCase):
+    """
+    Adapting a message withstands the adapters being imported lazily.
+    """
+
+    def test_adapted_message_passes_through(self):
+        """
+        An already adapted message survives localization unchanged.
+
+        ``localize.message`` tests the message with ``isinstance``,
+        reaching the class through a lazily imported module so that the
+        name resolves first. Were the class the lazy name itself, before
+        3.15 it would be a proxy, which answers as no match however the
+        object relates to it, and the message would be adapted a second
+        time. Run as a subprocess because reading a lazy name resolves it
+        for good, which any other test would do first.
+
+        Ref python/importlib_metadata#554.
+        """
+        script = (
+            'import email.message, importlib; '
+            'from importlib_metadata._compat import localize; '
+            'adapters = importlib.import_module("importlib_metadata._adapters"); '
+            'msg = adapters.Message(email.message.Message()); '
+            'print(localize.message(msg) is msg)'
+        )
+        proc = subprocess.run(
+            [sys.executable, '-c', script],
+            capture_output=True,
+            encoding='utf-8',
+            check=True,
+        )
+        assert proc.stdout.strip() == 'True', 'the message was adapted twice'

tests/test_main.py

@@ -115,9 +115,9 @@ class LazyImportTests(unittest.TestCase):
     The imports at module scope cost no more than the deferred ones did.
     """
 
-    def test_declared_modules_stay_unloaded(self):
+    def test_lazy_modules_stay_unloaded(self):
         """
-        Importing the package loads none of the modules it declares lazy.
+        Importing the package loads none of its ``__lazy_modules__``.
 
         ``importlib.abc`` goes first because the package imports it
         eagerly and, on some Pythons, it reaches ``inspect`` through
@@ -139,46 +139,6 @@ def test_declared_modules_stay_unloaded(self):
         )
         assert not proc.stdout.split(), f'imported eagerly: {proc.stdout.strip()}'
 
-    def test_reading_through_a_lazy_name(self):
-        """
-        Attribute access on a lazy name reaches the real module.
-
-        Note that the name itself need not be the module: before 3.15 the
-        backport binds a proxy that passes attribute access through, so
-        this holds while ``is`` comparison against the module does not.
-        """
-        assert importlib_metadata.csv.reader is importlib.import_module('csv').reader
-        assert isinstance(importlib_metadata.json.loads('{}'), dict)
-        assert importlib_metadata.inspect.getmodulename('f.py') == 'f'
-
-    def test_adapted_message_passes_through(self):
-        """
-        An already adapted message survives localization unchanged.
-
-        ``localize.message`` tests it with ``isinstance``, reaching the
-        class through a lazy module so that the name resolves first. A
-        proxy named directly answers as no match however the object
-        relates to it, and the message would be adapted a second time.
-        Run as a subprocess because reading a lazy name resolves it for
-        good, which every other test here would do first.
-
-        Ref python/importlib_metadata#554.
-        """
-        script = (
-            'import email.message, importlib; '
-            'from importlib_metadata._compat import localize; '
-            'adapters = importlib.import_module("importlib_metadata._adapters"); '
-            'msg = adapters.Message(email.message.Message()); '
-            'print(localize.message(msg) is msg)'
-        )
-        proc = subprocess.run(
-            [sys.executable, '-c', script],
-            capture_output=True,
-            encoding='utf-8',
-            check=True,
-        )
-        assert proc.stdout.strip() == 'True', 'the message was adapted twice'
-
 
 class NameNormalizationTests(fixtures.OnSysPath, fixtures.SiteDir, unittest.TestCase):
     @staticmethod