feat: add rscript interpreter and R test (#1586)

Author: zelosleone

src/package_test/run_test.rs

@@ -33,8 +33,8 @@ use crate::{
     env_vars,
     metadata::{Debug, PlatformWithVirtualPackages},
     recipe::parser::{
-        CommandsTest, DownstreamTest, PerlTest, PythonTest, PythonVersion, Script, ScriptContent,
-        TestType,
+        CommandsTest, DownstreamTest, PerlTest, PythonTest, PythonVersion, RTest, Script,
+        ScriptContent, TestType,
     },
     render::solver::create_environment,
     source::copy_dir::CopyDir,
@@ -456,6 +456,7 @@ pub async fn run_test(
                     perl.run_test(&pkg, &package_folder, &prefix, &config)
                         .await?
                 }
+                TestType::R { r } => r.run_test(&pkg, &package_folder, &prefix, &config).await?,
                 TestType::Downstream(downstream) if downstream_package.is_none() => {
                     downstream
                         .run_test(&pkg, package_file, &prefix, &config)
@@ -905,3 +906,72 @@ impl DownstreamTest {
         Ok(())
     }
 }
+
+impl RTest {
+    /// Execute the R test
+    pub async fn run_test(
+        &self,
+        pkg: &ArchiveIdentifier,
+        path: &Path,
+        prefix: &Path,
+        config: &TestConfiguration,
+    ) -> Result<(), TestError> {
+        let span = tracing::info_span!("Running R test");
+        let _guard = span.enter();
+
+        let match_spec = MatchSpec::from_str(
+            format!("{}={}={}", pkg.name, pkg.version, pkg.build_string).as_str(),
+            ParseStrictness::Lenient,
+        )?;
+
+        let dependencies = vec!["r-base".parse().unwrap(), match_spec];
+
+        create_environment(
+            "test",
+            &dependencies,
+            config
+                .host_platform
+                .as_ref()
+                .unwrap_or(&config.current_platform),
+            prefix,
+            &config.channels,
+            &config.tool_configuration,
+            config.channel_priority,
+            config.solve_strategy,
+        )
+        .await
+        .map_err(TestError::TestEnvironmentSetup)?;
+
+        let mut libraries = String::new();
+        tracing::info!("Testing R libraries:\n");
+
+        for library in &self.libraries {
+            writeln!(libraries, "library({})", library)?;
+            tracing::info!("  library({})", library);
+        }
+        tracing::info!("\n");
+
+        let script = Script {
+            content: ScriptContent::Command(libraries.clone()),
+            interpreter: Some("rscript".into()),
+            ..Script::default()
+        };
+
+        let tmp_dir = tempfile::tempdir()?;
+        script
+            .run_script(
+                Default::default(),
+                tmp_dir.path(),
+                path,
+                prefix,
+                None,
+                None,
+                None,
+                Debug::new(true),
+            )
+            .await
+            .map_err(|e| TestError::TestFailed(e.to_string()))?;
+
+        Ok(())
+    }
+}

src/recipe/parser.rs

@@ -49,7 +49,7 @@ pub use self::{
     source::{GitRev, GitSource, GitUrl, PathSource, Source, UrlSource},
     test::{
         CommandsTest, CommandsTestFiles, CommandsTestRequirements, DownstreamTest,
-        PackageContentsTest, PerlTest, PythonTest, PythonVersion, TestType,
+        PackageContentsTest, PerlTest, PythonTest, PythonVersion, RTest, TestType,
     },
 };
 

src/recipe/parser/test.rs

@@ -137,6 +137,13 @@ pub struct DownstreamTest {
     pub downstream: String,
 }
 
+/// A test that checks if R libraries can be loaded
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct RTest {
+    /// List of R libraries to test with library()
+    pub libraries: Vec<String>,
+}
+
 /// The test type enum
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -151,6 +158,11 @@ pub enum TestType {
         /// The modules to test
         perl: PerlTest,
     },
+    /// An R test that will test if the R libraries can be loaded
+    R {
+        /// The R libraries to load and test
+        r: RTest,
+    },
     /// A test that executes multiple commands in a freshly created environment
     Command(CommandsTest),
     /// A test that runs the tests of a downstream package
@@ -247,9 +259,9 @@ impl TryConvertNode<TestType> for RenderedMappingNode {
             match key_str {
                 "python" => {
                     let python = as_mapping(value, key_str)?.try_convert(key_str)?;
-                    test = TestType::Python{ python };
+                    test = TestType::Python { python };
                 }
-                "script" | "requirements" | "files"  => {
+                "script" | "requirements" | "files" => {
                     let commands = self.try_convert(key_str)?;
                     test = TestType::Command(commands);
                 }
@@ -265,10 +277,14 @@ impl TryConvertNode<TestType> for RenderedMappingNode {
                     let perl = as_mapping(value, key_str)?.try_convert(key_str)?;
                     test = TestType::Perl { perl };
                 }
+                "r" => {
+                    let rscript = as_mapping(value, key_str)?.try_convert(key_str)?;
+                    test = TestType::R { r: rscript };
+                }
                 invalid => Err(vec![_partialerror!(
                     *key.span(),
                     ErrorKind::InvalidField(invalid.to_string().into()),
-                    help = format!("expected fields for {name} is one of `python`, `perl`, `script`, `downstream`, `package_contents`")
+                    help = format!("expected fields for {name} is one of `python`, `perl`, `r`, `script`, `downstream`, `package_contents`")
                 )])?
             }
             Ok(())
@@ -414,6 +430,24 @@ impl TryConvertNode<PerlTest> for RenderedMappingNode {
     }
 }
 
+///////////////////////////
+/// R Test              ///
+///////////////////////////
+impl TryConvertNode<RTest> for RenderedMappingNode {
+    fn try_convert(&self, _name: &str) -> Result<RTest, Vec<PartialParsingError>> {
+        let mut rtest = RTest::default();
+        validate_keys!(rtest, self.iter(), libraries);
+        if rtest.libraries.is_empty() {
+            Err(vec![_partialerror!(
+                *self.span(),
+                ErrorKind::MissingField("libraries".into()),
+                help = "expected field `libraries` in R test to be a list of strings."
+            )])?;
+        }
+        Ok(rtest)
+    }
+}
+
 ///////////////////////////
 /// Package Contents    ///
 ///////////////////////////

src/script/interpreter/mod.rs

@@ -3,6 +3,7 @@ mod cmd_exe;
 mod nushell;
 mod perl;
 mod python;
+mod r;
 
 use std::path::PathBuf;
 
@@ -11,6 +12,7 @@ pub(crate) use cmd_exe::CmdExeInterpreter;
 pub(crate) use nushell::NuShellInterpreter;
 pub(crate) use perl::PerlInterpreter;
 pub(crate) use python::PythonInterpreter;
+pub(crate) use r::RInterpreter;
 
 use rattler_conda_types::Platform;
 use rattler_shell::{

src/script/interpreter/r.rs

@@ -0,0 +1,38 @@
+use std::path::PathBuf;
+
+use rattler_conda_types::Platform;
+
+use crate::script::{ExecutionArgs, ResolvedScriptContents};
+
+use super::{BashInterpreter, CmdExeInterpreter, Interpreter, find_interpreter};
+
+pub(crate) struct RInterpreter;
+
+// R interpreter calls either bash or cmd.exe interpreter for activation and then runs R script
+impl Interpreter for RInterpreter {
+    async fn run(&self, args: ExecutionArgs) -> Result<(), std::io::Error> {
+        let script = args.script.script();
+        let r_script = args.work_dir.join("conda_build_script.R");
+        tokio::fs::write(&r_script, script).await?;
+        let r_command = format!("Rscript {:?}", r_script);
+
+        let args = ExecutionArgs {
+            script: ResolvedScriptContents::Inline(r_command),
+            ..args
+        };
+
+        if cfg!(windows) {
+            CmdExeInterpreter.run(args).await
+        } else {
+            BashInterpreter.run(args).await
+        }
+    }
+
+    async fn find_interpreter(
+        &self,
+        build_prefix: Option<&PathBuf>,
+        platform: &Platform,
+    ) -> Result<Option<PathBuf>, which::Error> {
+        find_interpreter("Rscript", build_prefix, platform)
+    }
+}

src/script/mod.rs

@@ -8,7 +8,7 @@ use futures::TryStreamExt;
 use indexmap::IndexMap;
 use interpreter::{
     BASH_PREAMBLE, BashInterpreter, CMDEXE_PREAMBLE, CmdExeInterpreter, NuShellInterpreter,
-    PerlInterpreter, PythonInterpreter,
+    PerlInterpreter, PythonInterpreter, RInterpreter,
 };
 use itertools::Itertools;
 use minijinja::Value;
@@ -356,6 +356,7 @@ impl Script {
             "cmd" => CmdExeInterpreter.run(exec_args).await?,
             "python" => PythonInterpreter.run(exec_args).await?,
             "perl" => PerlInterpreter.run(exec_args).await?,
+            "rscript" => RInterpreter.run(exec_args).await?,
             _ => {
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::Other,

src/utils.rs

@@ -125,7 +125,7 @@ pub fn remove_dir_all_force(path: &Path) -> std::io::Result<()> {
 #[cfg(windows)]
 /// Retries clean up when encountered with OS 32 and OS 5 errors on Windows
 fn try_remove_with_retry(path: &Path, first_err: Option<std::io::Error>) -> std::io::Result<()> {
-    let retry_policy = ExponentialBackoff::builder().build_with_max_retries(5);
+    let retry_policy = ExponentialBackoff::builder().build_with_max_retries(10);
     let mut current_try = if first_err.is_some() { 1 } else { 0 };
     let mut last_err = first_err;
     let request_start = SystemTime::now();
@@ -144,7 +144,7 @@ fn try_remove_with_retry(path: &Path, first_err: Option<std::io::Error>) -> std:
                         .duration_since(SystemTime::now())
                         .unwrap_or(Duration::ZERO);
 
-                    tracing::info!("Retrying deletion {}/{}: {}", current_try + 1, 5, e);
+                    tracing::info!("Retrying deletion {}/{}: {}", current_try + 1, 10, e);
                     std::thread::sleep(sleep_for);
                 }
             }
@@ -243,16 +243,22 @@ mod tests {
                 let mut guard = file_handle_clone.lock().unwrap();
                 *guard = None;
             });
-            let result = try_remove_with_retry(&dir_path, Some(locked_file_error));
+
+            let dir_path_clone = dir_path.clone();
+            let remove_result = std::thread::spawn(move || {
+                try_remove_with_retry(&dir_path_clone, Some(locked_file_error))
+            });
 
             handle.join().unwrap();
+            let result = remove_result.join().unwrap();
+            std::thread::sleep(Duration::from_millis(1000));
+
             assert!(
                 result.is_ok(),
                 "Directory removal failed: {:?}",
                 result.err()
             );
 
-            std::thread::sleep(Duration::from_millis(200));
             assert!(!dir_path.exists(), "Directory still exists!");
 
             Ok(())

test-data/recipes/r-test/recipe.yaml

@@ -0,0 +1,43 @@
+package:
+  name: r-test
+  version: 0.1.0
+
+build:
+  number: 0
+  script:
+    interpreter: rscript
+    content: |
+      print("Testing R Interpreter", quote = FALSE)
+
+      # Create test data and output file
+      test_data <- data.frame(
+        name = c("package1", "package2"),
+        version = c("1.0", "2.0")
+      )
+
+      # Load and use ggplot2
+      library(ggplot2)
+      p <- ggplot(test_data, aes(x = name, y = as.numeric(version))) +
+        geom_bar(stat = "identity")
+
+      # Create output file
+      output_file <- file.path(Sys.getenv("PREFIX"), "r-test-output.txt")
+      writeLines(c(
+        "This file was created by the R interpreter in rattler-build",
+        "R test successful",
+        paste("R version:", R.version.string),
+        paste("PREFIX:", Sys.getenv("PREFIX"))
+      ), output_file)
+
+requirements:
+  host:
+    - r-base
+    - r-ggplot2
+  run:
+    - r-base
+    - r-ggplot2
+
+tests:
+  - r:
+      libraries:
+        - ggplot2

test/end-to-end/__snapshots__/test_tests.ambr

@@ -7,3 +7,11 @@
 
   '''
 # ---
+# name: test_r_tests
+  '''
+  - r:
+      libraries:
+      - ggplot2
+  
+  '''
+# ---

test/end-to-end/test_simple.py

@@ -1498,6 +1498,30 @@ def test_line_breaks(rattler_build: RattlerBuild, recipes: Path, tmp_path: Path)
     assert any("done" in line for line in output_lines)
 
 
+def test_r_interpreter(rattler_build: RattlerBuild, recipes: Path, tmp_path: Path):
+    rattler_build.build(recipes / "r-test", tmp_path)
+    pkg = get_extracted_package(tmp_path, "r-test")
+
+    assert (pkg / "r-test-output.txt").exists()
+
+    output_content = (pkg / "r-test-output.txt").read_text()
+    assert (
+        "This file was created by the R interpreter in rattler-build" in output_content
+    )
+    assert "R version:" in output_content
+    assert "PREFIX:" in output_content
+    assert (pkg / "info/recipe/recipe.yaml").exists()
+    assert (pkg / "info/tests/tests.yaml").exists()
+
+    # Verify index.json exists before running test
+    assert (pkg / "info/index.json").exists(), "index.json file missing from package"
+
+    pkg_file = get_package(tmp_path, "r-test")
+    test_result = rattler_build.test(pkg_file)
+    assert "Running R test" in test_result
+    assert "all tests passed!" in test_result
+
+
 def test_channel_sources(
     rattler_build: RattlerBuild, recipes: Path, tmp_path: Path, monkeypatch
 ):