set up integration test

rizsotto · rizsotto · commit fb4a644aad5b · 2025-05-11T18:53:17.000+10:00
diff --git a/.codespellrc b/.codespellrc
@@ -1,5 +1,5 @@
 [codespell]
-skip = .lock,*.toml
+skip = *.lock,*.toml,./bear/build.rs
 count = true
 quiet-level = 3
 
diff --git a/bear/Cargo.toml b/bear/Cargo.toml
@@ -37,6 +37,17 @@ shell-words.workspace = true
 tempfile.workspace = true
 signal-hook.workspace = true
 
+[dev-dependencies]
+tempfile.workspace = true
+anyhow.workspace = true
+assert_cmd = "2.0"
+predicates = "3.1"
+
+[build-dependencies]
+tempfile.workspace = true
+which = "7.0"
+cc = "1.2"
+
 [profile.release]
 strip = true
 lto = true
diff --git a/bear/build.rs b/bear/build.rs
@@ -1,6 +1,198 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+use std::io::Write;
+
 fn main() {
     println!("cargo:rustc-env=WRAPPER_EXECUTABLE_PATH=/usr/libexec/bear/wrapper");
     println!("cargo:rustc-env=PRELOAD_LIBRARY_PATH=/usr/libexec/bear/$LIB/libexec.so");
+
+    // Re-run build script if env changes
+    println!("cargo:rerun-if-env-changed=PATH");
+
+    // check things for the libexec.so
+    check_include_file("dlfcn.h", "dlfcn_h");
+    check_symbol_exists("dlopen", "dlfcn.h");
+    check_symbol_exists("dlsym", "dlfcn.h");
+    check_symbol_exists("dlerror", "dlfcn.h");
+    check_symbol_exists("dlclose", "dlfcn.h");
+    check_symbol_exists("RTLD_NEXT", "dlfcn.h");
+
+    check_include_file("errno.h", "errno_h");
+    check_symbol_exists("EACCES", "errno.h");
+    check_symbol_exists("ENOENT", "errno.h");
+
+    // check things for the integration tests
+    check_include_file("unistd.h", "unistd_h");
+    check_symbol_exists("execve", "unistd.h");
+    check_symbol_exists("execv", "unistd.h");
+    check_symbol_exists("execvpe", "unistd.h");
+    check_symbol_exists("execvp", "unistd.h");
+    check_symbol_exists("execvP", "unistd.h");
+    check_symbol_exists("exect", "unistd.h");
+    check_symbol_exists("execl", "unistd.h");
+    check_symbol_exists("execlp", "unistd.h");
+    check_symbol_exists("execle", "unistd.h");
+    check_symbol_exists("execveat", "unistd.h");
+    check_symbol_exists("fexecve", "unistd.h");
+
+    check_include_file("spawn.h", "spawn_h");
+    check_symbol_exists("posix_spawn", "spawn.h");
+    check_symbol_exists("posix_spawnp", "spawn.h");
+
+    check_include_file("stdio.h", "stdio_h");
+    check_symbol_exists("popen", "stdio.h");
+
+    check_include_file("stdlib.h", "stdlib_h");
+    check_symbol_exists("system", "stdlib.h");
+
+    check_executable_exists("true");
+    check_executable_exists("false");
+    check_executable_exists("echo");
+    check_executable_exists("sleep");
+    check_one_executable_exists("shell", &["sh", "zsh", "bash"]);
+    check_one_executable_exists("make", &["make", "gmake", "mingw32-make"]);
+    check_one_executable_exists("compiler_c", &["cc", "gcc", "clang"]);
+    check_one_executable_exists("compiler_cxx", &["c++", "g++", "clang++"]);
+    check_one_executable_exists("compiler_fortran", &["gfortran", "flang"]);
+    check_one_executable_exists("compiler_cuda", &["nvcc"]);
+    check_executable_exists("libtool");
+    check_executable_exists("fakeroot");
+    check_executable_exists("valgrind");
+    check_executable_exists("ar");
+}
+
+fn check_include_file(header: &str, define: &str) {
+    let result = cc::Build::new()
+        .cargo_metadata(false)
+        .cargo_output(false)
+        .cargo_warnings(false)
+        .inherit_rustflags(true)
+        .file(
+            tempfile::Builder::new()
+                .prefix("check_include_")
+                .suffix(".c")
+                .tempfile_in(std::env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string()))
+                .expect("Failed to create temp file for include check")
+                .keep() // Keep the file for cc to compile
+                .expect("Failed to keep temp file")
+                .1, // Get the PathBuf
+        )
+        .include(header)
+        .try_compile(define);
+
+    match result {
+        Ok(_) => {
+            println!("cargo:rustc-cfg=has_header_{}", define);
+            println!("cargo:rustc-check-cfg=cfg(has_header_{})", define);
+            println!(
+                "cargo:warning=Checking for include file: {} ... found",
+                header
+            );
+        }
+        Err(_) => {
+            println!(
+                "cargo:warning=Checking for include file: {} ... missing",
+                header
+            );
+        }
+    }
+}
+
+fn check_symbol_exists(symbol: &str, header: &str) {
+    let check_code = format!(
+        r#"
+        #include <stddef.h>
+        #include <{header}>
+
+        // Use a function pointer to avoid unused function warnings,
+        // and ensure the linker must find the symbol.
+        int main() {{
+            void *ptr = (void*){symbol};
+            (void)ptr; // Suppress unused variable warning
+            return 0;
+        }}
+        "#,
+        symbol = symbol,
+        header = header
+    );
+
+    let (mut file, path) = tempfile::Builder::new()
+        .prefix(&format!("check_{}", symbol))
+        .suffix(".c")
+        .tempfile_in(std::env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string()))
+        .expect("Failed to create temp file for symbol check")
+        .keep()
+        .expect("Failed to keep temp file");
+
+    file.write_all(check_code.as_bytes())
+        .expect("Failed to write to temp file");
+    file.flush().expect("Failed to flush temp file");
+
+    let result = cc::Build::new()
+        .cargo_metadata(false)
+        .cargo_output(false)
+        .cargo_warnings(false)
+        .inherit_rustflags(true)
+        .file(path)
+        .try_compile(&format!("check_{}", symbol));
+
+    match result {
+        Ok(_) => {
+            println!("cargo:rustc-cfg=has_symbol_{}", symbol);
+            println!("cargo:rustc-check-cfg=cfg(has_symbol_{})", symbol);
+            println!("cargo:warning=Checking for symbol: {} ... found", symbol);
+        }
+        Err(_) => {
+            println!("cargo:warning=Checking for symbol: {} ... missing", symbol);
+        }
+    }
+}
+
+fn check_executable_exists(executable: &str) {
+    match which::which(executable) {
+        Ok(path) => {
+            println!("cargo:rustc-cfg=has_executable_{}", executable);
+            println!("cargo:rustc-check-cfg=cfg(has_executable_{})", executable);
+            println!(
+                "cargo:rustc-env={}_PATH={}",
+                executable.to_uppercase(),
+                path.display()
+            );
+            println!(
+                "cargo:warning=Checking for executable: {} ... {}",
+                executable,
+                path.display()
+            );
+        }
+        Err(_) => {
+            println!(
+                "cargo:warning=Checking for executable: {} ... missing",
+                executable
+            );
+        }
+    }
+}
+
+fn check_one_executable_exists(define: &str, executables: &[&str]) {
+    for executable in executables {
+        if let Ok(path) = which::which(executable) {
+            println!("cargo:rustc-cfg=has_executable_{}", define);
+            println!("cargo:rustc-check-cfg=cfg(has_executable_{})", define);
+            println!(
+                "cargo:rustc-env={}_PATH={}",
+                define.to_uppercase(),
+                path.display()
+            );
+            println!(
+                "cargo:warning=Checking for executable: {} ... {}",
+                define,
+                path.display()
+            );
+            return;
+        }
+    }
+    println!(
+        "cargo:warning=Checking for executable: {} ... missing",
+        define
+    );
 }
diff --git a/bear/tests/cli.rs b/bear/tests/cli.rs
@@ -0,0 +1,93 @@
+// bear/tests/cli.rs
+use assert_cmd::Command;
+use predicates::prelude::*;
+use std::error::Error;
+use std::path::Path;
+use tempfile::tempdir;
+
+#[test]
+fn test_bear_help() -> Result<(), Box<dyn Error>> {
+    let mut cmd = Command::cargo_bin("bear")?;
+    cmd.arg("--help");
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("Usage: bear"));
+    Ok(())
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+#[cfg(has_executable_echo)]
+fn test_wrapper_basic() -> Result<(), Box<dyn Error>> {
+    let work_dir = tempdir()?;
+
+    let mut cmd = Command::cargo_bin("bear")?;
+    cmd.args(["--", "echo", "hello"]);
+    cmd.current_dir(work_dir.path());
+
+    println!("Running command: {:?}", cmd);
+
+    // Add assertions based on what bear/wrapper should do
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("hello")); // Adjust assertion as needed
+
+    work_dir.close()?; // Clean up the temporary directory
+    Ok(())
+}
+
+// Add more tests for different scenarios, arguments, and interactions
+// between 'bear' and 'wrapper'.
+
+#[test]
+#[cfg(target_os = "linux")]
+#[cfg(has_executable_make)] // Only compile this test if 'make' was found by build.rs
+fn test_with_make() -> Result<(), Box<dyn Error>> {
+    let make_path = env!("MAKE_PATH"); // Get path from env var set by build.rs
+    println!("Make found at: {}", make_path);
+
+    let mut cmd = Command::cargo_bin("bear")?;
+    let work_dir = tempdir()?;
+
+    // Setup: Create a dummy Makefile or project structure
+    std::fs::write(
+        work_dir.path().join("Makefile"),
+        "all:\n\techo \"Running make\"\n",
+    )?;
+
+    cmd.current_dir(work_dir.path());
+    // Use the detected make path if needed, or just run 'make' if it's in PATH
+    cmd.args(["--", make_path, "all"]); // Example: run make through bear
+
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("Running make"));
+
+    // Check for compile_commands.json, etc.
+    // assert!(work_dir.path().join("compile_commands.json").exists());
+
+    work_dir.close()?;
+    Ok(())
+}
+
+// Example test requiring 'cc'
+#[test]
+#[cfg(has_executable_compiler_c)]
+fn test_with_cc() -> Result<(), Box<dyn Error>> {
+    let cc_path = env!("COMPILER_C_PATH");
+    println!("C Compiler found at: {}", cc_path);
+    // ... test logic using cc_path ...
+    assert!(Path::new(cc_path).exists()); // Basic check
+    Ok(())
+}
+
+// Example test requiring 'c++'
+#[test]
+#[cfg(has_executable_compiler_cxx)]
+fn test_with_cplusplus() -> Result<(), Box<dyn Error>> {
+    let cxx_path = env!("COMPILER_CXX_PATH");
+    println!("C++ Compiler found at: {}", cxx_path);
+    // ... test logic using cxx_path ...
+    assert!(Path::new(cxx_path).exists()); // Basic check
+    Ok(())
+}
