codeplain 0.3.13.dev36__tar.gz → 0.3.13.dev38__tar.gz

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.13.dev36
+Version: 0.3.13.dev38
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/file_utils.py

@@ -142,7 +142,21 @@ def get_existing_files_content(build_folder, existing_files):
     return existing_files_content
 
 
+def ensure_final_newline(content: str) -> str:
+    """Ends non-empty text with a newline, as linters expect (e.g. RuboCop, ESLint eol-last, Ruff W292)."""
+    if content and not content.endswith("\n"):
+        return content + "\n"
+    return content
+
+
 def store_response_files(target_folder, response_files, existing_files):
+    """Writes the files returned by the API to target_folder. None content deletes the file.
+
+    Every written file ends with a newline - whole-file rewrites come back from the API without one. The
+    added newline is also written back into response_files, so callers that diff response_files against
+    the folder afterwards see exactly what is on disk. Content is written byte-for-byte, without newline
+    translation, so the disk matches response_files on every platform.
+    """
     for file_name in response_files:
         full_file_name = os.path.join(target_folder, file_name)
 
@@ -156,9 +170,11 @@ def store_response_files(target_folder, response_files, existing_files):
 
             continue
 
+        response_files[file_name] = ensure_final_newline(response_files[file_name])
+
         os.makedirs(os.path.dirname(full_file_name), exist_ok=True)
 
-        with open(full_file_name, "w", encoding="utf-8") as f:
+        with open(full_file_name, "w", encoding="utf-8", newline="") as f:
             f.write(response_files[file_name])
 
         if file_name not in existing_files:

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/module_renderer.py

@@ -134,10 +134,8 @@ class ModuleRenderer:
 
         code_renderer.run()
         if code_renderer.render_context.state == States.RENDER_FAILED.value:
-            error_message = RenderError.get_display_message(
-                code_renderer.render_context.previous_action_payload,
-                fallback_message=code_renderer.render_context.last_error_message,
-            )
+            # ExitWithError resolved and logged the stop reason; the TUI shows the same text.
+            error_message = code_renderer.render_context.last_error_message or RenderError.get_display_message(None)
             code_renderer.render_context.event_bus.publish(RenderFailed(error_message=error_message))
             return False, True
 

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/render_machine/actions/exit_with_error.py

@@ -10,7 +10,13 @@ class ExitWithError(BaseAction):
     SUCCESSFUL_OUTCOME = "error_handled"
 
     def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
-        console.error(previous_action_payload)
+        # The stop reason is the error payload of the failed action, or the message stored when the
+        # error was dispatched from a state callback. The log and the TUI both show this text.
+        error_message = RenderError.get_display_message(
+            previous_action_payload, fallback_message=render_context.last_error_message
+        )
+        render_context.last_error_message = error_message
+        console.error(error_message)
 
         render_context.codeplain_api.fail_functional_requirement(
             render_context.frid_context.frid,
@@ -27,9 +33,4 @@ class ExitWithError(BaseAction):
         if render_context.run_state.render_id is not None:
             console.info(f"Render ID: {render_context.run_state.render_id}")
 
-        return (
-            self.SUCCESSFUL_OUTCOME,
-            RenderError.encode(
-                message=render_context.last_error_message or "Unknown error",
-            ).to_payload(),
-        )
+        return self.SUCCESSFUL_OUTCOME, RenderError.encode(message=error_message).to_payload()

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/render_machine/actions/render_functional_requirement.py

@@ -7,7 +7,7 @@ from plain2code_console import RETRY_COLOR, console
 from plain2code_exceptions import FunctionalRequirementTooComplex
 from render_machine.actions.base_action import BaseAction
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
-from render_machine.render_context import RenderContext
+from render_machine.render_context import MAX_UNITTEST_FIX_ATTEMPTS, RenderContext
 from render_machine.render_types import RenderError
 
 MAX_CODE_GENERATION_RETRIES = 2
@@ -20,9 +20,16 @@ class RenderFunctionalRequirement(BaseAction):
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         if render_context.frid_context.functional_requirement_render_attempts >= MAX_CODE_GENERATION_RETRIES:
-            error_msg = f"Unittests could not be fixed after rendering the functionality {render_context.frid_context.frid} for the {MAX_CODE_GENERATION_RETRIES} times."
+            # A render attempt is only restarted once its unit tests used up every fix round.
+            error_msg = (
+                f"Functionality {render_context.frid_context.frid}: unit tests still fail after "
+                f"{MAX_CODE_GENERATION_RETRIES} render attempts, {MAX_UNITTEST_FIX_ATTEMPTS} fix rounds each."
+            )
+            last_output_path = render_context.script_execution_history.latest_unit_test_output_path
+            if last_output_path:
+                error_msg += f" Last unit tests output: {last_output_path}"
             render_context.last_error_message = error_msg
-            return self.ITERATION_LIMIT_EXCEEDED_OUTCOME, None
+            return self.ITERATION_LIMIT_EXCEEDED_OUTCOME, RenderError.encode(message=error_msg).to_payload()
 
         render_context.frid_context.functional_requirement_render_attempts += 1
 

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/render_machine/code_renderer.py

@@ -67,14 +67,11 @@ class CodeRenderer:
             self.render_context.run_state.current_render_state = self.render_context.state
             self.render_context.script_execution_history.should_update_script_outputs = False
 
-            self.render_context.previous_action_payload = previous_action_payload
-
             outcome, previous_action_payload = self.action_map[self.render_context.state].execute(
                 self.render_context, previous_action_payload
             )
 
             if self.render_context.state == States.RENDER_FAILED.value:
-                self.render_context.last_error_message = previous_action_payload
                 self.render_context.event_bus.publish(RenderModuleFailed(module_name=self.render_context.module_name))
                 break
 

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/render_machine/render_context.py

@@ -113,12 +113,11 @@ class RenderContext:
         self.machine = machine
 
     def dispatch_error(self, error_message: str):
-        """Log error, store it, and dispatch HANDLE_ERROR trigger.
+        """Store the error and dispatch HANDLE_ERROR trigger. ExitWithError logs it and the TUI displays it.
 
         Args:
             error_message: The error message to log and display to the user.
         """
-        console.error(error_message)
         self.last_error_message = error_message
         self.machine.dispatch(triggers.HANDLE_ERROR)
 

{codeplain-0.3.13.dev36 → codeplain-0.3.13.dev38}/render_machine/render_types.py

@@ -259,17 +259,15 @@ class RenderError:
         """Decode error from action payload.
 
         Expects standardized format: {"error": {"message": ..., "type": ..., "details": ...}}
+        Any other payload is not an error (e.g. the payload of the action that ran before an error was
+        dispatched from a state callback) and decodes to None.
         """
-        if payload is None:
+        if not isinstance(payload, dict) or "error" not in payload:
             return None
 
-        if isinstance(payload, dict) and "error" in payload:
-            error_data = payload["error"]
-            return cls(
-                message=error_data.get("message", "Unknown error"),
-                error_type=error_data.get("type"),
-                details=error_data.get("details"),
-            )
-
-        # Unexpected format - log and return generic error
-        return cls(message=f"Unexpected error format: {type(payload).__name__}")
+        error_data = payload["error"]
+        return cls(
+            message=error_data.get("message", "Unknown error"),
+            error_type=error_data.get("type"),
+            details=error_data.get("details"),
+        )

codeplain-0.3.13.dev38/tests/test_file_utils.py

@@ -0,0 +1,174 @@
+import os
+import tempfile
+
+import pytest
+
+import file_utils
+from diff_utils import get_code_diff
+from file_utils import get_existing_files_content, load_linked_resources, store_response_files
+from plain2code_exceptions import UnsupportedBase64Content, UnsupportedResourceType
+from plain2code_utils import MAX_BASE64_BLOB_LENGTH
+
+
+@pytest.fixture
+def template_dir():
+    with tempfile.TemporaryDirectory() as d:
+        yield d
+
+
+def test_load_linked_resources_text_file(template_dir):
+    file_path = os.path.join(template_dir, "notes.md")
+    with open(file_path, "w") as f:
+        f.write("# hello")
+
+    result = load_linked_resources([template_dir], [{"text": "Notes", "target": "notes.md"}], "my_thing")
+
+    assert result == {"notes.md": "# hello"}
+
+
+def test_load_linked_resources_binary_file_raises_unsupported_resource_type(template_dir):
+    file_path = os.path.join(template_dir, "icon.png")
+    with open(file_path, "wb") as f:
+        f.write(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\xff\xfe\xfd")
+
+    with pytest.raises(UnsupportedResourceType) as exc_info:
+        load_linked_resources([template_dir], [{"text": "Icon", "target": "icon.png"}], "my_thing")
+
+    assert "icon.png" in str(exc_info.value)
+    assert "binary file" in str(exc_info.value)
+    assert "my_thing" in str(exc_info.value)
+
+
+def test_load_linked_resources_missing_file_raises_file_not_found(template_dir):
+    with pytest.raises(FileNotFoundError):
+        load_linked_resources([template_dir], [{"text": "Missing", "target": "missing.md"}], "my_thing")
+
+
+def test_load_linked_resources_base64_blob_raises(template_dir):
+    file_path = os.path.join(template_dir, "request.txt")
+    with open(file_path, "w") as f:
+        f.write("curl -d 'selfie_image=" + "A" * (MAX_BASE64_BLOB_LENGTH + 100) + "'")
+
+    with pytest.raises(UnsupportedBase64Content) as exc_info:
+        load_linked_resources([template_dir], [{"text": "Request", "target": "request.txt"}], "my_thing")
+
+    assert "request.txt" in str(exc_info.value)
+    assert "my_thing" in str(exc_info.value)
+
+
+def test_load_linked_resources_small_base64_allowed(template_dir):
+    file_path = os.path.join(template_dir, "token.txt")
+    with open(file_path, "w") as f:
+        f.write("token=" + "A" * (MAX_BASE64_BLOB_LENGTH - 100))
+
+    result = load_linked_resources([template_dir], [{"text": "Token", "target": "token.txt"}], "my_thing")
+
+    assert "token.txt" in result
+
+
+def test_load_linked_resources_real_base64_image_raises(template_dir):
+    # Real base64-encoded JPEG that made Gemini 3 fail, inlined into a curl example resource.
+    sample_path = os.path.join(os.path.dirname(__file__), "data", "sample_base64_image.txt")
+    with open(sample_path) as f:
+        blob = f.read()
+
+    file_path = os.path.join(template_dir, "face_match_request.txt")
+    with open(file_path, "w") as f:
+        f.write(f"curl -d 'selfie_image={blob}' https://example.com/face-match")
+
+    with pytest.raises(UnsupportedBase64Content) as exc_info:
+        load_linked_resources([template_dir], [{"text": "Request", "target": "face_match_request.txt"}], "face_match")
+
+    assert "face_match_request.txt" in str(exc_info.value)
+    assert str(len(blob)) in str(exc_info.value)
+
+
+def test_store_response_files_writes_unicode_as_utf8(template_dir):
+    """A non-cp1252 character (📍 U+1F4CD) is written as UTF-8, whatever the platform's default encoding."""
+    content = "Location 📍 marker\n"
+    store_response_files(template_dir, {"notes.md": content}, [])
+
+    file_path = os.path.join(template_dir, "notes.md")
+    with open(file_path, "rb") as f:
+        assert f.read().decode("utf-8") == content
+
+
+def _read_bytes(folder, file_name):
+    """Returns a file's content exactly as stored on disk, without newline translation."""
+    with open(os.path.join(folder, file_name), "rb") as f:
+        return f.read().decode("utf-8")
+
+
+@pytest.mark.parametrize(
+    "content, expected",
+    [
+        ("class Foo\nend", "class Foo\nend\n"),
+        ("class Foo\nend\n", "class Foo\nend\n"),
+        ("class Foo\nend\n\n", "class Foo\nend\n\n"),
+        ("class Foo\r\nend\r\n", "class Foo\r\nend\r\n"),
+        ("", ""),
+    ],
+)
+def test_store_response_files_ends_every_text_file_with_a_newline(template_dir, content, expected):
+    """A missing final newline is added, as linters such as RuboCop, ESLint and Ruff require.
+
+    An existing final newline is not doubled, and empty content stays empty.
+    """
+    store_response_files(template_dir, {"app/foo.rb": content}, [])
+
+    assert _read_bytes(template_dir, "app/foo.rb") == expected
+
+
+def test_store_response_files_hands_back_the_content_it_wrote(template_dir):
+    """response_files holds the content as written, so diffs taken after storing match the disk.
+
+    The fix journal and the conformance fixes handed to the unit tests fixer take such diffs.
+    """
+    response_files = {"app/foo.rb": "class Foo\nend", "app/bar.rb": "class Bar\nend\n"}
+
+    store_response_files(template_dir, response_files, [])
+
+    assert response_files == {"app/foo.rb": "class Foo\nend\n", "app/bar.rb": "class Bar\nend\n"}
+
+
+def test_rewriting_a_file_without_its_final_newline_does_not_change_it(template_dir):
+    """A rewrite that drops only the final newline leaves the file byte-identical and produces no diff."""
+    existing_files = store_response_files(template_dir, {"app/foo.rb": "class Foo\nend\n"}, [])
+    existing_files_content = get_existing_files_content(template_dir, existing_files)
+
+    rewrite = {"app/foo.rb": "class Foo\nend"}
+    store_response_files(template_dir, rewrite, existing_files)
+
+    assert get_existing_files_content(template_dir, existing_files) == existing_files_content
+    assert get_code_diff(rewrite, existing_files_content) == {}
+
+
+def test_store_response_files_still_deletes_a_file_whose_content_is_none(template_dir):
+    """None content still deletes the file and removes it from existing_files, and is not turned into a newline."""
+    existing_files = store_response_files(template_dir, {"app/foo.rb": "class Foo\nend\n"}, [])
+
+    response_files = {"app/foo.rb": None}
+    store_response_files(template_dir, response_files, existing_files)
+
+    assert not os.path.exists(os.path.join(template_dir, "app/foo.rb"))
+    assert existing_files == []
+    assert response_files == {"app/foo.rb": None}
+
+
+def test_store_response_files_writes_the_same_bytes_where_text_mode_writes_crlf(template_dir, monkeypatch):
+    """Files hold exactly the normalized content even where text mode writes CRLF line endings (native Windows)."""
+    # Imported here: isort 8 and isort 9 disagree on which section a top-level `import _pyio` belongs to.
+    import _pyio
+
+    # Python's reference io (_pyio) takes its line separator from os.linesep, so here it translates like Windows.
+    monkeypatch.setattr(os, "linesep", "\r\n")
+    monkeypatch.setattr(file_utils, "open", _pyio.open, raising=False)
+    with _pyio.open(os.path.join(template_dir, "probe.txt"), "w") as probe:
+        probe.write("\n")
+    assert _read_bytes(template_dir, "probe.txt") == "\r\n"
+
+    response_files = {"app/foo.rb": "class Foo\nend", "app/bar.rb": "class Bar\r\nend\r\n"}
+    store_response_files(template_dir, response_files, [])
+
+    assert _read_bytes(template_dir, "app/foo.rb") == response_files["app/foo.rb"] == "class Foo\nend\n"
+    assert _read_bytes(template_dir, "app/bar.rb") == response_files["app/bar.rb"] == "class Bar\r\nend\r\n"

codeplain-0.3.13.dev38/tests/test_render_stop_reason.py

@@ -0,0 +1,210 @@
+"""Tests for the reason a render gives when it stops on an error.
+
+When a render stops, the reason is logged and shown in the TUI. These tests drive the
+real render state machine through the last failing unit-test run of a functionality
+and check that the stop reason names the cause, instead of the literal "None".
+"""
+
+import logging
+import os
+import stat
+import tempfile
+import threading
+from types import SimpleNamespace
+
+import pytest
+
+import plain2code_logger
+from event_bus import EventBus
+from memory_management import MemoryManager
+from plain2code_state import RunState
+from plain_modules import PlainModule
+from render_machine.actions.exit_with_error import ExitWithError
+from render_machine.actions.render_functional_requirement import MAX_CODE_GENERATION_RETRIES
+from render_machine.code_renderer import CodeRenderer
+from render_machine.render_context import (
+    MAX_FUNCTIONAL_REQUIREMENT_RENDER_ATTEMPTS_FAILED_UNIT_DURING_CONFORMANCE_TESTS,
+    MAX_UNITTEST_FIX_ATTEMPTS,
+    RenderContext,
+)
+from render_machine.render_types import RenderError, UnitTestsRunningContext
+from render_machine.states import States
+
+
+class FakeCodeplainAPI:
+    def __init__(self):
+        self.failed_frids = []
+
+    def fail_functional_requirement(self, frid, module_name, run_state):
+        self.failed_frids.append(frid)
+
+
+@pytest.fixture
+def workspace():
+    with tempfile.TemporaryDirectory() as folder:
+        build_folder = os.path.join(folder, "plain_modules")
+        os.makedirs(build_folder)
+
+        unittests_script = os.path.join(folder, "run_unittests.sh")
+        with open(unittests_script, "w", encoding="utf-8") as script:
+            script.write("#!/bin/sh\necho '1 failed, 0 passed'\nexit 1\n")
+        os.chmod(unittests_script, os.stat(unittests_script).st_mode | stat.S_IEXEC)
+
+        yield build_folder, unittests_script
+
+
+def make_render_context(api, build_folder, unittests_script, fixtures_dir):
+    plain_module = PlainModule("pr_solo.plain", build_folder, [fixtures_dir])
+    os.makedirs(plain_module.module_build_folder, exist_ok=True)
+    return RenderContext(
+        api,
+        MemoryManager(api, plain_module.module_memory_folder),
+        plain_module,
+        build_folder=plain_module.module_build_folder,
+        build_dest="dist",
+        conformance_tests_dest="dist_tests",
+        unittests_script=unittests_script,
+        conformance_tests_script=None,
+        prepare_environment_script=None,
+        copy_build=False,
+        copy_conformance_tests=False,
+        render_range=None,
+        render_conformance_tests=False,
+        base_folder=fixtures_dir,
+        run_state=RunState(spec_filename="pr_solo.plain"),
+        event_bus=EventBus(),
+        enter_pause_event=threading.Event(),
+    )
+
+
+def nested_state(*states: States) -> str:
+    return "_".join(state.value for state in states)
+
+
+def error_log_messages(caplog) -> list[str]:
+    return [
+        record.getMessage()
+        for record in caplog.records
+        if record.name == plain2code_logger.LOGGER_NAME and record.levelno == logging.ERROR
+    ]
+
+
+@pytest.fixture
+def fixtures_dir(get_test_data_path):
+    return get_test_data_path("data/partial_rendering")
+
+
+def test_unit_tests_failing_after_the_last_attempt_name_the_cause(workspace, fixtures_dir, caplog):
+    build_folder, unittests_script = workspace
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, build_folder, unittests_script, fixtures_dir)
+    code_renderer = CodeRenderer(render_context)
+
+    # The last render attempt of functionality 1, after its last unit-test fix round.
+    render_context.start_implementing_frid()
+    render_context.frid_context.functional_requirement_render_attempts = MAX_CODE_GENERATION_RETRIES
+    render_context.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=MAX_UNITTEST_FIX_ATTEMPTS)
+    code_renderer.machine.set_state(
+        nested_state(States.IMPLEMENTING_FRID, States.PROCESSING_UNIT_TESTS, States.UNIT_TESTS_READY)
+    )
+
+    with caplog.at_level(logging.DEBUG, logger=plain2code_logger.LOGGER_NAME):
+        code_renderer.run()
+
+    assert render_context.state == States.RENDER_FAILED.value
+    assert api.failed_frids == ["1"]
+
+    last_output_path = render_context.script_execution_history.latest_unit_test_output_path
+    assert last_output_path is not None and os.path.exists(last_output_path)
+
+    expected_message = (
+        f"Functionality 1: unit tests still fail after {MAX_CODE_GENERATION_RETRIES} render attempts, "
+        f"{MAX_UNITTEST_FIX_ATTEMPTS} fix rounds each. Last unit tests output: {last_output_path}"
+    )
+    assert error_log_messages(caplog) == [expected_message]
+    # The TUI shows the same stop reason as the log.
+    assert render_context.last_error_message == expected_message
+
+
+def test_unit_tests_failing_again_during_conformance_tests_name_the_cause_once(workspace, fixtures_dir, caplog):
+    build_folder, unittests_script = workspace
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, build_folder, unittests_script, fixtures_dir)
+    code_renderer = CodeRenderer(render_context)
+
+    # Unit tests broken by a conformance fix, failing their last fix round for the last allowed time.
+    render_context.start_implementing_frid()
+    render_context.start_conformance_tests_processing()
+    render_context.functional_requirements_render_attempts_failed_unit_during_conformance_tests = (
+        MAX_FUNCTIONAL_REQUIREMENT_RENDER_ATTEMPTS_FAILED_UNIT_DURING_CONFORMANCE_TESTS - 1
+    )
+    render_context.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=MAX_UNITTEST_FIX_ATTEMPTS)
+    code_renderer.machine.set_state(
+        nested_state(
+            States.IMPLEMENTING_FRID,
+            States.PROCESSING_CONFORMANCE_TESTS,
+            States.PROCESSING_UNIT_TESTS,
+            States.UNIT_TESTS_READY,
+        )
+    )
+
+    with caplog.at_level(logging.DEBUG, logger=plain2code_logger.LOGGER_NAME):
+        code_renderer.run()
+
+    assert render_context.state == States.RENDER_FAILED.value
+    error_messages = error_log_messages(caplog)
+    assert len(error_messages) == 1
+    assert error_messages[0].startswith("Failed to adjust the unit tests")
+    assert "functionality 1" in error_messages[0]
+    # The TUI shows the same stop reason as the log, not the unit tests output of the payload.
+    assert render_context.last_error_message == error_messages[0]
+
+
+class TestExitWithErrorMessage:
+    @staticmethod
+    def make_context(last_error_message=None):
+        render_context = RenderContext.__new__(RenderContext)
+        render_context.codeplain_api = FakeCodeplainAPI()
+        render_context.frid_context = SimpleNamespace(frid="1")
+        render_context.module_name = "mod"
+        render_context.run_state = RunState(spec_filename="mod.plain")
+        render_context.last_error_message = last_error_message
+        return render_context
+
+    def run_exit(self, render_context, payload, caplog):
+        with caplog.at_level(logging.DEBUG, logger=plain2code_logger.LOGGER_NAME):
+            ExitWithError().execute(render_context, payload)
+        return error_log_messages(caplog)
+
+    def test_logs_the_message_of_an_error_payload(self, caplog):
+        render_context = self.make_context()
+        payload = RenderError.encode(
+            message="Unit tests script failed due to problems in the environment setup.",
+            error_type="ENVIRONMENT_ERROR",
+            script="run_unittests.sh",
+        ).to_payload()
+
+        messages = self.run_exit(render_context, payload, caplog)
+
+        expected = (
+            "Unit tests script failed due to problems in the environment setup.\n\nDetails:\n  Script: run_unittests.sh"
+        )
+        assert messages == [expected]
+        assert render_context.last_error_message == expected
+
+    def test_logs_the_stored_message_when_the_payload_is_not_an_error(self, caplog):
+        render_context = self.make_context(last_error_message="Conformance tests could not be fixed.")
+
+        messages = self.run_exit(render_context, {"previous_unittests_issue": "1 failed"}, caplog)
+
+        assert messages == ["Conformance tests could not be fixed."]
+        assert render_context.last_error_message == "Conformance tests could not be fixed."
+
+    def test_never_logs_none(self, caplog):
+        render_context = self.make_context()
+
+        messages = self.run_exit(render_context, None, caplog)
+
+        assert len(messages) == 1
+        assert "None" not in messages[0]
+        assert render_context.last_error_message == messages[0]

codeplain-0.3.13.dev36/tests/test_file_utils.py

@@ -1,92 +0,0 @@
-import os
-import tempfile
-
-import pytest
-
-from file_utils import load_linked_resources, store_response_files
-from plain2code_exceptions import UnsupportedBase64Content, UnsupportedResourceType
-from plain2code_utils import MAX_BASE64_BLOB_LENGTH
-
-
-@pytest.fixture
-def template_dir():
-    with tempfile.TemporaryDirectory() as d:
-        yield d
-
-
-def test_load_linked_resources_text_file(template_dir):
-    file_path = os.path.join(template_dir, "notes.md")
-    with open(file_path, "w") as f:
-        f.write("# hello")
-
-    result = load_linked_resources([template_dir], [{"text": "Notes", "target": "notes.md"}], "my_thing")
-
-    assert result == {"notes.md": "# hello"}
-
-
-def test_load_linked_resources_binary_file_raises_unsupported_resource_type(template_dir):
-    file_path = os.path.join(template_dir, "icon.png")
-    with open(file_path, "wb") as f:
-        f.write(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\xff\xfe\xfd")
-
-    with pytest.raises(UnsupportedResourceType) as exc_info:
-        load_linked_resources([template_dir], [{"text": "Icon", "target": "icon.png"}], "my_thing")
-
-    assert "icon.png" in str(exc_info.value)
-    assert "binary file" in str(exc_info.value)
-    assert "my_thing" in str(exc_info.value)
-
-
-def test_load_linked_resources_missing_file_raises_file_not_found(template_dir):
-    with pytest.raises(FileNotFoundError):
-        load_linked_resources([template_dir], [{"text": "Missing", "target": "missing.md"}], "my_thing")
-
-
-def test_load_linked_resources_base64_blob_raises(template_dir):
-    file_path = os.path.join(template_dir, "request.txt")
-    with open(file_path, "w") as f:
-        f.write("curl -d 'selfie_image=" + "A" * (MAX_BASE64_BLOB_LENGTH + 100) + "'")
-
-    with pytest.raises(UnsupportedBase64Content) as exc_info:
-        load_linked_resources([template_dir], [{"text": "Request", "target": "request.txt"}], "my_thing")
-
-    assert "request.txt" in str(exc_info.value)
-    assert "my_thing" in str(exc_info.value)
-
-
-def test_load_linked_resources_small_base64_allowed(template_dir):
-    file_path = os.path.join(template_dir, "token.txt")
-    with open(file_path, "w") as f:
-        f.write("token=" + "A" * (MAX_BASE64_BLOB_LENGTH - 100))
-
-    result = load_linked_resources([template_dir], [{"text": "Token", "target": "token.txt"}], "my_thing")
-
-    assert "token.txt" in result
-
-
-def test_load_linked_resources_real_base64_image_raises(template_dir):
-    # Real base64-encoded JPEG that made Gemini 3 fail, inlined into a curl example resource.
-    sample_path = os.path.join(os.path.dirname(__file__), "data", "sample_base64_image.txt")
-    with open(sample_path) as f:
-        blob = f.read()
-
-    file_path = os.path.join(template_dir, "face_match_request.txt")
-    with open(file_path, "w") as f:
-        f.write(f"curl -d 'selfie_image={blob}' https://example.com/face-match")
-
-    with pytest.raises(UnsupportedBase64Content) as exc_info:
-        load_linked_resources([template_dir], [{"text": "Request", "target": "face_match_request.txt"}], "face_match")
-
-    assert "face_match_request.txt" in str(exc_info.value)
-    assert str(len(blob)) in str(exc_info.value)
-
-
-def test_store_response_files_writes_unicode_as_utf8(template_dir):
-    # Content with a non-cp1252 character (📍 U+1F4CD) must be written as UTF-8
-    # regardless of the platform's default text encoding (e.g. cp1252 on Windows).
-    content = "Location 📍 marker"
-    store_response_files(template_dir, {"notes.md": content}, [])
-
-    file_path = os.path.join(template_dir, "notes.md")
-    with open(file_path, "rb") as f:
-        assert f.read().decode("utf-8") == content