integration tests: use install.sh instead of hand-rolled setup

Replace the manual file-copy logic in InstallEnvironment with a call to
scripts/install.sh, so the install script is exercised on every test run.
Add SOURCE_DIR env var to install.sh for pointing at non-release artifact
directories (e.g. target/debug/).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: rizsotto

integration-tests/build.rs

@@ -39,6 +39,14 @@ fn main() {
     println!("cargo:rerun-if-changed=../bear/src");
     println!("cargo:rerun-if-changed=../intercept-preload/src");
 
+    // Locate install script and repo root for integration tests
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let repo_root = std::path::Path::new(&manifest_dir).parent().unwrap();
+    let install_script = repo_root.join("scripts").join("install.sh");
+    println!("cargo:rerun-if-changed={}", install_script.display());
+    println!("cargo:rustc-env=REPO_ROOT={}", repo_root.display());
+    println!("cargo:rustc-env=INSTALL_SCRIPT_PATH={}", install_script.display());
+
     // Set up paths for driver, wrapper and preload artifacts
     let (driver_path, wrapper_path, preload_path) = find_intercept_artifacts();
     println!("cargo:rustc-env=DRIVER_EXECUTABLE={}", DRIVER_NAME);

integration-tests/tests/fixtures/constants.rs

@@ -72,3 +72,12 @@ pub const MKDIR_PATH: &str = env!("MKDIR_PATH");
 #[cfg(has_executable_rm)]
 #[allow(dead_code)]
 pub const RM_PATH: &str = env!("RM_PATH");
+
+#[allow(dead_code)]
+pub const INSTALL_SCRIPT_PATH: &str = env!("INSTALL_SCRIPT_PATH");
+
+#[allow(dead_code)]
+pub const INTERCEPT_LIBDIR: &str = env!("INTERCEPT_LIBDIR");
+
+#[allow(dead_code)]
+pub const REPO_ROOT: &str = env!("REPO_ROOT");

integration-tests/tests/fixtures/infrastructure.rs

@@ -56,68 +56,52 @@ use std::process::Output;
 use tempfile;
 
 /// Install environment for Bear
+///
+/// Uses `scripts/install.sh` to create a proper installation layout in a temp
+/// directory. This exercises the install script on every test run.
 pub struct InstallEnvironment {
     #[allow(dead_code)]
     install_dir: tempfile::TempDir,
-    #[allow(dead_code)]
-    bin_dir: tempfile::TempDir,
     bear: PathBuf,
 }
 
 impl InstallEnvironment {
     pub fn new() -> Result<Self> {
         let install_dir = tempfile::TempDir::new().with_context(|| "install dir tempdir failed")?;
-        let bin_dir = tempfile::TempDir::new().with_context(|| "bin dir tempdir failed")?;
-
-        let driver = Self::prepare_install_dir(install_dir.path())?;
-        let bear = Self::prepare_entry_script(bin_dir.path(), &driver)?;
-
-        Ok(Self { install_dir, bin_dir, bear })
-    }
-
-    fn prepare_install_dir(path: &Path) -> Result<PathBuf> {
-        let bin_dir = path.join("bin");
-        std::fs::create_dir(&bin_dir).with_context(|| format!("create dir={:?}", &bin_dir))?;
 
-        let driver = &bin_dir.join(DRIVER_EXECUTABLE);
-        std::fs::copy(DRIVER_EXECUTABLE_PATH, driver)
-            .with_context(|| format!("copy from={}, to={:?}", DRIVER_EXECUTABLE_PATH, &driver))?;
+        Self::run_install_script(install_dir.path())?;
 
-        let wrapper = &bin_dir.join(WRAPPER_EXECUTABLE);
-        std::fs::copy(WRAPPER_EXECUTABLE_PATH, wrapper)
-            .with_context(|| format!("copy from={}, to={:?}", WRAPPER_EXECUTABLE_PATH, &wrapper))?;
+        let bear = install_dir.path().join("bin").join("bear");
 
-        let lib_dir = path.join(env!("INTERCEPT_LIBDIR"));
-        std::fs::create_dir(&lib_dir).with_context(|| format!("create dir={:?}", &lib_dir))?;
-
-        let library = &lib_dir.join(PRELOAD_LIBRARY);
-        std::fs::copy(PRELOAD_LIBRARY_PATH, library)
-            .with_context(|| format!("copy from={}, to={:?}", PRELOAD_LIBRARY_PATH, &library))?;
-
-        Ok(bin_dir.join(env!("DRIVER_EXECUTABLE")))
+        Ok(Self { install_dir, bear })
     }
 
-    #[cfg(unix)]
-    fn prepare_entry_script(path: &Path, driver: &Path) -> Result<PathBuf> {
-        let file = path.join("bear");
-        let script = format!("#!/usr/bin/sh\n{driver:?} $@\n");
-
-        std::fs::write(&file, script).with_context(|| format!("writing file={:?}", &file))?;
-
-        use std::os::unix::fs::PermissionsExt;
-        std::fs::set_permissions(&file, std::fs::Permissions::from_mode(0o755)).unwrap();
-
-        Ok(file)
-    }
+    fn run_install_script(destdir: &Path) -> Result<()> {
+        // Find the build artifact directory (same logic as build.rs)
+        let source_dir = Path::new(DRIVER_EXECUTABLE_PATH)
+            .parent()
+            .with_context(|| "cannot determine artifact directory from DRIVER_EXECUTABLE_PATH")?;
 
-    #[cfg(not(unix))]
-    fn prepare_entry_script(path: &Path, driver: &Path) -> Result<PathBuf> {
-        let file = path.join("bear.bat");
-        let script = format!("@echo off\r\n{driver:?} %*\r\n");
+        let output = std::process::Command::new("sh")
+            .arg(INSTALL_SCRIPT_PATH)
+            .env("DESTDIR", destdir)
+            .env("INTERCEPT_LIBDIR", INTERCEPT_LIBDIR)
+            .env("SOURCE_DIR", source_dir)
+            .output()
+            .with_context(|| "failed to run install.sh")?;
 
-        std::fs::write(&file, script).with_context(|| "writing the script failed")?;
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            anyhow::bail!(
+                "install.sh failed with exit code {:?}\nstdout: {}\nstderr: {}",
+                output.status.code(),
+                stdout,
+                stderr
+            );
+        }
 
-        Ok(file)
+        Ok(())
     }
 
     pub fn path(&self) -> &Path {

scripts/install.sh

@@ -6,6 +6,7 @@
 # Environment variables:
 #   DESTDIR          — installation prefix (default: /usr/local if root, $HOME/.local otherwise)
 #   INTERCEPT_LIBDIR — library directory name (default: lib)
+#   SOURCE_DIR       — directory containing build artifacts (default: target/release)
 #
 # Usage:
 #   ./scripts/install.sh              # install with defaults
@@ -48,8 +49,11 @@ refuse_root_destdir() {
 
 # When run from the source repo, artifacts are in target/release/.
 # When run from a release archive, artifacts are next to the script.
+# Override with SOURCE_DIR to use a custom artifact directory (e.g. target/debug/).
 find_source_dir() {
-    if [ -d "$REPO_ROOT/target/release" ]; then
+    if [ -n "${SOURCE_DIR:-}" ]; then
+        echo "$SOURCE_DIR"
+    elif [ -d "$REPO_ROOT/target/release" ]; then
         echo "$REPO_ROOT/target/release"
     elif [ -f "$REPO_ROOT/bin/bear-driver" ] || [ -f "$REPO_ROOT/bin/bear-driver.exe" ]; then
         echo "$REPO_ROOT"