prizmkit 1.0.13 → 1.0.14

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

@@ -0,0 +1,181 @@
+"""Tests for generate-bugfix-prompt.py."""
+
+import os
+import sys
+import pytest
+
+
+def _import_generate_bugfix_prompt():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "generate-bugfix-prompt.py"
+    )
+    spec = importlib.util.spec_from_file_location("generate_bugfix_prompt", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["generate_bugfix_prompt"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+gen_bugfix = _import_generate_bugfix_prompt()
+format_acceptance_criteria = gen_bugfix.format_acceptance_criteria
+format_global_context = gen_bugfix.format_global_context
+format_error_source_details = gen_bugfix.format_error_source_details
+format_environment = gen_bugfix.format_environment
+process_conditional_blocks = gen_bugfix.process_conditional_blocks
+
+
+class TestFormatAcceptanceCriteria:
+    def test_normal(self):
+        result = format_acceptance_criteria(["Fix A", "Fix B"])
+        assert result == "- Fix A\n- Fix B"
+
+    def test_empty(self):
+        result = format_acceptance_criteria([])
+        assert "none specified" in result
+
+    def test_none(self):
+        result = format_acceptance_criteria(None)
+        assert "none specified" in result
+
+    def test_single(self):
+        result = format_acceptance_criteria(["Only one"])
+        assert result == "- Only one"
+
+
+class TestFormatGlobalContext:
+    def test_normal(self):
+        result = format_global_context({"lang": "Python"})
+        assert "**lang**" in result
+        assert "Python" in result
+
+    def test_empty(self):
+        assert "none specified" in format_global_context({})
+
+    def test_none(self):
+        assert "none specified" in format_global_context(None)
+
+
+class TestFormatErrorSourceDetails:
+    def test_stack_trace(self):
+        error_source = {
+            "type": "stack_trace",
+            "stack_trace": "Traceback ... Error",
+            "error_message": "Something broke",
+        }
+        result = format_error_source_details(error_source)
+        assert "Stack Trace" in result
+        assert "Traceback ... Error" in result
+        assert "Error Message" in result
+        assert "Something broke" in result
+
+    def test_log_pattern(self):
+        error_source = {
+            "type": "log_pattern",
+            "log_snippet": "ERROR 2024-01-01 ...",
+        }
+        result = format_error_source_details(error_source)
+        assert "Log Snippet" in result
+
+    def test_failed_test(self):
+        error_source = {
+            "type": "failed_test",
+            "failed_test_path": "tests/test_auth.py::test_login",
+        }
+        result = format_error_source_details(error_source)
+        assert "Failed Test" in result
+        assert "test_auth.py" in result
+
+    def test_user_report(self):
+        error_source = {
+            "type": "user_report",
+            "reproduction_steps": ["Step 1", "Step 2"],
+        }
+        result = format_error_source_details(error_source)
+        assert "Reproduction Steps" in result
+        assert "Step 1" in result
+        assert "Step 2" in result
+
+    def test_none_source(self):
+        result = format_error_source_details(None)
+        assert "no error source details" in result
+
+    def test_empty_source(self):
+        result = format_error_source_details({})
+        assert "no error source details" in result
+
+    def test_non_dict_source(self):
+        result = format_error_source_details("not a dict")
+        assert "no error source details" in result
+
+    def test_unknown_type_with_error_message(self):
+        error_source = {
+            "type": "unknown",
+            "error_message": "Something happened",
+        }
+        result = format_error_source_details(error_source)
+        assert "Error Message" in result
+
+
+class TestFormatEnvironment:
+    def test_normal(self):
+        result = format_environment({"os": "macOS", "browser": "Chrome"})
+        assert "**browser**" in result
+        assert "**os**" in result
+
+    def test_empty(self):
+        result = format_environment({})
+        assert "not specified" in result
+
+    def test_none(self):
+        result = format_environment(None)
+        assert "not specified" in result
+
+    def test_non_dict(self):
+        result = format_environment("not a dict")
+        assert "not specified" in result
+
+    def test_empty_values_filtered(self):
+        result = format_environment({"os": "macOS", "empty_key": ""})
+        assert "os" in result
+        # empty_key should be filtered because its value is falsy
+        assert "empty_key" not in result
+
+    def test_all_empty_values(self):
+        result = format_environment({"a": "", "b": None})
+        assert "not specified" in result
+
+
+class TestProcessConditionalBlocks:
+    def test_manual_verification_keeps_block(self):
+        bug = {"verification_type": "manual"}
+        content = "before\n{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nmanual stuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nafter"
+        result = process_conditional_blocks(content, bug)
+        assert "manual stuff" in result
+        assert "{{IF_VERIFICATION" not in result
+
+    def test_hybrid_verification_keeps_block(self):
+        bug = {"verification_type": "hybrid"}
+        content = "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nhybrid stuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}"
+        result = process_conditional_blocks(content, bug)
+        assert "hybrid stuff" in result
+
+    def test_automated_verification_removes_block(self):
+        bug = {"verification_type": "automated"}
+        content = "before\n{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nmanual stuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nafter"
+        result = process_conditional_blocks(content, bug)
+        assert "manual stuff" not in result
+        assert "after" in result
+
+    def test_no_verification_type_defaults_automated(self):
+        bug = {}
+        content = "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nstuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nrest"
+        result = process_conditional_blocks(content, bug)
+        assert "stuff" not in result
+        assert "rest" in result
+
+    def test_no_conditional_blocks(self):
+        bug = {"verification_type": "automated"}
+        content = "plain text"
+        result = process_conditional_blocks(content, bug)
+        assert result == "plain text"

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

@@ -0,0 +1,190 @@
+"""Tests for generate-bootstrap-prompt.py."""
+
+import os
+import sys
+import pytest
+
+
+def _import_generate_prompt():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "generate-bootstrap-prompt.py"
+    )
+    spec = importlib.util.spec_from_file_location("generate_bootstrap_prompt", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["generate_bootstrap_prompt"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+gen_prompt = _import_generate_prompt()
+compute_feature_slug = gen_prompt.compute_feature_slug
+format_acceptance_criteria = gen_prompt.format_acceptance_criteria
+format_global_context = gen_prompt.format_global_context
+process_conditional_blocks = gen_prompt.process_conditional_blocks
+process_mode_blocks = gen_prompt.process_mode_blocks
+determine_pipeline_mode = gen_prompt.determine_pipeline_mode
+
+
+class TestComputeFeatureSlug:
+    def test_basic(self):
+        result = compute_feature_slug("F-001", "Project Infrastructure Setup")
+        assert result == "001-project-infrastructure-setup"
+
+    def test_special_characters(self):
+        result = compute_feature_slug("F-002", "User Auth (OAuth2.0)")
+        assert result == "002-user-auth-oauth20"
+
+    def test_uppercase_id(self):
+        result = compute_feature_slug("F-042", "My Feature")
+        assert result == "042-my-feature"
+
+    def test_lowercase_f(self):
+        result = compute_feature_slug("f-5", "Quick Fix")
+        assert result == "005-quick-fix"
+
+    def test_extra_spaces(self):
+        result = compute_feature_slug("F-010", "  Extra   Spaces  ")
+        assert result == "010-extra-spaces"
+
+    def test_empty_title(self):
+        result = compute_feature_slug("F-001", "")
+        # Numeric part only, no trailing hyphen
+        assert result.startswith("001")
+
+    def test_numeric_padding(self):
+        result = compute_feature_slug("F-1", "Test")
+        assert result.startswith("001-")
+
+
+class TestFormatAcceptanceCriteria:
+    def test_single_item(self):
+        result = format_acceptance_criteria(["Must work"])
+        assert result == "- Must work"
+
+    def test_multiple_items(self):
+        result = format_acceptance_criteria(["A", "B", "C"])
+        assert result == "- A\n- B\n- C"
+
+    def test_empty_list(self):
+        result = format_acceptance_criteria([])
+        assert "none specified" in result
+
+    def test_none_input(self):
+        result = format_acceptance_criteria(None)
+        assert "none specified" in result
+
+
+class TestFormatGlobalContext:
+    def test_basic(self):
+        result = format_global_context({"language": "Python", "framework": "FastAPI"})
+        assert "**framework**" in result
+        assert "**language**" in result
+        assert "Python" in result
+        assert "FastAPI" in result
+
+    def test_sorted_keys(self):
+        result = format_global_context({"z_key": "z", "a_key": "a"})
+        lines = result.split("\n")
+        assert "a_key" in lines[0]
+        assert "z_key" in lines[1]
+
+    def test_empty_context(self):
+        result = format_global_context({})
+        assert "none specified" in result
+
+    def test_none_context(self):
+        result = format_global_context(None)
+        assert "none specified" in result
+
+
+class TestProcessConditionalBlocks:
+    def test_fresh_start_keeps_fresh_block(self):
+        content = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(content, "null")
+        assert "fresh content" in result
+        assert "{{IF_FRESH_START}}" not in result
+        assert "after" in result
+
+    def test_fresh_start_removes_resume_block(self):
+        content = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(content, "null")
+        assert "resume content" not in result
+        assert "after" in result
+
+    def test_resume_keeps_resume_block(self):
+        content = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(content, "3")
+        assert "resume content" in result
+        assert "{{IF_RESUME}}" not in result
+
+    def test_resume_removes_fresh_block(self):
+        content = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(content, "3")
+        assert "fresh content" not in result
+        assert "after" in result
+
+    def test_no_conditional_blocks(self):
+        content = "just plain text"
+        result = process_conditional_blocks(content, "null")
+        assert result == "just plain text"
+
+
+class TestProcessModeBlocks:
+    def test_keeps_matching_mode(self):
+        content = "before\n{{IF_MODE_LITE}}\nlite content\n{{END_IF_MODE_LITE}}\nafter"
+        result = process_mode_blocks(content, "lite", False)
+        assert "lite content" in result
+        assert "{{IF_MODE_LITE}}" not in result
+
+    def test_removes_non_matching_mode(self):
+        content = "{{IF_MODE_FULL}}\nfull content\n{{END_IF_MODE_FULL}}\nrest"
+        result = process_mode_blocks(content, "lite", False)
+        assert "full content" not in result
+        assert "rest" in result
+
+    def test_init_done_keeps_init_done_block(self):
+        content = "{{IF_INIT_DONE}}\ninit done\n{{END_IF_INIT_DONE}}\n"
+        result = process_mode_blocks(content, "standard", True)
+        assert "init done" in result
+
+    def test_init_done_removes_init_needed_block(self):
+        content = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}\n"
+        result = process_mode_blocks(content, "standard", True)
+        assert "need init" not in result
+
+    def test_init_not_done_keeps_init_needed_block(self):
+        content = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}\n"
+        result = process_mode_blocks(content, "standard", False)
+        assert "need init" in result
+
+    def test_multiple_modes(self):
+        content = (
+            "{{IF_MODE_LITE}}\nlite\n{{END_IF_MODE_LITE}}\n"
+            "{{IF_MODE_STANDARD}}\nstandard\n{{END_IF_MODE_STANDARD}}\n"
+            "{{IF_MODE_FULL}}\nfull\n{{END_IF_MODE_FULL}}\n"
+        )
+        result = process_mode_blocks(content, "standard", False)
+        assert "lite" not in result
+        assert "standard" in result
+        assert "full" not in result
+
+
+class TestDeterminePipelineMode:
+    def test_low_complexity(self):
+        assert determine_pipeline_mode("low") == "lite"
+
+    def test_medium_complexity(self):
+        assert determine_pipeline_mode("medium") == "standard"
+
+    def test_high_complexity(self):
+        assert determine_pipeline_mode("high") == "full"
+
+    def test_critical_complexity(self):
+        assert determine_pipeline_mode("critical") == "full"
+
+    def test_unknown_complexity(self):
+        assert determine_pipeline_mode("unknown") == "standard"
+
+    def test_none_complexity(self):
+        assert determine_pipeline_mode(None) == "standard"

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

@@ -0,0 +1,153 @@
+"""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",
+    }