Add resolve path tests

Author: ranfdev

src/create_distrobox_dialog.rs

@@ -332,13 +332,8 @@ impl CreateDistroboxDialog {
             #[weak]
             this,
             async move {
-                this.root_store()
-                    .is_nvidia_host()
-                    .await
-                    .ok()
-                    .map(|is_nvidia| {
-                        this.imp().nvidia_row.set_active(is_nvidia);
-                    });
+                let is_nvidia = this.root_store().is_nvidia_host().await;
+                this.imp().nvidia_row.set_active(is_nvidia);
             }
         ));
 

src/distrobox/mod.rs

@@ -483,7 +483,7 @@ impl Distrobox {
         let mut builder = NullCommandRunnerBuilder::new();
         for res in responses {
             for (cmd, out) in res.clone().to_commands() {
-                builder.cmd_full(cmd, out.clone());
+                builder.cmd_full(cmd, move || out());
             }
         }
         builder.build()

src/fakers/command_runner.rs

@@ -2,18 +2,23 @@
 // returning predefined outputs, to ease code testing.
 
 use std::{
-    collections::HashMap, future::Future, io::{self}, os::unix::process::ExitStatusExt, pin::Pin, process::ExitStatus, rc::Rc
+    collections::HashMap,
+    future::Future,
+    io::{self},
+    os::unix::process::ExitStatusExt,
+    pin::Pin,
+    process::ExitStatus,
+    rc::Rc,
 };
 
-use crate::fakers::{OutputTracker, Command};
+use crate::fakers::{Command, OutputTracker};
 
 use async_process::{Command as AsyncCommand, Output};
 use futures::{
     io::{AsyncRead, AsyncWrite, Cursor},
     FutureExt,
 };
 
-
 #[derive(Debug, Clone)]
 pub enum CommandRunnerEvent {
     Spawned(usize, Command),
@@ -69,7 +74,10 @@ impl CommandRunner {
     }
 
     pub fn spawn(&self, command: Command) -> io::Result<Box<dyn Child + Send>> {
-        self.output_tracker.push(CommandRunnerEvent::Spawned(self.event_id(), command.clone()));
+        self.output_tracker.push(CommandRunnerEvent::Spawned(
+            self.event_id(),
+            command.clone(),
+        ));
         self.inner.spawn(command)
     }
 
@@ -78,17 +86,17 @@ impl CommandRunner {
         command: Command,
     ) -> Pin<Box<dyn Future<Output = io::Result<std::process::Output>>>> {
         let event_id = self.event_id();
-        self.output_tracker.push(CommandRunnerEvent::Started(event_id, command.clone()));
+        self.output_tracker
+            .push(CommandRunnerEvent::Started(event_id, command.clone()));
         let fut = self.inner.output(command);
         let this = self.clone();
         fut.map(move |result| {
             let res_summary = match &result {
-                Ok(_output) => {
-                    Ok(())
-                }
+                Ok(_output) => Ok(()),
                 Err(_e) => Err(()),
             };
-            this.output_tracker.push(CommandRunnerEvent::Output(event_id, res_summary));
+            this.output_tracker
+                .push(CommandRunnerEvent::Output(event_id, res_summary));
             result
         })
         .boxed_local()
@@ -131,8 +139,6 @@ impl InnerCommandRunner for RealCommandRunner {
     }
 }
 
-
-
 #[derive(Default, Clone)]
 pub struct NullCommandRunnerBuilder {
     responses: HashMap<Vec<String>, Rc<dyn Fn() -> Result<String, io::Error>>>,
@@ -148,15 +154,15 @@ impl NullCommandRunnerBuilder {
         let mut cmd = Command::new(args[0]);
         cmd.args(&args[1..]);
         let out_text = out.as_ref().to_string();
-        self.cmd_full(cmd, Rc::new(move || Ok(out_text.clone())))
+        self.cmd_full(cmd, move || Ok(out_text.clone()))
     }
     pub fn cmd_full(
         &mut self,
         cmd: Command,
-        out: Rc<dyn Fn() -> Result<String, io::Error>>,
+        out: impl Fn() -> Result<String, io::Error> + 'static,
     ) -> &mut Self {
         let key = NullCommandRunner::key_for_cmd(&cmd);
-        self.responses.insert(key, out);
+        self.responses.insert(key, Rc::new(out));
         self
     }
     pub fn fallback(&mut self, status: ExitStatus) -> &mut Self {

src/store/root_store.rs

@@ -396,7 +396,7 @@ impl RootStore {
         })?)
     }
 
-    pub async fn is_nvidia_host(&self) -> Result<bool, distrobox::Error> {
+    pub async fn is_nvidia_host(&self) -> bool {
         // uses lspci to check if the host has an NVIDIA GPU
         debug!("Checking if host is NVIDIA");
         let cmd = Command::new("lspci");
@@ -405,15 +405,27 @@ impl RootStore {
             Ok(output) => {
                 let is_nvidia = output.contains("NVIDIA") || output.contains("nVidia");
                 debug!(is_nvidia, "Checked if host is NVIDIA");
-                Ok(is_nvidia)
+                is_nvidia
             }
             Err(e) => {
                 debug!(?e, "Failed to check if host is NVIDIA");
-                Ok(false) // If we can't run lspci, we assume it's not NVIDIA
+                false // If we can't run lspci, we assume it's not NVIDIA
             }
         }
     }
 
+    fn getfattr_cmd(path: &str) -> Command {
+        Command::new_with_args(
+            "getfattr",
+            [
+                "-n",
+                "user.document-portal.host-path",
+                "--only-values",
+                path,
+            ],
+        )
+    }
+
     pub async fn resolve_host_path(&self, path: &str) -> Result<String, distrobox::Error> {
         // The path could be a:
         // 1. Host path, already resolved to a real location, e.g., "/home/user/Documents/custom-home-folder".
@@ -425,15 +437,7 @@ impl RootStore {
 
         debug!(?path, "Resolving host path");
 
-        let cmd = Command::new_with_args(
-            "getfattr",
-            [
-                "-n",
-                "user.document-portal.host-path",
-                "--only-values",
-                path,
-            ],
-        );
+        let cmd = Self::getfattr_cmd(path);
         let output = self
             .run_to_string(cmd)
             .await
@@ -470,3 +474,49 @@ impl Default for RootStore {
         glib::Object::builder().build()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io;
+
+    use super::*;
+    use crate::fakers::NullCommandRunnerBuilder;
+
+    #[test]
+    fn test_resolve_path() {
+        // (input_path, getfattr_output, expected_resolved_path)
+        let tests = [
+            (
+                "/run/user/1000/doc/abc123",
+                Ok("/home/user/Documents/custom-home-folder"),
+                Ok("/home/user/Documents/custom-home-folder"),
+            ),
+            ("/home/user/Documents/custom-home-folder", Ok(""), {
+                Ok("/home/user/Documents/custom-home-folder")
+            }),
+            // If the resolution fails and the path is from a sandbox, we expect an error
+            ("/run/user/1000/doc/xyz456", Err(()), Err(())),
+        ];
+
+        for (input_path, getfattr_output, expected_resolved_path) in tests {
+            let runner = NullCommandRunnerBuilder::new()
+                .cmd_full(RootStore::getfattr_cmd(input_path), move || {
+                    getfattr_output
+                        .map(|s| s.to_string())
+                        // we need to return a real io::Error here
+                        .map_err(|_| io::Error::new(io::ErrorKind::NotFound, "Command not found"))
+                })
+                .build();
+            let store = RootStore::new(runner);
+
+            let resolved_path: Result<String, distrobox::Error> =
+                smol::block_on(store.resolve_host_path(input_path));
+
+            if let Ok(expected_resolved_path) = expected_resolved_path {
+                assert_eq!(resolved_path.unwrap(), expected_resolved_path);
+            } else {
+                assert!(expected_resolved_path.is_err());
+            }
+        }
+    }
+}