add better unit tests (#90)

* add better unit tests

Author: fpgmaas

pyproject.toml

@@ -61,6 +61,7 @@ packages = ["cookiecutter_uv"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = ["slow: tests that install dependencies and run commands in baked projects"]
 
 [tool.coverage.report]
 skip_empty = true

tests/conftest.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import pytest
+import yaml
+
+
+@dataclass
+class BakedProject:
+    """Wrapper around a baked cookiecutter project with convenience methods for testing."""
+
+    project_path: Path
+    exit_code: int
+    exception: Exception | None
+    options: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def path(self) -> Path:
+        return self.project_path
+
+    def has_file(self, rel_path: str) -> bool:
+        return (self.path / rel_path).is_file()
+
+    def has_dir(self, rel_path: str) -> bool:
+        return (self.path / rel_path).is_dir()
+
+    def read_file(self, rel_path: str) -> str:
+        return (self.path / rel_path).read_text()
+
+    def file_contains(self, rel_path: str, text: str) -> bool:
+        return text in self.read_file(rel_path)
+
+    def is_valid_yaml(self, rel_path: str) -> bool:
+        path = self.path / rel_path
+        if not path.is_file():
+            return False
+        try:
+            with path.open() as f:
+                yaml.safe_load(f)
+        except (yaml.YAMLError, OSError):
+            return False
+        return True
+
+    def run(self, command: str, check: bool = False) -> subprocess.CompletedProcess:
+        # Strip VIRTUAL_ENV so the outer test environment doesn't leak
+        # into the baked project's subprocess.
+        env = {k: v for k, v in os.environ.items() if k != "VIRTUAL_ENV"}
+        return subprocess.run(
+            shlex.split(command),
+            cwd=self.path,
+            capture_output=True,
+            text=True,
+            check=check,
+            env=env,
+        )
+
+    def git_init(self) -> None:
+        """Initialize a git repo and stage all files (needed for pre-commit)."""
+        self.run("git init", check=True)
+        self.run("git add .", check=True)
+
+    def install(self) -> None:
+        self.git_init()
+        result = self.run("uv sync")
+        assert result.returncode == 0, f"uv sync failed:\n{result.stderr}"
+
+    def run_tests(self) -> None:
+        result = self.run("uv run make test")
+        assert result.returncode == 0, f"make test failed:\n{result.stderr}"
+
+    def run_check(self) -> None:
+        # Run pre-commit once to auto-fix formatting issues from Jinja2 rendering
+        # (e.g. end-of-file-fixer), then re-stage and run the real check.
+        self.run("uv run pre-commit run -a")
+        self.run("git add .", check=True)
+        result = self.run("uv run make check")
+        assert result.returncode == 0, f"make check failed:\n{result.stdout}\n{result.stderr}"
+
+
+@pytest.fixture
+def bake(cookies):
+    """Fixture factory that bakes a cookiecutter project and returns a BakedProject.
+
+    Usage:
+        def test_something(bake):
+            project = bake(mkdocs="n", codecov="y")
+            assert project.has_file("pyproject.toml")
+    """
+
+    def _bake(**options) -> BakedProject:
+        result = cookies.bake(extra_context=options)
+        project = BakedProject(
+            project_path=result.project_path,
+            exit_code=result.exit_code,
+            exception=result.exception,
+            options=options,
+        )
+        assert project.exit_code == 0, f"Bake failed with options {options}: {project.exception}"
+        assert project.exception is None
+        return project
+
+    return _bake

tests/test_combinations.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import pytest
+
+MINIMAL = {
+    "include_github_actions": "n",
+    "publish_to_pypi": "n",
+    "deptry": "n",
+    "mkdocs": "n",
+    "codecov": "n",
+    "dockerfile": "n",
+    "devcontainer": "n",
+}
+
+COMBINATIONS = [
+    pytest.param({}, id="all-defaults"),
+    pytest.param(MINIMAL, id="minimal"),
+    pytest.param({"layout": "src"}, id="src-layout-defaults"),
+    pytest.param({**MINIMAL, "layout": "src"}, id="src-layout-minimal"),
+    pytest.param({"publish_to_pypi": "n", "mkdocs": "n"}, id="no-publish-no-mkdocs"),
+    pytest.param({"include_github_actions": "n"}, id="no-github-actions"),
+    pytest.param({"type_checker": "ty"}, id="ty-type-checker"),
+    pytest.param({"mkdocs": "y", "codecov": "n"}, id="mkdocs-no-codecov"),
+    pytest.param({"codecov": "n", "include_github_actions": "n"}, id="no-codecov-no-actions"),
+    pytest.param({"layout": "src", "type_checker": "ty", "publish_to_pypi": "n"}, id="src-ty-no-publish"),
+]
+
+# Defaults from cookiecutter.json (first item in each list)
+DEFAULTS = {
+    "layout": "flat",
+    "include_github_actions": "y",
+    "publish_to_pypi": "y",
+    "deptry": "y",
+    "mkdocs": "y",
+    "codecov": "y",
+    "dockerfile": "y",
+    "devcontainer": "y",
+    "type_checker": "mypy",
+}
+
+
+def resolve_options(options: dict[str, str]) -> dict[str, str]:
+    """Return the full set of resolved options (defaults merged with overrides)."""
+    return {**DEFAULTS, **options}
+
+
+@pytest.mark.parametrize("options", COMBINATIONS)
+class TestStructure:
+    """Validate file presence/absence for each option combination."""
+
+    def test_always_present_files(self, bake, options):
+        EXPECTED_FILES = [
+            ".gitignore",
+            ".pre-commit-config.yaml",
+            "CONTRIBUTING.md",
+            "LICENSE",
+            "Makefile",
+            "README.md",
+            "pyproject.toml",
+            "tests",
+            "tox.ini",
+        ]
+        project = bake(**options)
+        for rel_path in EXPECTED_FILES:
+            assert (project.path / rel_path).exists(), f"Expected {rel_path} to exist"
+
+    def test_conditional_files(self, bake, options):
+        project = bake(**options)
+        effective = resolve_options(options)
+
+        if effective["dockerfile"] == "y":
+            assert project.has_file("Dockerfile")
+        else:
+            assert not project.has_file("Dockerfile")
+
+        if effective["mkdocs"] == "y":
+            assert project.has_dir("docs")
+            assert project.has_file("mkdocs.yml")
+        else:
+            assert not project.has_dir("docs")
+            assert not project.has_file("mkdocs.yml")
+
+        if effective["codecov"] == "y":
+            assert project.has_file("codecov.yaml")
+        else:
+            assert not project.has_file("codecov.yaml")
+
+        if effective["devcontainer"] == "y":
+            assert project.has_dir(".devcontainer")
+        else:
+            assert not project.has_dir(".devcontainer")
+
+        if effective["include_github_actions"] == "y":
+            assert project.has_dir(".github")
+        else:
+            assert not project.has_dir(".github")
+
+    def test_layout(self, bake, options):
+        effective = resolve_options(options)
+        project = bake(**options)
+        if effective["layout"] == "src":
+            assert project.has_dir("src/example_project")
+            assert not project.has_dir("example_project")
+        else:
+            assert project.has_dir("example_project")
+            assert not project.has_dir("src")
+
+    def test_release_workflow(self, bake, options):
+        effective = resolve_options(options)
+        project = bake(**options)
+        if effective["include_github_actions"] != "y":
+            return  # no .github at all
+        has_release = effective["publish_to_pypi"] == "y" or effective["mkdocs"] == "y"
+        workflow = ".github/workflows/on-release-main.yml"
+        if has_release:
+            assert project.has_file(workflow), "Expected release workflow to exist"
+        else:
+            assert not project.has_file(workflow), "Expected release workflow to be absent"
+
+    def test_yaml_validity(self, bake, options):
+        effective = resolve_options(options)
+        project = bake(**options)
+        if effective["include_github_actions"] == "y":
+            assert project.is_valid_yaml(".github/workflows/main.yml")
+
+    def test_pyproject_type_checker(self, bake, options):
+        effective = resolve_options(options)
+        project = bake(**options)
+        content = project.read_file("pyproject.toml")
+        if effective["type_checker"] == "mypy":
+            assert '"mypy' in content
+            assert '"ty' not in content
+        else:
+            assert '"ty' in content
+            assert '"mypy' not in content
+
+    def test_makefile_targets(self, bake, options):
+        effective = resolve_options(options)
+        project = bake(**options)
+        content = project.read_file("Makefile")
+
+        if effective["publish_to_pypi"] == "y":
+            assert "build-and-publish" in content
+        else:
+            assert "build-and-publish" not in content
+
+        if effective["mkdocs"] == "y":
+            assert "docs:" in content
+        else:
+            assert "docs:" not in content
+
+    def test_codecov_workflow(self, bake, options):
+        effective = resolve_options(options)
+        project = bake(**options)
+        if effective["include_github_actions"] == "y":
+            if effective["codecov"] == "y":
+                assert project.has_file(".github/workflows/validate-codecov-config.yml")
+                assert project.has_file("codecov.yaml")
+            else:
+                assert not project.has_file(".github/workflows/validate-codecov-config.yml")
+                assert not project.has_file("codecov.yaml")
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("options", COMBINATIONS)
+def test_install_and_run_tests(bake, options):
+    """Bake, install dependencies, and run the generated project's test suite."""
+    project = bake(**options)
+    project.install()
+    project.run_tests()
+
+
+@pytest.mark.slow
+def test_check_passes_on_default_project(bake):
+    """A freshly baked default project should pass its own ``make check``."""
+    project = bake()
+    project.install()
+    project.run_check()