Collect test cases for test_venv_install

Collect test cases for dev and non-dev requirements in one,
more generalized test function.

Author: connesy

tests/helpers.py

@@ -1,7 +1,11 @@
 import os
 import subprocess
 import sys
+from functools import wraps
 from pathlib import Path
+from typing import Callable
+
+from tests.types import P, RawFilesDict, RequirementsBase, RequirementsDict
 
 RequirementFiles = dict[str, Path]
 current_python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
@@ -31,3 +35,20 @@ def run_command(commands: str | list[str], cwd: Path = Path.cwd(), activated: bo
 
     result = subprocess.run(all_commands, cwd=cwd)
     result.check_returncode()
+
+
+def collect_requirements(
+    func: Callable[P, tuple[RawFilesDict, RequirementsBase]]
+) -> Callable[P, tuple[RequirementsDict, RequirementsBase]]:
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> tuple[RequirementsDict, RequirementsBase]:
+        files_dict, requirements_base = func(*args, **kwargs)
+        requirements_dict = {filename: "\n".join(requirements) for filename, requirements in files_dict.items()}
+        return requirements_dict, requirements_base
+
+    return wrapper
+
+
+def write_files(files: RequirementsDict, dir: Path) -> None:
+    for filename, contents in files.items():
+        (dir / filename).write_text(contents)

tests/test_venv_install.py

@@ -1,76 +1,62 @@
 import re
+from itertools import chain
 from pathlib import Path
 
 import pytest
 from pytest_cases import parametrize_with_cases
 
-from tests.helpers import run_command
-from tests.test_venv_install_cases import CasesVenvInstallDevRequirementstxt, CasesVenvInstallRequirementstxt
+from tests.helpers import run_command, write_files
+from tests.test_venv_install_cases import CasesVenvInstallRequirementstxt
+from tests.types import RequirementsBase, RequirementsDict
 
-_package_regex = re.compile(r"^([a-zA-Z0-9_-]+)\b")
+_package_name_regex = re.compile(r"^([a-zA-Z0-9_-]+)\b")
 
 
-@pytest.mark.order(after="test_venv_activate.py::test_venv_activate")
-@pytest.mark.parametrize("command_arg", ["", "requirements.txt"])
-@parametrize_with_cases(argnames=["files"], cases=CasesVenvInstallRequirementstxt)
-def test_venv_install_requirements_txt(
-    command_arg: str,
-    files: dict[str, str],
-    tmp_path: Path,
-    capfd: pytest.CaptureFixture,
-):
-    (tmp_path / "requirements.txt").write_text(files["requirements.txt"])
-
-    # Install the requirements
-    run_command(f"venv install {command_arg} --skip-lock", cwd=tmp_path, activated=True)
-
-    # Check pip install log output
-    output: str = capfd.readouterr().out
-    assert "Installing requirements from requirements.txt" in output
-
-    installed_line = [line for line in output.splitlines() if line.startswith("Successfully installed")][0]
-    for requirement in files["requirements.txt"].splitlines():
-        re_match = _package_regex.match(requirement)
-        if re_match is None:
-            raise ValueError(f"Could not extract package name from requirement '{requirement}'")
+def _check_package_was_installed(requirement: str, installed_line: str) -> None:
+    """Check the 'Succesfully installed ...' output from 'pip install' to see that requirement was installed"""
+    re_match = _package_name_regex.match(requirement)
+    if re_match is None:
+        raise ValueError(f"Could not extract package name from requirement '{requirement}'")
 
-        package_name = re_match.group()
-        assert package_name in installed_line
+    package_name = re_match.group()
+    assert package_name in installed_line, f"Package {package_name} was not installed succesfully"
 
 
 @pytest.mark.order(after="test_venv_activate.py::test_venv_activate")
-@parametrize_with_cases(argnames=["files"], cases=CasesVenvInstallDevRequirementstxt)
-def test_venv_install_dev_requirements_txt(
-    files: dict[str, str],
+@parametrize_with_cases(argnames=["files", "requirements_base"], cases=CasesVenvInstallRequirementstxt)
+@pytest.mark.parametrize("use_file_name", [True, False])
+def test_venv_install_requirements(
+    files: RequirementsDict,
+    requirements_base: RequirementsBase,
+    use_file_name: bool,
     tmp_path: Path,
     capfd: pytest.CaptureFixture,
 ):
-    for file_name, contents in files.items():
-        (tmp_path / file_name).write_text(contents)
+    write_files(files=files, dir=tmp_path)
 
     # Install the requirements
-    run_command("venv install dev-requirements.txt --skip-lock", cwd=tmp_path, activated=True)
+    if not (requirements_base is RequirementsBase.requirements or use_file_name):
+        pytest.skip(f"Empty file name case only valid for requirements.txt, not {requirements_base}")
+
+    install_file_name = ""
+    if use_file_name:
+        install_file_name = f"{requirements_base.value}.txt"
+
+    run_command(
+        f"venv install {install_file_name} --skip-lock",
+        cwd=tmp_path,
+        activated=True,
+    )
 
     # Check pip install log output
     output: str = capfd.readouterr().out
-    assert "Installing requirements from dev-requirements.txt" in output
+    assert f"Installing requirements from {requirements_base.value}.txt" in output
 
     installed_line = [line for line in output.splitlines() if line.startswith("Successfully installed")][0]
-    for requirement in [
-        *files["requirements.txt"].splitlines(),
-        *files["dev-requirements.txt"].splitlines(),
-    ]:
+    requirement_lines = chain.from_iterable(contents.splitlines() for contents in files.values())
+    for requirement in requirement_lines:
         if requirement.startswith("-r"):
             # Skip '-r requirements.txt' line
             continue
 
         _check_package_was_installed(requirement=requirement, installed_line=installed_line)
-
-
-def _check_package_was_installed(requirement: str, installed_line: str) -> None:
-    re_match = _package_regex.match(requirement)
-    if re_match is None:
-        raise ValueError(f"Could not extract package name from requirement '{requirement}'")
-
-    package_name = re_match.group()
-    assert package_name in installed_line

tests/test_venv_install_cases.py

@@ -1,92 +1,56 @@
+from tests.helpers import collect_requirements
+from tests.types import RawFilesDict, RequirementsBase
+
+
 class CasesVenvInstallRequirementstxt:
-    def case_pypi(self):
-        requirements = [
+    @collect_requirements
+    def case_pypi(self) -> tuple[RawFilesDict, RequirementsBase]:
+        requirements_txt = [
             "python-json-logger==2.0.7",
         ]
 
-        return {"requirements.txt": "\n".join(requirements)}
+        files = {"requirements.txt": requirements_txt}
+        return files, RequirementsBase.requirements
 
-    def case_git(self):
-        requirements = [
+    @collect_requirements
+    def case_git(self) -> tuple[RawFilesDict, RequirementsBase]:
+        requirements_txt = [
             "python-json-logger @ git+https://github.com/madzak/[email protected]",
         ]
 
-        return {"requirements.txt": "\n".join(requirements)}
-
-    def case_git_token(self, create_test_credentials: None):
-        requirements = ["python-json-logger @ git+https://${TEST_TOKEN}@github.com/madzak/[email protected]"]
-
-        return {"requirements.txt": "\n".join(requirements)}
-
-    def case_git_user_pass(self, create_test_credentials: None):
-        requirements = [
-            "python-json-logger @ git+https://${TEST_USER}:${TEST_PASS}@github.com/madzak/[email protected]"
-        ]
-
-        return {"requirements.txt": "\n".join(requirements)}
+        files = {"requirements.txt": requirements_txt}
+        return files, RequirementsBase.requirements
 
-
-class CasesVenvInstallDevRequirementstxt:
-    def case_pypi_dev(self):
-        requirements = [
+    @collect_requirements
+    def case_pypi_dev(self) -> tuple[RawFilesDict, RequirementsBase]:
+        requirements_txt = [
             "python-json-logger==2.0.7",
         ]
 
-        dev_requirements = [
+        dev_requirements_txt = [
             "-r requirements.txt",
             "numpy==1.26.0",
         ]
 
         files = {
-            "requirements.txt": "\n".join(requirements),
-            "dev-requirements.txt": "\n".join(dev_requirements),
+            "requirements.txt": requirements_txt,
+            "dev-requirements.txt": dev_requirements_txt,
         }
-        return files
+        return files, RequirementsBase.dev_requirements
 
-    def case_git_dev(self):
-        requirements = [
+    @collect_requirements
+    def case_git_dev(self) -> tuple[RawFilesDict, RequirementsBase]:
+        requirements_txt = [
             "python-json-logger @ git+https://github.com/madzak/[email protected]",
         ]
 
-        dev_requirements = [
-            "-r requirements.txt",
-            "numpy==1.26.0",
-        ]
-
-        files = {
-            "requirements.txt": "\n".join(requirements),
-            "dev-requirements.txt": "\n".join(dev_requirements),
-        }
-        return files
-
-    def case_git_token_dev(self, create_test_credentials: None):
-        requirements = [
-            "python-json-logger @ git+https://${TEST_TOKEN}@github.com/madzak/[email protected]",
-        ]
-
-        dev_requirements = [
-            "-r requirements.txt",
-            "numpy==1.26.0",
-        ]
-
-        files = {
-            "requirements.txt": "\n".join(requirements),
-            "dev-requirements.txt": "\n".join(dev_requirements),
-        }
-        return files
-
-    def case_git_user_pass_dev(self, create_test_credentials: None):
-        requirements = [
-            "python-json-logger @ git+https://${TEST_USER}:${TEST_PASS}@github.com/madzak/[email protected]",
-        ]
-
-        dev_requirements = [
+        dev_requirements_txt = [
             "-r requirements.txt",
             "numpy==1.26.0",
         ]
 
         files = {
-            "requirements.txt": "\n".join(requirements),
-            "dev-requirements.txt": "\n".join(dev_requirements),
+            "requirements.txt": requirements_txt,
+            "dev-requirements.txt": dev_requirements_txt,
         }
-        return files
+        return files, RequirementsBase.dev_requirements

tests/types.py

@@ -0,0 +1,13 @@
+from enum import Enum
+from pathlib import Path
+from typing import ParamSpec
+
+P = ParamSpec("P")
+RawFilesDict = dict[str, list[str]]
+RequirementsDict = dict[str, str]
+RequirementFiles = dict[str, Path]
+
+
+class RequirementsBase(str, Enum):
+    requirements = "requirements"
+    dev_requirements = "dev-requirements"