prizmkit 1.0.45 → 1.0.66

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

@@ -1,153 +0,0 @@
-"""Tests for init-bugfix-pipeline.py."""
-
-import json
-import os
-import sys
-import pytest
-
-
-def _import_init_bugfix_pipeline():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "init-bugfix-pipeline.py"
-    )
-    spec = importlib.util.spec_from_file_location("init_bugfix_pipeline", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["init_bugfix_pipeline"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-init_bugfix = _import_init_bugfix_pipeline()
-validate_schema = init_bugfix.validate_schema
-validate_bugs = init_bugfix.validate_bugs
-create_state_directory = init_bugfix.create_state_directory
-
-
-class TestValidateSchema:
-    def test_valid_schema(self, sample_bug_list):
-        errors = validate_schema(sample_bug_list)
-        assert errors == []
-
-    def test_wrong_schema(self):
-        data = {
-            "$schema": "wrong",
-            "project_name": "Test",
-            "bugs": [{"id": "B-001"}],
-        }
-        errors = validate_schema(data)
-        assert any("$schema" in e for e in errors)
-
-    def test_missing_project_name(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "bugs": [{"id": "B-001"}],
-        }
-        errors = validate_schema(data)
-        assert any("project_name" in e for e in errors)
-
-    def test_empty_project_name(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "  ",
-            "bugs": [{"id": "B-001"}],
-        }
-        errors = validate_schema(data)
-        assert any("project_name" in e for e in errors)
-
-    def test_missing_bugs(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "Test",
-        }
-        errors = validate_schema(data)
-        assert any("bugs" in e for e in errors)
-
-    def test_bugs_not_array(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "Test",
-            "bugs": "not array",
-        }
-        errors = validate_schema(data)
-        assert any("bugs must be an array" in e for e in errors)
-
-    def test_empty_bugs_array(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "Test",
-            "bugs": [],
-        }
-        errors = validate_schema(data)
-        assert any("at least one bug" in e for e in errors)
-
-
-class TestValidateBugs:
-    def test_valid_bugs(self, sample_bug_list):
-        errors, ids = validate_bugs(sample_bug_list["bugs"])
-        assert errors == []
-        assert ids == {"B-001", "B-002"}
-
-    def test_duplicate_ids(self):
-        bugs = [
-            _make_bug("B-001"), _make_bug("B-001", title="Other"),
-        ]
-        errors, ids = validate_bugs(bugs)
-        assert any("Duplicate" in e for e in errors)
-
-    def test_invalid_id_format(self):
-        bugs = [_make_bug("X-001")]
-        errors, ids = validate_bugs(bugs)
-        assert any("invalid id" in e for e in errors)
-
-    def test_invalid_severity(self):
-        bug = _make_bug("B-001")
-        bug["severity"] = "super_critical"
-        errors, ids = validate_bugs([bug])
-        assert any("invalid severity" in e for e in errors)
-
-    def test_invalid_verification_type(self):
-        bug = _make_bug("B-001")
-        bug["verification_type"] = "magic"
-        errors, ids = validate_bugs([bug])
-        assert any("invalid verification_type" in e for e in errors)
-
-    def test_invalid_status(self):
-        bug = _make_bug("B-001")
-        bug["status"] = "nonexistent_status"
-        errors, ids = validate_bugs([bug])
-        assert any("invalid status" in e for e in errors)
-
-    def test_missing_required_fields(self):
-        bugs = [{"id": "B-001"}]
-        errors, ids = validate_bugs(bugs)
-        assert len(errors) > 0
-
-    def test_error_source_not_object(self):
-        bug = _make_bug("B-001")
-        bug["error_source"] = "a string"
-        errors, ids = validate_bugs([bug])
-        assert any("error_source must be an object" in e for e in errors)
-
-    def test_error_source_missing_type(self):
-        bug = _make_bug("B-001")
-        bug["error_source"] = {"detail": "something"}
-        errors, ids = validate_bugs([bug])
-        assert any("error_source missing required field: type" in e for e in errors)
-
-    def test_non_dict_bug(self):
-        errors, ids = validate_bugs(["not a dict"])
-        assert any("not an object" in e for e in errors)
-
-
-def _make_bug(bid, title="Test Bug"):
-    return {
-        "id": bid,
-        "title": title,
-        "description": "A bug",
-        "severity": "medium",
-        "error_source": {"type": "stack_trace"},
-        "verification_type": "automated",
-        "acceptance_criteria": ["Fixed"],
-        "status": "pending",
-    }

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

@@ -1,241 +0,0 @@
-"""Tests for init-pipeline.py."""
-
-import json
-import os
-import sys
-import importlib
-import pytest
-
-
-# The module has a hyphen in the name, so we need importlib
-def _import_init_pipeline():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "init-pipeline.py"
-    )
-    spec = importlib.util.spec_from_file_location("init_pipeline", path)
-    mod = importlib.util.module_from_spec(spec)
-    # Prevent main() from running on import
-    sys.modules["init_pipeline"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-init_pipeline = _import_init_pipeline()
-validate_schema = init_pipeline.validate_schema
-validate_features = init_pipeline.validate_features
-check_dag = init_pipeline.check_dag
-create_state_directory = init_pipeline.create_state_directory
-
-
-class TestValidateSchema:
-    def test_valid_schema(self, sample_feature_list):
-        errors = validate_schema(sample_feature_list)
-        assert errors == []
-
-    def test_wrong_schema_value(self):
-        data = {
-            "$schema": "wrong-schema",
-            "app_name": "Test",
-            "features": [],
-        }
-        errors = validate_schema(data)
-        assert len(errors) == 1
-        assert "Invalid $schema" in errors[0]
-
-    def test_missing_schema(self):
-        data = {"app_name": "Test", "features": []}
-        errors = validate_schema(data)
-        assert any("$schema" in e for e in errors)
-
-    def test_missing_app_name(self):
-        data = {
-            "$schema": "dev-pipeline-feature-list-v1",
-            "features": [],
-        }
-        errors = validate_schema(data)
-        assert any("app_name" in e for e in errors)
-
-    def test_empty_app_name(self):
-        data = {
-            "$schema": "dev-pipeline-feature-list-v1",
-            "app_name": "   ",
-            "features": [],
-        }
-        errors = validate_schema(data)
-        assert any("app_name" in e for e in errors)
-
-    def test_missing_features(self):
-        data = {
-            "$schema": "dev-pipeline-feature-list-v1",
-            "app_name": "Test",
-        }
-        errors = validate_schema(data)
-        assert any("features" in e for e in errors)
-
-    def test_features_not_array(self):
-        data = {
-            "$schema": "dev-pipeline-feature-list-v1",
-            "app_name": "Test",
-            "features": "not an array",
-        }
-        errors = validate_schema(data)
-        assert any("features must be an array" in e for e in errors)
-
-
-class TestValidateFeatures:
-    def test_valid_features(self, sample_feature_list):
-        errors, ids = validate_features(sample_feature_list["features"])
-        assert errors == []
-        assert ids == {"F-001", "F-002", "F-003"}
-
-    def test_duplicate_ids(self):
-        features = [
-            {"id": "F-001", "title": "A", "description": "D", "priority": 1,
-             "dependencies": [], "acceptance_criteria": [], "status": "pending"},
-            {"id": "F-001", "title": "B", "description": "D", "priority": 2,
-             "dependencies": [], "acceptance_criteria": [], "status": "pending"},
-        ]
-        errors, ids = validate_features(features)
-        assert any("Duplicate" in e for e in errors)
-
-    def test_invalid_id_format(self):
-        features = [
-            {"id": "X-001", "title": "A", "description": "D", "priority": 1,
-             "dependencies": [], "acceptance_criteria": [], "status": "pending"},
-        ]
-        errors, ids = validate_features(features)
-        assert any("invalid id" in e for e in errors)
-
-    def test_missing_required_fields(self):
-        features = [{"id": "F-001"}]
-        errors, ids = validate_features(features)
-        # Should have errors for missing title, description, etc.
-        assert len(errors) > 0
-        assert any("missing required field" in e for e in errors)
-
-    def test_non_object_feature(self):
-        features = ["not a dict"]
-        errors, ids = validate_features(features)
-        assert any("not an object" in e for e in errors)
-
-    def test_unknown_dependency(self):
-        features = [
-            {"id": "F-001", "title": "A", "description": "D", "priority": 1,
-             "dependencies": ["F-999"], "acceptance_criteria": [], "status": "pending"},
-        ]
-        errors, ids = validate_features(features)
-        assert any("unknown feature" in e for e in errors)
-
-    def test_dependencies_not_array(self):
-        features = [
-            {"id": "F-001", "title": "A", "description": "D", "priority": 1,
-             "dependencies": "not-a-list", "acceptance_criteria": [], "status": "pending"},
-        ]
-        errors, ids = validate_features(features)
-        assert any("dependencies must be an array" in e for e in errors)
-
-
-class TestCheckDag:
-    def test_simple_chain(self):
-        features = [
-            {"id": "F-001", "dependencies": []},
-            {"id": "F-002", "dependencies": ["F-001"]},
-            {"id": "F-003", "dependencies": ["F-002"]},
-        ]
-        errors = check_dag(features)
-        assert errors == []
-
-    def test_diamond_dependency(self):
-        features = [
-            {"id": "F-001", "dependencies": []},
-            {"id": "F-002", "dependencies": ["F-001"]},
-            {"id": "F-003", "dependencies": ["F-001"]},
-            {"id": "F-004", "dependencies": ["F-002", "F-003"]},
-        ]
-        errors = check_dag(features)
-        assert errors == []
-
-    def test_circular_dependency(self):
-        features = [
-            {"id": "F-001", "dependencies": ["F-003"]},
-            {"id": "F-002", "dependencies": ["F-001"]},
-            {"id": "F-003", "dependencies": ["F-002"]},
-        ]
-        errors = check_dag(features)
-        assert len(errors) == 1
-        assert "cycle" in errors[0].lower()
-
-    def test_self_dependency(self):
-        features = [
-            {"id": "F-001", "dependencies": ["F-001"]},
-        ]
-        errors = check_dag(features)
-        assert len(errors) == 1
-        assert "cycle" in errors[0].lower()
-
-    def test_no_features(self):
-        errors = check_dag([])
-        assert errors == []
-
-    def test_independent_features(self):
-        features = [
-            {"id": "F-001", "dependencies": []},
-            {"id": "F-002", "dependencies": []},
-        ]
-        errors = check_dag(features)
-        assert errors == []
-
-
-class TestCreateStateDirectory:
-    def test_creates_expected_structure(self, tmp_path, sample_feature_list):
-        state_dir = str(tmp_path / "state")
-        fl_path = str(tmp_path / "feature-list.json")
-        with open(fl_path, "w") as f:
-            json.dump(sample_feature_list, f)
-
-        result = create_state_directory(
-            state_dir, fl_path, sample_feature_list["features"]
-        )
-
-        assert os.path.isdir(result)
-        assert os.path.isfile(os.path.join(result, "pipeline.json"))
-
-        # Check per-feature dirs
-        for feature in sample_feature_list["features"]:
-            fid = feature["id"]
-            fdir = os.path.join(result, "features", fid)
-            assert os.path.isdir(fdir)
-            assert os.path.isfile(os.path.join(fdir, "status.json"))
-            assert os.path.isdir(os.path.join(fdir, "sessions"))
-
-    def test_pipeline_json_contents(self, tmp_path, sample_feature_list):
-        state_dir = str(tmp_path / "state")
-        fl_path = str(tmp_path / "fl.json")
-        with open(fl_path, "w") as f:
-            json.dump(sample_feature_list, f)
-
-        create_state_directory(state_dir, fl_path, sample_feature_list["features"])
-
-        with open(os.path.join(state_dir, "pipeline.json")) as f:
-            pipeline = json.load(f)
-
-        assert pipeline["status"] == "initialized"
-        assert pipeline["total_features"] == 3
-        assert pipeline["completed_features"] == 0
-        assert pipeline["run_id"].startswith("run-")
-
-    def test_feature_status_contents(self, tmp_path, sample_feature_list):
-        state_dir = str(tmp_path / "state")
-        fl_path = str(tmp_path / "fl.json")
-        with open(fl_path, "w") as f:
-            json.dump(sample_feature_list, f)
-
-        create_state_directory(state_dir, fl_path, sample_feature_list["features"])
-
-        with open(os.path.join(state_dir, "features", "F-001", "status.json")) as f:
-            status = json.load(f)
-
-        assert status["feature_id"] == "F-001"
-        assert status["status"] == "pending"
-        assert status["retry_count"] == 0

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

@@ -1,142 +0,0 @@
-"""Tests for update-bug-status.py."""
-
-import json
-import os
-import re
-import sys
-import pytest
-
-
-def _import_update_bug_status():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "update-bug-status.py"
-    )
-    spec = importlib.util.spec_from_file_location("update_bug_status", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["update_bug_status"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-ubs = _import_update_bug_status()
-now_iso = ubs.now_iso
-load_bug_status = ubs.load_bug_status
-save_bug_status = ubs.save_bug_status
-action_get_next = ubs.action_get_next
-SEVERITY_PRIORITY = ubs.SEVERITY_PRIORITY
-
-
-class TestNowIso:
-    def test_valid_format(self):
-        result = now_iso()
-        pattern = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$"
-        assert re.match(pattern, result) is not None
-
-
-class TestLoadAndSaveBugStatus:
-    def test_round_trip(self, bugfix_state_dir):
-        bid = "B-001"
-        bdir = os.path.join(bugfix_state_dir, "bugs", bid)
-        os.makedirs(bdir, exist_ok=True)
-
-        data = {
-            "bug_id": bid,
-            "status": "in_progress",
-            "retry_count": 2,
-            "max_retries": 3,
-            "sessions": ["s-001"],
-            "last_session_id": "s-001",
-            "resume_from_phase": None,
-            "created_at": "2024-01-01T00:00:00Z",
-            "updated_at": "2024-01-01T01:00:00Z",
-        }
-        err = save_bug_status(bugfix_state_dir, bid, data)
-        assert err is None
-
-        loaded = load_bug_status(bugfix_state_dir, bid)
-        assert loaded["bug_id"] == bid
-        assert loaded["status"] == "in_progress"
-        assert loaded["retry_count"] == 2
-
-    def test_load_missing_returns_default(self, bugfix_state_dir):
-        result = load_bug_status(bugfix_state_dir, "B-999")
-        assert result["bug_id"] == "B-999"
-        assert result["status"] == "pending"
-        assert result["retry_count"] == 0
-
-    def test_load_invalid_json_returns_default(self, bugfix_state_dir):
-        bid = "B-BAD"
-        bdir = os.path.join(bugfix_state_dir, "bugs", bid)
-        os.makedirs(bdir, exist_ok=True)
-        with open(os.path.join(bdir, "status.json"), "w") as f:
-            f.write("not json!")
-        result = load_bug_status(bugfix_state_dir, bid)
-        assert result["status"] == "pending"
-
-
-class TestActionGetNext:
-    def test_selects_critical_before_medium(self, bugfix_state_dir, capsys):
-        bug_list = {
-            "bugs": [
-                {"id": "B-001", "title": "Low", "severity": "medium", "priority": 1},
-                {"id": "B-002", "title": "High", "severity": "critical", "priority": 2},
-            ]
-        }
-        action_get_next(bug_list, bugfix_state_dir)
-        captured = capsys.readouterr()
-        result = json.loads(captured.out)
-        assert result["bug_id"] == "B-002"
-        assert result["severity"] == "critical"
-
-    def test_same_severity_sorted_by_priority(self, bugfix_state_dir, capsys):
-        bug_list = {
-            "bugs": [
-                {"id": "B-001", "title": "P3", "severity": "high", "priority": 3},
-                {"id": "B-002", "title": "P1", "severity": "high", "priority": 1},
-            ]
-        }
-        action_get_next(bug_list, bugfix_state_dir)
-        captured = capsys.readouterr()
-        result = json.loads(captured.out)
-        assert result["bug_id"] == "B-002"
-
-    def test_all_completed_prints_pipeline_complete(self, bugfix_state_dir, capsys):
-        bug_list = {"bugs": [{"id": "B-001", "title": "Done", "severity": "low"}]}
-        # Mark as completed
-        bdir = os.path.join(bugfix_state_dir, "bugs", "B-001")
-        os.makedirs(bdir, exist_ok=True)
-        with open(os.path.join(bdir, "status.json"), "w") as f:
-            json.dump({"status": "completed"}, f)
-        action_get_next(bug_list, bugfix_state_dir)
-        captured = capsys.readouterr()
-        assert "PIPELINE_COMPLETE" in captured.out
-
-    def test_empty_bugs_prints_pipeline_complete(self, bugfix_state_dir, capsys):
-        action_get_next({"bugs": []}, bugfix_state_dir)
-        captured = capsys.readouterr()
-        assert "PIPELINE_COMPLETE" in captured.out
-
-    def test_prefers_in_progress_over_pending(self, bugfix_state_dir, capsys):
-        bug_list = {
-            "bugs": [
-                {"id": "B-001", "title": "Pending", "severity": "critical", "priority": 1},
-                {"id": "B-002", "title": "In Progress", "severity": "low", "priority": 2},
-            ]
-        }
-        # Mark B-002 as in_progress
-        bdir = os.path.join(bugfix_state_dir, "bugs", "B-002")
-        os.makedirs(bdir, exist_ok=True)
-        with open(os.path.join(bdir, "status.json"), "w") as f:
-            json.dump({"status": "in_progress", "retry_count": 0}, f)
-        action_get_next(bug_list, bugfix_state_dir)
-        captured = capsys.readouterr()
-        result = json.loads(captured.out)
-        assert result["bug_id"] == "B-002"
-
-
-class TestSeverityPriority:
-    def test_order(self):
-        assert SEVERITY_PRIORITY["critical"] < SEVERITY_PRIORITY["high"]
-        assert SEVERITY_PRIORITY["high"] < SEVERITY_PRIORITY["medium"]
-        assert SEVERITY_PRIORITY["medium"] < SEVERITY_PRIORITY["low"]