test: stop using paths from the nginx binary

We had an inconvenient expectation that the nginx binary is installed
to the configured location and the default prefix is writable.

Instead of that, we should take the same approach as perl tests:

 * Create a temporary prefix and pass it to nginx.
 * Use binary from the build dir and allow overriding it with environment
   variable.

Author: bavshin-f5

Cargo.lock

@@ -45,4 +45,4 @@ vendored = ["nginx-sys/vendored"]
 maintenance = { status = "experimental" }
 
 [dev-dependencies]
-target-triple = "0.1.2"
+tempfile = { version = "3.20.0", default-features = false }

Cargo.toml

@@ -53,6 +53,12 @@ fn main() {
         }
     }
 
+    // Pass build directory to the tests
+    println!("cargo::rerun-if-env-changed=DEP_NGINX_BUILD_DIR");
+    if let Ok(build_dir) = std::env::var("DEP_NGINX_BUILD_DIR") {
+        println!("cargo::rustc-env=DEP_NGINX_BUILD_DIR={}", build_dir);
+    }
+
     // Generate required compiler flags
     if cfg!(target_os = "macos") {
         // https://stackoverflow.com/questions/28124221/error-linking-with-cc-failed-exit-code-1

build.rs

@@ -202,7 +202,7 @@ fn generate_binding(nginx: &NginxSource) {
         .map(|path| format!("-I{}", path.to_string_lossy()))
         .collect();
 
-    print_cargo_metadata(&includes).expect("cargo dependency metadata");
+    print_cargo_metadata(nginx, &includes).expect("cargo dependency metadata");
 
     // bindgen targets the latest known stable by default
     let rust_target: bindgen::RustTarget = env::var("CARGO_PKG_RUST_VERSION")
@@ -287,7 +287,10 @@ fn parse_includes_from_makefile(nginx_autoconf_makefile_path: &PathBuf) -> Vec<P
 
 /// Collect info about the nginx configuration and expose it to the dependents via
 /// `DEP_NGINX_...` variables.
-pub fn print_cargo_metadata<T: AsRef<Path>>(includes: &[T]) -> Result<(), Box<dyn StdError>> {
+pub fn print_cargo_metadata<T: AsRef<Path>>(
+    nginx: &NginxSource,
+    includes: &[T],
+) -> Result<(), Box<dyn StdError>> {
     // Unquote and merge C string constants
     let unquote_re = regex::Regex::new(r#""(.*?[^\\])"\s*"#).unwrap();
     let unquote = |data: &str| -> String {
@@ -327,6 +330,11 @@ pub fn print_cargo_metadata<T: AsRef<Path>>(includes: &[T]) -> Result<(), Box<dy
         }
     }
 
+    println!(
+        "cargo::metadata=build_dir={}",
+        nginx.build_dir.to_str().expect("Unicode build path")
+    );
+
     println!(
         "cargo::metadata=include={}",
         // The str conversion is necessary because cargo directives must be valid UTF-8

nginx-sys/build/main.rs

@@ -1,12 +1,14 @@
+use std::env;
 use std::fs;
+use std::io;
 use std::io::Result;
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::process::Output;
 
-use ngx::ffi::{NGX_CONF_PATH, NGX_PREFIX, NGX_SBIN_PATH};
+const NGINX_BINARY_NAME: &str = "nginx";
 
 /// Convert a CStr to a PathBuf
 pub fn cstr_to_path(val: &std::ffi::CStr) -> Option<PathBuf> {
@@ -22,42 +24,68 @@ pub fn cstr_to_path(val: &std::ffi::CStr) -> Option<PathBuf> {
     Some(PathBuf::from(str))
 }
 
+/// Find nginx binary in the build directory
+pub fn find_nginx_binary() -> io::Result<PathBuf> {
+    let path = [
+        // TEST_NGINX_BINARY is specified for tests
+        env::var("TEST_NGINX_BINARY").ok().map(PathBuf::from),
+        // The module is built against an external NGINX source tree
+        env::var("NGINX_BUILD_DIR")
+            .map(PathBuf::from)
+            .map(|x| x.join(NGINX_BINARY_NAME))
+            .ok(),
+        env::var("NGINX_SOURCE_DIR")
+            .map(PathBuf::from)
+            .map(|x| x.join("objs").join(NGINX_BINARY_NAME))
+            .ok(),
+        // Fallback to the build directory exposed by nginx-sys
+        option_env!("DEP_NGINX_BUILD_DIR")
+            .map(PathBuf::from)
+            .map(|x| x.join(NGINX_BINARY_NAME)),
+    ]
+    .into_iter()
+    .flatten()
+    .find(|x| x.is_file())
+    .ok_or(io::ErrorKind::NotFound)?;
+
+    Ok(path)
+}
+
 /// harness to test nginx
 pub struct Nginx {
-    pub install_path: PathBuf,
+    pub prefix: tempfile::TempDir,
+    pub bin_path: PathBuf,
     pub config_path: PathBuf,
 }
 
 impl Default for Nginx {
     /// create nginx with default
     fn default() -> Nginx {
-        let install_path = cstr_to_path(NGX_PREFIX).expect("installation prefix");
-        Nginx::new(install_path)
+        let binary = find_nginx_binary().expect("nginx binary");
+        Nginx::new(binary).expect("test harness")
     }
 }
 
 impl Nginx {
-    pub fn new<P: AsRef<Path>>(path: P) -> Nginx {
-        let install_path = path.as_ref();
-        let config_path = cstr_to_path(NGX_CONF_PATH).expect("configuration path");
-        let config_path = install_path.join(config_path);
-
-        Nginx {
-            install_path: install_path.into(),
-            config_path,
-        }
-    }
+    pub fn new(binary: impl AsRef<Path>) -> io::Result<Nginx> {
+        let prefix = tempfile::tempdir()?;
+        let config = prefix.path().join("nginx.conf");
+
+        fs::create_dir(prefix.path().join("logs"))?;
 
-    /// get bin path to nginx instance
-    pub fn bin_path(&mut self) -> PathBuf {
-        let bin_path = cstr_to_path(NGX_SBIN_PATH).expect("binary path");
-        self.install_path.join(bin_path)
+        Ok(Nginx {
+            prefix,
+            bin_path: binary.as_ref().to_owned(),
+            config_path: config,
+        })
     }
 
     /// start nginx process with arguments
-    pub fn cmd(&mut self, args: &[&str]) -> Result<Output> {
-        let bin_path = self.bin_path();
-        let result = Command::new(bin_path).args(args).output();
+    pub fn cmd(&self, args: &[&str]) -> Result<Output> {
+        let prefix = self.prefix.path().to_string_lossy();
+        let config_path = self.config_path.to_string_lossy();
+        let args = [&["-p", &prefix, "-c", &config_path], args].concat();
+        let result = Command::new(&self.bin_path).args(args).output();
 
         match result {
             Err(e) => Err(e),

tests/build.rs

@@ -16,7 +16,7 @@ events {
 
 
 http {
-    include       mime.types;
+    # include       mime.types;
     default_type  application/octet-stream;