feat(cache): serve every checkout's own cache declarations

A checkout that declared a new cache host rendered the artefacts and reached nothing: the Nexus proxy repository, the frontend's leaf certificate and the nginx upstream map all live in the running stack, which only the owning checkout set up. cache-apply installs all three and reloads the frontend, and compose up runs it for a checkout that merely joins the network, so the manual call is left for a declaration changed between two bring-ups.

The map source is no longer selectable. INFINITO_CACHE_CONF_SOURCE existed to let a worktree read the primary checkout's map instead of its own, but the frontend mounts one map and the install replaces it, so the checkout that applied last wins either way: the knob chose which file to point at, never who prevailed. Dropping it also retires the git subprocess that resolved the owning checkout on every env build.

Two checkouts sharing a stack therefore overwrite each other's map, which the documentation now states instead of implying a selector could prevent it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/unit/python/cli/administration/deploy/development/test_compose.py

@@ -295,6 +295,41 @@ class TestComposeUpRetries(unittest.TestCase):
         compose._generate_package_frontend_certs.assert_called_once()
         compose._install_package_frontend_ca_in_runner.assert_called_once()
 
+    @patch.dict(
+        os.environ,
+        {
+            "INFINITO_BUILD": "1",
+            "INFINITO_IMAGE": "infinito-debian",
+            "INFINITO_PULL_POLICY": "never",
+            "CI": "",
+            "GITHUB_ACTIONS": "",
+            "INFINITO_RUNNING_ON_GITHUB": "",
+            "INFINITO_GIT_COMMON_DIR": "/primary/.git",
+            "INFINITO_CACHE_NETWORK": "infinito-nexus-core_default",
+            "INFINITO_CACHE_STACK": "",
+        },
+        clear=False,
+    )
+    def test_up_applies_the_declarations_to_a_cache_stack_it_shares(self) -> None:
+        compose = self._compose()
+        compose._render_coredns_corefile = MagicMock()
+        compose._compose_up_with_retries = MagicMock()
+        compose.wait_for_healthy = MagicMock()
+        compose._bootstrap_package_cache = MagicMock()
+        compose._generate_package_frontend_certs = MagicMock()
+        compose._apply_shared_cache = MagicMock()
+        compose._install_package_frontend_ca_in_runner = MagicMock()
+
+        compose.up(run_entry_init=False)
+
+        compose._compose_up_with_retries.assert_called_once_with(
+            ["up", "-d", "coredns", "infinito"], attempts=6, delay_s=30
+        )
+        compose._generate_package_frontend_certs.assert_not_called()
+        compose._bootstrap_package_cache.assert_not_called()
+        compose._apply_shared_cache.assert_called_once()
+        compose._install_package_frontend_ca_in_runner.assert_called_once()
+
 
 if __name__ == "__main__":  # pragma: no cover
     unittest.main()

tests/unit/python/utils/env/handlers/infinito/test_cache_conf.py

@@ -2,22 +2,17 @@
 
 from __future__ import annotations
 
-import os
-import subprocess
 import unittest
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from unittest.mock import patch
 
 from utils.env.builder import BuildContext, EnvBuilder
 from utils.env.handlers.infinito.cache import conf as handler
 
-_BLANK = {handler.SOURCE_KEY: "", handler.KEY: ""}
 
-
-def _ctx(root: Path, static: dict[str, str] | None = None) -> BuildContext:
+def _ctx(root: Path) -> BuildContext:
     return BuildContext(
-        static=static or {},
+        static={},
         static_comments={handler.KEY: handler.COMMENT},
         repo_root=root,
         on_gha=False,
@@ -25,79 +20,18 @@ def _ctx(root: Path, static: dict[str, str] | None = None) -> BuildContext:
     )
 
 
-def _apply(ctx: BuildContext) -> str:
-    eb = EnvBuilder()
-    handler.apply(eb, ctx)
-    return eb.values[handler.KEY]
-
-
-class TestPrimaryCheckout(unittest.TestCase):
-    def setUp(self) -> None:
-        self._tmp = TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        self.root = Path(self._tmp.name).resolve()
-        self.primary = self.root / "primary"
-        self.primary.mkdir()
-        self._git("init", "-q", "-b", "main", cwd=self.primary)
-        self._git("config", "user.email", "t@t", cwd=self.primary)
-        self._git("config", "user.name", "t", cwd=self.primary)
-        (self.primary / "seed").write_text("seed\n")
-        self._git("add", "seed", cwd=self.primary)
-        self._git("commit", "-qm", "seed", cwd=self.primary)
-
-    def _git(self, *args: str, cwd: Path) -> None:
-        subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
-
-    def test_the_primary_checkout_resolves_to_itself(self) -> None:
-        self.assertEqual(handler.primary_checkout(self.primary), self.primary)
-
-    def test_a_worktree_resolves_to_the_primary_checkout(self) -> None:
-        linked = self.root / "linked"
-        self._git("worktree", "add", "-q", str(linked), "-b", "side", cwd=self.primary)
-
-        self.assertEqual(handler.primary_checkout(linked), self.primary)
-
-    def test_a_directory_outside_git_falls_back_to_itself(self) -> None:
-        outside = self.root / "outside"
-        outside.mkdir()
-
-        self.assertEqual(handler.primary_checkout(outside), outside)
-
-    def test_a_root_git_cannot_be_run_in_falls_back_to_itself(self) -> None:
-        missing = self.root / "gone"
-
-        self.assertEqual(handler.primary_checkout(missing), missing)
-
-
 class TestApply(unittest.TestCase):
     def setUp(self) -> None:
         self._tmp = TemporaryDirectory()
         self.addCleanup(self._tmp.cleanup)
         self.root = Path(self._tmp.name).resolve()
 
-    @patch.dict(os.environ, _BLANK, clear=False)
-    def test_the_default_follows_the_primary_checkout(self) -> None:
-        with patch.object(handler, "primary_checkout", return_value=Path("/primary")):
-            self.assertEqual(
-                _apply(_ctx(self.root)), str(Path("/primary") / handler.RELATIVE)
-            )
+    def test_the_map_is_rendered_in_the_checkout_that_builds_it(self) -> None:
+        eb = EnvBuilder()
 
-    @patch.dict(os.environ, {**_BLANK, handler.SOURCE_KEY: "worktree"}, clear=False)
-    def test_the_environment_can_pin_the_worktree(self) -> None:
-        self.assertEqual(_apply(_ctx(self.root)), str(self.root / handler.RELATIVE))
+        handler.apply(eb, _ctx(self.root))
 
-    @patch.dict(os.environ, _BLANK, clear=False)
-    def test_a_static_entry_can_pin_the_worktree(self) -> None:
-        ctx = _ctx(self.root, {handler.SOURCE_KEY: "Worktree"})
-
-        self.assertEqual(_apply(ctx), str(self.root / handler.RELATIVE))
-
-    @patch.dict(os.environ, {**_BLANK, handler.SOURCE_KEY: "primary"}, clear=False)
-    def test_an_unknown_source_keeps_the_primary_checkout(self) -> None:
-        with patch.object(handler, "primary_checkout", return_value=Path("/primary")):
-            self.assertEqual(
-                _apply(_ctx(self.root)), str(Path("/primary") / handler.RELATIVE)
-            )
+        self.assertEqual(eb.values[handler.KEY], str(self.root / handler.RELATIVE))
 
 
 if __name__ == "__main__":