#!/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 runpy import subprocess import sys import tempfile import unittest from unittest import mock 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") for name in ("activate-native-package.py", "verify-native-package.py", "native-package-manifest.py"): shutil.copy2(INSTALLER.with_name(name), self.repo / "scripts" / name) (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/package cat > build/native/package/ai-engineering <<'EOF' #!/bin/bash case "${1:-}" in --version) echo "ai-engineering 0.1.0" ;; init) mkdir -p .ai-engineering; touch .ai-engineering/aie.db ;; *) echo "fixture CLI" ;; esac exit "${FIXTURE_BINARY_EXIT:-0}" EOF chmod +x build/native/package/ai-engineering cat > build/native/package/sqlite3 <<'EOF' #!/bin/bash [[ "${1:-}" == --version ]] && echo "3.54.1 fixture" || echo "ok" EOF chmod +x build/native/package/sqlite3 if [[ "${FIXTURE_MISSING_LIBRARY:-0}" == 0 ]]; then echo "fixture library" > build/native/package/libsqlitejdbc.so; fi python3 scripts/native-package-manifest.py build/native/package if [[ "${FIXTURE_CORRUPT_PACKAGE:-0}" == 1 ]]; then echo "changed" >> build/native/package/libsqlitejdbc.so; fi ''') 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.assertTrue((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_complete_package_uses_custom_library_directory(self): library = self.root / "custom library" self.run_installer("--lib-dir", str(library)) current = library / "current" self.assertTrue(current.is_symlink()) self.assertTrue((current / "libsqlitejdbc.so").is_file()) self.assertTrue((current / "sqlite3").is_file()) shortcut = self.home / ".local/bin/aie-sqlite3" self.assertEqual(subprocess.check_output([str(shortcut), "--version"], text=True).split()[0], "3.54.1") previous = os.readlink(current) self.run_installer("--lib-dir", str(library)) self.assertNotEqual(os.readlink(current), previous) self.assertTrue((library / previous).is_dir()) def test_missing_or_corrupt_library_preserves_previous_installation(self): dest = self.old_installation() for key in ("FIXTURE_MISSING_LIBRARY", "FIXTURE_CORRUPT_PACKAGE"): with self.subTest(key=key): self.env[key] = "1" self.run_installer(success=False) self.assert_old_installation(dest) del self.env[key] def test_activation_failure_restores_current_release_and_all_shortcuts(self): self.run_installer() library = self.home / ".local/lib/ai-engineering" dest = self.home / ".local/bin" previous = os.readlink(library / "current") links = {name: os.readlink(dest / name) for name in ("ai-engineering", "aie", "aie-sqlite3")} replace = os.replace def fail_second_shortcut(source, target): if Path(source).name == "aie.new": raise OSError("Synthetic activation failure") return replace(source, target) arguments = [str(self.repo / "scripts/activate-native-package.py"), str(self.repo / "build/native/package"), "--bin-dir", str(dest), "--lib-dir", str(library)] with mock.patch.dict(os.environ, self.env, clear=True), mock.patch.object(sys, "argv", arguments), mock.patch("os.replace", side_effect=fail_second_shortcut): with self.assertRaisesRegex(OSError, "Synthetic activation failure"): runpy.run_path(arguments[0], run_name="__main__") self.assertEqual(os.readlink(library / "current"), previous) self.assertEqual({name: os.readlink(dest / name) for name in links}, links) self.assertEqual(list(dest.glob(".aie-install.*")), []) 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.assertTrue((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)