Make API tests generic over packages

Author: johnslavik

tests/test_api.py

@@ -5,38 +5,41 @@
 from collections import defaultdict
 from fnmatch import fnmatch
 from pathlib import Path
+from types import ModuleType
 from typing import TYPE_CHECKING
 
 import pytest
 from mkdocstrings import Inventory
 
 import griffe
+import griffecli
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
 
-@pytest.fixture(name="loader", scope="module")
-def _fixture_loader() -> griffe.GriffeLoader:
+def _load_module(module: ModuleType) -> griffe.GriffeLoader:
     loader = griffe.GriffeLoader(
         extensions=griffe.load_extensions(
             "griffe_inherited_docstrings",
             "unpack_typeddict",
         ),
     )
-    loader.load("griffe")
+    loader.load(module.__name__)
     loader.resolve_aliases()
     return loader
 
 
-@pytest.fixture(name="internal_api", scope="module")
-def _fixture_internal_api(loader: griffe.GriffeLoader) -> griffe.Module:
-    return loader.modules_collection["griffe._internal"]
+def _get_internal_api(module: ModuleType, loader: griffe.GriffeLoader | None = None) -> griffe.Module:
+    if loader is None:
+        loader = _load_module(module)
+    return loader.modules_collection[module.__name__ + "._internal"]
 
 
-@pytest.fixture(name="public_api", scope="module")
-def _fixture_public_api(loader: griffe.GriffeLoader) -> griffe.Module:
-    return loader.modules_collection["griffe"]
+def _get_public_api(module: ModuleType, loader: griffe.GriffeLoader | None = None) -> griffe.Module:
+    if loader is None:
+        loader = _load_module(module)
+    return loader.modules_collection[module.__name__]
 
 
 def _yield_public_objects(
@@ -76,19 +79,12 @@ def _yield_public_objects(
             continue
 
 
-@pytest.fixture(name="modulelevel_internal_objects", scope="module")
-def _fixture_modulelevel_internal_objects(internal_api: griffe.Module) -> list[griffe.Object | griffe.Alias]:
-    return list(_yield_public_objects(internal_api, modulelevel=True))
+def _get_modulelevel_internal_objects(tested_module: ModuleType) -> list[griffe.Object | griffe.Alias]:
+    return list(_yield_public_objects(_get_internal_api(tested_module), modulelevel=True))
 
 
-@pytest.fixture(name="internal_objects", scope="module")
-def _fixture_internal_objects(internal_api: griffe.Module) -> list[griffe.Object | griffe.Alias]:
-    return list(_yield_public_objects(internal_api, modulelevel=False, special=True))
-
-
-@pytest.fixture(name="public_objects", scope="module")
-def _fixture_public_objects(public_api: griffe.Module) -> list[griffe.Object | griffe.Alias]:
-    return list(_yield_public_objects(public_api, modulelevel=False, inherited=True, special=True))
+def _get_public_objects(tested_module: ModuleType) -> list[griffe.Object | griffe.Alias]:
+    return list(_yield_public_objects(_get_public_api(tested_module), modulelevel=False, inherited=True, special=True))
 
 
 @pytest.fixture(name="inventory", scope="module")
@@ -100,8 +96,9 @@ def _fixture_inventory() -> Inventory:
         return Inventory.parse_sphinx(file)
 
 
-def test_alias_proxies(internal_api: griffe.Module) -> None:
+def test_alias_proxies() -> None:
     """The Alias class has all the necessary methods and properties."""
+    internal_api = _get_internal_api(griffe)
     alias_members = set(internal_api["models.Alias"].all_members.keys())
     for cls in (
         internal_api["models.Module"],
@@ -114,33 +111,39 @@ def test_alias_proxies(internal_api: griffe.Module) -> None:
                 assert name in alias_members
 
 
-def test_exposed_objects(modulelevel_internal_objects: list[griffe.Object | griffe.Alias]) -> None:
+@pytest.mark.parametrize("tested_module", [griffe, griffecli])
+def test_exposed_objects(tested_module: ModuleType) -> None:
     """All public objects in the internal API are exposed under `griffe`."""
+    modulelevel_internal_objects = _get_modulelevel_internal_objects(tested_module)
     not_exposed = [
         obj.path
         for obj in modulelevel_internal_objects
-        if obj.name not in griffe.__all__ or not hasattr(griffe, obj.name)
+        if obj.name not in tested_module.__all__ or not hasattr(tested_module, obj.name)
     ]
     assert not not_exposed, "Objects not exposed:\n" + "\n".join(sorted(not_exposed))
 
 
-def test_unique_names(modulelevel_internal_objects: list[griffe.Object | griffe.Alias]) -> None:
+@pytest.mark.parametrize("tested_module", [griffe, griffecli])
+def test_unique_names(tested_module: ModuleType) -> None:
     """All internal objects have unique names."""
+    modulelevel_internal_objects = _get_modulelevel_internal_objects(tested_module)
     names_to_paths = defaultdict(list)
     for obj in modulelevel_internal_objects:
         names_to_paths[obj.name].append(obj.path)
     non_unique = [paths for paths in names_to_paths.values() if len(paths) > 1]
     assert not non_unique, "Non-unique names:\n" + "\n".join(str(paths) for paths in non_unique)
 
 
-def test_single_locations(public_api: griffe.Module) -> None:
+@pytest.mark.parametrize("tested_module", [griffe, griffecli])
+def test_single_locations(tested_module: ModuleType) -> None:
     """All objects have a single public location."""
 
     def _public_path(obj: griffe.Object | griffe.Alias) -> bool:
         return obj.is_public and (obj.parent is None or _public_path(obj.parent))
 
+    public_api = _get_public_api(tested_module)
     multiple_locations = {}
-    for obj_name in set(griffe.__all__) - griffe._CLI_MISSING_FEATURES:
+    for obj_name in tested_module.__all__:
         obj = public_api[obj_name]
         if obj.aliases and (
             public_aliases := [path for path, alias in obj.aliases.items() if path != obj.path and _public_path(alias)]
@@ -168,16 +171,19 @@ def test_api_matches_inventory(inventory: Inventory, public_objects: list[griffe
     assert not not_in_inventory, msg.format(paths="\n".join(sorted(not_in_inventory)))
 
 
+@pytest.mark.parametrize("tested_module", [griffe, griffecli])
 def test_inventory_matches_api(
     inventory: Inventory,
     public_objects: list[griffe.Object | griffe.Alias],
-    loader: griffe.GriffeLoader,
+    tested_module: ModuleType,
 ) -> None:
     """The inventory doesn't contain any additional Python object."""
+    loader = _load_module(tested_module)
+    public_api = _get_public_api(tested_module, loader=loader)
+    public_objects = _get_public_objects(public_api)
     not_in_api = []
     public_api_paths = {obj.path for obj in public_objects}
-    public_api_paths.add("griffe")
-    public_api_paths.add("griffecli")
+    public_api_paths.add(tested_module.__name__)
     for item in inventory.values():
         if item.domain == "py" and "(" not in item.name:
             obj = loader.modules_collection[item.name]
@@ -187,13 +193,16 @@ def test_inventory_matches_api(
     assert not not_in_api, msg.format(paths="\n".join(sorted(not_in_api)))
 
 
-def test_no_module_docstrings_in_internal_api(internal_api: griffe.Module) -> None:
+@pytest.mark.parametrize("tested_module", [griffe, griffecli])
+def test_no_module_docstrings_in_internal_api(tested_module: ModuleType) -> None:
     """No module docstrings should be written in our internal API.
 
     The reasoning is that docstrings are addressed to users of the public API,
     but internal modules are not exposed to users, so they should not have docstrings.
     """
 
+    internal_api = _get_internal_api(tested_module)
+
     def _modules(obj: griffe.Module) -> Iterator[griffe.Module]:
         for member in obj.modules.values():
             yield member