claude-dev-env 1.38.0 → 1.39.0

package/skills/bugteam/scripts/test_bugteam_fix_hookspath.py

@@ -0,0 +1,384 @@
+"""Tests for bugteam_fix_hookspath auto-remediation.
+
+Covers:
+- removes a local-scope core.hooksPath override and re-runs preflight
+- sets global core.hooksPath when missing
+- idempotent: second invocation produces the same final state with no errors
+- no-op when no override exists and global is already canonical
+- exits non-zero with a clear message when canonical hooks dir is missing
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+from unittest.mock import patch
+
+import pytest
+
+
+def _load_fix_module() -> ModuleType:
+    module_path = Path(__file__).parent / "bugteam_fix_hookspath.py"
+    spec = importlib.util.spec_from_file_location("bugteam_fix_hookspath", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+bugteam_fix_hookspath = _load_fix_module()
+
+
+def _make_isolated_git_environment(home_directory: Path) -> dict[str, str]:
+    """Build an env dict that pins git's HOME and XDG paths into a tmp directory.
+
+    Without this, real `git config --global` reads/writes hit the developer's
+    actual ~/.gitconfig — which would corrupt the host machine and make tests
+    depend on global state. Pointing HOME, USERPROFILE, and XDG_CONFIG_HOME
+    at a temp directory isolates the test fully on every supported git
+    version. GIT_CONFIG_GLOBAL would tighten the binding but requires
+    git >= 2.32 (August 2021); HOME/USERPROFILE already isolate on older git.
+    """
+    isolated_environment = os.environ.copy()
+    isolated_environment["HOME"] = str(home_directory)
+    isolated_environment["USERPROFILE"] = str(home_directory)
+    isolated_environment["XDG_CONFIG_HOME"] = str(home_directory / ".config")
+    isolated_environment["GIT_CONFIG_NOSYSTEM"] = "1"
+    return isolated_environment
+
+
+def _initialize_repository(repository_path: Path, environment: dict[str, str]) -> None:
+    repository_path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        ["git", "init", "--quiet", str(repository_path)],
+        check=True,
+        env=environment,
+    )
+
+
+def _set_local_hooks_path(
+    repository_path: Path,
+    hooks_path_value: str,
+    environment: dict[str, str],
+) -> None:
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "config",
+            "--local",
+            "core.hooksPath",
+            hooks_path_value,
+        ],
+        check=True,
+        env=environment,
+    )
+
+
+def _set_global_hooks_path(hooks_path_value: str, environment: dict[str, str]) -> None:
+    subprocess.run(
+        ["git", "config", "--global", "core.hooksPath", hooks_path_value],
+        check=True,
+        env=environment,
+    )
+
+
+def _read_local_hooks_path(repository_path: Path, environment: dict[str, str]) -> str:
+    completed_process = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "config",
+            "--local",
+            "--get",
+            "core.hooksPath",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment,
+    )
+    return completed_process.stdout.strip()
+
+
+def _read_global_hooks_path(environment: dict[str, str]) -> str:
+    completed_process = subprocess.run(
+        ["git", "config", "--global", "--get", "core.hooksPath"],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment,
+    )
+    return completed_process.stdout.strip()
+
+
+def _create_canonical_hooks_directory(home_directory: Path) -> Path:
+    canonical_hooks_directory = home_directory / ".claude" / "hooks" / "git-hooks"
+    canonical_hooks_directory.mkdir(parents=True)
+    return canonical_hooks_directory
+
+
+def test_should_remove_local_override_and_pass_preflight(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+
+    assert exit_code == 0, (
+        "fix script must succeed when canonical global hooks dir exists"
+    )
+    assert _read_local_hooks_path(repository_path, environment) == "", (
+        "local core.hooksPath override must be removed"
+    )
+
+
+def test_should_set_global_hooks_path_when_missing(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    global_value_after_fix = _read_global_hooks_path(environment)
+    assert (
+        global_value_after_fix.replace("\\", "/")
+        .rstrip("/")
+        .endswith("hooks/git-hooks")
+    ), (
+        "fix script must set canonical global core.hooksPath when missing; "
+        f"got '{global_value_after_fix}'"
+    )
+
+
+def test_should_be_idempotent(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    first_exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+    second_exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+
+    assert first_exit_code == 0
+    assert second_exit_code == 0, "second invocation must succeed without errors"
+    assert _read_local_hooks_path(repository_path, environment) == ""
+
+
+def test_should_no_op_when_already_clean(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    assert _read_local_hooks_path(repository_path, environment) == ""
+    assert (
+        _read_global_hooks_path(environment)
+        .replace("\\", "/")
+        .rstrip("/")
+        .endswith("hooks/git-hooks")
+    )
+
+
+def test_should_exit_nonzero_when_canonical_hooks_directory_missing(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+
+    assert exit_code != 0, (
+        "fix script must fail clearly when ~/.claude/hooks/git-hooks does not exist "
+        "so the user knows to run `npx claude-dev-env .`"
+    )
+    captured_streams = capsys.readouterr()
+    assert "hooks/git-hooks" in captured_streams.err.replace("\\", "/")
+
+
+def test_should_handle_paths_with_spaces(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home with space"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "repo with space"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        all_environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    assert _read_local_hooks_path(repository_path, environment) == ""
+
+
+def test_list_local_core_hooks_path_values_raises_on_unexpected_git_failure(
+    tmp_path: Path,
+) -> None:
+    """A non-empty stderr from git config must propagate as an error.
+
+    Regression for loop1-5: returning [] on every non-zero git exit collapses
+    "key unset" with "git failed for some other reason" — the caller then
+    skips the unset call, leaving a stale local override in place.
+    """
+    repository_path = tmp_path / "repo"
+    repository_path.mkdir()
+
+    def fake_run(*_args: object, **_kwargs: object) -> subprocess.CompletedProcess:
+        return subprocess.CompletedProcess(
+            args=[],
+            returncode=128,
+            stdout="",
+            stderr="fatal: unable to read config file: permission denied\n",
+        )
+
+    with patch.object(subprocess, "run", fake_run):
+        with pytest.raises(RuntimeError):
+            bugteam_fix_hookspath.list_local_core_hooks_path_values(
+                repository_path,
+                None,
+            )
+
+
+def test_read_global_core_hooks_path_raises_on_unexpected_git_failure() -> None:
+    """A non-empty stderr from git config must propagate as an error.
+
+    Regression for loop1-6: returning "" on every non-zero git exit conflates
+    "global hooksPath unset" with "git failed for some other reason" — the
+    caller then overwrites global git config based on a non-truthful read.
+    """
+
+    def fake_run(*_args: object, **_kwargs: object) -> subprocess.CompletedProcess:
+        return subprocess.CompletedProcess(
+            args=[],
+            returncode=128,
+            stdout="",
+            stderr="fatal: bad config line\n",
+        )
+
+    with patch.object(subprocess, "run", fake_run):
+        with pytest.raises(RuntimeError):
+            bugteam_fix_hookspath.read_global_core_hooks_path(None)
+
+
+def test_list_local_core_hooks_path_values_returns_empty_when_key_unset(
+    tmp_path: Path,
+) -> None:
+    """Genuine key-unset (exit 1 + empty stderr) must continue to return []."""
+    repository_path = tmp_path / "repo"
+    repository_path.mkdir()
+
+    def fake_run(*_args: object, **_kwargs: object) -> subprocess.CompletedProcess:
+        return subprocess.CompletedProcess(
+            args=[],
+            returncode=1,
+            stdout="",
+            stderr="",
+        )
+
+    with patch.object(subprocess, "run", fake_run):
+        result = bugteam_fix_hookspath.list_local_core_hooks_path_values(
+            repository_path,
+            None,
+        )
+    assert result == []
+
+
+def test_read_global_core_hooks_path_returns_empty_when_key_unset() -> None:
+    """Genuine key-unset (exit 1 + empty stderr) must continue to return ''."""
+
+    def fake_run(*_args: object, **_kwargs: object) -> subprocess.CompletedProcess:
+        return subprocess.CompletedProcess(
+            args=[],
+            returncode=1,
+            stdout="",
+            stderr="",
+        )
+
+    with patch.object(subprocess, "run", fake_run):
+        result = bugteam_fix_hookspath.read_global_core_hooks_path(None)
+    assert result == ""
+
+
+def test_module_import_evicts_cached_config_submodules() -> None:
+    """Importing bugteam_fix_hookspath must evict cached `config.*` submodules.
+
+    Regression for loop1-1: without a defensive cache pop above sys.path.insert,
+    a previously-cached `config` package shadows scripts/config/ and the
+    from-import raises ModuleNotFoundError.
+    """
+    fake_submodule_name = "config.bugteam_fix_hookspath_constants"
+    fake_parent_name = "config"
+    sentinel_module_a = ModuleType(fake_parent_name)
+    sentinel_module_b = ModuleType(fake_submodule_name)
+    sys.modules[fake_parent_name] = sentinel_module_a
+    sys.modules[fake_submodule_name] = sentinel_module_b
+    try:
+        _load_fix_module()
+    finally:
+        sys.modules.pop(fake_parent_name, None)
+        sys.modules.pop(fake_submodule_name, None)
+    assert sys.modules.get(fake_parent_name) is not sentinel_module_a, (
+        "parent `config` cache entry must be evicted on module import"
+    )
+    assert sys.modules.get(fake_submodule_name) is not sentinel_module_b, (
+        "cached `config.<submodule>` entries must be evicted on module import"
+    )

package/skills/bugteam/scripts/test_bugteam_preflight.py

@@ -0,0 +1,268 @@
+"""Tests for bugteam_preflight git hooks path verification.
+
+Covers:
+- core.hooksPath unset: exits non-zero with correction message
+- core.hooksPath pointing to the correct claude hooks dir: exits zero
+- core.hooksPath pointing elsewhere (husky override): exits non-zero
+- core.hooksPath with trailing slash: must still pass after normalization
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+def _load_preflight_module() -> ModuleType:
+    module_path = Path(__file__).parent / "bugteam_preflight.py"
+    spec = importlib.util.spec_from_file_location("bugteam_preflight", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+bugteam_preflight = _load_preflight_module()
+
+
+def _make_completed_process(
+    stdout: str, returncode: int
+) -> subprocess.CompletedProcess:
+    process = MagicMock(spec=subprocess.CompletedProcess)
+    process.stdout = stdout
+    process.returncode = returncode
+    return process
+
+
+def test_should_exit_nonzero_when_core_hooks_path_unset(capsys: pytest.CaptureFixture[str]) -> None:
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process("", returncode=1)
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code != 0
+    captured = capsys.readouterr()
+    assert "core.hooksPath" in captured.err
+    assert "npx claude-dev-env" in captured.err or "git config" in captured.err
+
+
+def test_should_exit_zero_when_core_hooks_path_points_to_claude_hooks(tmp_path: Path) -> None:
+    claude_hooks_path = tmp_path / ".claude" / "hooks" / "git-hooks"
+    claude_hooks_path.mkdir(parents=True)
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            str(claude_hooks_path) + "\n", returncode=0
+        )
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code == 0
+
+
+def test_should_exit_nonzero_when_core_hooks_path_points_elsewhere(capsys: pytest.CaptureFixture[str]) -> None:
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            "/some/other/path/.husky\n", returncode=0
+        )
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code != 0
+    captured = capsys.readouterr()
+    assert "core.hooksPath" in captured.err
+
+
+def test_should_include_correction_commands_in_error_message(capsys: pytest.CaptureFixture[str]) -> None:
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process("", returncode=1)
+        bugteam_preflight.verify_git_hooks_path(Path("."))
+    captured = capsys.readouterr()
+    assert (
+        "npx claude-dev-env" in captured.err
+        or "git config --global core.hooksPath" in captured.err
+    )
+
+
+def test_main_should_exit_nonzero_when_hooks_path_unset() -> None:
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process("", returncode=1)
+        exit_code = bugteam_preflight.main(["--no-pytest"])
+    assert exit_code != 0
+
+
+def test_main_should_continue_when_hooks_path_valid(tmp_path: Path) -> None:
+    claude_hooks_path = tmp_path / ".claude" / "hooks" / "git-hooks"
+    claude_hooks_path.mkdir(parents=True)
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            str(claude_hooks_path) + "\n", returncode=0
+        )
+        exit_code = bugteam_preflight.main(["--no-pytest"])
+    assert exit_code == 0
+
+
+def test_should_accept_hooks_path_with_trailing_slash() -> None:
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            "/home/user/.claude/hooks/git-hooks/\n", returncode=0
+        )
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code == 0, (
+        "hooksPath with trailing slash must pass verification after normalization"
+    )
+
+
+def test_should_exit_zero_when_hooks_path_set_at_repo_scope(tmp_path: Path) -> None:
+    claude_hooks_path = tmp_path / ".claude" / "hooks" / "git-hooks"
+    claude_hooks_path.mkdir(parents=True)
+    repo_root = tmp_path / "my-repo"
+    repo_root.mkdir()
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            str(claude_hooks_path) + "\n", returncode=0
+        )
+        exit_code = bugteam_preflight.verify_git_hooks_path(repo_root)
+    assert exit_code == 0, (
+        "verify_git_hooks_path must accept a valid path returned by effective "
+        "config query (not restricted to --global scope)"
+    )
+    called_command = mock_run.call_args[0][0]
+    assert "--global" not in called_command, (
+        "verify_git_hooks_path must query effective config, not --global only"
+    )
+    assert "-C" in called_command, (
+        "verify_git_hooks_path must use git -C <repo_root> for repo-effective config"
+    )
+    dash_c_index = called_command.index("-C")
+    assert called_command[dash_c_index + 1] == str(repo_root), (
+        "git -C must receive the resolved repository root path"
+    )
+
+
+def test_verify_git_hooks_path_accepts_none_repository_root(tmp_path: Path) -> None:
+    """When repository_root is None, the call must use git's cwd-effective config.
+
+    Binds the documented optional contract: passing None must not raise and must
+    omit the `-C <root>` arguments so git falls back to the working directory.
+    """
+    claude_hooks_path = tmp_path / ".claude" / "hooks" / "git-hooks"
+    claude_hooks_path.mkdir(parents=True)
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            str(claude_hooks_path) + "\n", returncode=0
+        )
+        exit_code = bugteam_preflight.verify_git_hooks_path(None)
+    assert exit_code == 0
+    called_command = mock_run.call_args[0][0]
+    assert "-C" not in called_command, (
+        "verify_git_hooks_path(None) must omit -C so git uses cwd-effective config"
+    )
+
+
+def test_should_accept_hooks_path_with_backslash_and_trailing_slash() -> None:
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _make_completed_process(
+            "C:\\Users\\user\\.claude\\hooks\\git-hooks\\\n", returncode=0
+        )
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code == 0, (
+        "Windows hooksPath with trailing backslash must pass after normalization"
+    )
+
+
+def test_should_exit_nonzero_when_git_executable_not_found(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Preflight must not crash with a traceback when git is missing from PATH."""
+    with patch("subprocess.run", side_effect=FileNotFoundError()):
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code != 0, (
+        "FileNotFoundError from subprocess.run must produce a non-zero exit, "
+        "not a propagated traceback"
+    )
+    captured = capsys.readouterr()
+    assert "git" in captured.err.lower(), (
+        "Error message must mention git so the user knows what is missing"
+    )
+    assert (
+        "npx claude-dev-env" in captured.err
+        or "git config --global core.hooksPath" in captured.err
+    ), "Error message must include the enforcement-absent remediation hints"
+
+
+def test_should_exit_nonzero_when_subprocess_run_raises_os_error(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Preflight must surface a clean error for other OS-level git launch failures."""
+    with patch("subprocess.run", side_effect=OSError("permission denied")):
+        exit_code = bugteam_preflight.verify_git_hooks_path(Path("."))
+    assert exit_code != 0, (
+        "OSError from subprocess.run must produce a non-zero exit, "
+        "not a propagated traceback"
+    )
+    captured = capsys.readouterr()
+    assert "bugteam_preflight" in captured.err, (
+        "Error message must be prefixed with the preflight tool name for context"
+    )
+    assert "permission denied" in captured.err, (
+        "Error message must include the underlying OSError detail for diagnosis"
+    )
+
+
+def test_module_import_evicts_cached_config_submodules() -> None:
+    """Importing bugteam_preflight must evict cached `config.*` submodules.
+
+    Regression for loop1-4: a single `sys.modules.pop("config", None)` only
+    removes the parent key, leaving stale `config.<submodule>` entries that
+    satisfy the next from-import with the wrong bindings.
+    """
+    fake_submodule_name = "config.bugteam_preflight_constants"
+    fake_parent_name = "config"
+    sentinel_module_a = ModuleType(fake_parent_name)
+    sentinel_module_b = ModuleType(fake_submodule_name)
+    sys.modules[fake_parent_name] = sentinel_module_a
+    sys.modules[fake_submodule_name] = sentinel_module_b
+    try:
+        _load_preflight_module()
+    finally:
+        sys.modules.pop(fake_parent_name, None)
+        sys.modules.pop(fake_submodule_name, None)
+    assert sys.modules.get(fake_parent_name) is not sentinel_module_a, (
+        "parent `config` cache entry must be evicted on module import"
+    )
+    assert sys.modules.get(fake_submodule_name) is not sentinel_module_b, (
+        "cached `config.<submodule>` entries must be evicted on module import"
+    )
+
+
+def test_has_pytest_configuration_finds_pytest_ini(tmp_path: Path) -> None:
+    """has_pytest_configuration must detect pytest.ini at the repo root.
+
+    Regression for loop1-17/loop1-18: the literals "pytest.ini",
+    "pyproject.toml", and "[tool.pytest" were inlined in production function
+    bodies; centralizing them in config and importing here pins the contract.
+    """
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    (repository_root / "pytest.ini").write_text("[pytest]\n", encoding="utf-8")
+    assert bugteam_preflight.has_pytest_configuration(repository_root) is True
+
+
+def test_has_pytest_configuration_finds_pyproject_pytest_section(
+    tmp_path: Path,
+) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    (repository_root / "pyproject.toml").write_text(
+        "[tool.pytest.ini_options]\nminversion = '6.0'\n", encoding="utf-8"
+    )
+    assert bugteam_preflight.has_pytest_configuration(repository_root) is True
+
+
+def test_has_pytest_configuration_returns_false_without_either_file(
+    tmp_path: Path,
+) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    assert bugteam_preflight.has_pytest_configuration(repository_root) is False