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

plain_file.py

@@ -90,7 +90,7 @@ def remove_quotes(token):
     token.children = tuple(new_children)
 
 
-def check_section_for_linked_resources(section):
+def check_section_for_linked_resources(section, template_dirs):
     linked_resources = []
     for link in traverse(section, klass=Link):
         parsed_url = urlparse(link.node.target)
@@ -99,11 +99,19 @@ def check_section_for_linked_resources(section):
                 f"Plain syntax error: Only relative links are allowed (text: {link.node.children[0].content}, target: {link.node.target})."
             )
 
-        if not os.path.exists(link.node.target):
-            raise PlainSyntaxError(f"Plain syntax error: Link {link.node.target} does not exist.")
+        resolved_target = file_utils.resolve_linked_resource(template_dirs, link.node.target)
+        if resolved_target is None:
+            searched_dirs = "\n".join(f"  {position}. {dir}" for position, dir in enumerate(template_dirs, start=1))
+            raise PlainSyntaxError(
+                f"Plain syntax error: Link {link.node.target} does not exist. "
+                f"Linked resources are looked up relative to the following directories "
+                f"(highest to lowest precedence):\n{searched_dirs}"
+            )
 
-        if not os.path.isfile(link.node.target):
-            raise PlainSyntaxError(f"Plain syntax error: Link {link.node.target} must be a file.")
+        if not os.path.isfile(resolved_target):
+            raise PlainSyntaxError(
+                f"Plain syntax error: Link {link.node.target} must be a file (resolved to {resolved_target})."
+            )
 
         if len(link.node.children) != 1:
             raise PlainSyntaxError(f"Plain syntax error: Link must have text specified (link: {link.node.target}).")
@@ -122,15 +130,15 @@ def check_section_for_linked_resources(section):
         section.linked_resources = linked_resources
 
 
-def check_for_linked_resources(plain_source):
+def check_for_linked_resources(plain_source, template_dirs):
     for specification_heading in plain_spec.ALLOWED_SPECIFICATION_HEADINGS:
         if specification_heading in plain_source and hasattr(plain_source[specification_heading], "children"):
             for requirement in plain_source[specification_heading].children:
-                check_section_for_linked_resources(requirement)
+                check_section_for_linked_resources(requirement, template_dirs)
 
                 if hasattr(requirement, plain_spec.ACCEPTANCE_TESTS):
                     for acceptance_test in requirement.acceptance_tests:
-                        check_section_for_linked_resources(acceptance_test)
+                        check_section_for_linked_resources(acceptance_test, template_dirs)
 
 
 def process_section_code_variables(section, code_variables):
@@ -615,15 +623,45 @@ def parse_plain_source(  # noqa: C901
                 f"Plain syntax error: Syntax error at line {nested_acceptance_test_heading.line_number}: {plain_spec.ACCEPTANCE_TEST_HEADING} heading should be nested under specific functional spec."
             )
 
+    defined_concepts = set[str]()
     if plain_source[plain_spec.DEFINITIONS] is not None:
         with PlainRenderer() as renderer:
             for token in plain_source[plain_spec.DEFINITIONS].children:
                 rendered_token = renderer.render(token)
                 new_concepts, _ = concept_utils.extract_concepts_from_definition(rendered_token)
+                defined_concepts.update(new_concepts)
                 for concept in new_concepts:
                     if concept in required_concepts:
                         required_concepts.remove(concept)
 
+    if EXPORTED_CONCEPTS_DIRECTIVE in plain_source_obj.metadata:
+        module_name = modules_trace[-1] if modules_trace else None
+        subject = f"Module '{module_name}'" if module_name else "Module"
+
+        for entry in plain_source_obj.metadata[EXPORTED_CONCEPTS_DIRECTIVE]:
+            exported_concepts, errors = concept_utils.extract_concepts_from_definition(entry)
+            if errors:
+                raise PlainSyntaxError(
+                    f"Plain syntax error: {subject} exports an invalid concept (`{entry}`). "
+                    f"Expected a concept token, e.g. :ConceptName:."
+                )
+
+            for exported_concept in exported_concepts:
+                if exported_concept in concept_utils.DEFAULT_CONCEPTS:
+                    raise PlainSyntaxError(
+                        f"Plain syntax error: {subject} cannot export default concept {exported_concept}. "
+                        f"Only user-defined concepts can be exported."
+                    )
+
+                if exported_concept not in defined_concepts:
+                    message = f"Plain syntax error: {subject} exports undefined concept {exported_concept}."
+                    if REQUIRES_DIRECTIVE in plain_source_obj.metadata:
+                        message += (
+                            " An exported concept must be defined in this module's definitions or in an "
+                            "imported module; a concept inherited through requires cannot be re-exported."
+                        )
+                    raise PlainSyntaxError(message)
+
     required_modules = []
     if REQUIRES_DIRECTIVE in plain_source_obj.metadata:
         required_modules = plain_source_obj.metadata[REQUIRES_DIRECTIVE]
@@ -710,15 +748,7 @@ def process_required_modules(
         if EXPORTED_CONCEPTS_DIRECTIVE in plain_file_parse_result.plain_source_obj.metadata:
             exported_concepts = list[str]()
             for concept in plain_file_parse_result.plain_source_obj.metadata[EXPORTED_CONCEPTS_DIRECTIVE]:
-                if concept in concept_utils.DEFAULT_CONCEPTS:
-                    raise PlainSyntaxError(
-                        f"Plain syntax error: Default concept cannot be exported: {concept}. Only user-defined concepts can be exported."
-                    )
-
-                if isinstance(concept, str):
-                    exported_concepts.extend(concept_utils.extract_concepts_from_definition(concept)[0])
-                else:
-                    raise PlainSyntaxError(f"Plain syntax error: Invalid exported concept: {concept}.")
+                exported_concepts.extend(concept_utils.extract_concepts_from_definition(concept)[0])
 
             with PlainRenderer() as renderer:
                 for exported_concept in exported_concepts:
@@ -737,6 +767,9 @@ def process_exported_definitions(plain_source: dict, exported_definitions: list[
     if len(exported_definitions) == 0:
         return
 
+    if plain_source[plain_spec.DEFINITIONS] is None:
+        plain_source[plain_spec.DEFINITIONS] = mistletoe.Document("")
+
     with PlainRenderer() as renderer:
         for exported_definition in exported_definitions:
             add_defintion = True
@@ -820,7 +853,7 @@ def plain_file_parser(  # noqa: C901
 
     process_acceptance_tests(plain_file_parse_result.plain_source)
 
-    check_for_linked_resources(plain_file_parse_result.plain_source)
+    check_for_linked_resources(plain_file_parse_result.plain_source, template_dirs)
 
     marshalled_plain_source = marshall_plain_source(plain_file_parse_result.plain_source)
 

plain_modules.py

@@ -6,18 +6,18 @@ import tempfile
 import zipfile
 from functools import cached_property
 
+from git_preflight import require_git
 from plain2code_exceptions import (
-    GitNotInstalledError,
     InvalidModuleArchiveError,
     MissingPreviousFunctionalitiesError,
     ModuleDoesNotExistError,
 )
 
-try:
-    from git import Repo
-    from git.exc import NoSuchPathError
-except ImportError:
-    raise GitNotInstalledError("git is not installed. Please install git and try again.")
+# Must run before GitPython is imported, which raises on a missing or broken git.
+require_git()
+
+from git import Repo
+from git.exc import NoSuchPathError
 
 import file_utils
 import git_utils

render_machine/actions/fix_conformance_test.py

@@ -189,6 +189,17 @@ class FixConformanceTest(BaseAction):
                 ctx.test_that_triggered_code_change = (ctx.current_testing_module_name, ctx.current_testing_frid)
                 ctx.execution_phase = TestExecutionPhase.RETRYING_AFTER_CODE_CHANGE
 
+                # Remember the change so that the unit tests fixer (which runs next) preserves it instead of
+                # reverting it - see FixUnitTests.
+                summary = fix_attempt_summary if isinstance(fix_attempt_summary, dict) else {}
+                ctx.implementation_code_fixes.append(
+                    {
+                        "hypothesis": summary.get("hypothesis"),
+                        "approach": summary.get("approach"),
+                        "code_diff": code_diff_files_content,
+                    }
+                )
+
                 journal.record_fix(
                     ctx.current_testing_module_name,
                     ctx.current_testing_frid,

render_machine/actions/fix_unit_tests.py

@@ -32,6 +32,13 @@ class FixUnitTests(BaseAction):
 
         render_utils.print_inputs(render_context, existing_files_content, "Files sent as input to unit tests fixing:")
 
+        conformance_tests_fixes = self._get_conformance_tests_fixes(render_context)
+        if conformance_tests_fixes:
+            console.info(
+                f"Unit tests are fixed while preserving {len(conformance_tests_fixes)} implementation code change(s) "
+                "made to fix the conformance tests."
+            )
+
         response_files = render_context.codeplain_api.fix_unittests_issue(
             render_context.frid_context.frid,
             render_context.plain_source_tree,
@@ -41,6 +48,7 @@ class FixUnitTests(BaseAction):
             render_context.get_required_modules_functionalities(),
             previous_unittests_issue,
             run_state=render_context.run_state,
+            conformance_tests_fixes=conformance_tests_fixes,
         )
 
         _, changed_files = file_utils.update_build_folder_with_rendered_files(
@@ -52,3 +60,20 @@ class FixUnitTests(BaseAction):
         console.print_files("Files fixed:", render_context.build_folder, response_files, style=console.OUTPUT_STYLE)
 
         return self.SUCCESSFUL_OUTCOME, None
+
+    @staticmethod
+    def _get_conformance_tests_fixes(render_context: RenderContext) -> list[dict] | None:
+        """Implementation code changes the conformance tests fixer made before these unit tests were run.
+
+        Only present when unit tests are processed inside the conformance tests phase - the implementation
+        and refactoring unit test passes have no conformance tests running context.
+        """
+        conformance_tests_running_context = getattr(render_context, "conformance_tests_running_context", None)
+        if conformance_tests_running_context is None:
+            return None
+
+        implementation_code_fixes = getattr(conformance_tests_running_context, "implementation_code_fixes", None)
+        if not implementation_code_fixes:
+            return None
+
+        return list(implementation_code_fixes)

render_machine/render_types.py

@@ -91,6 +91,11 @@ class ConformanceTestsRunningContext:
 
         self.current_testing_frid_high_level_implementation_plan: Optional[str] = None
 
+        # Implementation code changes made by the conformance tests fixer during this conformance phase, in
+        # order. Each entry is {"hypothesis": str | None, "approach": str | None, "code_diff": {file: diff}}.
+        # Handed to the unit tests fixer so it adjusts the unit tests instead of reverting these changes.
+        self.implementation_code_fixes: list[dict] = []
+
     def get_conformance_tests_json(self, module_name: str) -> dict:
         return self._conformance_tests_json[module_name]
 

tests/test_cli_output.py

@@ -67,7 +67,7 @@ class TestDisplayCreditLine:
 
     @patch("cli_output.status.console")
     def test_display_active_free_trial(self, mock_console):
-        """Test displaying active free trial credits."""
+        """Test displaying active free credits."""
         plan_credits = {
             "type": "free",
             "total": 50,
@@ -78,7 +78,7 @@ class TestDisplayCreditLine:
 
         mock_console.print.assert_called_once()
         call_args = mock_console.print.call_args[0][0]
-        assert "Free trial" in call_args
+        assert "Free credits" in call_args
         assert "4 of 50 remaining" in call_args
         assert "expires Dec 1, 2028" in call_args
 
@@ -216,8 +216,10 @@ class TestDisplayStatusMessage:
         }
         _display_status_message(plan_credits, [], [])
 
-        # Should not print warning message
-        mock_console.print.assert_not_called()
+        mock_console.print.assert_called_once()
+        call_args = mock_console.print.call_args[0][0]
+        assert "To manage your plan" in call_args
+        assert "No rendering credits remaining" not in call_args
 
     @patch("cli_output.status.console")
     def test_has_active_purchased_credits(self, mock_console):
@@ -230,8 +232,10 @@ class TestDisplayStatusMessage:
         ]
         _display_status_message(None, purchased_credits, [])
 
-        # Should not print warning message
-        mock_console.print.assert_not_called()
+        mock_console.print.assert_called_once()
+        call_args = mock_console.print.call_args[0][0]
+        assert "To manage your plan" in call_args
+        assert "No rendering credits remaining" not in call_args
 
     @patch("cli_output.status.console")
     def test_has_active_promo_credits(self, mock_console):
@@ -244,8 +248,10 @@ class TestDisplayStatusMessage:
         ]
         _display_status_message(None, [], promo_credits)
 
-        # Should not print warning message
-        mock_console.print.assert_not_called()
+        mock_console.print.assert_called_once()
+        call_args = mock_console.print.call_args[0][0]
+        assert "To manage your plan" in call_args
+        assert "No rendering credits remaining" not in call_args
 
     @patch("cli_output.status.console")
     def test_no_credits_remaining(self, mock_console):
@@ -259,6 +265,7 @@ class TestDisplayStatusMessage:
         mock_console.print.assert_called_once()
         call_args = mock_console.print.call_args[0][0]
         assert "No rendering credits remaining" in call_args
+        assert "https://platform.codeplain.ai/plans" in call_args
 
     @patch("cli_output.status.console")
     def test_expired_plan_credits(self, mock_console):

tests/test_console_log_styles.py

@@ -70,14 +70,70 @@ class TestConsoleColorParam:
 
         assert handler.records[0].log_color is None
 
-    def test_bracketed_error_text_prints_verbatim(self):
-        console, handler = make_console_with_capture()
-        console.quiet = False
+
+class TestTerminalTextRendersVerbatim:
+    """
+    Message text must reach the terminal unchanged, and must not influence its own
+    styling. Colors are still applied but they are chosen by the call, never parsed
+    out of the text:
+     - Rich markup tags must not be interpreted
+     - the repr highlighter must not restyle brackets and numbers
+     - emoji shortcodes must not be substituted by glyphs
+    """
+
+    def test_markup_closing_tag_prints_verbatim(self):
+        console = Plain2CodeConsole()
         with console.capture() as capture:
-            console.info("Error: [Errno 8] failed [/closing] tag", color=RETRY_COLOR)
-        assert "[Errno 8]" in capture.get()
+            console.error("Error: [/closing] tag")
+        # markup=True raises MarkupError on an unmatched closing tag
         assert "[/closing]" in capture.get()
 
+    def test_markup_style_tag_prints_verbatim(self):
+        console = Plain2CodeConsole()
+        with console.capture() as capture:
+            console.error("Error: [bold]important text")
+        # markup=True silently consumes the tag and styles the rest
+        assert "[bold]" in capture.get()
+
+    def test_bracketed_number_prints_verbatim(self, monkeypatch):
+        # Rich emits no ANSI unless it believes it is writing to a colored terminal
+        # (FORCE_COLOR alone is not enough: TERM=dumb still resolves to no colors)
+        monkeypatch.setenv("FORCE_COLOR", "1")
+        monkeypatch.setenv("TERM", "xterm-256color")
+        console = Plain2CodeConsole()
+        assert console.color_system is not None  # should fail test immediately if no colors
+
+        with console.capture() as capture:
+            console.error("Error: [Errno 8] failed")
+        # highlight=True breaks this up with colour codes
+        assert "[Errno 8]" in capture.get()
+
+    def test_concept_name_matching_emoji_prints_verbatim(self):
+        console = Plain2CodeConsole()
+        with console.capture() as capture:
+            console.error("Syntax error: Invalid concept: :Package:")
+        assert ":Package:" in capture.get()
+        assert "📦" not in capture.get()
+
+
+class TestPrintHelpersDoNotSubstituteEmoji:
+    """
+    Same rule as TestTerminalTextRendersVerbatim, for the two helpers that bypass _log_and_print.
+    Only emoji is covered here, markup and highlighting still apply to them.
+    """
+
+    def test_print_list_does_not_substitute_emoji(self):
+        console = Plain2CodeConsole()
+        with console.capture() as capture:
+            console.print_list(["The :Package: is a concept"])
+        assert ":Package:" in capture.get()
+
+    def test_print_files_does_not_substitute_emoji_in_tree_labels(self):
+        console = Plain2CodeConsole()
+        with console.capture() as capture:
+            console.print_files("Files added:", "build", {":Package:.py": "x"})
+        assert ":Package:" in capture.get()
+
 
 class TestLoggingHandlerForwardsColor:
     """LoggingHandler must forward the log_color record attribute into LogMessageEmitted."""

tests/test_dry_run_link_validation.py

@@ -0,0 +1,60 @@
+"""Regression tests for linked-resource validation during --dry-run.
+
+A linked resource must be a single text-based file. Rendering rejects binary
+targets in ``file_utils.load_linked_resources`` (a failed UTF-8 decode raises
+``UnsupportedResourceType``); dry-run must surface the same errors through
+``plain2code.validate_linked_resources``, which reuses that exact mechanism.
+"""
+
+import pytest
+
+from plain2code import validate_linked_resources
+from plain2code_exceptions import UnsupportedResourceType
+from plain_modules import PlainModule
+
+PLAIN_TEMPLATE = """***definitions***
+
+- :Widget: is an item managed by the application.
+  - Its icon is [the widget resource](resources/{resource_name}).
+
+***implementation reqs***
+
+- Implementation should be in Python.
+
+***functional specs***
+
+- A :Widget: can be created.
+"""
+
+
+def _make_module(tmp_path, monkeypatch, resource_name, resource_bytes):
+    resources_dir = tmp_path / "resources"
+    resources_dir.mkdir()
+    (resources_dir / resource_name).write_bytes(resource_bytes)
+    (tmp_path / "binlink.plain").write_text(PLAIN_TEMPLATE.format(resource_name=resource_name))
+
+    # Link targets are resolved relative to the current working directory at parse time.
+    monkeypatch.chdir(tmp_path)
+    return PlainModule("binlink.plain", str(tmp_path / "build"), [str(tmp_path)])
+
+
+def test_dry_run_validation_rejects_binary_linked_resource(tmp_path, monkeypatch):
+    module = _make_module(tmp_path, monkeypatch, "image.png", b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\xff\xfe\xfd")
+
+    with pytest.raises(UnsupportedResourceType) as exc_info:
+        validate_linked_resources(module)
+
+    assert "resources/image.png" in str(exc_info.value)
+    assert "binary file" in str(exc_info.value)
+
+
+def test_dry_run_validation_accepts_text_file_with_unusual_extension(tmp_path, monkeypatch):
+    module = _make_module(tmp_path, monkeypatch, "notes.xyz123", b"plain text content\n")
+
+    validate_linked_resources(module)
+
+
+def test_dry_run_validation_accepts_empty_file(tmp_path, monkeypatch):
+    module = _make_module(tmp_path, monkeypatch, "empty.txt", b"")
+
+    validate_linked_resources(module)

tests/test_fix_unit_tests_conformance_context.py

@@ -0,0 +1,230 @@
+"""Tests for handing the conformance tests fixer's implementation changes to the unit tests fixer.
+
+When the conformance tests fixer changes implementation code, the unit tests are re-run and fixed next.
+The unit tests fixer must know about that change so it adjusts the unit tests instead of reverting it.
+"""
+
+import os
+import tempfile
+from types import SimpleNamespace
+
+import pytest
+
+import plain_spec
+from memory_management import MemoryManager
+from render_machine.actions import fix_unit_tests as fix_unit_tests_module
+from render_machine.actions.fix_conformance_test import FixConformanceTest
+from render_machine.actions.fix_unit_tests import FixUnitTests
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
+from render_machine.render_types import ConformanceTestsRunningContext, UnitTestsRunningContext
+
+
+class FakeCodeplainAPI:
+    def __init__(self, conformance_fix_response=None, unittests_fix_response=None):
+        self.conformance_fix_response = conformance_fix_response
+        self.unittests_fix_response = unittests_fix_response or {}
+        self.unittests_fix_calls = []
+
+    def fix_conformance_tests_issue(self, *args, **kwargs):
+        return self.conformance_fix_response
+
+    def fix_unittests_issue(self, *args, **kwargs):
+        self.unittests_fix_calls.append(kwargs)
+        return self.unittests_fix_response
+
+
+class FakeConformanceTests:
+    def fetch_existing_conformance_test_files(self, *args):
+        return {}, {}
+
+    def store_conformance_tests_files(self, *args):
+        pass
+
+
+@pytest.fixture
+def build_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        with open(os.path.join(folder, "app.py"), "w", encoding="utf-8") as source_file:
+            source_file.write("def add(a, b):\n    return a + b\n")
+        yield folder
+
+
+@pytest.fixture
+def memory_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        yield folder
+
+
+@pytest.fixture(autouse=True)
+def isolate_from_git_and_console(monkeypatch):
+    monkeypatch.setattr(ImplementationCodeHelpers, "get_code_diff", staticmethod(lambda *args: {}))
+    monkeypatch.setattr(plain_spec, "collect_linked_resources", lambda *args: None)
+    monkeypatch.setattr(fix_unit_tests_module.render_utils, "print_inputs", lambda *args: None)
+
+
+def make_conformance_context():
+    return ConformanceTestsRunningContext(
+        current_testing_module_name="mod",
+        current_testing_frid="1",
+        fix_attempts=0,
+        conformance_tests_json={"1": {"folder_name": "conformance_1"}},
+        conformance_tests_render_attempts=0,
+        current_testing_frid_specifications={},
+        should_prepare_testing_environment=False,
+        frid_being_implemented="1",
+    )
+
+
+def make_render_context(api, build_folder, memory_folder, conformance_tests_running_context):
+    return SimpleNamespace(
+        codeplain_api=api,
+        build_folder=build_folder,
+        memory_manager=MemoryManager(api, memory_folder),
+        conformance_tests=FakeConformanceTests(),
+        conformance_tests_running_context=conformance_tests_running_context,
+        unit_tests_running_context=UnitTestsRunningContext(fix_attempts=1),
+        plain_source_tree={},
+        module_name="mod",
+        required_modules=None,
+        frid_context=SimpleNamespace(frid="1", linked_resources={}),
+        get_required_modules_functionalities=lambda: {},
+        run_state=SimpleNamespace(render_id="test-render-id", unittest_batch_id=1),
+    )
+
+
+def run_conformance_fix(render_context):
+    return FixConformanceTest().execute(render_context, {"previous_conformance_tests_issue": "tests failed"})
+
+
+def test_conformance_fix_of_implementation_code_is_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+            {"app.py": "def add(a, b):\n    return a + b + 1\n"},
+            {"hypothesis": "off by one", "approach": "add one"},
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_conformance_fix(render_context)
+
+    assert outcome == FixConformanceTest.IMPLEMENTATION_CODE_UPDATED
+    assert len(ctx.implementation_code_fixes) == 1
+    recorded_fix = ctx.implementation_code_fixes[0]
+    assert recorded_fix["hypothesis"] == "off by one"
+    assert recorded_fix["approach"] == "add one"
+    assert list(recorded_fix["code_diff"]) == ["app.py"]
+    assert "+    return a + b + 1" in recorded_fix["code_diff"]["app.py"]
+
+
+def test_consecutive_implementation_fixes_accumulate(build_folder, memory_folder):
+    ctx = make_conformance_context()
+    for attempt in range(2):
+        api = FakeCodeplainAPI(
+            conformance_fix_response=[
+                FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+                {"app.py": f"def add(a, b):\n    return a + b + {attempt + 1}\n"},
+                {"hypothesis": f"hypothesis {attempt}", "approach": f"approach {attempt}"},
+                "prepared issue",
+            ]
+        )
+        render_context = make_render_context(api, build_folder, memory_folder, ctx)
+        run_conformance_fix(render_context)
+
+    assert [fix["hypothesis"] for fix in ctx.implementation_code_fixes] == ["hypothesis 0", "hypothesis 1"]
+
+
+def test_conformance_fix_without_summary_is_still_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+            {"app.py": "def add(a, b):\n    return a + b + 1\n"},
+            None,
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    run_conformance_fix(render_context)
+
+    assert ctx.implementation_code_fixes[0]["hypothesis"] is None
+    assert ctx.implementation_code_fixes[0]["approach"] is None
+    assert "app.py" in ctx.implementation_code_fixes[0]["code_diff"]
+
+
+def test_conformance_fix_of_conformance_tests_is_not_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_CONFORMANCE_TESTS,
+            {"test_app.py": "def test_add(): pass\n"},
+            {"hypothesis": "wrong assertion", "approach": "fix test"},
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_conformance_fix(render_context)
+
+    assert outcome == FixConformanceTest.IMPLEMENTATION_CODE_NOT_UPDATED
+    assert ctx.implementation_code_fixes == []
+
+
+def test_implementation_fix_with_no_files_is_not_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+            {},
+            {"hypothesis": "nothing", "approach": "nothing"},
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_conformance_fix(render_context)
+
+    assert outcome == FixConformanceTest.IMPLEMENTATION_CODE_NOT_UPDATED
+    assert ctx.implementation_code_fixes == []
+
+
+def run_unit_tests_fix(render_context):
+    return FixUnitTests().execute(render_context, {"previous_unittests_issue": "1 failed"})
+
+
+def test_unit_tests_fix_forwards_conformance_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI(unittests_fix_response={"test_app.py": "def test_add(): pass\n"})
+    ctx = make_conformance_context()
+    ctx.implementation_code_fixes.append(
+        {"hypothesis": "off by one", "approach": "add one", "code_diff": {"app.py": "+    return a + b + 1"}}
+    )
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_unit_tests_fix(render_context)
+
+    assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
+    assert len(api.unittests_fix_calls) == 1
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] == ctx.implementation_code_fixes
+    # The forwarded list is a copy, so later conformance fixes do not mutate what was sent.
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is not ctx.implementation_code_fixes
+
+
+def test_unit_tests_fix_outside_conformance_phase_sends_no_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, build_folder, memory_folder, None)
+
+    run_unit_tests_fix(render_context)
+
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None
+
+
+def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_sends_no_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, build_folder, memory_folder, make_conformance_context())
+
+    run_unit_tests_fix(render_context)
+
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None