harden test_version_from git and more type fixes

Author: RonnyPfannschmidt

testing/test_git.py

@@ -4,11 +4,14 @@
 from datetime import datetime
 from datetime import timezone
 from os.path import join as opj
+from textwrap import dedent
+from typing import Dict
 from unittest.mock import Mock
 from unittest.mock import patch
 
 import pytest
 
+from .wd_wrapper import WorkDir
 from setuptools_scm import Configuration
 from setuptools_scm import format_version
 from setuptools_scm import git
@@ -19,7 +22,6 @@
 from setuptools_scm.utils import do
 from setuptools_scm.utils import has_command
 
-
 pytestmark = pytest.mark.skipif(
     not has_command("git", warn=False), reason="git executable not found"
 )
@@ -58,11 +60,11 @@ def test_root_relative_to(tmpdir, wd, monkeypatch):
                        "relative_to": __file__})
 """
     )
-    res = do((sys.executable, "setup.py", "--version"), p)
+    res = do([sys.executable, "setup.py", "--version"], p)
     assert res == "0.1.dev0"
 
 
-def test_root_search_parent_directories(tmpdir, wd, monkeypatch):
+def test_root_search_parent_directories(tmpdir, wd: WorkDir, monkeypatch):
     monkeypatch.delenv("SETUPTOOLS_SCM_DEBUG")
     p = wd.cwd.joinpath("sub/package")
     p.mkdir(parents=True)
@@ -71,7 +73,7 @@ def test_root_search_parent_directories(tmpdir, wd, monkeypatch):
 setup(use_scm_version={"search_parent_directories": True})
 """
     )
-    res = do((sys.executable, "setup.py", "--version"), p)
+    res = do([sys.executable, "setup.py", "--version"], p)
     assert res == "0.1.dev0"
 
 
@@ -137,60 +139,59 @@ def test_version_from_git(wd):
     )
 
 
-@pytest.mark.parametrize("with_class", [False, type, str])
-def test_git_version_unnormalized_setuptools(with_class, tmpdir, wd, monkeypatch):
+setup_py_with_normalize: Dict[str, str] = {
+    "false": """
+        from setuptools import setup
+        setup(use_scm_version={'normalize': False, 'write_to': 'VERSION.txt'})
+        """,
+    "with_created_class": """
+        from setuptools import setup
+
+        class MyVersion:
+            def __init__(self, tag_str: str):
+                self.version = tag_str
+
+            def __repr__(self):
+                return self.version
+
+        setup(use_scm_version={'version_cls': MyVersion, 'write_to': 'VERSION.txt'})
+        """,
+    "with_named_import": """
+        from setuptools import setup
+        setup(use_scm_version={
+            'version_cls': 'setuptools_scm.NonNormalizedVersion',
+            'write_to': 'VERSION.txt'
+        })
+        """,
+}
+
+
+@pytest.mark.parametrize(
+    "setup_py_txt",
+    [pytest.param(text, id=key) for key, text in setup_py_with_normalize.items()],
+)
+def test_git_version_unnormalized_setuptools(
+    setup_py_txt: str, wd: WorkDir, monkeypatch
+):
     """
     Test that when integrating with setuptools without normalization,
     the version is not normalized in write_to files,
     but still normalized by setuptools for the final dist metadata.
     """
     monkeypatch.delenv("SETUPTOOLS_SCM_DEBUG")
-    p = wd.cwd
-
-    # create a setup.py
-    dest_file = str(tmpdir.join("VERSION.txt")).replace("\\", "/")
-    if with_class is False:
-        # try normalize = False
-        setup_py = """
-from setuptools import setup
-setup(use_scm_version={'normalize': False, 'write_to': '%s'})
-"""
-    elif with_class is type:
-        # custom non-normalizing class
-        setup_py = """
-from setuptools import setup
-
-class MyVersion:
-    def __init__(self, tag_str: str):
-        self.version = tag_str
-
-    def __repr__(self):
-        return self.version
-
-setup(use_scm_version={'version_cls': MyVersion, 'write_to': '%s'})
-"""
-    elif with_class is str:
-        # non-normalizing class referenced by name
-        setup_py = """from setuptools import setup
-setup(use_scm_version={
-    'version_cls': 'setuptools_scm.NonNormalizedVersion',
-    'write_to': '%s'
-})
-"""
 
-    # finally write the setup.py file
-    p.joinpath("setup.py").write_text(setup_py % dest_file)
+    wd.write("setup.py", dedent(setup_py_txt))
 
     # do git operations and tag
     wd.commit_testfile()
     wd("git tag 17.33.0-rc1")
 
     # setuptools still normalizes using packaging.Version (removing the dash)
-    res = do((sys.executable, "setup.py", "--version"), p)
+    res = wd([sys.executable, "setup.py", "--version"])
     assert res == "17.33.0rc1"
 
     # but the version tag in the file is non-normalized (with the dash)
-    assert tmpdir.join("VERSION.txt").read() == "17.33.0-rc1"
+    assert wd.cwd.joinpath("VERSION.txt").read_text() == "17.33.0-rc1"
 
 
 @pytest.mark.issue(179)

testing/wd_wrapper.py

@@ -1,5 +1,6 @@
 import itertools
 from pathlib import Path
+from typing import List
 
 
 class WorkDir:
@@ -12,20 +13,22 @@ class WorkDir:
     def __repr__(self):
         return f"<WD {self.cwd}>"
 
-    def __init__(self, cwd: Path):
+    def __init__(self, cwd: Path) -> None:
         self.cwd = cwd
         self.__counter = itertools.count()
 
-    def __call__(self, cmd, **kw):
+    def __call__(self, cmd: "List[str] | str", **kw):
         if kw:
+            assert isinstance(cmd, str), "formatting the command requires text input"
             cmd = cmd.format(**kw)
         from setuptools_scm.utils import do
 
         return do(cmd, self.cwd)
 
-    def write(self, name, value, **kw):
+    def write(self, name: str, value: "str | bytes", **kw: object) -> Path:
         filename = self.cwd / name
         if kw:
+            assert isinstance(value, str)
             value = value.format(**kw)
         if isinstance(value, bytes):
             filename.write_bytes(value)
@@ -39,22 +42,22 @@ def _reason(self, given_reason: "str | None") -> str:
         else:
             return given_reason
 
-    def add_and_commit(self, reason=None, **kwargs):
+    def add_and_commit(self, reason: "str | None" = None, **kwargs):
         self(self.add_command)
         self.commit(reason, **kwargs)
 
-    def commit(self, reason=None, signed=False):
+    def commit(self, reason: "str | None" = None, signed: bool = False) -> None:
         reason = self._reason(reason)
         self(
             self.commit_command if not signed else self.signed_commit_command,
             reason=reason,
         )
 
-    def commit_testfile(self, reason=None, **kwargs):
+    def commit_testfile(self, reason: "str | None" = None, signed: bool = False):
         reason = self._reason(reason)
         self.write("test.txt", "test {reason}", reason=reason)
         self(self.add_command)
-        self.commit(reason=reason, **kwargs)
+        self.commit(reason=reason, signed=signed)
 
     def get_version(self, **kw):
         __tracebackhide__ = True