fix(tests): fix e2e tests that are failing for release and not running all tests durring regression

Author: markurtz

.detect-secrets.scan.json

@@ -139,5 +139,5 @@
       }
     ]
   },
-  "generated_at": "2026-06-12T09:44:07Z"
+  "generated_at": "2026-06-12T10:03:55Z"
 }

.github/actions/python/tests/action.yml

@@ -24,8 +24,8 @@ inputs:
     required: false
     default: "functional"
   test-category:
-    description: "Test category: smoke, sanity, regression, or all (supports combinations\
-      \ like 'smoke or sanity')"
+    description: "Test category: smoke, sanity, regression, or all (regression/all runs all\
+      \ tests, other categories filter using pytest keyword matching -k)"
     required: false
     default: "all"
   force-run:
@@ -71,8 +71,8 @@ runs:
       env:
         TEST_CATEGORY: ${{ inputs.test-category }}
       run: |-
-        if [ "$TEST_CATEGORY" != "all" ] && [ -n "$TEST_CATEGORY" ]; then
-          echo "args=-m \"$TEST_CATEGORY\"" >> "$GITHUB_OUTPUT"
+        if [ "$TEST_CATEGORY" != "all" ] && [ "$TEST_CATEGORY" != "regression" ] && [ -n "$TEST_CATEGORY" ]; then
+          echo "args=-k \"$TEST_CATEGORY\"" >> "$GITHUB_OUTPUT"
         else
           echo "args=" >> "$GITHUB_OUTPUT"
         fi

pyproject.toml

@@ -261,6 +261,22 @@ builder = true
 template = "python"
 python = "3.10"
 
+[tool.hatch.envs.py311]
+template = "python"
+python = "3.11"
+
+[tool.hatch.envs.py312]
+template = "python"
+python = "3.12"
+
+[tool.hatch.envs.py313]
+template = "python"
+python = "3.13"
+
+[tool.hatch.envs.py314]
+template = "python"
+python = "3.14"
+
 [tool.hatch.envs.python.scripts]
 lint = [
   "ruff check {args:{env:PYTHON_TARGETS}}",

src/gitversioned/compat.py

@@ -1,20 +1,31 @@
-"""
-Compatibility abstractions for optional dependencies.
-
-This module centralizes fallback logic for safely importing optional dependencies
-like ``psutil``, ``opentelemetry``, and TOML parsers. It provides standardized
-access points for these modules, avoiding scattered ``try-except`` blocks across
-the codebase. Maintainers should import optional dependencies from this module
-rather than attempting direct imports elsewhere.
+"""Compatibility abstractions for optional dependencies and packaging errors.
+
+This module centralizes fallback logic for safely importing optional
+dependencies such as ``psutil``, ``opentelemetry``, and TOML parsers.
+By providing standardized module-level variables that resolve to either
+the imported module or ``None``, it prevents scattered ``try-except``
+blocks and import errors across the library.
+
+In addition to optional dependencies, it abstracts differences in
+packaging-related setup exception classes. It resolves and exposes
+tools to check or raise setup errors compatible with both legacy
+``distutils`` and modern ``setuptools``.
 """
 
 from __future__ import annotations
 
 import importlib
 import types
-from typing import Annotated
+from typing import Annotated, NoReturn
 
-__all__ = ["DistutilsSetupError", "maturin", "opentelemetry_trace", "psutil", "tomllib"]
+__all__ = [
+    "is_distutils_setup_error",
+    "maturin",
+    "opentelemetry_trace",
+    "psutil",
+    "raise_distutils_setup_error",
+    "tomllib",
+]
 
 _maturin: types.ModuleType | None = None
 try:
@@ -45,18 +56,86 @@
 except ImportError:
     _psutil = None
 
-_DistutilsSetupError: type[Exception]
-try:
-    import setuptools.errors
 
-    _DistutilsSetupError = setuptools.errors.SetupError
-except ImportError:
+def raise_distutils_setup_error(
+    message: str, from_exception: Exception | None = None
+) -> NoReturn:
+    """Dynamically resolve and raise the appropriate setup error class.
+
+    Resolves the setup error class by attempting to import
+    ``setuptools.errors.SetupError``, falling back to
+    ``distutils.errors.DistutilsSetupError``, and ultimately using the
+    builtin ``Exception`` if neither is available. This avoids import-time
+    monkeypatching race conditions with ``setuptools``.
+
+    Example:
+        >>> try:
+        ...     # Perform some custom setup or build operation
+        ...     pass
+        ... except Exception as err:
+        ...     raise_distutils_setup_error("Setup failed", from_exception=err)
+
+    :param message: The descriptive error message to associate with the
+        raised exception.
+    :param from_exception: An optional exception instance to chain via
+        ``raise ... from``.
+    :raises Exception: The resolved setup error or a standard base
+        ``Exception``.
+    """
     try:
-        import distutils.errors
+        import setuptools.errors  # noqa: PLC0415
 
-        _DistutilsSetupError = distutils.errors.DistutilsSetupError
+        exc_class = setuptools.errors.SetupError
     except ImportError:
-        _DistutilsSetupError = Exception
+        try:
+            import distutils.errors  # noqa: PLC0415
+
+            exc_class = distutils.errors.DistutilsSetupError
+        except ImportError:
+            exc_class = Exception
+
+    if from_exception is not None:
+        raise exc_class(message) from from_exception
+    raise exc_class(message)
+
+
+def is_distutils_setup_error(error: Exception) -> bool:
+    """Verify if an exception instance matches the resolved SetupError.
+
+    Checks the given exception against ``setuptools.errors.SetupError`` and
+    ``distutils.errors.DistutilsSetupError`` if their respective modules
+    can be imported.
+
+    Example:
+        >>> try:
+        ...     # Run packaging tool logic
+        ...     pass
+        ... except Exception as err:
+        ...     if is_distutils_setup_error(err):
+        ...         print("Packaging setup error detected")
+
+    :param error: The exception instance to evaluate.
+    :returns: ``True`` if the error is a setup error instance; otherwise
+        ``False``.
+    """
+    try:
+        import setuptools.errors  # noqa: PLC0415
+
+        if isinstance(error, setuptools.errors.SetupError):
+            return True
+    except ImportError:
+        pass
+
+    try:
+        import distutils.errors  # noqa: PLC0415
+
+        if isinstance(error, distutils.errors.DistutilsSetupError):
+            return True
+    except ImportError:
+        pass
+
+    return False
+
 
 maturin: Annotated[
     types.ModuleType | None,
@@ -83,8 +162,3 @@
     "``pyproject.toml``. Provides the standard library ``tomllib``, the "
     "third-party ``tomli``, or ``None``.",
 ] = _tomllib
-
-DistutilsSetupError: Annotated[
-    type[Exception],
-    "The SetupError exception class resolved from setuptools or distutils.",
-] = _DistutilsSetupError

src/gitversioned/plugins/setuptools_plugin.py

@@ -24,7 +24,7 @@
 from packaging.utils import canonicalize_name
 from setuptools import Distribution
 
-from gitversioned.compat import DistutilsSetupError
+from gitversioned.compat import is_distutils_setup_error, raise_distutils_setup_error
 from gitversioned.logging import autolog, configure_logger, logger
 from gitversioned.settings import Settings
 from gitversioned.utils import BuildEnvironment, GitRepository
@@ -72,11 +72,11 @@ def setup_keywords(distribution: Distribution, attribute: str, value: Any) -> No
 
     if attribute != "gitversioned":
         logger.error(f"Unknown keyword argument: {attribute}")
-        raise DistutilsSetupError(f"Unknown keyword argument: {attribute}")
+        raise_distutils_setup_error(f"Unknown keyword argument: {attribute}")
 
     if not isinstance(value, (dict, bool)):
         logger.error("gitversioned keyword argument must be a dict or bool")
-        raise DistutilsSetupError("gitversioned must be a dict or bool")
+        raise_distutils_setup_error("gitversioned must be a dict or bool")
 
     cast("Any", distribution).gitversioned_config = (
         {} if isinstance(value, bool) else value
@@ -116,7 +116,7 @@ def finalize_distribution_options(distribution: Distribution) -> None:
 
     project_root, source_root, package_name = _resolve_project_context(distribution)
     if not package_name:
-        raise DistutilsSetupError("Could not determine package name.")
+        raise_distutils_setup_error("Could not determine package name.")
 
     # Check for an established version to avoid redundant Git resolution
     established_version = _extract_established_version(distribution, project_root)
@@ -162,10 +162,12 @@ def finalize_distribution_options(distribution: Distribution) -> None:
             )
 
     except Exception as error:
-        if isinstance(error, DistutilsSetupError):
+        if is_distutils_setup_error(error):
             raise
         logger.exception("Unexpected failure during version resolution")
-        raise DistutilsSetupError(f"Failed to resolve version: {error}") from error
+        raise_distutils_setup_error(
+            f"Failed to resolve version: {error}", from_exception=error
+        )
 
 
 @autolog

tests/python/unit/test_compat.py

@@ -44,16 +44,18 @@ def restore_compat_module() -> Any:
 def test_smoke_module_exports() -> None:
     """Verify that compat exposes the expected variables and matches expected types."""
     assert compat.__all__ == [
-        "DistutilsSetupError",
+        "is_distutils_setup_error",
         "maturin",
         "opentelemetry_trace",
         "psutil",
+        "raise_distutils_setup_error",
         "tomllib",
     ]
-    assert hasattr(compat, "DistutilsSetupError")
+    assert hasattr(compat, "is_distutils_setup_error")
     assert hasattr(compat, "maturin")
     assert hasattr(compat, "opentelemetry_trace")
     assert hasattr(compat, "psutil")
+    assert hasattr(compat, "raise_distutils_setup_error")
     assert hasattr(compat, "tomllib")
 
 
@@ -142,3 +144,14 @@ def test_regression_tomllib_all_unavailable(monkeypatch: pytest.MonkeyPatch) ->
     monkeypatch.setitem(sys.modules, "tomli", cast("Any", None))
     importlib.reload(compat)
     assert compat.tomllib is None
+
+
+@pytest.mark.sanity
+def test_raise_and_check_distutils_setup_error() -> None:
+    """Verify raising and checking of distutils setup errors works dynamically."""
+    with pytest.raises(Exception) as exc_info:
+        compat.raise_distutils_setup_error("Test setup error")
+
+    assert compat.is_distutils_setup_error(exc_info.value) is True
+    assert str(exc_info.value) == "Test setup error"
+    assert compat.is_distutils_setup_error(ValueError("Not a setup error")) is False