enhance testability of setuptools integration points

- enable dependency injecting supposed pyporject data
- migrate tests to ue the api directly instead of writing

Author: RonnyPfannschmidt

src/setuptools_scm/_integration/setuptools.py

@@ -8,6 +8,7 @@
 
 import setuptools
 
+from .pyproject_reading import PyProjectData
 from .pyproject_reading import read_pyproject
 from .setup_cfg import _dist_name_from_legacy
 from .version_inference import get_version_inference_config
@@ -64,6 +65,8 @@ def version_keyword(
     dist: setuptools.Distribution,
     keyword: str,
     value: bool | dict[str, Any] | Callable[[], dict[str, Any]],
+    *,
+    _given_pyproject_data: PyProjectData | None = None,
 ) -> None:
     """apply version infernce when setup(use_scm_version=...) is used
     this takes priority over the finalize_options based version
@@ -83,11 +86,16 @@ def version_keyword(
     was_set_by_infer = getattr(dist, "_setuptools_scm_version_set_by_infer", False)
 
     # Get pyproject data
-    try:
-        pyproject_data = read_pyproject(missing_section_ok=True, missing_file_ok=True)
-    except (LookupError, ValueError) as e:
-        log.debug("Configuration issue in pyproject.toml: %s", e)
-        return
+    if _given_pyproject_data is not None:
+        pyproject_data = _given_pyproject_data
+    else:
+        try:
+            pyproject_data = read_pyproject(
+                missing_section_ok=True, missing_file_ok=True
+            )
+        except (LookupError, ValueError) as e:
+            log.debug("Configuration issue in pyproject.toml: %s", e)
+            return
 
     result = get_version_inference_config(
         dist_name=dist_name,
@@ -100,7 +108,9 @@ def version_keyword(
     result.apply(dist)
 
 
-def infer_version(dist: setuptools.Distribution) -> None:
+def infer_version(
+    dist: setuptools.Distribution, *, _given_pyproject_data: PyProjectData | None = None
+) -> None:
     """apply version inference from the finalize_options hook
     this is the default for pyproject.toml based projects that don't use the use_scm_version keyword
 
@@ -112,14 +122,17 @@ def infer_version(dist: setuptools.Distribution) -> None:
 
     dist_name = _dist_name_from_legacy(dist)
 
-    try:
-        pyproject_data = read_pyproject(missing_section_ok=True)
-    except FileNotFoundError:
-        log.debug("pyproject.toml not found, skipping infer_version")
-        return
-    except (LookupError, ValueError) as e:
-        log.debug("Configuration issue in pyproject.toml: %s", e)
-        return
+    if _given_pyproject_data is not None:
+        pyproject_data = _given_pyproject_data
+    else:
+        try:
+            pyproject_data = read_pyproject(missing_section_ok=True)
+        except FileNotFoundError:
+            log.debug("pyproject.toml not found, skipping infer_version")
+            return
+        except (LookupError, ValueError) as e:
+            log.debug("Configuration issue in pyproject.toml: %s", e)
+            return
 
     result = get_version_inference_config(
         dist_name=dist_name,

testing/test_integration.py

@@ -1037,33 +1037,28 @@ def test_infer_version_with_build_requires_no_tool_section(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test that infer_version works when setuptools-scm is in build_requires but no [tool.setuptools_scm] section"""
-    if sys.version_info < (3, 11):
-        pytest.importorskip("tomli")
-
     # Set up a git repository with a tag
     wd.commit_testfile("test")
     wd("git tag 1.0.0")
     monkeypatch.chdir(wd.cwd)
 
-    # Create a pyproject.toml file with setuptools_scm in build-system.requires but NO [tool.setuptools_scm] section
-    pyproject_content = """
-[build-system]
-requires = ["setuptools>=80", "setuptools_scm>=8"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "test-package-infer-version"
-dynamic = ["version"]
-"""
-    wd.write("pyproject.toml", pyproject_content)
-
+    from setuptools_scm._integration.pyproject_reading import PyProjectData
     from setuptools_scm._integration.setuptools import infer_version
 
+    # Create pyproject data: setuptools_scm required, no tool section, project with dynamic=['version']
+    pyproject_data = PyProjectData.for_testing(
+        is_required=True,
+        section_present=False,
+        project_present=True,
+        project_name="test-package-infer-version",
+        has_dynamic_version=True,
+    )
+
     # Create clean distribution
     dist = create_clean_distribution("test-package-infer-version")
 
-    # Call infer_version - this should work because setuptools_scm is in build-system.requires
-    infer_version(dist)
+    # Call infer_version with direct data injection - no file I/O!
+    infer_version(dist, _given_pyproject_data=pyproject_data)
 
     # Verify that version was set
     assert dist.metadata.version is not None
@@ -1077,33 +1072,28 @@ def test_infer_version_with_build_requires_dash_variant_no_tool_section(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test that infer_version works when setuptools-scm (dash variant) is in build_requires but no [tool.setuptools_scm] section"""
-    if sys.version_info < (3, 11):
-        pytest.importorskip("tomli")
-
     # Set up a git repository with a tag
     wd.commit_testfile("test")
     wd("git tag 1.0.0")
     monkeypatch.chdir(wd.cwd)
 
-    # Create a pyproject.toml file with setuptools-scm (dash variant) in build-system.requires but NO [tool.setuptools_scm] section
-    pyproject_content = """
-[build-system]
-requires = ["setuptools>=80", "setuptools-scm>=8"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "test-package-infer-version-dash"
-dynamic = ["version"]
-"""
-    wd.write("pyproject.toml", pyproject_content)
-
+    from setuptools_scm._integration.pyproject_reading import PyProjectData
     from setuptools_scm._integration.setuptools import infer_version
 
+    # Create pyproject data: setuptools-scm required, no tool section, project with dynamic=['version']
+    pyproject_data = PyProjectData.for_testing(
+        is_required=True,
+        section_present=False,
+        project_present=True,
+        project_name="test-package-infer-version-dash",
+        has_dynamic_version=True,
+    )
+
     # Create clean distribution
     dist = create_clean_distribution("test-package-infer-version-dash")
 
-    # Call infer_version - this should work because setuptools-scm is in build-system.requires
-    infer_version(dist)
+    # Call infer_version with direct data injection - no file I/O!
+    infer_version(dist, _given_pyproject_data=pyproject_data)
 
     # Verify that version was set
     assert dist.metadata.version is not None
@@ -1117,32 +1107,28 @@ def test_infer_version_without_build_requires_no_tool_section_silently_returns(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test that infer_version silently returns when setuptools-scm is NOT in build_requires and no [tool.setuptools_scm] section"""
-    if sys.version_info < (3, 11):
-        pytest.importorskip("tomli")
-
     # Set up a git repository with a tag
     wd.commit_testfile("test")
     wd("git tag 1.0.0")
     monkeypatch.chdir(wd.cwd)
 
-    # Create a pyproject.toml file WITHOUT setuptools_scm in build-system.requires and NO [tool.setuptools_scm] section
-    pyproject_content = """
-[build-system]
-requires = ["setuptools>=80", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "test-package-no-scm"
-dynamic = ["version"]
-"""
-    wd.write("pyproject.toml", pyproject_content)
-
+    from setuptools_scm._integration.pyproject_reading import PyProjectData
     from setuptools_scm._integration.setuptools import infer_version
 
+    # Create pyproject data: setuptools-scm NOT required, no tool section, project with dynamic=['version']
+    pyproject_data = PyProjectData.for_testing(
+        is_required=False,  # This is the key: NOT in build-system.requires
+        section_present=False,
+        project_present=True,
+        project_name="test-package-no-scm",
+        has_dynamic_version=True,
+    )
+
     # Create clean distribution
     dist = create_clean_distribution("test-package-no-scm")
 
-    infer_version(dist)
+    # Call infer_version with direct data injection - should silently return
+    infer_version(dist, _given_pyproject_data=pyproject_data)
     assert dist.metadata.version is None
 
 
@@ -1154,27 +1140,25 @@ def test_version_keyword_no_scm_dependency_works(
     wd("git tag 1.0.0")
     monkeypatch.chdir(wd.cwd)
 
-    # Create a pyproject.toml file WITHOUT setuptools_scm in build-system.requires
-    # and WITHOUT [tool.setuptools_scm] section
-    pyproject_content = """
-[build-system]
-requires = ["setuptools>=80"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "test-package-no-scm"
-dynamic = ["version"]
-"""
-    wd.write("pyproject.toml", pyproject_content)
-
     import setuptools
 
+    from setuptools_scm._integration.pyproject_reading import PyProjectData
     from setuptools_scm._integration.setuptools import version_keyword
 
+    # Create pyproject data: setuptools-scm NOT required, no tool section, project with dynamic=['version']
+    pyproject_data = PyProjectData.for_testing(
+        is_required=False,  # This is the key: NOT in build-system.requires
+        section_present=False,
+        project_present=True,
+        project_name="test-package-no-scm",
+        has_dynamic_version=True,
+    )
+
     # Create distribution
     dist = setuptools.Distribution({"name": "test-package-no-scm"})
 
-    version_keyword(dist, "use_scm_version", True)
+    # Call version_keyword with direct data injection - should work regardless of config
+    version_keyword(dist, "use_scm_version", True, _given_pyproject_data=pyproject_data)
     assert dist.metadata.version == "1.0.0"
 
 
@@ -1242,33 +1226,28 @@ def test_infer_version_logs_debug_when_missing_dynamic_version(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """Test that infer_version gracefully handles and logs debug info when setuptools-scm is in build-system.requires but dynamic=['version'] is missing"""
-    if sys.version_info < (3, 11):
-        pytest.importorskip("tomli")
-
     # Set up a git repository with a tag
     wd.commit_testfile("test")
     wd("git tag 1.0.0")
     monkeypatch.chdir(wd.cwd)
 
-    # Create a pyproject.toml file with setuptools-scm in build-system.requires but NO dynamic=['version']
-    pyproject_content = """
-[build-system]
-requires = ["setuptools>=80", "setuptools-scm>=8"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "test-package-missing-dynamic"
-# Missing: dynamic = ["version"]
-"""
-    wd.write("pyproject.toml", pyproject_content)
-
+    from setuptools_scm._integration.pyproject_reading import PyProjectData
     from setuptools_scm._integration.setuptools import infer_version
 
+    # Create pyproject data: setuptools-scm required, project present, but no dynamic=['version']
+    pyproject_data = PyProjectData.for_testing(
+        is_required=True,
+        section_present=False,
+        project_present=True,
+        project_name="test-package-missing-dynamic",
+        has_dynamic_version=False,  # This is the key: missing dynamic=['version']
+    )
+
     # Create clean distribution
     dist = create_clean_distribution("test-package-missing-dynamic")
 
-    # This should not raise an error, but should log debug info about the configuration issue
-    infer_version(dist)
+    # This should not raise an error, but should silently return (the configuration issue is handled internally)
+    infer_version(dist, _given_pyproject_data=pyproject_data)
 
     # Verify that version was not set due to configuration issue
     assert dist.metadata.version is None