Send an earlier functionality's passing conformance tests as a reference

The conformance tests generator only saw the implementation, so the tests of
every functionality started with the same broken project setup: in airplain
most conformance fixes added the same missing dependencies, parent POM or
way of starting the application, one functionality after another. The client
now sends the files of the most recent earlier functionality's conformance
tests (of the current module, or of the closest required module for the
first functionality of a module) as reference_conformance_tests, bounded to
MAX_REFERENCE_TESTS_CHARS.

Author: VitjanZ

codeplain_REST_api.py

@@ -369,7 +369,10 @@ def render_conformance_tests(
         conformance_tests_folder_name,
         conformance_tests_json,
         run_state: RunState,
+        reference_conformance_tests: Optional[dict] = None,
     ):
+        """`reference_conformance_tests`: files of an earlier functionality's passing conformance tests, by path, for
+        the new tests to follow in their setup."""
         endpoint_url = f"{self.api_url}/render_conformance_tests"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
 
@@ -384,6 +387,7 @@ def render_conformance_tests(
             "required_modules": required_modules,
             "conformance_tests_folder_name": conformance_tests_folder_name,
             "conformance_tests_json": conformance_tests_json,
+            "reference_conformance_tests": reference_conformance_tests or {},
         }
 
         response = self.post_request(endpoint_url, headers, payload, run_state)

render_machine/actions/render_conformance_tests.py

@@ -10,6 +10,9 @@
 from render_machine.render_context import RenderContext
 from render_machine.render_types import AcceptanceTestPhase, TestExecutionPhase
 
+# Bound on the reference conformance tests sent for generating new ones (see _reference_conformance_tests).
+MAX_REFERENCE_TESTS_CHARS = 40_000
+
 
 class RenderConformanceTests(BaseAction):
     SUCCESSFUL_OUTCOME = "conformance_test_rendered"
@@ -42,6 +45,28 @@ def _should_render_conformance_tests(self, render_context: RenderContext) -> boo
         # 3. All other cases (IN_PROGRESS, COMPLETED): Render acceptance tests incrementally
         return False
 
+    @staticmethod
+    def _reference_conformance_tests(render_context: RenderContext, target_folder: str) -> dict[str, str]:
+        """The files of the most recent earlier functionality's conformance tests (they pass, or the render would
+        not have moved on), as a reference for setting up new ones: of the current module if it has any, otherwise
+        of the closest required module. Files by full path, smallest first, within MAX_REFERENCE_TESTS_CHARS."""
+        running = render_context.conformance_tests_running_context
+        candidates: list[dict] = []
+        if running.conformance_tests_json_has_module_populated(render_context.module_name):
+            candidates.append(running.get_conformance_tests_json(render_context.module_name))
+        for module in reversed(render_context.plain_module.all_required_modules):
+            candidates.append(render_context.conformance_tests.get_conformance_tests_json(module.module_name))
+        target = os.path.normpath(os.path.abspath(target_folder))
+        for tests_json in candidates:
+            for entry in reversed(list(tests_json.values())):
+                folder = os.path.normpath(os.path.abspath(entry.get("folder_name") or ""))
+                if folder == target or not os.path.isdir(folder):
+                    continue
+                files = _text_files(folder, MAX_REFERENCE_TESTS_CHARS)
+                if files:
+                    return files
+        return {}
+
     def _render_conformance_tests(self, render_context: RenderContext):
         # Check if tests already exist (e.g., during regression) - if so, skip rendering
         if not render_context.conformance_tests_running_context.current_conformance_tests_exist():
@@ -109,6 +134,13 @@ def _render_conformance_tests(self, render_context: RenderContext):
             style=console.INPUT_STYLE,
         )
 
+        reference_conformance_tests = self._reference_conformance_tests(render_context, conformance_tests_folder_name)
+        if reference_conformance_tests:
+            console.debug(
+                "Reference conformance tests sent for generating conformance tests: "
+                + ", ".join(sorted(reference_conformance_tests))
+            )
+
         response_files, traceability = render_context.codeplain_api.render_conformance_tests(
             render_context.frid_context.frid,
             render_context.conformance_tests_running_context.current_testing_frid,
@@ -123,6 +155,7 @@ def _render_conformance_tests(self, render_context: RenderContext):
                 render_context.conformance_tests_running_context.current_testing_module_name
             ),
             run_state=render_context.run_state,
+            reference_conformance_tests=reference_conformance_tests,
         )
 
         self._warn_about_untraced_scenarios(render_context, traceability)
@@ -223,3 +256,15 @@ def _render_acceptance_test(self, render_context: RenderContext):
             style=console.OUTPUT_STYLE,
         )
         return self.SUCCESSFUL_OUTCOME, None
+
+
+def _text_files(folder: str, max_chars: int) -> dict[str, str]:
+    """The text files of `folder` by full path, smallest first, within `max_chars`."""
+    contents = file_utils.get_existing_files_content(folder, file_utils.list_all_text_files(folder))
+    selected, total = {}, 0
+    for name in sorted(contents, key=lambda n: (len(contents[n]), n)):
+        if total + len(contents[name]) > max_chars:
+            break
+        selected[os.path.join(folder, name)] = contents[name]
+        total += len(contents[name])
+    return dict(sorted(selected.items()))

tests/test_reference_conformance_tests.py

@@ -0,0 +1,62 @@
+from types import SimpleNamespace
+
+from render_machine.actions.render_conformance_tests import RenderConformanceTests
+
+
+class FakeRunningContext:
+    def __init__(self, tests_json):
+        self.tests_json = tests_json
+
+    def conformance_tests_json_has_module_populated(self, module_name):
+        return bool(self.tests_json)
+
+    def get_conformance_tests_json(self, module_name):
+        return self.tests_json
+
+
+def make_render_context(tmp_path, current_json, required_jsons):
+    return SimpleNamespace(
+        module_name="messages",
+        conformance_tests_running_context=FakeRunningContext(current_json),
+        plain_module=SimpleNamespace(all_required_modules=[SimpleNamespace(module_name=m) for m in required_jsons]),
+        conformance_tests=SimpleNamespace(get_conformance_tests_json=lambda module: required_jsons[module]),
+    )
+
+
+def folder(tmp_path, name, files):
+    path = tmp_path / name
+    path.mkdir(parents=True)
+    for file_name, content in files.items():
+        (path / file_name).write_text(content)
+    return str(path)
+
+
+def test_reference_is_the_latest_earlier_functionality_of_the_current_module(tmp_path):
+    first = folder(tmp_path, "messages/publish", {"pom.xml": "first"})
+    second = folder(tmp_path, "messages/fetch", {"pom.xml": "second"})
+    target = str(tmp_path / "messages/list")
+    current = {"publish": {"folder_name": first}, "fetch": {"folder_name": second}, "list": {"folder_name": target}}
+    context = make_render_context(tmp_path, current, {"accounts": {}})
+
+    reference = RenderConformanceTests._reference_conformance_tests(context, target)
+
+    assert reference == {f"{second}/pom.xml": "second"}
+
+
+def test_first_functionality_of_a_module_uses_the_closest_required_module(tmp_path):
+    healthcheck = folder(tmp_path, "healthcheck/health", {"pom.xml": "health"})
+    accounts = folder(tmp_path, "accounts/delete", {"pom.xml": "accounts"})
+    target = str(tmp_path / "messages/publish")
+    required = {
+        "healthcheck": {"health": {"folder_name": healthcheck}},
+        "accounts": {"delete": {"folder_name": accounts}},
+    }
+    context = make_render_context(tmp_path, {"publish": {"folder_name": target}}, required)
+
+    assert RenderConformanceTests._reference_conformance_tests(context, target) == {f"{accounts}/pom.xml": "accounts"}
+
+
+def test_no_earlier_tests_give_no_reference(tmp_path):
+    target = str(tmp_path / "healthcheck/health")
+    context = make_render_context(tmp_path, {"health": {"folder_name": target}}, {})
+    assert RenderConformanceTests._reference_conformance_tests(context, target) == {}