prizmkit 1.0.45 → 1.0.66

package/bundled/dev-pipeline/tests/test_update_feature_status.py

@@ -1,338 +0,0 @@
-"""Tests for update-feature-status.py."""
-
-import json
-import os
-import re
-import sys
-import pytest
-from types import SimpleNamespace
-
-
-def _import_update_feature_status():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "update-feature-status.py"
-    )
-    spec = importlib.util.spec_from_file_location("update_feature_status", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["update_feature_status"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-ufs = _import_update_feature_status()
-now_iso = ufs.now_iso
-load_feature_status = ufs.load_feature_status
-save_feature_status = ufs.save_feature_status
-_build_feature_slug = ufs._build_feature_slug
-_format_duration = ufs._format_duration
-_calc_feature_duration = ufs._calc_feature_duration
-
-
-class TestSessionStatusValues:
-    def test_contains_commit_missing(self):
-        assert "commit_missing" in ufs.SESSION_STATUS_VALUES
-
-    def test_contains_docs_missing(self):
-        assert "docs_missing" in ufs.SESSION_STATUS_VALUES
-
-    def test_contains_merge_conflict(self):
-        assert "merge_conflict" in ufs.SESSION_STATUS_VALUES
-
-
-class TestNowIso:
-    def test_returns_valid_iso_format(self):
-        result = now_iso()
-        # Should match YYYY-MM-DDTHH:MM:SSZ
-        pattern = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$"
-        assert re.match(pattern, result) is not None
-
-    def test_returns_string(self):
-        assert isinstance(now_iso(), str)
-
-
-class TestLoadAndSaveFeatureStatus:
-    def test_round_trip(self, state_dir):
-        fid = "F-001"
-        # Create the feature directory
-        fdir = os.path.join(state_dir, "features", fid)
-        os.makedirs(fdir, exist_ok=True)
-
-        status_data = {
-            "feature_id": fid,
-            "status": "in_progress",
-            "retry_count": 1,
-            "max_retries": 3,
-            "sessions": ["s-001"],
-            "last_session_id": "s-001",
-            "resume_from_phase": "3",
-            "created_at": "2024-01-01T00:00:00Z",
-            "updated_at": "2024-01-01T01:00:00Z",
-        }
-        err = save_feature_status(state_dir, fid, status_data)
-        assert err is None
-
-        loaded = load_feature_status(state_dir, fid)
-        assert loaded["feature_id"] == fid
-        assert loaded["status"] == "in_progress"
-        assert loaded["retry_count"] == 1
-
-    def test_load_missing_returns_default(self, state_dir):
-        result = load_feature_status(state_dir, "F-999")
-        assert result["feature_id"] == "F-999"
-        assert result["status"] == "pending"
-        assert result["retry_count"] == 0
-
-    def test_load_invalid_json_returns_default(self, state_dir):
-        fid = "F-BAD"
-        fdir = os.path.join(state_dir, "features", fid)
-        os.makedirs(fdir, exist_ok=True)
-        with open(os.path.join(fdir, "status.json"), "w") as f:
-            f.write("{invalid json")
-        result = load_feature_status(state_dir, fid)
-        assert result["status"] == "pending"
-
-
-class TestBuildFeatureSlug:
-    def test_basic(self):
-        assert _build_feature_slug("F-001", "Project Setup") == "001-project-setup"
-
-    def test_special_chars(self):
-        result = _build_feature_slug("F-002", "Auth (OAuth2.0)")
-        assert result == "002-auth-oauth20"
-
-    def test_empty_title(self):
-        result = _build_feature_slug("F-003", "")
-        assert result == "003-feature"
-
-    def test_none_title(self):
-        result = _build_feature_slug("F-003", None)
-        assert result == "003-feature"
-
-    def test_lowercase_f(self):
-        result = _build_feature_slug("f-5", "Test")
-        assert result == "005-test"
-
-    def test_numeric_padding(self):
-        result = _build_feature_slug("F-1", "A")
-        assert result.startswith("001-")
-
-
-class TestFormatDuration:
-    def test_none(self):
-        assert _format_duration(None) == "N/A"
-
-    def test_seconds(self):
-        assert _format_duration(45) == "45s"
-
-    def test_minutes(self):
-        assert _format_duration(125) == "2m5s"
-
-    def test_hours(self):
-        assert _format_duration(3661) == "1h1m"
-
-    def test_zero(self):
-        assert _format_duration(0) == "0s"
-
-    def test_exact_minute(self):
-        assert _format_duration(60) == "1m0s"
-
-    def test_exact_hour(self):
-        assert _format_duration(3600) == "1h0m"
-
-
-class TestCalcFeatureDuration:
-    def test_valid_duration(self, state_dir):
-        fid = "F-001"
-        fdir = os.path.join(state_dir, "features", fid)
-        os.makedirs(fdir, exist_ok=True)
-        status = {
-            "created_at": "2024-01-01T00:00:00Z",
-            "updated_at": "2024-01-01T00:05:00Z",  # 300 seconds
-        }
-        with open(os.path.join(fdir, "status.json"), "w") as f:
-            json.dump(status, f)
-        result = _calc_feature_duration(state_dir, fid)
-        assert result == 300.0
-
-    def test_too_short_duration(self, state_dir):
-        fid = "F-002"
-        fdir = os.path.join(state_dir, "features", fid)
-        os.makedirs(fdir, exist_ok=True)
-        status = {
-            "created_at": "2024-01-01T00:00:00Z",
-            "updated_at": "2024-01-01T00:00:05Z",  # 5 seconds - below 10s threshold
-        }
-        with open(os.path.join(fdir, "status.json"), "w") as f:
-            json.dump(status, f)
-        result = _calc_feature_duration(state_dir, fid)
-        assert result is None
-
-    def test_missing_file(self, state_dir):
-        result = _calc_feature_duration(state_dir, "F-MISSING")
-        assert result is None
-
-    def test_missing_timestamps(self, state_dir):
-        fid = "F-003"
-        fdir = os.path.join(state_dir, "features", fid)
-        os.makedirs(fdir, exist_ok=True)
-        with open(os.path.join(fdir, "status.json"), "w") as f:
-            json.dump({"status": "pending"}, f)
-        result = _calc_feature_duration(state_dir, fid)
-        assert result is None
-
-
-class TestActionUpdateDegradedStatuses:
-    def test_commit_missing_updates_feature_state_without_cleanup(
-        self, feature_list_file, state_dir, monkeypatch, capsys
-    ):
-        called = {"cleanup": 0}
-
-        def _fake_cleanup(**_kwargs):
-            called["cleanup"] += 1
-            return []
-
-        monkeypatch.setattr(ufs, "cleanup_feature_artifacts", _fake_cleanup)
-
-        args = SimpleNamespace(
-            feature_id="F-001",
-            session_status="commit_missing",
-            session_id="s-commit-missing",
-            max_retries=3,
-            project_root=None,
-        )
-
-        ufs.action_update(args, feature_list_file, state_dir)
-        out = capsys.readouterr().out
-        summary = json.loads(out)
-
-        fs = ufs.load_feature_status(state_dir, "F-001")
-        assert fs["status"] == "commit_missing"
-        assert fs["retry_count"] == 1
-        assert summary["new_status"] == "commit_missing"
-        assert summary["degraded_reason"] == "commit_missing"
-        assert summary["restart_policy"] == "finalization_retry"
-        assert called["cleanup"] == 0
-
-        with open(feature_list_file, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        f1 = next(x for x in data["features"] if x["id"] == "F-001")
-        assert f1["status"] == "commit_missing"
-
-    def test_docs_missing_reaches_failed_when_retry_exhausted(
-        self, feature_list_file, state_dir, monkeypatch, capsys
-    ):
-        called = {"cleanup": 0}
-
-        def _fake_cleanup(**_kwargs):
-            called["cleanup"] += 1
-            return []
-
-        monkeypatch.setattr(ufs, "cleanup_feature_artifacts", _fake_cleanup)
-
-        args = SimpleNamespace(
-            feature_id="F-001",
-            session_status="docs_missing",
-            session_id="s-docs-missing",
-            max_retries=1,
-            project_root=None,
-        )
-
-        ufs.action_update(args, feature_list_file, state_dir)
-        out = capsys.readouterr().out
-        summary = json.loads(out)
-
-        fs = ufs.load_feature_status(state_dir, "F-001")
-        assert fs["status"] == "failed"
-        assert fs["retry_count"] == 1
-        assert summary["new_status"] == "failed"
-        assert summary["degraded_reason"] == "docs_missing"
-        assert summary["restart_policy"] == "finalization_retry"
-        assert called["cleanup"] == 0
-
-        with open(feature_list_file, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        f1 = next(x for x in data["features"] if x["id"] == "F-001")
-        assert f1["status"] == "failed"
-
-    def test_merge_conflict_updates_feature_state_without_cleanup(
-        self, feature_list_file, state_dir, monkeypatch, capsys
-    ):
-        """merge_conflict is treated like commit_missing: retryable, no artifact cleanup."""
-        called = {"cleanup": 0}
-
-        def _fake_cleanup(**_kwargs):
-            called["cleanup"] += 1
-            return []
-
-        monkeypatch.setattr(ufs, "cleanup_feature_artifacts", _fake_cleanup)
-
-        args = SimpleNamespace(
-            feature_id="F-001",
-            session_status="merge_conflict",
-            session_id="s-merge-conflict",
-            max_retries=3,
-            project_root=None,
-        )
-
-        ufs.action_update(args, feature_list_file, state_dir)
-        out = capsys.readouterr().out
-        summary = json.loads(out)
-
-        fs = ufs.load_feature_status(state_dir, "F-001")
-        assert fs["status"] == "merge_conflict"
-        assert fs["retry_count"] == 1
-        assert summary["new_status"] == "merge_conflict"
-        assert summary["degraded_reason"] == "merge_conflict"
-        assert summary["restart_policy"] == "finalization_retry"
-        assert called["cleanup"] == 0
-
-        with open(feature_list_file, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        f1 = next(x for x in data["features"] if x["id"] == "F-001")
-        assert f1["status"] == "merge_conflict"
-
-    def test_merge_conflict_reaches_failed_when_retry_exhausted(
-        self, feature_list_file, state_dir, monkeypatch, capsys
-    ):
-        """merge_conflict with max_retries=1 should fail the feature."""
-        called = {"cleanup": 0}
-
-        def _fake_cleanup(**_kwargs):
-            called["cleanup"] += 1
-            return []
-
-        monkeypatch.setattr(ufs, "cleanup_feature_artifacts", _fake_cleanup)
-
-        args = SimpleNamespace(
-            feature_id="F-001",
-            session_status="merge_conflict",
-            session_id="s-merge-conflict-fail",
-            max_retries=1,
-            project_root=None,
-        )
-
-        ufs.action_update(args, feature_list_file, state_dir)
-        out = capsys.readouterr().out
-        summary = json.loads(out)
-
-        fs = ufs.load_feature_status(state_dir, "F-001")
-        assert fs["status"] == "failed"
-        assert fs["retry_count"] == 1
-        assert summary["new_status"] == "failed"
-        assert called["cleanup"] == 0
-
-
-class TestActionStatusForDegradedStates:
-    def test_status_output_contains_degraded_counters(self, feature_list_file, state_dir, capsys):
-        # Update feature-list.json to set degraded statuses (single source of truth)
-        with open(feature_list_file, "r", encoding="utf-8") as f:
-            feature_list_data = json.load(f)
-
-        feature_list_data["features"][0]["status"] = "commit_missing"
-        feature_list_data["features"][1]["status"] = "docs_missing"
-
-        ufs.action_status(feature_list_data, state_dir)
-        out = capsys.readouterr().out
-
-        assert "Commit Missing: 1 | Docs Missing: 1" in out

package/bundled/dev-pipeline/tests/test_worktree.py

@@ -1,236 +0,0 @@
-"""Tests for dev-pipeline/lib/worktree.sh.
-
-Uses subprocess to invoke the worktree functions in a real (temporary) git repo
-to verify create/merge/cleanup/prune lifecycle.
-"""
-
-import json
-import os
-import subprocess
-import pytest
-
-
-SCRIPT_DIR = os.path.join(os.path.dirname(__file__), "..")
-LIB_DIR = os.path.join(SCRIPT_DIR, "lib")
-
-
-def _run_worktree_script(script_body, env=None):
-    """Run a bash script that sources worktree.sh (with stub log functions), then executes body."""
-    # We define stub log functions instead of sourcing common.sh to avoid
-    # CLI/platform detection which requires cbc/claude in PATH.
-    worktree_sh_path = os.path.join(os.path.abspath(LIB_DIR), "worktree.sh")
-    full_script = "\n".join([
-        "#!/usr/bin/env bash",
-        "set -euo pipefail",
-        # Stub log functions (worktree.sh uses log_info, log_warn, log_error, log_success)
-        'log_info()    { echo "[INFO] $*"; }',
-        'log_warn()    { echo "[WARN] $*"; }',
-        'log_error()   { echo "[ERROR] $*"; }',
-        'log_success() { echo "[SUCCESS] $*"; }',
-        'source "%s"' % worktree_sh_path,
-        script_body,
-    ])
-    merged_env = dict(os.environ)
-    if env:
-        merged_env.update(env)
-    result = subprocess.run(
-        ["bash", "-c", full_script],
-        capture_output=True,
-        text=True,
-        env=merged_env,
-    )
-    return result
-
-
-def _init_git_repo(path):
-    """Initialize a bare-bones git repo with an initial commit on 'main' branch."""
-    subprocess.run(["git", "init", str(path)], capture_output=True, check=True)
-    subprocess.run(
-        ["git", "-C", str(path), "config", "user.email", "test@test.com"],
-        capture_output=True,
-        check=True,
-    )
-    subprocess.run(
-        ["git", "-C", str(path), "config", "user.name", "Test"],
-        capture_output=True,
-        check=True,
-    )
-    # Create an initial commit so we have a branch
-    readme = os.path.join(str(path), "README.md")
-    with open(readme, "w") as f:
-        f.write("# Test Repo\n")
-    subprocess.run(
-        ["git", "-C", str(path), "add", "."], capture_output=True, check=True
-    )
-    subprocess.run(
-        ["git", "-C", str(path), "commit", "-m", "Initial commit"],
-        capture_output=True,
-        check=True,
-    )
-    # Ensure the branch is named 'main' regardless of git defaults
-    subprocess.run(
-        ["git", "-C", str(path), "branch", "-M", "main"],
-        capture_output=True,
-        check=True,
-    )
-
-
-class TestWorktreeCreate:
-    def test_creates_worktree_and_branch(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-        wt_base = tmp_path / "worktrees"
-
-        script = (
-            'worktree_create "{repo}" "{wt_base}" "test-session-001" "main"\n'
-            'echo "PATH=$_WORKTREE_PATH"\n'
-            'echo "BRANCH=$_WORKTREE_BRANCH"\n'
-        ).format(repo=repo, wt_base=wt_base)
-
-        result = _run_worktree_script(script)
-        assert result.returncode == 0, f"stderr: {result.stderr}"
-
-        lines = result.stdout.strip().split("\n")
-        path_line = [l for l in lines if l.startswith("PATH=")]
-        branch_line = [l for l in lines if l.startswith("BRANCH=")]
-
-        assert len(path_line) == 1
-        assert len(branch_line) == 1
-
-        wt_path = path_line[0].split("=", 1)[1]
-        wt_branch = branch_line[0].split("=", 1)[1]
-
-        assert os.path.isdir(wt_path)
-        assert wt_branch == "worktree/test-session-001"
-
-        # Verify git branch exists
-        branch_check = subprocess.run(
-            ["git", "-C", str(repo), "rev-parse", "--verify", wt_branch],
-            capture_output=True,
-        )
-        assert branch_check.returncode == 0
-
-    def test_fails_when_worktree_already_exists(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-        wt_base = tmp_path / "worktrees"
-
-        # Create the worktree directory manually to trigger failure
-        wt_path = wt_base / "dup-session"
-        wt_path.mkdir(parents=True)
-
-        script = (
-            'worktree_create "{repo}" "{wt_base}" "dup-session" "main"\n'
-            'echo "RC=$?"\n'
-        ).format(repo=repo, wt_base=wt_base)
-
-        # Since set -e is on and worktree_create returns 1, the script exits with 1
-        result = _run_worktree_script(script)
-        assert result.returncode != 0 or "RC=1" in result.stdout
-
-
-class TestWorktreeMerge:
-    def test_merge_success(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-        wt_base = tmp_path / "worktrees"
-
-        # Create worktree, add a file, commit, then merge
-        script = (
-            'worktree_create "{repo}" "{wt_base}" "merge-test" "main"\n'
-            'echo "hello" > "$_WORKTREE_PATH/newfile.txt"\n'
-            'git -C "$_WORKTREE_PATH" add newfile.txt\n'
-            'git -C "$_WORKTREE_PATH" commit -m "Add newfile"\n'
-            'worktree_merge "{repo}" "$_WORKTREE_BRANCH" "main" "F-001" "merge-test"\n'
-            'echo "MERGE=$_MERGE_RESULT"\n'
-        ).format(repo=repo, wt_base=wt_base)
-
-        result = _run_worktree_script(script)
-        assert result.returncode == 0, f"stderr: {result.stderr}"
-        assert "MERGE=success" in result.stdout
-
-        # Verify the file exists on main
-        assert os.path.isfile(str(repo / "newfile.txt"))
-
-    def test_merge_conflict(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-        wt_base = tmp_path / "worktrees"
-
-        # Create worktree, modify README on both main and worktree to cause conflict
-        script = (
-            # Create worktree
-            'worktree_create "{repo}" "{wt_base}" "conflict-test" "main"\n'
-            # Modify file in worktree and commit
-            'echo "worktree change" > "$_WORKTREE_PATH/README.md"\n'
-            'git -C "$_WORKTREE_PATH" add README.md\n'
-            'git -C "$_WORKTREE_PATH" commit -m "Worktree change"\n'
-            # Modify same file in main and commit
-            'echo "main change" > "{repo}/README.md"\n'
-            'git -C "{repo}" add README.md\n'
-            'git -C "{repo}" commit -m "Main change"\n'
-            # Attempt merge (should conflict)
-            'worktree_merge "{repo}" "worktree/conflict-test" "main" "F-001" "conflict-test" || true\n'
-            'echo "MERGE=$_MERGE_RESULT"\n'
-        ).format(repo=repo, wt_base=wt_base)
-
-        result = _run_worktree_script(script)
-        # Script may exit non-zero due to merge conflict detection
-        assert "MERGE=conflict" in result.stdout
-
-
-class TestWorktreeCleanup:
-    def test_cleanup_removes_worktree_and_branch(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-        wt_base = tmp_path / "worktrees"
-
-        script = (
-            'worktree_create "{repo}" "{wt_base}" "cleanup-test" "main"\n'
-            'local_path="$_WORKTREE_PATH"\n'
-            'local_branch="$_WORKTREE_BRANCH"\n'
-            'worktree_cleanup "{repo}" "$local_path" "$local_branch"\n'
-            '[ -d "$local_path" ] && echo "DIR_EXISTS" || echo "DIR_GONE"\n'
-            'git -C "{repo}" rev-parse --verify "$local_branch" 2>/dev/null && echo "BRANCH_EXISTS" || echo "BRANCH_GONE"\n'
-        ).format(repo=repo, wt_base=wt_base)
-
-        result = _run_worktree_script(script)
-        assert result.returncode == 0, f"stderr: {result.stderr}"
-        assert "DIR_GONE" in result.stdout
-        assert "BRANCH_GONE" in result.stdout
-
-    def test_cleanup_idempotent(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-
-        # Call cleanup on non-existent worktree/branch
-        script = (
-            'worktree_cleanup "{repo}" "/nonexistent/path" "nonexistent-branch"\n'
-            'echo "OK"\n'
-        ).format(repo=repo)
-
-        result = _run_worktree_script(script)
-        assert result.returncode == 0
-        assert "OK" in result.stdout
-
-
-class TestWorktreePruneStale:
-    def test_prune_stale(self, tmp_path):
-        repo = tmp_path / "repo"
-        repo.mkdir()
-        _init_git_repo(repo)
-
-        script = (
-            'worktree_prune_stale "{repo}"\n'
-            'echo "OK"\n'
-        ).format(repo=repo)
-
-        result = _run_worktree_script(script)
-        assert result.returncode == 0
-        assert "OK" in result.stdout