Files
ai-engineering/scripts/test-install-native.py
T

277 lines
13 KiB
Python

#!/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)