prizmkit 1.0.45 → 1.0.66

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

@@ -0,0 +1,207 @@
+"""Tests for generate-bootstrap-prompt.py core functions."""
+
+import re
+
+from generate_bootstrap_prompt import (
+    compute_feature_slug,
+    find_feature,
+    format_acceptance_criteria,
+    format_global_context,
+    get_completed_dependencies,
+    determine_pipeline_mode,
+    process_conditional_blocks,
+    process_mode_blocks,
+)
+
+
+# ---------------------------------------------------------------------------
+# compute_feature_slug
+# ---------------------------------------------------------------------------
+
+class TestComputeFeatureSlug:
+    def test_basic(self):
+        assert compute_feature_slug("F-001", "Project Infrastructure Setup") == "001-project-infrastructure-setup"
+
+    def test_strips_special_chars(self):
+        assert compute_feature_slug("F-012", "Add (User) Auth!") == "012-add-user-auth"
+
+    def test_pads_numeric(self):
+        assert compute_feature_slug("F-1", "Init") == "001-init"
+
+    def test_collapses_hyphens(self):
+        assert compute_feature_slug("F-003", "foo - - bar") == "003-foo---bar" or \
+               compute_feature_slug("F-003", "foo   bar") == "003-foo-bar"
+
+    def test_empty_title(self):
+        result = compute_feature_slug("F-099", "")
+        assert result == "099-"
+
+
+# ---------------------------------------------------------------------------
+# find_feature
+# ---------------------------------------------------------------------------
+
+class TestFindFeature:
+    def test_found(self):
+        features = [{"id": "F-001", "title": "A"}, {"id": "F-002", "title": "B"}]
+        assert find_feature(features, "F-002") == {"id": "F-002", "title": "B"}
+
+    def test_not_found(self):
+        assert find_feature([{"id": "F-001"}], "F-999") is None
+
+    def test_empty_list(self):
+        assert find_feature([], "F-001") is None
+
+    def test_non_dict_items(self):
+        assert find_feature(["garbage", 42, None, {"id": "F-001"}], "F-001") == {"id": "F-001"}
+
+
+# ---------------------------------------------------------------------------
+# format_acceptance_criteria
+# ---------------------------------------------------------------------------
+
+class TestFormatAcceptanceCriteria:
+    def test_none(self):
+        assert format_acceptance_criteria(None) == "- (none specified)"
+
+    def test_empty(self):
+        assert format_acceptance_criteria([]) == "- (none specified)"
+
+    def test_items(self):
+        result = format_acceptance_criteria(["Users can log in", "Password reset works"])
+        assert "- Users can log in" in result
+        assert "- Password reset works" in result
+
+
+# ---------------------------------------------------------------------------
+# format_global_context
+# ---------------------------------------------------------------------------
+
+class TestFormatGlobalContext:
+    def test_none(self):
+        assert format_global_context(None) == "- (none specified)"
+
+    def test_empty(self):
+        assert format_global_context({}) == "- (none specified)"
+
+    def test_dict(self):
+        result = format_global_context({"framework": "React", "lang": "TypeScript"})
+        assert "**framework**: React" in result
+        assert "**lang**: TypeScript" in result
+
+
+# ---------------------------------------------------------------------------
+# get_completed_dependencies
+# ---------------------------------------------------------------------------
+
+class TestGetCompletedDependencies:
+    def test_no_deps(self):
+        feature = {"id": "F-002", "dependencies": []}
+        assert "no dependencies" in get_completed_dependencies([], feature)
+
+    def test_with_completed_dep(self):
+        features = [
+            {"id": "F-001", "title": "Setup", "status": "completed"},
+            {"id": "F-002", "title": "Auth", "dependencies": ["F-001"]},
+        ]
+        result = get_completed_dependencies(features, features[1])
+        assert "F-001" in result
+        assert "completed" in result
+
+    def test_no_completed_dep(self):
+        features = [
+            {"id": "F-001", "title": "Setup", "status": "pending"},
+            {"id": "F-002", "title": "Auth", "dependencies": ["F-001"]},
+        ]
+        result = get_completed_dependencies(features, features[1])
+        assert "no completed dependencies" in result
+
+
+# ---------------------------------------------------------------------------
+# determine_pipeline_mode
+# ---------------------------------------------------------------------------
+
+class TestDeterminePipelineMode:
+    def test_low(self):
+        assert determine_pipeline_mode("low") == "lite"
+
+    def test_medium(self):
+        assert determine_pipeline_mode("medium") == "standard"
+
+    def test_high(self):
+        assert determine_pipeline_mode("high") == "full"
+
+    def test_critical(self):
+        assert determine_pipeline_mode("critical") == "full"
+
+    def test_unknown(self):
+        assert determine_pipeline_mode("banana") == "standard"
+
+
+# ---------------------------------------------------------------------------
+# process_conditional_blocks
+# ---------------------------------------------------------------------------
+
+class TestProcessConditionalBlocks:
+    def test_fresh_start_keeps_fresh_block(self):
+        tpl = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(tpl, "null")
+        assert "fresh content" in result
+        assert "IF_FRESH_START" not in result
+
+    def test_fresh_start_removes_resume_block(self):
+        tpl = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(tpl, "null")
+        assert "resume content" not in result
+
+    def test_resume_keeps_resume_block(self):
+        tpl = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(tpl, "3")
+        assert "resume content" in result
+        assert "IF_RESUME" not in result
+
+    def test_resume_removes_fresh_block(self):
+        tpl = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(tpl, "3")
+        assert "fresh content" not in result
+
+
+# ---------------------------------------------------------------------------
+# process_mode_blocks
+# ---------------------------------------------------------------------------
+
+class TestProcessModeBlocks:
+    def test_lite_mode_keeps_lite(self):
+        tpl = "{{IF_MODE_LITE}}lite content{{END_IF_MODE_LITE}}"
+        result = process_mode_blocks(tpl, "lite", init_done=True)
+        assert "lite content" in result
+        assert "IF_MODE" not in result
+
+    def test_lite_mode_removes_full(self):
+        tpl = "{{IF_MODE_FULL}}full content{{END_IF_MODE_FULL}}"
+        result = process_mode_blocks(tpl, "lite", init_done=True)
+        assert "full content" not in result
+
+    def test_init_done_keeps_init_done_block(self):
+        tpl = "{{IF_INIT_DONE}}\ninit done\n{{END_IF_INIT_DONE}}"
+        result = process_mode_blocks(tpl, "standard", init_done=True)
+        assert "init done" in result
+
+    def test_init_needed_when_not_done(self):
+        tpl = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}"
+        result = process_mode_blocks(tpl, "standard", init_done=False)
+        assert "need init" in result
+
+    def test_self_evolve_keeps_self_evolve_and_full(self):
+        tpl = (
+            "{{IF_MODE_SELF_EVOLVE}}se content{{END_IF_MODE_SELF_EVOLVE}}"
+            "{{IF_MODE_FULL}}full content{{END_IF_MODE_FULL}}"
+        )
+        result = process_mode_blocks(tpl, "self-evolve", init_done=True)
+        assert "se content" in result
+        assert "full content" in result
+
+    def test_self_evolve_removes_lite(self):
+        tpl = "{{IF_MODE_LITE}}lite content{{END_IF_MODE_LITE}}"
+        result = process_mode_blocks(tpl, "self-evolve", init_done=True)
+        assert "lite content" not in result

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

@@ -1,181 +1,168 @@
-"""Tests for generate-bugfix-prompt.py."""
+"""Tests for generate-bugfix-prompt.py core functions."""
 
-import os
-import sys
-import pytest
+from generate_bugfix_prompt import (
+    find_bug,
+    format_acceptance_criteria,
+    format_global_context,
+    format_error_source_details,
+    format_environment,
+    process_conditional_blocks,
+    render_template,
+)
 
 
-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
+# ---------------------------------------------------------------------------
+# find_bug
+# ---------------------------------------------------------------------------
 
+class TestFindBug:
+    def test_found(self):
+        bugs = [{"id": "B-001", "title": "A"}, {"id": "B-002", "title": "B"}]
+        assert find_bug(bugs, "B-002") == {"id": "B-002", "title": "B"}
 
-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
+    def test_not_found(self):
+        assert find_bug([{"id": "B-001"}], "B-999") is None
 
+    def test_empty_list(self):
+        assert find_bug([], "B-001") is None
 
-class TestFormatAcceptanceCriteria:
-    def test_normal(self):
-        result = format_acceptance_criteria(["Fix A", "Fix B"])
-        assert result == "- Fix A\n- Fix B"
+    def test_non_dict_items(self):
+        assert find_bug(["garbage", 42, None, {"id": "B-001"}], "B-001") == {"id": "B-001"}
 
-    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({})
+# ---------------------------------------------------------------------------
+# format_error_source_details
+# ---------------------------------------------------------------------------
 
+class TestFormatErrorSourceDetails:
     def test_none(self):
-        assert "none specified" in format_global_context(None)
+        result = format_error_source_details(None)
+        assert "no error source" in result
 
+    def test_empty_dict(self):
+        result = format_error_source_details({})
+        assert "no error source" in result
 
-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)
+        source = {"type": "stack_trace", "stack_trace": "Error at line 42"}
+        result = format_error_source_details(source)
+        assert "Error at line 42" in result
         assert "Stack Trace" in result
-        assert "Traceback ... Error" in result
-        assert "Error Message" in result
-        assert "Something broke" in result
+
+    def test_error_message(self):
+        source = {"type": "unknown", "error_message": "Something went wrong"}
+        result = format_error_source_details(source)
+        assert "Something went wrong" 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
+        source = {"type": "log_pattern", "log_snippet": "FATAL: connection refused"}
+        result = format_error_source_details(source)
+        assert "connection refused" 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
+        source = {"type": "failed_test", "failed_test_path": "tests/auth.test.js"}
+        result = format_error_source_details(source)
+        assert "tests/auth.test.js" 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
+        source = {"type": "user_report", "reproduction_steps": ["Click login", "Enter bad password"]}
+        result = format_error_source_details(source)
+        assert "Click login" in result
+        assert "Enter bad password" 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
 
+# ---------------------------------------------------------------------------
+# format_environment
+# ---------------------------------------------------------------------------
 
 class TestFormatEnvironment:
-    def test_normal(self):
-        result = format_environment({"os": "macOS", "browser": "Chrome"})
-        assert "**browser**" in result
-        assert "**os**" in result
+    def test_none(self):
+        assert "not specified" in format_environment(None)
 
     def test_empty(self):
-        result = format_environment({})
-        assert "not specified" in result
+        assert "not specified" in format_environment({})
 
-    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_with_values(self):
+        result = format_environment({"os": "Linux", "node": "20.1"})
+        assert "**node**: 20.1" in result
+        assert "**os**: Linux" 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_skips_empty_values(self):
+        result = format_environment({"os": "Linux", "browser": ""})
+        assert "**os**: Linux" in result
+        assert "browser" not in result
 
-    def test_all_empty_values(self):
-        result = format_environment({"a": "", "b": None})
-        assert "not specified" in result
 
+# ---------------------------------------------------------------------------
+# process_conditional_blocks
+# ---------------------------------------------------------------------------
 
 class TestProcessConditionalBlocks:
-    def test_manual_verification_keeps_block(self):
+    def test_automated_removes_manual_block(self):
+        tpl = "before\n{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nmanual content\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nafter"
+        bug = {"verification_type": "automated"}
+        result = process_conditional_blocks(tpl, bug)
+        assert "manual content" not in result
+        assert "before" in result
+        assert "after" in result
+
+    def test_manual_keeps_block(self):
+        tpl = "before\n{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nmanual content\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nafter"
         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
+        result = process_conditional_blocks(tpl, bug)
+        assert "manual content" in result
+        assert "IF_VERIFICATION" not in result
 
-    def test_hybrid_verification_keeps_block(self):
+    def test_hybrid_keeps_block(self):
+        tpl = "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}hybrid{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}"
         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
+        result = process_conditional_blocks(tpl, bug)
+        assert "hybrid" 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):
+    def test_default_is_automated(self):
+        tpl = "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}content{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}"
         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
+        result = process_conditional_blocks(tpl, bug)
+        assert "content" not in result
+
 
-    def test_no_conditional_blocks(self):
+# ---------------------------------------------------------------------------
+# render_template (integration)
+# ---------------------------------------------------------------------------
+
+class TestRenderTemplate:
+    def test_placeholders_replaced(self):
+        tpl = "Bug: {{BUG_ID}} — {{BUG_TITLE}}"
+        replacements = {"{{BUG_ID}}": "B-042", "{{BUG_TITLE}}": "Login crash"}
+        bug = {"verification_type": "automated"}
+        result = render_template(tpl, replacements, bug)
+        assert result == "Bug: B-042 — Login crash"
+
+    def test_conditional_and_replacement(self):
+        tpl = (
+            "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}manual{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}"
+            "id={{BUG_ID}}"
+        )
+        replacements = {"{{BUG_ID}}": "B-001"}
         bug = {"verification_type": "automated"}
-        content = "plain text"
-        result = process_conditional_blocks(content, bug)
-        assert result == "plain text"
+        result = render_template(tpl, replacements, bug)
+        assert "manual" not in result
+        assert "id=B-001" in result
+
+
+# ---------------------------------------------------------------------------
+# Reuse shared helpers (same as bootstrap prompt — verify they are present)
+# ---------------------------------------------------------------------------
+
+class TestSharedHelpers:
+    def test_format_acceptance_criteria_items(self):
+        result = format_acceptance_criteria(["Fix works", "No regression"])
+        assert "- Fix works" in result
+        assert "- No regression" in result
+
+    def test_format_acceptance_criteria_empty(self):
+        assert "none specified" in format_acceptance_criteria([])
+
+    def test_format_global_context_dict(self):
+        result = format_global_context({"lang": "Python"})
+        assert "**lang**: Python" in result