Add native tests workflow and path handling

Author: lyskov

.github/workflows/build.yml

@@ -33,4 +33,15 @@ jobs:
       - uses: actions/checkout@v4
       - name: Run Docker tests
         run: cargo test --verbose -F docker-tests
-        # run: cargo test --verbose -F docker-tests -- --test-threads 1
+
+  native-tests:
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Pixi
+        uses: prefix-dev/setup-pixi@v@v0.9.4
+      - name: Run Native tests
+        run: |
+          cargo test --verbose -F native-tests

Cargo.toml

@@ -8,8 +8,9 @@ description = "Command line tool to run various biomolecular structural predicti
 [features]
 docker-tests = []
 hpc-tests = []
+native-tests = []
 high-memory-tests = []
-all = ["docker-tests", "hpc-tests", "high-memory-tests"]
+all = ["docker-tests", "hpc-tests", "native-tests", "high-memory-tests"]
 
 [dependencies]
 anyhow = "1.0.100"

src/app/rfdiffusion.rs

@@ -23,32 +23,27 @@ pub fn native_spec(mut app_args: Vec<String>, working_dir: &Path) -> NativeRunSp
     const OUTPUT_PREFIX: &str = "inference.output_prefix=";
 
     let mut output_prefix_present = false;
+
+    let make_absolute = |path_str: &str| -> String {
+        let path = PathBuf::from(path_str);
+        if path.is_absolute() {
+            path_str.to_string()
+        } else {
+            working_dir.join(path).to_string_lossy().into()
+        }
+    };
+
     for arg in &mut app_args {
-        if arg.starts_with(INPUT_PDB_PREFIX) {
-            let input_pdb = arg.split_at(INPUT_PDB_PREFIX.len()).1;
-
-            let input_pdb_path = PathBuf::from(input_pdb);
-            if !input_pdb_path.is_absolute() {
-                let abs_input_pdb = working_dir.join(input_pdb_path);
-                *arg = format!("inference.input_pdb={}", abs_input_pdb.to_str().unwrap());
-            }
-        } else if arg.starts_with(OUTPUT_PREFIX) {
-            let output_prefix = arg.split_at(OUTPUT_PREFIX.len()).1;
-
-            let output_prefix_path = PathBuf::from(output_prefix);
-            if !output_prefix_path.is_absolute() {
-                let abs_output_prefix = working_dir.join(output_prefix_path);
-                *arg = format!(
-                    "inference.output_prefix={}",
-                    abs_output_prefix.to_str().unwrap()
-                );
-            }
+        if let Some(input_pdb) = arg.strip_prefix(INPUT_PDB_PREFIX) {
+            *arg = format!("{INPUT_PDB_PREFIX}{}", make_absolute(input_pdb));
+        } else if let Some(output_prefix) = arg.strip_prefix(OUTPUT_PREFIX) {
+            *arg = format!("{OUTPUT_PREFIX}{}", make_absolute(output_prefix));
             output_prefix_present = true;
         }
     }
 
     if !output_prefix_present {
-        app_args.extend_from_slice(&[format!("{OUTPUT_PREFIX}{}/", working_dir.to_str().unwrap())]);
+        app_args.push(format!("{OUTPUT_PREFIX}{}/", working_dir.to_string_lossy()));
     }
 
     NativeRunSpec::new(include_asset!("pixi/rfdiffusion.toml"), app_args)

src/executor/native.rs

@@ -1,8 +1,11 @@
+use std::fs;
+
 use anyhow::Result;
 use anyhow::anyhow;
 use home::home_dir;
 use yansi::Paint;
 
+use crate::executor::Telemetry;
 use crate::run;
 use crate::util::Command;
 use crate::util::ensure_dir_signature;
@@ -44,14 +47,46 @@ impl Executor {
             .collect::<Vec<_>>()
             .join(" ");
 
-        Command::new("pixi")
+        let command = Command::new("pixi")
             .cd(&pixi_evn_root)
             .arg("run")
             .arg("execute")
             .arg(new_args)
-            .live()
-            .exec()?;
-        
+            .live();
+
+        let result = command.call();
+
+        let t = Telemetry::new(&self.working_dir);
+
+        let logs = format!(
+            "{command}\nprocess success: {}\n{}\n{}\n{}\n",
+            result.success, result.stdout, result.stderr, result.stderr
+        );
+
+        fs::write(t.log_file_name(), logs)?;
+
+        if !result.success {
+            eprintln!(
+                "{}",
+                "Container {engine} exited with non-zero status"
+                    .bright_red()
+                    .bold()
+            );
+            return Err(anyhow::anyhow!(
+                "Docker container exited with non-zero status"
+            ));
+        }
+
+        println!(
+            "{}",
+            format!(
+                "The exact command line used and full log saved into {:?}\nScratch dir for this run is: {:?}\n",
+                t.log_file_name(), t.scratch_dir()
+            )
+            .blue()
+            .dim()
+        );
+
         Ok(())
     }
 

tests/common/macros.rs

@@ -1,54 +1,101 @@
 #[allow(unused_macros)]
 macro_rules! engine_tests {
-    // Handles both cases:
-    //   common::engine_tests!(rfdiffusion);
-    //   common::engine_tests!(rfdiffusion; "high-memory-tests");
-    //   common::engine_tests!(rfdiffusion; "high-memory-tests", "some-awesome-feature");
-    //
-    ($test_fn:ident $(; $($feature:literal),+ $(,)?)?) => {
-        ::paste::paste! {
+    // Default: all engines (including none), optional features
+    ($test_fn:ident $(; $($feature:literal),* $(,)?)? ) => {
+        $crate::common::engine_tests!(
+            @gen $test_fn;
+            //engines(docker, singularity, apptainer, none);
+            engines(docker, singularity, apptainer);
+            features($($($feature),*)?)
+        );
+    };
+
+    // Explicit engines override (+ optional features)
+    ($test_fn:ident;
+        engines($($eng:ident),+ $(,)? )
+        $(; $($feature:literal),* $(,)?)?
+    ) => {
+        $crate::common::engine_tests!(
+            @gen $test_fn;
+            engines($($eng),+);
+            features($($($feature),*)?)
+        );
+    };
+
+    // Normalize: features are passed as ONE token tree: ( ... )
+    (@gen $test_fn:ident; engines($($eng:ident),+); features $features:tt) => {
+        $(
+            $crate::common::engine_tests!(@emit $test_fn; $eng; $features);
+        )+
+    };
+
+    // ---- Per-engine expansion (re-parse features here) ----
 
+    (@emit $test_fn:ident; docker; ($($feature:literal),*) ) => {
+        ::paste::paste! {
             #[test]
             #[serial_test::serial]
             #[cfg_attr(
-                not(all(
-                    feature = "docker-tests"
-                    $( $(, feature = $feature)*)?
-                )),
+                not(all(feature = "docker-tests" $(, feature = $feature)*)),
                 ignore
             )]
             fn [<docker_ $test_fn>]() {
-                common::docker_clear_cache();
+                $crate::common::docker_clear_cache();
                 $test_fn("docker");
             }
+        }
+    };
 
+    (@emit $test_fn:ident; singularity; ($($feature:literal),*) ) => {
+        ::paste::paste! {
             #[test]
             #[serial_test::serial]
             #[cfg_attr(
-                not(all(
-                    feature = "hpc-tests"
-                    $($(, feature = $feature)*)?
-                )),
+                not(all(feature = "hpc-tests" $(, feature = $feature)*)),
                 ignore
             )]
             fn [<singularity_ $test_fn>]() {
                 $test_fn("singularity");
             }
+        }
+    };
 
+    (@emit $test_fn:ident; apptainer; ($($feature:literal),*) ) => {
+        ::paste::paste! {
             #[test]
             #[serial_test::serial]
             #[cfg_attr(
-                not(all(
-                    feature = "hpc-tests"
-                    $($(, feature = $feature)*)?
-                )),
+                not(all(feature = "hpc-tests" $(, feature = $feature)*)),
                 ignore
             )]
             fn [<apptainer_ $test_fn>]() {
                 $test_fn("apptainer");
             }
         }
     };
+
+    (@emit $test_fn:ident; none; ($($feature:literal),*) ) => {
+        ::paste::paste! {
+            #[test]
+            #[serial_test::serial]
+            #[cfg_attr(
+                not(all(feature = "native-tests" $(, feature = $feature)*)),
+                ignore
+            )]
+            fn [<native_ $test_fn>]() {
+                $test_fn("none");
+            }
+        }
+    };
+
+    // Nice error for typos / unsupported engines
+    (@emit $test_fn:ident; $other:ident; $features:tt ) => {
+        compile_error!(concat!(
+            "engine_tests!: unknown engine '",
+            stringify!($other),
+            "'. Expected: docker, singularity, apptainer, none."
+        ));
+    };
 }
 
 // macro_rules! engine_tests {

tests/rfdiffusion.rs

@@ -3,7 +3,7 @@ use assert_fs::TempDir;
 
 mod common;
 
-common::engine_tests!(rfdiffusion; "high-memory-tests");
+common::engine_tests!(rfdiffusion; engines(docker, apptainer, singularity, none); "high-memory-tests");
 
 fn rfdiffusion(engine: &str) {
     use assert_fs::assert::PathAssert;