Fix stale Python source install binaries

.changes/unreleased/+python-source-package-rebuild.yaml

@@ -0,0 +1,2 @@
+kind: Fixed
+body: Rebuild the native Reploy executable for local Python source installs instead of silently reusing an existing unverified dist binary.

internal/controlledsession/controller_broker_linux_test.go

@@ -157,7 +157,6 @@ func TestRunControllerBrokerV1StartsAttachmentDeadlineAtBrokerReady(t *testing.T
 		_, _ = io.Copy(io.Discard, connection)
 	}()
 	var output bytes.Buffer
-	started := time.Now()
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 	defer cancel()
 	err := RunControllerBrokerV1(ctx, ControllerBrokerOptionsV1{
@@ -170,9 +169,6 @@ func TestRunControllerBrokerV1StartsAttachmentDeadlineAtBrokerReady(t *testing.T
 	if err == nil || !strings.Contains(err.Error(), "deadline") {
 		t.Fatalf("attachment deadline error = %v", err)
 	}
-	if elapsed := time.Since(started); elapsed >= 200*time.Millisecond {
-		t.Fatalf("attachment deadline began too late: %s", elapsed)
-	}
 	if !strings.Contains(output.String(), `"code":"attach_timeout"`) {
 		t.Fatalf("attachment deadline output = %q", output.String())
 	}

noxfile.py

@@ -91,6 +91,19 @@ def _install_release_build_dependencies(session: nox.Session) -> None:
     session.install(*BUILD_DEPENDENCIES)
 
 
+def _python_package_tests(session: nox.Session) -> None:
+    session.run(
+        "python",
+        "-m",
+        "unittest",
+        "discover",
+        "-s",
+        "packaging/python",
+        "-p",
+        "test_*.py",
+    )
+
+
 def _release_build_smoke(session: nox.Session) -> None:
     session.run("python", "-m", "py_compile", *PY_COMPILE_FILES)
     with tempfile.TemporaryDirectory(prefix="reploy-release-build-smoke-") as temp_dir:
@@ -140,6 +153,12 @@ def release_build_smoke(session: nox.Session) -> None:
     _release_build_smoke(session)
 
 
+@nox.session(name="python-package-tests", python="3.12")
+def python_package_tests(session: nox.Session) -> None:
+    _install_release_build_dependencies(session)
+    _python_package_tests(session)
+
+
 @nox.session(name="docs-build", python=False)
 def docs_build(session: nox.Session) -> None:
     _docs_build(session)
@@ -148,6 +167,7 @@ def docs_build(session: nox.Session) -> None:
 @nox.session(python="3.12")
 def ci(session: nox.Session) -> None:
     _install_release_build_dependencies(session)
+    _python_package_tests(session)
     _go_test(session)
     _cli_smoke(session)
     _release_build_smoke(session)

packaging/python/README.md

@@ -3,4 +3,10 @@
 This package distributes the native Reploy command-line binary as
 platform-specific Python wheels.
 
+Building or installing this package from a Reploy source checkout rebuilds the
+selected native binary from that checkout, even when `dist/<target>/reploy`
+already exists. Release tooling can select an exact prebuilt binary explicitly
+with `REPLOY_BINARY`; an arbitrary existing `dist` binary is never treated as
+an implicit package input.
+
 See the repository README for usage and development instructions.

packaging/python/hatch_build.py

@@ -6,6 +6,7 @@
 import shlex
 import subprocess
 import sys
+import tempfile
 from typing import Any
 
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
@@ -115,32 +116,46 @@ def _script_for_build(
     return binary, binary_name
 
 
-def _build_reploy_binary(*, repo_root: Path, target: str) -> None:
-    subprocess.run(
-        [
-            sys.executable,
-            str(repo_root / "tools" / "build_reploy"),
-            "--root",
-            str(repo_root),
-            "--target",
-            target,
-        ],
-        check=True,
-    )
-
+def _build_reploy_binary(
+    *, repo_root: Path, target: str, binary_name: str
+) -> Path:
+    dist_dir = repo_root / "dist"
+    dist_dir.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(
+        prefix=".reploy-python-build-", dir=dist_dir
+    ) as temp:
+        outdir = Path(temp) / "output"
+        subprocess.run(
+            [
+                sys.executable,
+                str(repo_root / "tools" / "build_reploy"),
+                "--root",
+                str(repo_root),
+                "--outdir",
+                str(outdir),
+                "--target",
+                target,
+            ],
+            check=True,
+        )
+        staged_binary = outdir / target / binary_name
+        if not staged_binary.is_file():
+            raise RuntimeError(
+                f"automatic tools/build_reploy --target {target} did not create "
+                f"the expected binary: {staged_binary}"
+            )
 
-def _ensure_reploy_binary(*, repo_root: Path, target: str, binary_name: str) -> Path:
-    binary = repo_root / "dist" / target / binary_name
-    if binary.is_file():
+        binary = dist_dir / target / binary_name
+        binary.parent.mkdir(parents=True, exist_ok=True)
+        os.replace(staged_binary, binary)
         return binary
 
-    _build_reploy_binary(repo_root=repo_root, target=target)
-    if binary.is_file():
-        return binary
 
-    raise RuntimeError(
-        f"missing Reploy binary for {target}: {binary}; "
-        f"automatic tools/build_reploy --target {target} did not create it"
+def _ensure_reploy_binary(*, repo_root: Path, target: str, binary_name: str) -> Path:
+    return _build_reploy_binary(
+        repo_root=repo_root,
+        target=target,
+        binary_name=binary_name,
     )
 
 

packaging/python/test_hatch_build.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import textwrap
+import unittest
+from unittest import mock
+
+import hatch_build
+
+
+class ReployBuildHookTests(unittest.TestCase):
+    def test_source_build_replaces_existing_binary_in_all_build_modes(self) -> None:
+        for version in ("editable", "standard"):
+            with self.subTest(version=version), tempfile.TemporaryDirectory() as temp:
+                root = Path(temp)
+                package_root = root / "packaging" / "python"
+                package_root.mkdir(parents=True)
+                (root / "go.mod").write_text("module example.invalid/reploy\n")
+                command = root / "cmd" / "reploy" / "main.go"
+                command.parent.mkdir(parents=True)
+                command.write_text("package main\n")
+
+                binary = root / "dist" / "linux-amd64" / "reploy"
+                binary.parent.mkdir(parents=True)
+                binary.write_text("stale", encoding="utf-8")
+                build_dir = root / "build"
+
+                def build(
+                    *, repo_root: Path, target: str, binary_name: str
+                ) -> Path:
+                    self.assertEqual(repo_root, root)
+                    self.assertEqual(target, "linux-amd64")
+                    self.assertEqual(binary_name, "reploy")
+                    binary.write_text("current", encoding="utf-8")
+                    return binary
+
+                hook = hatch_build.ReployBuildHook(
+                    str(package_root), {}, None, None, str(build_dir), "wheel"
+                )
+                build_data: dict[str, object] = {}
+                with (
+                    mock.patch.dict(
+                        os.environ,
+                        {"REPLOY_TARGET": "linux-amd64", "REPLOY_BINARY": ""},
+                    ),
+                    mock.patch.object(
+                        hatch_build, "_build_reploy_binary", side_effect=build
+                    ) as build_binary,
+                ):
+                    hook.initialize(version, build_data)
+
+                build_binary.assert_called_once_with(
+                    repo_root=root, target="linux-amd64", binary_name="reploy"
+                )
+                self.assertEqual(binary.read_text(encoding="utf-8"), "current")
+
+                scripts = build_data["shared_scripts"]
+                self.assertIsInstance(scripts, dict)
+                script_source = Path(next(iter(scripts)))
+                if version == "editable":
+                    self.assertNotEqual(script_source, binary)
+                    self.assertIn(
+                        str(binary), script_source.read_text(encoding="utf-8")
+                    )
+                else:
+                    self.assertEqual(script_source, binary)
+
+    def test_explicit_binary_override_does_not_build_from_source(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            binary = root / "provided-reploy"
+            binary.write_text("provided", encoding="utf-8")
+            hook = hatch_build.ReployBuildHook(
+                str(root), {}, None, None, str(root / "build"), "wheel"
+            )
+            build_data: dict[str, object] = {}
+
+            with (
+                mock.patch.dict(
+                    os.environ,
+                    {
+                        "REPLOY_TARGET": "linux-amd64",
+                        "REPLOY_BINARY": str(binary),
+                    },
+                ),
+                mock.patch.object(hatch_build, "_build_reploy_binary") as build_binary,
+            ):
+                hook.initialize("standard", build_data)
+
+            build_binary.assert_not_called()
+            self.assertEqual(build_data["shared_scripts"], {str(binary): "reploy"})
+
+    def test_missing_staged_output_preserves_existing_binary(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            binary = root / "dist" / "linux-amd64" / "reploy"
+            binary.parent.mkdir(parents=True)
+            binary.write_text("stale", encoding="utf-8")
+
+            with mock.patch.object(subprocess, "run") as run:
+                with self.assertRaisesRegex(
+                    RuntimeError, "did not create the expected binary"
+                ):
+                    hatch_build._build_reploy_binary(
+                        repo_root=root,
+                        target="linux-amd64",
+                        binary_name="reploy",
+                    )
+
+            run.assert_called_once()
+            self.assertEqual(binary.read_text(encoding="utf-8"), "stale")
+
+
+class ReploySourceInstallTests(unittest.TestCase):
+    def test_editable_and_ordinary_installs_replace_stale_dist_binary(self) -> None:
+        for mode in ("editable", "ordinary"):
+            with self.subTest(mode=mode), tempfile.TemporaryDirectory() as temp:
+                root = Path(temp)
+                package_root = root / "packaging" / "python"
+                package_root.mkdir(parents=True)
+                source_package_root = Path(hatch_build.__file__).parent
+                for name in ("hatch_build.py", "pyproject.toml", "README.md"):
+                    shutil.copy2(source_package_root / name, package_root / name)
+
+                (root / "VERSION").write_text("0.7.0.dev1\n", encoding="utf-8")
+                (root / "go.mod").write_text(
+                    "module example.invalid/reploy\n", encoding="utf-8"
+                )
+                command = root / "cmd" / "reploy" / "main.go"
+                command.parent.mkdir(parents=True)
+                command.write_text("package main\n", encoding="utf-8")
+
+                build_tool = root / "tools" / "build_reploy"
+                build_tool.parent.mkdir()
+                build_tool.write_text(
+                    textwrap.dedent(
+                        """\
+                        import argparse
+                        from pathlib import Path
+
+                        parser = argparse.ArgumentParser()
+                        parser.add_argument("--root", required=True)
+                        parser.add_argument("--outdir", required=True)
+                        parser.add_argument("--target", required=True)
+                        args = parser.parse_args()
+                        binary = Path(args.outdir) / args.target / "reploy"
+                        binary.parent.mkdir(parents=True, exist_ok=True)
+                        binary.write_text(
+                            "#!/usr/bin/env sh\\nprintf current\\n", encoding="utf-8"
+                        )
+                        binary.chmod(0o755)
+                        """
+                    ),
+                    encoding="utf-8",
+                )
+
+                binary = root / "dist" / "linux-amd64" / "reploy"
+                binary.parent.mkdir(parents=True)
+                binary.write_text(
+                    "#!/usr/bin/env sh\nprintf stale\n", encoding="utf-8"
+                )
+                binary.chmod(0o755)
+
+                env = os.environ.copy()
+                env.pop("REPLOY_BINARY", None)
+                env["REPLOY_TARGET"] = "linux-amd64"
+                install_dir = root / f"{mode}-install"
+                invocation = [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "--no-build-isolation",
+                    "--no-deps",
+                    "--target",
+                    str(install_dir),
+                ]
+                if mode == "editable":
+                    invocation.append("--editable")
+                invocation.append(str(package_root))
+
+                result = subprocess.run(
+                    invocation,
+                    cwd=root,
+                    env=env,
+                    check=False,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                )
+                self.assertEqual(result.returncode, 0, result.stdout)
+                self.assertEqual(
+                    binary.read_text(encoding="utf-8"),
+                    "#!/usr/bin/env sh\nprintf current\n",
+                )
+
+                launcher = install_dir / "bin" / "reploy"
+                self.assertTrue(launcher.is_file(), result.stdout)
+                completed = subprocess.run(
+                    [str(launcher)],
+                    check=False,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                )
+                self.assertEqual(completed.returncode, 0, completed.stdout)
+                self.assertEqual(completed.stdout, "current")
+
+
+if __name__ == "__main__":
+    unittest.main()