test_branch_policy.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_branch_policy.py
 
"""
Purpose
-------
Tests for branch naming enforcement and auto-profile selection
(Phase 4E — G-E3, G-E4, G-E10).
 
Responsibilities
----------------
- Validate ``validate_branch_name`` against default and custom patterns.
- Validate ``_resolve_auto_profile`` branch-to-profile mapping.
- Validate ``resolve_effective_profile`` with ``"auto"`` config value.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 — test lifecycle
    L3 — test details
    L4 — deep tracing
 
Contracts
---------
- All tests are pure unit tests (no git repo needed).
"""
 
import pytest
 
from oct.git.policy import (
    validate_branch_name,
    _resolve_auto_profile,
    resolve_effective_profile,
    generate_branch_name_from_message,
    DEFAULT_BRANCH_PATTERNS,
    DEFAULT_PROFILE,
)
 
 
# =====================================================================
# TestBranchNaming
# =====================================================================
 
 
class TestBranchNaming:
    """Tests for validate_branch_name()."""
 
    def test_main_valid(self) -> None:
        valid, msg = validate_branch_name("main", None)
        assert valid is True
        assert msg == ""
 
    def test_feature_branch_valid(self) -> None:
        valid, msg = validate_branch_name("feature/add-auth", None)
        assert valid is True
 
    def test_release_branch_valid(self) -> None:
        valid, msg = validate_branch_name("release/v1.0", None)
        assert valid is True
 
    def test_hotfix_branch_valid(self) -> None:
        valid, msg = validate_branch_name("hotfix/fix-crash", None)
        assert valid is True
 
    def test_invalid_random_name(self) -> None:
        valid, msg = validate_branch_name("my-random-branch", None)
        assert valid is False
        assert "does not match" in msg
 
    def test_custom_patterns_in_octrc(self) -> None:
        """Custom patterns from octrc override defaults."""
        octrc = {
            "git": {
                "branch_naming": {
                    "enabled": True,
                    "patterns": [r"^custom/.+$"],
                },
            },
        }
        valid, _ = validate_branch_name("custom/my-branch", octrc)
        assert valid is True
        # Default pattern should not match.
        valid2, _ = validate_branch_name("feature/something", octrc)
        assert valid2 is False
 
    def test_disabled_always_valid(self) -> None:
        """When branch_naming.enabled is false, everything is valid."""
        octrc = {
            "git": {
                "branch_naming": {"enabled": False},
            },
        }
        valid, msg = validate_branch_name("anything-goes", octrc)
        assert valid is True
        assert msg == ""
 
    def test_none_branch_valid(self) -> None:
        """None branch (detached HEAD) is always valid."""
        valid, msg = validate_branch_name(None, None)
        assert valid is True
 
    def test_head_branch_valid(self) -> None:
        """Literal 'HEAD' (detached) is always valid."""
        valid, msg = validate_branch_name("HEAD", None)
        assert valid is True
 
    def test_empty_patterns_all_valid(self) -> None:
        """Empty patterns list means everything is valid."""
        octrc = {
            "git": {
                "branch_naming": {
                    "enabled": True,
                    "patterns": [],
                },
            },
        }
        valid, msg = validate_branch_name("whatever", octrc)
        assert valid is True
 
    def test_develop_valid(self) -> None:
        valid, _ = validate_branch_name("develop", None)
        assert valid is True
 
    def test_docs_branch_valid(self) -> None:
        valid, _ = validate_branch_name("docs/update-readme", None)
        assert valid is True
 
    def test_bugfix_branch_valid(self) -> None:
        valid, _ = validate_branch_name("bugfix/null-pointer", None)
        assert valid is True
 
    def test_chore_branch_valid(self) -> None:
        valid, _ = validate_branch_name("chore/deps-update", None)
        assert valid is True
 
 
# =====================================================================
# TestAutoProfile
# =====================================================================
 
 
class TestAutoProfile:
    """Tests for _resolve_auto_profile()."""
 
    def test_main_strict(self) -> None:
        assert _resolve_auto_profile("main") == "strict"
 
    def test_master_strict(self) -> None:
        assert _resolve_auto_profile("master") == "strict"
 
    def test_feature_compact(self) -> None:
        assert _resolve_auto_profile("feature/something") == "compact"
 
    def test_release_strict(self) -> None:
        assert _resolve_auto_profile("release/v1.0") == "strict"
 
    def test_hotfix_strict(self) -> None:
        assert _resolve_auto_profile("hotfix/urgent") == "strict"
 
    def test_docs_compact(self) -> None:
        assert _resolve_auto_profile("docs/update") == "compact"
 
    def test_chore_compact(self) -> None:
        assert _resolve_auto_profile("chore/cleanup") == "compact"
 
    def test_unrecognized_default(self) -> None:
        assert _resolve_auto_profile("random-branch") == DEFAULT_PROFILE
 
    def test_none_branch_default(self) -> None:
        assert _resolve_auto_profile(None) == DEFAULT_PROFILE
 
    def test_head_default(self) -> None:
        assert _resolve_auto_profile("HEAD") == DEFAULT_PROFILE
 
    def test_bugfix_compact(self) -> None:
        assert _resolve_auto_profile("bugfix/fix-it") == "compact"
 
 
# =====================================================================
# TestResolveEffectiveProfileAuto
# =====================================================================
 
 
class TestResolveEffectiveProfileAuto:
    """Tests for resolve_effective_profile with auto mode."""
 
    def test_auto_on_main(self) -> None:
        """Auto on main resolves to strict (protected branch takes precedence)."""
        octrc = {"git": {"pre_commit_profile": "auto", "protected_branches": ["main"]}}
        # Protected branch override kicks in before auto.
        result = resolve_effective_profile("main", octrc, None)
        assert result == "strict"
 
    def test_auto_on_feature(self) -> None:
        """Auto on feature branch resolves to compact."""
        octrc = {"git": {"pre_commit_profile": "auto"}}
        result = resolve_effective_profile("feature/thing", octrc, None)
        assert result == "compact"
 
    def test_cli_overrides_auto(self) -> None:
        """CLI --profile overrides auto."""
        octrc = {"git": {"pre_commit_profile": "auto"}}
        result = resolve_effective_profile("feature/thing", octrc, "proto")
        assert result == "proto"
 
    def test_auto_on_release(self) -> None:
        """Auto on release branch resolves to strict."""
        octrc = {"git": {"pre_commit_profile": "auto", "protected_branches": []}}
        result = resolve_effective_profile("release/v1.0", octrc, None)
        assert result == "strict"
 
 
# =====================================================================
# TestGenerateBranchName (Phase 4F — G-F2)
# =====================================================================
 
 
class TestGenerateBranchName:
    """Tests for generate_branch_name_from_message()."""
 
    def test_feat_produces_feature_prefix(self) -> None:
        name = generate_branch_name_from_message("feat: add login page")
        assert name is not None
        assert name.startswith("feature/")
        assert "add-login-page" in name
 
    def test_feat_with_scope(self) -> None:
        name = generate_branch_name_from_message("feat(auth): add JWT tokens")
        assert name == "feature/auth-add-jwt-tokens"
 
    def test_fix_produces_bugfix_prefix(self) -> None:
        name = generate_branch_name_from_message("fix: null pointer in parser")
        assert name is not None
        assert name.startswith("bugfix/")
 
    def test_sec_produces_hotfix_prefix(self) -> None:
        name = generate_branch_name_from_message("sec: patch CVE-2024-1234")
        assert name is not None
        assert name.startswith("hotfix/")
 
    def test_docs_produces_docs_prefix(self) -> None:
        name = generate_branch_name_from_message("docs: update changelog")
        assert name == "docs/update-changelog"
 
    def test_chore_produces_chore_prefix(self) -> None:
        name = generate_branch_name_from_message("chore: cleanup deps")
        assert name is not None
        assert name.startswith("chore/")
 
    def test_refactor_produces_chore_prefix(self) -> None:
        name = generate_branch_name_from_message("refactor: simplify parser")
        assert name is not None
        assert name.startswith("chore/")
 
    def test_special_chars_slugified(self) -> None:
        name = generate_branch_name_from_message("feat: add API v2 (beta)")
        assert name is not None
        # No parentheses, spaces, or special chars.
        assert "(" not in name
        assert " " not in name
 
    def test_long_subject_truncated(self) -> None:
        long_msg = "feat: " + "a" * 100
        name = generate_branch_name_from_message(long_msg)
        assert name is not None
        # Slug portion should not exceed 50 chars.
        slug = name.split("/", 1)[1]
        assert len(slug) <= 50
 
    def test_unparseable_returns_none(self) -> None:
        assert generate_branch_name_from_message("not a valid commit") is None
        assert generate_branch_name_from_message("") is None
 
    def test_generated_names_pass_validation(self) -> None:
        """All commit types produce names that pass validate_branch_name."""
        messages = [
            "feat: add feature",
            "fix: fix bug",
            "docs: update docs",
            "style: fix formatting",
            "refactor: simplify",
            "perf: optimise query",
            "test: add tests",
            "chore: bump deps",
            "sec: patch vuln",
        ]
        for msg in messages:
            name = generate_branch_name_from_message(msg)
            assert name is not None, f"failed for {msg!r}"
            valid, val_msg = validate_branch_name(name, None)
            assert valid, f"{name!r} from {msg!r}: {val_msg}"