codeplain 0.3.10.dev4__py3-none-any.whl → 0.3.11__py3-none-any.whl

tests/test_git_preflight.py

@@ -0,0 +1,98 @@
+"""Regression tests for issue #133.
+
+When git is unusable the CLI must report a clean message and exit 1, never dump
+a traceback. The failure is at import time (GitPython raises from module scope
+before main() runs), so the CLI is run in a subprocess and asserted on what a
+user would actually see. sys.executable is launched by absolute path, so
+replacing PATH only controls which git, if any, can be found.
+"""
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from git_preflight import GIT_BROKEN_MESSAGE, GIT_MISSING_MESSAGE
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+TRACEBACK_MARKER = "Traceback (most recent call last)"
+
+# The crash was in the import chain, so it hit every entry point equally.
+CLI_INVOCATIONS = [["--version"], ["--status"], ["does-not-exist.plain"]]
+
+
+def run_cli(args, path_dir=None):
+    """Run the CLI and return its exit code and output, stripped of styling and
+    with whitespace collapsed, so assertions survive console line wrapping."""
+    env = os.environ.copy()
+    # Drop GitPython overrides so the PATH search decides whether git is found.
+    env.pop("GIT_PYTHON_GIT_EXECUTABLE", None)
+    env.pop("GIT_PYTHON_REFRESH", None)
+    env.setdefault("CODEPLAIN_API_KEY", "dummy")
+    if path_dir is not None:
+        env["PATH"] = str(path_dir)
+
+    result = subprocess.run(
+        [sys.executable, "plain2code.py", *args],
+        cwd=REPO_ROOT,
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    output = re.sub(r"\x1b\[[0-9;]*m", "", result.stdout + result.stderr)
+    return result.returncode, " ".join(output.split())
+
+
+@pytest.fixture
+def no_git_dir(tmp_path):
+    """A directory containing no git at all, used as the whole PATH."""
+    d = tmp_path / "no-git"
+    d.mkdir()
+    return d
+
+
+@pytest.fixture
+def broken_git_dir(tmp_path):
+    """A directory whose git resolves but always fails, used as the whole PATH.
+    This is the shape of macOS without the Command Line Tools."""
+    d = tmp_path / "broken-git"
+    d.mkdir()
+    if sys.platform == "win32":
+        (d / "git.bat").write_text("@echo off\nexit /b 127\n")
+    else:
+        git = d / "git"
+        git.write_text("#!/bin/sh\nexit 127\n")
+        git.chmod(0o755)
+    return d
+
+
+@pytest.mark.parametrize("args", CLI_INVOCATIONS)
+def test_missing_git_reports_cleanly(args, no_git_dir):
+    rc, output = run_cli(args, no_git_dir)
+
+    assert GIT_MISSING_MESSAGE in output, output
+    assert TRACEBACK_MARKER not in output, output
+    # GitPython's own advice about GIT_PYTHON_REFRESH must not reach the user.
+    assert "GIT_PYTHON_REFRESH" not in output, output
+    assert rc == 1, output
+
+
+@pytest.mark.parametrize("args", CLI_INVOCATIONS)
+def test_broken_git_reports_cleanly(args, broken_git_dir):
+    rc, output = run_cli(args, broken_git_dir)
+
+    assert GIT_BROKEN_MESSAGE in output, output
+    assert GIT_MISSING_MESSAGE not in output, output
+    assert TRACEBACK_MARKER not in output, output
+    assert rc == 1, output
+
+
+def test_cli_works_when_git_is_present():
+    rc, output = run_cli(["--version"])
+
+    assert rc == 0, output
+    assert "codeplain version" in output, output

tests/test_plainfileparser.py

@@ -146,14 +146,30 @@ def test_invalid_absolute_link(get_test_data_path):
         )
 
 
+def test_missing_link_error_lists_searched_directories(get_test_data_path):
+    """The error tells the user which directories were searched for the linked resource."""
+    plain_file_dir = get_test_data_path("data/plainfile")
+
+    with pytest.raises(PlainSyntaxError) as exception_info:
+        plain_file.plain_file_parser(
+            "plain_source_with_missing_link.plain",
+            [plain_file_dir],
+        )
+
+    message = str(exception_info.value)
+    assert "resources/missing_resource.yaml does not exist" in message
+    assert "highest to lowest precedence" in message
+    assert plain_file_dir in message
+
+
 def test_reference_link_parsing(get_test_data_path):
     _, plain_sections, _ = plain_file.plain_file_parser(
         "task_manager_with_reference_links.plain",
         [get_test_data_path("data/plainfile")],
     )
     asserted_resources = [
-        "tests/data/plainfile/task_list_ui_specification.yaml",
-        "tests/data/plainfile/add_new_task_modal_specification.yaml",
+        "task_list_ui_specification.yaml",
+        "add_new_task_modal_specification.yaml",
     ]
     for functional_requirement in plain_sections[plain_spec.FUNCTIONAL_REQUIREMENTS]:
         if "linked_resources" not in functional_requirement:
@@ -180,13 +196,36 @@ def test_reference_link_parsing(get_test_data_path):
     assert plain_sections[plain_spec.FUNCTIONAL_REQUIREMENTS][1]["linked_resources"] == [
         {
             "text": "task_list_ui_specification.yaml",
-            "target": "tests/data/plainfile/task_list_ui_specification.yaml",
+            "target": "task_list_ui_specification.yaml",
+        }
+    ]
+    assert plain_sections[plain_spec.FUNCTIONAL_REQUIREMENTS][2]["linked_resources"] == [
+        {
+            "text": "add_new_task_modal_specification.yaml",
+            "target": "add_new_task_modal_specification.yaml",
+        }
+    ]
+
+
+def test_reference_link_parsing_independent_of_working_directory(get_test_data_path, monkeypatch, tmp_path):
+    """Linked resources resolve against the plain file's directory, not the invocation cwd."""
+    monkeypatch.chdir(tmp_path)
+
+    _, plain_sections, _ = plain_file.plain_file_parser(
+        "task_manager_with_reference_links.plain",
+        [get_test_data_path("data/plainfile")],
+    )
+
+    assert plain_sections[plain_spec.FUNCTIONAL_REQUIREMENTS][1]["linked_resources"] == [
+        {
+            "text": "task_list_ui_specification.yaml",
+            "target": "task_list_ui_specification.yaml",
         }
     ]
     assert plain_sections[plain_spec.FUNCTIONAL_REQUIREMENTS][2]["linked_resources"] == [
         {
             "text": "add_new_task_modal_specification.yaml",
-            "target": "tests/data/plainfile/add_new_task_modal_specification.yaml",
+            "target": "add_new_task_modal_specification.yaml",
         }
     ]
 
@@ -632,6 +671,11 @@ def test_concept_validation_acceptance_tests(get_test_data_path):
         )
 
 
+def test_concept_validation_cyclic_definitions(get_test_data_path):
+    with pytest.raises(PlainSyntaxError, match="cycles in the concept graph"):
+        plain_file.plain_file_parser("cyclic_definitions.plain", [get_test_data_path("data/plainfileparser")])
+
+
 def test_required_concepts(get_test_data_path):
     plain_file.plain_file_parser(
         "required_concepts_example.plain",
@@ -661,28 +705,44 @@ def test_required_concepts(get_test_data_path):
         )
 
 
-def test_exported_concepts(get_test_data_path):
-    plain_file.plain_file_parser(
+@pytest.mark.parametrize(
+    "fixture",
+    [
         "exported_concepts_example.plain",
-        [get_test_data_path("data/plainfileparser")],
-    )
-
-    plain_file.plain_file_parser(
+        "exported_concepts_imported_exported.plain",
+        "exported_concepts_multiple_per_bullet.plain",
         "exported_concepts_nested_example.plain",
+    ],
+)
+def test_exported_concepts_valid(get_test_data_path, fixture):
+    plain_file.plain_file_parser(fixture, [get_test_data_path("data/plainfileparser")])
+
+
+@pytest.mark.parametrize(
+    ("fixture", "expected_word"),
+    [
+        ("exported_concepts_defaults_exported.plain", "cannot export default concept"),
+        ("exported_concepts_inherited_reexported.plain", "cannot be re-exported"),
+        ("exported_concepts_malformed.plain", "exports an invalid concept"),
+        ("exported_concepts_missing_definition_example.plain", "'exported_concepts_missing_definition' exports"),
+        ("exported_concepts_missing_definition.plain", "exports undefined concept"),
+        ("exported_concepts_multiple_per_bullet_undefined.plain", "exports undefined concept"),
+        ("exported_concepts_no_definitions.plain", "exports undefined concept"),
+        ("exported_concepts_not_declared_example.plain", "not defined"),
+        ("exported_concepts_transitive_example.plain", "not defined"),
+    ],
+)
+def test_exported_concepts_invalid(get_test_data_path, fixture, expected_word):
+    with pytest.raises(PlainSyntaxError, match=expected_word):
+        plain_file.plain_file_parser(fixture, [get_test_data_path("data/plainfileparser")])
+
+
+def test_requires_without_definitions(get_test_data_path):
+    _, plain_source, _ = plain_file.plain_file_parser(
+        "requires_without_definitions_example.plain",
         [get_test_data_path("data/plainfileparser")],
     )
-
-    with pytest.raises(PlainSyntaxError):
-        plain_file.plain_file_parser(
-            "exported_concepts_missing_example.plain",
-            [get_test_data_path("data/plainfileparser")],
-        )
-
-    with pytest.raises(PlainSyntaxError):
-        plain_file.plain_file_parser(
-            "exported_concepts_transitive_example.plain",
-            [get_test_data_path("data/plainfileparser")],
-        )
+    assert plain_source[plain_spec.DEFINITIONS] == [{"markdown": "- :Concept: is a concept."}]
 
 
 def test_topological_sort(get_test_data_path):

tests/test_render_finished_report.py

@@ -0,0 +1,200 @@
+"""Tests for reporting a render's terminal state to the API.
+
+The render state machine lives in the client, so the API only learns how a
+render ended because main() tells it. Two things are worth proving: that the
+outcome names the right ending, and that main() reports on every path out -
+including the ones the state machine never sees, like a keyboard interrupt.
+"""
+
+from argparse import Namespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+import plain2code
+from plain2code_exceptions import InvalidAPIKey
+from plain2code_state import RunState
+
+
+def make_run_state(succeeded=False, cancelled=False, user_email="user@codeplain.ai"):
+    run_state = RunState(spec_filename="project.plain")
+    run_state.set_render_succeeded(succeeded)
+    if cancelled:
+        run_state.set_render_cancelled()
+    run_state.user_email = user_email
+    return run_state
+
+
+class TestRenderOutcome:
+    def test_a_successful_render_is_completed(self):
+        assert plain2code._render_outcome(make_run_state(succeeded=True)) == "completed"
+
+    def test_an_unsuccessful_render_is_failed(self):
+        assert plain2code._render_outcome(make_run_state(succeeded=False)) == "failed"
+
+    def test_a_cancelled_render_is_cancelled(self):
+        """A cancelled render leaves render_succeeded False, so cancellation has to
+        be asked about first or it would be reported as a failure."""
+        assert plain2code._render_outcome(make_run_state(cancelled=True)) == "cancelled"
+
+    def test_cancellation_wins_over_a_success_already_recorded(self):
+        """Cancelling during the dist step leaves both flags set."""
+        assert plain2code._render_outcome(make_run_state(succeeded=True, cancelled=True)) == "cancelled"
+
+    def test_an_interrupted_render_is_cancelled(self):
+        """Ctrl-C is the user stopping the render. It does not set the cancelled
+        flag, so the outcome has to be told about it."""
+        assert plain2code._render_outcome(make_run_state(), interrupted=True) == "cancelled"
+
+
+class TestReportRenderFinished:
+    def test_reports_the_outcome_with_the_render_state(self):
+        api = MagicMock()
+        run_state = make_run_state(succeeded=True)
+
+        plain2code.report_render_finished(api, run_state)
+
+        api.render_finished.assert_called_once_with("completed", run_state)
+
+    def test_says_nothing_when_the_api_never_identified_us(self):
+        """user_email is set by the connection check, so an absent one means a
+        missing key, an invalid key or an outdated client - none of which rendered."""
+        api = MagicMock()
+
+        plain2code.report_render_finished(api, make_run_state(user_email=None))
+
+        api.render_finished.assert_not_called()
+
+    @pytest.mark.parametrize(
+        "failure",
+        [
+            ConnectionError("api unreachable"),
+            TimeoutError("api slow"),
+            RuntimeError("something else entirely"),
+        ],
+    )
+    def test_a_failed_report_never_propagates(self, failure):
+        """The report is the last thing a render does. It must not become the
+        reason the render looks like it failed."""
+        api = MagicMock()
+        api.render_finished.side_effect = failure
+
+        plain2code.report_render_finished(api, make_run_state(succeeded=True))
+
+
+def make_args(api_key="test-key", headless=False):
+    return Namespace(
+        version=False,
+        status=False,
+        full_plain=False,
+        dry_run=False,
+        api_key=api_key,
+        api="https://api.example.com",
+        filename="project.plain",
+        template_dir=None,
+        build_folder="build",
+        render_range=None,
+        render_from=None,
+        headless=headless,
+        replay_with=None,
+        log_to_file=False,
+        log_file_name="codeplain.log",
+        conformance_tests_script=None,
+        unittests_script=None,
+        prepare_environment_script=None,
+    )
+
+
+def run_main(render_side_effect=None, api_key="test-key"):
+    """Drive main() with everything but the reporting path stubbed out.
+
+    render() is replaced, so the stub is what decides how the render "ended" -
+    which is the point: the report must be made from main()'s finally whatever
+    render did, not from inside the state machine.
+
+    Returns the API client mock so the caller can inspect the report.
+    """
+    api = MagicMock()
+
+    def fake_render(plain_module, codeplainAPI, args, run_state, event_bus, default_log_level="INFO"):
+        run_state.user_email = "user@codeplain.ai"
+        if render_side_effect is not None:
+            render_side_effect(run_state)
+
+    with (
+        patch("plain2code.parse_arguments", return_value=make_args(api_key=api_key)),
+        patch("plain2code.file_utils.get_template_directories", return_value=["templates"]),
+        patch("plain2code.plain_modules.PlainModule", return_value=MagicMock(all_required_modules=[])),
+        patch("plain2code.setup_logging", return_value="INFO"),
+        patch("plain2code.initialize_telemetry"),
+        patch("plain2code.stop_narrating"),
+        patch("plain2code.print_exit_summary"),
+        patch("plain2code.dump_crash_logs"),
+        patch("plain2code.capture_crash"),
+        patch("plain2code.codeplain_api.CodeplainAPI", return_value=api),
+        patch("plain2code.render", side_effect=fake_render),
+    ):
+        plain2code.main()
+
+    return api
+
+
+class TestMainReportsEveryEnding:
+    """main()'s finally is the only place that sees all of these."""
+
+    def test_a_completed_render_is_reported(self):
+        api = run_main(lambda run_state: run_state.set_render_succeeded(True))
+
+        assert api.render_finished.call_args.args[0] == "completed"
+
+    def test_a_failed_render_is_reported(self):
+        def fail(run_state):
+            run_state.set_render_succeeded(False)
+            raise Exception("rendering blew up")
+
+        api = run_main(fail)
+
+        assert api.render_finished.call_args.args[0] == "failed"
+
+    def test_an_expected_error_is_reported_as_a_failure(self):
+        def fail(run_state):
+            raise InvalidAPIKey("key went stale mid-render")
+
+        api = run_main(fail)
+
+        assert api.render_finished.call_args.args[0] == "failed"
+
+    def test_a_cancelled_render_is_reported(self):
+        api = run_main(lambda run_state: run_state.set_render_cancelled())
+
+        assert api.render_finished.call_args.args[0] == "cancelled"
+
+    def test_a_keyboard_interrupt_is_reported_as_cancelled(self):
+        """Ctrl-C never enters a terminal state in the state machine, so this
+        ending exists only in main(). In headless mode it is the only way to stop
+        a render, and stopping is a cancellation, not a failure."""
+
+        def interrupt(run_state):
+            raise KeyboardInterrupt()
+
+        api = run_main(interrupt)
+
+        assert api.render_finished.call_args.args[0] == "cancelled"
+
+    def test_a_keyboard_interrupt_leaves_the_exit_summary_alone(self):
+        """The summary reads render_cancelled. Only the reported outcome changes."""
+        captured = {}
+
+        def interrupt(run_state):
+            captured["run_state"] = run_state
+            raise KeyboardInterrupt()
+
+        run_main(interrupt)
+
+        assert captured["run_state"].render_cancelled is False
+
+    def test_a_missing_api_key_reports_nothing(self):
+        """render() is never reached, so nothing identified the caller."""
+        api = run_main(api_key=None)
+
+        api.render_finished.assert_not_called()

tests/test_tui_components.py

@@ -0,0 +1,147 @@
+"""Regression tests: spec-derived text with square brackets must never be parsed as Textual markup."""
+
+import asyncio
+
+from textual.widgets import Static
+
+from event_bus import EventBus
+from plain2code_state import RunState
+from tui.components import FRIDProgress, ProgressItem, RenderingInfoBox, SubstateLine, TUIComponents
+from tui.models import Substate
+from tui.plain2code_tui import Plain2CodeTUI
+from tui.widget_helpers import display_error_message, display_success_message, update_progress_item_substates
+
+# Exact acceptance-test text that crashed the TUI with
+# "MarkupError: closing tag '[/#888888]' does not match any open tag":
+# the unterminated "[b" swallowed the timer's opening tag.
+UNTERMINATED_BRACKET_TEXT = (
+    "Rendering acceptance test: With a=1, b=2, c=3, d=4: ZRANK z c should reply 2, "
+    'ZREVRANK z c WITHSCORE should reply [1, "3"], ZRANK z zz should reply null, '
+    "ZCOUNT z (1 3 should reply 2, and ZLEXCOUNT z [b + should reply 3."
+)
+# Terminated brackets used to be silently eaten as a markup tag ("LPOP key ").
+TERMINATED_BRACKET_TEXT = "LPOP key [count] and RPOP key [count] reply one element"
+
+
+def _make_app(run_state: RunState, event_bus: EventBus) -> Plain2CodeTUI:
+    return Plain2CodeTUI(
+        event_bus=event_bus,
+        run_state=run_state,
+        on_ready=lambda: None,
+        render_id="test-render-id",
+        unittests_script=None,
+        conformance_tests_script="run_conformance_tests.sh",
+        prepare_environment_script=None,
+        state_machine_version="0.0.0",
+        css_path="styles.css",
+    )
+
+
+def test_substate_line_keeps_bracket_text_verbatim():
+    for text in (UNTERMINATED_BRACKET_TEXT, TERMINATED_BRACKET_TEXT):
+        line = SubstateLine(text, "    ", ProgressItem.PROCESSING)._format_line()
+        assert text in line.plain
+        assert line.plain.endswith("(0s)")
+        # Only the timer carries the muted style; the text itself is unstyled.
+        assert len(line.spans) == 1
+        assert line.plain[line.spans[0].start : line.spans[0].end] == "(0s)"
+
+
+def test_substate_with_brackets_renders_without_markup_error():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            widget_id = TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value
+            update_progress_item_substates(
+                app, widget_id, [Substate(UNTERMINATED_BRACKET_TEXT), Substate(TERMINATED_BRACKET_TEXT)]
+            )
+            await pilot.pause()
+            await pilot.pause()
+
+            lines = app.query(".substate-line-text").results(Static)
+            rendered = [str(line.content) for line in lines]
+            assert any(UNTERMINATED_BRACKET_TEXT in text for text in rendered)
+            assert any(TERMINATED_BRACKET_TEXT in text for text in rendered)
+
+    asyncio.run(scenario())
+
+
+def test_status_messages_keep_brackets():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            status = app.query_one(f"#{TUIComponents.RENDER_STATUS_WIDGET.value}", Static)
+
+            display_success_message(app, "out/[weird] path")
+            await pilot.pause()
+            assert "rendering completed!" in str(status.content)
+            assert "generated code folder: out/[weird] path" in str(status.content)
+
+            display_error_message(app, "Error: [Errno 2] No such file: run_tests.sh [b")
+            await pilot.pause()
+            assert "[Errno 2] No such file: run_tests.sh [b" in str(status.content)
+
+    asyncio.run(scenario())
+
+
+# A functionality quote as the render TUI receives it: several lines, square brackets included.
+MULTILINE_FUNCTIONALITY_TEXT = (
+    "Functionality 3: :User: should be able to add a :Task: [optional]\n"
+    "  - The :Task: must have non-empty content.\n"
+    "  - The :Task: is appended to the end of the list."
+)
+
+
+def test_functionality_text_collapses_and_expands_with_ctrl_o():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            frid_progress = app.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress)
+            info_box = frid_progress.query_one(RenderingInfoBox)
+            info_box.update_functionality(MULTILINE_FUNCTIONALITY_TEXT)
+            await pilot.pause()
+
+            widget = info_box.functionality_widget
+            assert widget is not None
+
+            # Collapsed by default: first line only, with the expand hint.
+            collapsed = str(widget.content)
+            assert "Functionality 3: :User: should be able to add a :Task: [optional]" in collapsed
+            assert "non-empty content" not in collapsed
+            assert RenderingInfoBox.EXPAND_HINT in collapsed
+
+            await pilot.press("ctrl+o")
+            await pilot.pause()
+            expanded = str(widget.content)
+            assert "non-empty content" in expanded
+            assert "appended to the end of the list" in expanded
+            assert RenderingInfoBox.COLLAPSE_HINT in expanded
+
+            await pilot.press("ctrl+o")
+            await pilot.pause()
+            assert str(widget.content) == collapsed
+
+    asyncio.run(scenario())
+
+
+def test_single_line_functionality_text_has_no_hint():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            info_box = app.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress).query_one(RenderingInfoBox)
+            info_box.update_functionality("Functionality 1: :User: should be able to add a :Task:")
+            await pilot.pause()
+
+            widget = info_box.functionality_widget
+            assert widget is not None
+            assert str(widget.content) == "Functionality 1: :User: should be able to add a :Task:"
+
+    asyncio.run(scenario())