Add more type hints to test suite

Author: dwoz

tests/test_module_imports.py

@@ -1,15 +1,18 @@
 # Copyright 2025 Broadcom.
 # SPDX-License-Identifier: Apache-2.0
 #
+from __future__ import annotations
+
 import importlib
 import pathlib
+from typing import List
 
 import pytest
 
 
-def _top_level_modules():
+def _top_level_modules() -> List[pytest.ParameterSet]:
     relenv_dir = pathlib.Path(__file__).resolve().parents[1] / "relenv"
-    params = []
+    params: List[pytest.ParameterSet] = []
     for path in sorted(relenv_dir.iterdir()):
         if not path.is_file() or path.suffix != ".py":
             continue

tests/test_pyversions_runtime.py

@@ -1,54 +1,60 @@
 # Copyright 2025 Broadcom.
 # SPDX-License-Identifier: Apache-2.0
 #
+from __future__ import annotations
+
 import hashlib
+import pathlib
 import subprocess
+from typing import Dict
+
+import pytest
 
 from relenv import pyversions
 
 
-def test_python_versions_returns_versions():
-    versions = pyversions.python_versions()
+def test_python_versions_returns_versions() -> None:
+    versions: Dict[pyversions.Version, str] = pyversions.python_versions()
     assert versions, "python_versions() should return known versions"
     first_version = next(iter(versions))
     assert isinstance(first_version, pyversions.Version)
     assert isinstance(versions[first_version], str)
 
 
-def test_python_versions_filters_minor():
+def test_python_versions_filters_minor() -> None:
     versions = pyversions.python_versions("3.11")
     assert versions
     assert all(version.major == 3 and version.minor == 11 for version in versions)
     sorted_versions = sorted(versions)
     assert sorted_versions[-1] in versions
 
 
-def test_release_urls_handles_old_versions():
+def test_release_urls_handles_old_versions() -> None:
     tarball, signature = pyversions._release_urls(pyversions.Version("3.1.3"))
     assert tarball.endswith(".tar.xz")
     assert signature is not None
 
 
-def test_release_urls_no_signature_before_23():
+def test_release_urls_no_signature_before_23() -> None:
     tarball, signature = pyversions._release_urls(pyversions.Version("2.2.3"))
     assert tarball.endswith(".tar.xz")
     assert signature is None
 
 
-def test_ref_version_and_path_helpers():
+def test_ref_version_and_path_helpers() -> None:
     html = '<a href="download/Python-3.11.9.tgz">Python 3.11.9</a>'
     version = pyversions._ref_version(html)
     assert str(version) == "3.11.9"
     assert pyversions._ref_path(html) == "download/Python-3.11.9.tgz"
 
 
-def test_digest(tmp_path):
+def test_digest(tmp_path: pathlib.Path) -> None:
     file = tmp_path / "data.bin"
     file.write_bytes(b"abc")
     assert pyversions.digest(file) == hashlib.sha1(b"abc").hexdigest()
 
 
-def test_get_keyid_parses_second_line():
+def test_get_keyid_parses_second_line() -> None:
     proc = subprocess.CompletedProcess(
         ["gpg"],
         1,
@@ -58,20 +64,24 @@ def test_get_keyid_parses_second_line():
     assert pyversions._get_keyid(proc) == "CB1234"
 
 
-def test_verify_signature_success(monkeypatch, tmp_path):
-    called = {}
+def test_verify_signature_success(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    called: Dict[str, list[str]] = {}
 
     def fake_run(cmd, **kwargs):
-        called["cmd"] = cmd
+        called.setdefault("cmd", []).extend(cmd)
         return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
 
     monkeypatch.setattr(pyversions.subprocess, "run", fake_run)
     assert pyversions.verify_signature("archive.tgz", "archive.tgz.asc") is True
     assert called["cmd"][0] == "gpg"
 
 
-def test_verify_signature_failure_with_missing_key(monkeypatch):
-    responses = []
+def test_verify_signature_failure_with_missing_key(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    responses: list[str] = []
 
     def fake_run(cmd, **kwargs):
         if len(responses) == 0:

tests/test_relocate_module.py

@@ -1,27 +1,32 @@
 # Copyright 2025 Broadcom.
 # SPDX-License-Identifier: Apache-2.0
 #
+from __future__ import annotations
+
 import os
 import pathlib
 import shutil
 import subprocess
+from typing import Dict, List
+
+import pytest
 
 from relenv import relocate
 
 
-def test_is_elf_on_text_file(tmp_path):
+def test_is_elf_on_text_file(tmp_path: pathlib.Path) -> None:
     sample = tmp_path / "sample.txt"
     sample.write_text("not an ELF binary\n")
     assert relocate.is_elf(sample) is False
 
 
-def test_is_macho_on_text_file(tmp_path):
+def test_is_macho_on_text_file(tmp_path: pathlib.Path) -> None:
     sample = tmp_path / "sample.txt"
     sample.write_text("plain text\n")
     assert relocate.is_macho(sample) is False
 
 
-def test_parse_readelf_output():
+def test_parse_readelf_output() -> None:
     output = """
  0x000000000000000f (NEEDED)             Shared library: [libc.so.6]
  0x000000000000001d (RUNPATH)            Library runpath: [/usr/lib:/opt/lib]
@@ -30,7 +35,7 @@ def test_parse_readelf_output():
     assert result == ["/usr/lib", "/opt/lib"]
 
 
-def test_parse_otool_output_extracts_rpaths():
+def test_parse_otool_output_extracts_rpaths() -> None:
     sample_output = """
 Load command 0
       cmd LC_LOAD_DYLIB
@@ -46,7 +51,9 @@ def test_parse_otool_output_extracts_rpaths():
     assert parsed[relocate.LC_RPATH] == ["@loader_path/../lib"]
 
 
-def test_patch_rpath_adds_new_entry(monkeypatch, tmp_path):
+def test_patch_rpath_adds_new_entry(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     binary = tmp_path / "prog"
     binary.write_text("dummy")
 
@@ -56,10 +63,12 @@ def test_patch_rpath_adds_new_entry(monkeypatch, tmp_path):
         lambda path: ["$ORIGIN/lib", "/abs/lib"],
     )
 
-    recorded = {}
+    recorded: Dict[str, List[str]] = {}
 
-    def fake_run(cmd, **kwargs):
-        recorded["cmd"] = cmd
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        recorded.setdefault("cmd", []).extend(cmd)
         return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
 
     monkeypatch.setattr(relocate.subprocess, "run", fake_run)
@@ -69,13 +78,15 @@ def fake_run(cmd, **kwargs):
     assert pathlib.Path(recorded["cmd"][-1]) == binary
 
 
-def test_patch_rpath_skips_when_present(monkeypatch, tmp_path):
+def test_patch_rpath_skips_when_present(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     binary = tmp_path / "prog"
     binary.write_text("dummy")
 
     monkeypatch.setattr(relocate, "parse_rpath", lambda path: ["$ORIGIN/lib"])
 
-    def fail_run(*_args, **_kwargs):
+    def fail_run(*_args: object, **_kwargs: object) -> None:
         raise AssertionError("patchelf should not be invoked")
 
     monkeypatch.setattr(relocate.subprocess, "run", fail_run)
@@ -84,7 +95,9 @@ def fail_run(*_args, **_kwargs):
     assert result == "$ORIGIN/lib"
 
 
-def test_handle_elf_sets_rpath(monkeypatch, tmp_path):
+def test_handle_elf_sets_rpath(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     bin_dir = tmp_path / "bin"
     lib_dir = tmp_path / "lib"
     bin_dir.mkdir()
@@ -95,7 +108,9 @@ def test_handle_elf_sets_rpath(monkeypatch, tmp_path):
     resident = lib_dir / "libfoo.so"
     resident.write_text("library")
 
-    def fake_run(cmd, **kwargs):
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
         if cmd[0] == "ldd":
             stdout = f"libfoo.so => {resident} (0x00007)\nlibc.so.6 => /lib/libc.so.6 (0x00007)\n"
             return subprocess.CompletedProcess(
@@ -105,9 +120,9 @@ def fake_run(cmd, **kwargs):
 
     monkeypatch.setattr(relocate.subprocess, "run", fake_run)
 
-    captured = {}
+    captured: Dict[str, str] = {}
 
-    def fake_patch_rpath(path, relpath):
+    def fake_patch_rpath(path: str, relpath: str) -> str:
         captured["path"] = path
         captured["relpath"] = relpath
         return relpath
@@ -125,21 +140,27 @@ def fake_patch_rpath(path, relpath):
     assert captured["relpath"] == expected_rpath
 
 
-def test_patch_rpath_failure(monkeypatch, tmp_path):
+def test_patch_rpath_failure(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     binary = tmp_path / "prog"
     binary.write_text("dummy")
 
     monkeypatch.setattr(relocate, "parse_rpath", lambda path: [])
 
-    def fake_run(cmd, **kwargs):
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
         return subprocess.CompletedProcess(cmd, 1, stdout=b"", stderr=b"err")
 
     monkeypatch.setattr(relocate.subprocess, "run", fake_run)
 
     assert relocate.patch_rpath(binary, "$ORIGIN/lib") is False
 
 
-def test_parse_macho_non_object(monkeypatch, tmp_path):
+def test_parse_macho_non_object(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     output = "foo: is not an object file\n"
     monkeypatch.setattr(
         relocate.subprocess,
@@ -151,7 +172,9 @@ def test_parse_macho_non_object(monkeypatch, tmp_path):
     assert relocate.parse_macho(tmp_path / "lib.dylib") is None
 
 
-def test_handle_macho_copies_when_needed(monkeypatch, tmp_path):
+def test_handle_macho_copies_when_needed(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     binary = tmp_path / "bin" / "prog"
     binary.parent.mkdir()
     binary.write_text("exe")
@@ -178,10 +201,12 @@ def test_handle_macho_copies_when_needed(monkeypatch, tmp_path):
         shutil, "copymode", lambda src, dst: copied.setdefault("copymode", (src, dst))
     )
 
-    recorded = {}
+    recorded: Dict[str, List[str]] = {}
 
-    def fake_run(cmd, **kwargs):
-        recorded["cmd"] = cmd
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        recorded.setdefault("cmd", []).extend(cmd)
         return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
 
     monkeypatch.setattr(relocate.subprocess, "run", fake_run)
@@ -193,7 +218,9 @@ def fake_run(cmd, **kwargs):
     assert recorded["cmd"][0] == "install_name_tool"
 
 
-def test_handle_macho_rpath_only(monkeypatch, tmp_path):
+def test_handle_macho_rpath_only(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
     binary = tmp_path / "bin" / "prog"
     binary.parent.mkdir()
     binary.write_text("exe")
@@ -218,7 +245,9 @@ def test_handle_macho_rpath_only(monkeypatch, tmp_path):
     monkeypatch.setattr(shutil, "copy", lambda *_args, **_kw: (_args, _kw))
     monkeypatch.setattr(shutil, "copymode", lambda *_args, **_kw: (_args, _kw))
 
-    def fake_run(cmd, **kwargs):
+    def fake_run(
+        cmd: List[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[bytes]:
         if cmd[0] == "install_name_tool":
             raise AssertionError("install_name_tool should not run in rpath_only mode")
         return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")