feat: add local native CLI installer for Linux and macOS
Test / Tests and coverage occurred while executing withChecks step.
Intrepid/AI Engineering/pipeline/head There was a failure building this commit
build / jvm (push) Canceled after 0s
build / native (macos-15, macos-arm64) (push) Canceled after 0s
build / native (ubuntu-24.04, linux-x86_64) (push) Canceled after 0s
build / native (windows-2025, windows-x86_64) (push) Canceled after 0s

Bootstrap the pinned GraalVM when needed, validate native build prerequisites, and install a verified standalone executable with the aie shortcut. Document usage and add installer fixtures to native CI.

Validated with 14 installer tests, a real macOS ARM64 native build and installation, and the full installed CLI smoke suite. Publication explicitly authorized by the user: commit e push.
This commit is contained in:
Nilton Constantino
2026-11-16 15:32:01 +00:00
parent 8e75bf7516
commit f296d252c6
16 changed files with 764 additions and 1 deletions
+216
View File
@@ -0,0 +1,216 @@
#!/usr/bin/env python3
"""Installer process tests with disposable homes and offline toolchain fixtures.
Run: python3 scripts/test-install-native.py
These test installation behavior, not native compilation itself.
"""
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
INSTALLER = Path(__file__).resolve().with_name("install-native.sh")
class NativeInstallerTest(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix="aie installer ")
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name).resolve()
self.repo = self.root / "source checkout"
self.home = self.root / "user home"
self.tools = self.root / "tools"
self.jdk = self.root / "graalvm 25"
self.home.mkdir()
self.tools.mkdir()
(self.repo / "scripts").mkdir(parents=True)
shutil.copy2(INSTALLER, self.repo / "scripts/install-native.sh")
(self.repo / ".sdkmanrc").write_text("java=25-test-graalce\n")
self.env = {key: value for key, value in os.environ.items()
if not key.startswith(("JAVA", "GRAAL", "SDKMAN", "BASH_ENV"))}
self.env.update(HOME=str(self.home), SDKMAN_DIR=str(self.home / ".sdkman"),
GRAALVM_HOME=str(self.jdk), PATH=f"{self.tools}:/usr/bin:/bin",
FIXTURE_OS="Linux", FIXTURE_ARCH="x86_64",
FIXTURE_LOG=str(self.root / "calls"), FIXTURE_JDK=str(self.jdk))
self.executable(self.tools / "uname", '[[ "$1" == -s ]] && echo "$FIXTURE_OS" || echo "$FIXTURE_ARCH"')
self.executable(self.tools / "gcc", 'exit "${FIXTURE_COMPILER_EXIT:-0}"')
self.executable(self.tools / "clang", 'exit "${FIXTURE_COMPILER_EXIT:-0}"')
self.executable(self.tools / "xcode-select", 'exit "${FIXTURE_XCODE_EXIT:-0}"')
self.executable(self.jdk / "bin/java", 'echo \'openjdk version "25.0.2"\' >&2')
self.executable(self.jdk / "bin/native-image", 'echo "native-image 25.0.2 GraalVM CE"')
self.executable(self.repo / "gradlew", '''
printf '%s\n' "$PWD" "$JAVA_HOME" "$GRAALVM_HOME" "$@" >> "$FIXTURE_LOG"
[[ "$JAVA_HOME" == "$GRAALVM_HOME" ]] || exit 91
[[ "${FIXTURE_BUILD_EXIT:-0}" == 0 ]] || exit "$FIXTURE_BUILD_EXIT"
[[ "${FIXTURE_MISSING_BINARY:-0}" == 0 ]] || exit 0
mkdir -p build/native/nativeCompile
cat > build/native/nativeCompile/ai-engineering <<'EOF'
#!/bin/bash
echo "fixture CLI"
exit "${FIXTURE_BINARY_EXIT:-0}"
EOF
chmod +x build/native/nativeCompile/ai-engineering
''')
def executable(self, path, body):
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("#!/bin/bash\nset -e\n" + body + "\n")
path.chmod(0o755)
def run_installer(self, *args, success=True):
result = subprocess.run(["/bin/bash", str(self.repo / "scripts/install-native.sh"), *args],
cwd=self.root, env=self.env, text=True,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=20)
if success:
self.assertEqual(result.returncode, 0, result.stdout)
else:
self.assertNotEqual(result.returncode, 0, result.stdout)
return result.stdout
def old_installation(self):
dest = self.home / ".local/bin"
self.executable(dest / "ai-engineering", 'echo "old CLI"')
(dest / "aie").symlink_to("ai-engineering")
return dest
def assert_old_installation(self, dest):
self.assertIn("old CLI", (dest / "ai-engineering").read_text())
self.assertEqual(os.readlink(dest / "aie"), "ai-engineering")
self.assertEqual(list(dest.glob(".aie-install.*")), [])
def test_default_install_is_independent_and_can_be_updated(self):
output = self.run_installer()
dest = self.home / ".local/bin"
self.assertFalse((dest / "ai-engineering").is_symlink())
self.assertEqual(os.readlink(dest / "aie"), "ai-engineering")
self.assertEqual((dest / "ai-engineering").stat().st_mode & 0o777, 0o755)
self.assertIn('export PATH=', output)
self.run_installer()
shutil.rmtree(self.repo)
result = subprocess.run([str(dest / "aie"), "--help"], capture_output=True, text=True)
self.assertEqual(result.returncode, 0)
self.assertIn("fixture CLI", result.stdout)
calls = (self.root / "calls").read_text()
self.assertIn(str(self.repo), calls)
self.assertIn(f"-Porg.gradle.java.installations.paths={self.jdk}", calls)
def test_macos_arm_with_relative_destination(self):
self.env.update(FIXTURE_OS="Darwin", FIXTURE_ARCH="arm64")
self.run_installer("--bin-dir", "custom bin")
self.assertTrue((self.root / "custom bin/aie").is_file())
def test_linux_arm(self):
self.env["FIXTURE_ARCH"] = "aarch64"
self.run_installer()
def test_replaces_previous_symlinks_without_following_them(self):
dest = self.home / ".local/bin"
dest.mkdir(parents=True)
old = self.root / "old binary"
old.write_text("keep this target")
(dest / "ai-engineering").symlink_to(old)
(dest / "aie").symlink_to(old)
self.run_installer()
self.assertEqual(old.read_text(), "keep this target")
self.assertFalse((dest / "ai-engineering").is_symlink())
self.assertEqual(os.readlink(dest / "aie"), "ai-engineering")
def test_build_failure_preserves_installation(self):
dest = self.old_installation()
self.env["FIXTURE_BUILD_EXIT"] = "42"
self.run_installer(success=False)
self.assert_old_installation(dest)
def test_binary_check_failure_preserves_installation(self):
dest = self.old_installation()
self.env["FIXTURE_BINARY_EXIT"] = "43"
self.run_installer(success=False)
self.assert_old_installation(dest)
def test_missing_build_output_preserves_installation(self):
dest = self.old_installation()
self.env["FIXTURE_MISSING_BINARY"] = "1"
self.assertIn("did not produce", self.run_installer(success=False))
self.assert_old_installation(dest)
def test_invalid_explicit_graalvm_fails_before_build(self):
self.executable(self.jdk / "bin/java", 'echo \'openjdk version "21.0.2"\' >&2')
self.assertIn("GRAALVM_HOME", self.run_installer(success=False))
self.assertFalse((self.root / "calls").exists())
def test_compatible_java_home(self):
del self.env["GRAALVM_HOME"]
self.env["JAVA_HOME"] = str(self.jdk)
self.run_installer()
self.assertFalse((self.home / ".sdkman").exists())
def test_existing_pinned_jdk_ignores_regular_java_home(self):
del self.env["GRAALVM_HOME"]
self.env["JAVA_HOME"] = str(self.root / "regular JDK")
pinned = self.home / ".sdkman/candidates/java/25-test-graalce"
shutil.copytree(self.jdk, pinned)
self.run_installer()
self.assertIn(str(pinned), (self.root / "calls").read_text())
def test_sdkman_bootstrap_and_install(self):
del self.env["GRAALVM_HOME"]
init = self.root / "sdkman-init.sh"
init.write_text('''
echo "${SDKMAN_UNSET_FIXTURE}" >/dev/null
sdk() {
[[ "$1" == install && "$2" == java && "$3" == 25-test-graalce ]] || return 90
read -r answer
[[ "$answer" == n ]] || return 91
mkdir -p "$SDKMAN_DIR/candidates/java"
cp -R "$FIXTURE_JDK" "$SDKMAN_DIR/candidates/java/$3"
}
''')
bootstrap = self.root / "sdkman-bootstrap.sh"
self.executable(bootstrap, '''
mkdir -p "$SDKMAN_DIR/bin"
cp "$FIXTURE_INIT" "$SDKMAN_DIR/bin/sdkman-init.sh"
''')
self.env.update(FIXTURE_INIT=str(init), FIXTURE_BOOTSTRAP=str(bootstrap))
self.executable(self.tools / "curl", '''
printf '%s\n' "$@" >> "$FIXTURE_LOG"
while [[ $# -gt 0 ]]; do
if [[ "$1" == -o ]]; then cp "$FIXTURE_BOOTSTRAP" "$2"; exit; fi
shift
done
exit 92
''')
for dependency in ("zip", "unzip"):
self.executable(self.tools / dependency, "exit 0")
self.run_installer()
self.assertIn("ci=true&rcupdate=false", (self.root / "calls").read_text())
self.assertFalse((self.home / ".bashrc").exists())
self.assertFalse((self.home / ".zshrc").exists())
def test_unsupported_platforms_and_missing_tools(self):
for platform, arch in (("Darwin", "x86_64"), ("Windows_NT", "x86_64")):
with self.subTest(platform=platform):
self.env.update(FIXTURE_OS=platform, FIXTURE_ARCH=arch)
self.run_installer(success=False)
self.assertFalse((self.root / "calls").exists())
self.env.update(FIXTURE_OS="Darwin", FIXTURE_ARCH="arm64", FIXTURE_XCODE_EXIT="1")
self.assertIn("xcode-select --install", self.run_installer(success=False))
self.env.update(FIXTURE_OS="Linux", FIXTURE_COMPILER_EXIT="1")
self.assertIn("zlib1g-dev", self.run_installer(success=False))
def test_directory_collision_fails_before_build(self):
(self.home / ".local/bin/aie").mkdir(parents=True)
self.assertIn("target is a directory", self.run_installer(success=False))
self.assertFalse((self.root / "calls").exists())
def test_help_and_bad_arguments(self):
self.assertIn("Usage:", self.run_installer("--help"))
for args in (("--bin-dir",), ("--bin-dir", ""), ("--unknown",)):
self.run_installer(*args, success=False)
self.assertFalse((self.root / "calls").exists())
if __name__ == "__main__":
unittest.main(verbosity=2)