Implement missing methods on Command and on CompletedProcess

Author: GuillaumeGomez

src/tools/run-make-support/src/command.rs

@@ -1,8 +1,6 @@
-use std::ffi;
 use std::ffi::OsStr;
 use std::io::Write;
 use std::panic;
-use std::path::Path;
 use std::process::{Command as StdCommand, ExitStatus, Output, Stdio};
 
 use crate::drop_bomb::DropBomb;
@@ -39,63 +37,6 @@ impl Command {
         self.stdin = Some(stdin);
     }
 
-    /// Specify an environment variable.
-    pub fn env<K, V>(&mut self, key: K, value: V) -> &mut Self
-    where
-        K: AsRef<ffi::OsStr>,
-        V: AsRef<ffi::OsStr>,
-    {
-        self.cmd.env(key, value);
-        self
-    }
-
-    /// Remove an environmental variable.
-    pub fn env_remove<K>(&mut self, key: K) -> &mut Self
-    where
-        K: AsRef<ffi::OsStr>,
-    {
-        self.cmd.env_remove(key);
-        self
-    }
-
-    /// Generic command argument provider. Prefer specific helper methods if possible.
-    /// Note that for some executables, arguments might be platform specific. For C/C++
-    /// compilers, arguments might be platform *and* compiler specific.
-    pub fn arg<S>(&mut self, arg: S) -> &mut Self
-    where
-        S: AsRef<ffi::OsStr>,
-    {
-        self.cmd.arg(arg);
-        self
-    }
-
-    /// Generic command arguments provider. Prefer specific helper methods if possible.
-    /// Note that for some executables, arguments might be platform specific. For C/C++
-    /// compilers, arguments might be platform *and* compiler specific.
-    pub fn args<S>(&mut self, args: &[S]) -> &mut Self
-    where
-        S: AsRef<ffi::OsStr>,
-    {
-        self.cmd.args(args);
-        self
-    }
-
-    /// Inspect what the underlying [`std::process::Command`] is up to the
-    /// current construction.
-    pub fn inspect<I>(&mut self, inspector: I) -> &mut Self
-    where
-        I: FnOnce(&StdCommand),
-    {
-        inspector(&self.cmd);
-        self
-    }
-
-    /// Set the path where the command will be run.
-    pub fn current_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
-        self.cmd.current_dir(path);
-        self
-    }
-
     /// Run the constructed command and assert that it is successfully run.
     #[track_caller]
     pub fn run(&mut self) -> CompletedProcess {
@@ -140,6 +81,22 @@ impl Command {
     }
 }
 
+crate::impl_common_helpers_without_run!(Command);
+
+impl std::ops::Deref for Command {
+    type Target = StdCommand;
+
+    fn deref(&self) -> &Self::Target {
+        &self.cmd
+    }
+}
+
+impl std::ops::DerefMut for Command {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.cmd
+    }
+}
+
 /// Represents the result of an executed process.
 /// The various `assert_` helper methods should preferably be used for
 /// checking the contents of stdout/stderr.
@@ -171,7 +128,13 @@ impl CompletedProcess {
     }
 
     #[track_caller]
-    pub fn assert_stdout_not_contains<S: AsRef<str>>(&self, needle: S) -> &Self {
+    pub fn assert_stdout_contains<S: AsRef<str>>(self, content: S) -> Self {
+        assert!(self.stdout_utf8().contains(content.as_ref()));
+        self
+    }
+
+    #[track_caller]
+    pub fn assert_stdout_not_contains<S: AsRef<str>>(self, needle: S) -> Self {
         assert_not_contains(&self.stdout_utf8(), needle.as_ref());
         self
     }

src/tools/run-make-support/src/lib.rs

@@ -365,32 +365,7 @@ pub fn run_in_tmpdir<F: FnOnce()>(callback: F) {
     fs::remove_dir_all(tmpdir).unwrap();
 }
 
-/// Implement common helpers for command wrappers. This assumes that the command wrapper is a struct
-/// containing a `cmd: Command` field. The provided helpers are:
-///
-/// 1. Generic argument acceptors: `arg` and `args` (delegated to [`Command`]). These are intended
-///    to be *fallback* argument acceptors, when specific helpers don't make sense. Prefer to add
-///    new specific helper methods over relying on these generic argument providers.
-/// 2. Environment manipulation methods: `env`, `env_remove` and `env_clear`: these delegate to
-///    methods of the same name on [`Command`].
-/// 3. Output and execution: `run` and `run_fail` are provided. These are
-///    higher-level convenience methods which wait for the command to finish running and assert
-///    that the command successfully ran or failed as expected. They return
-///    [`CompletedProcess`], which can be used to assert the stdout/stderr/exit code of the executed
-///    process.
-///
-/// Example usage:
-///
-/// ```ignore (illustrative)
-/// struct CommandWrapper { cmd: Command } // <- required `cmd` field
-///
-/// crate::impl_common_helpers!(CommandWrapper);
-///
-/// impl CommandWrapper {
-///     // ... additional specific helper methods
-/// }
-/// ```
-macro_rules! impl_common_helpers {
+macro_rules! impl_common_helpers_without_run {
     ($wrapper: ident) => {
         impl $wrapper {
             /// Specify an environment variable.
@@ -434,13 +409,50 @@ macro_rules! impl_common_helpers {
                 self
             }
 
-            /// Inspect what the underlying [`Command`] is up to the
-            /// current construction.
             pub fn inspect<I>(&mut self, inspector: I) -> &mut Self
             where
                 I: FnOnce(&::std::process::Command),
             {
-                self.cmd.inspect(inspector);
+                inspector(&self.cmd);
+                self
+            }
+        }
+    };
+}
+
+/// Implement common helpers for command wrappers. This assumes that the command wrapper is a struct
+/// containing a `cmd: Command` field. The provided helpers are:
+///
+/// 1. Generic argument acceptors: `arg` and `args` (delegated to [`Command`]). These are intended
+///    to be *fallback* argument acceptors, when specific helpers don't make sense. Prefer to add
+///    new specific helper methods over relying on these generic argument providers.
+/// 2. Environment manipulation methods: `env`, `env_remove` and `env_clear`: these delegate to
+///    methods of the same name on [`Command`].
+/// 3. Output and execution: `run` and `run_fail` are provided. These are
+///    higher-level convenience methods which wait for the command to finish running and assert
+///    that the command successfully ran or failed as expected. They return
+///    [`CompletedProcess`], which can be used to assert the stdout/stderr/exit code of the executed
+///    process.
+///
+/// Example usage:
+///
+/// ```ignore (illustrative)
+/// struct CommandWrapper { cmd: Command } // <- required `cmd` field
+///
+/// crate::impl_common_helpers!(CommandWrapper);
+///
+/// impl CommandWrapper {
+///     // ... additional specific helper methods
+/// }
+/// ```
+macro_rules! impl_common_helpers {
+    ($wrapper: ident) => {
+        crate::impl_common_helpers_without_run!($wrapper);
+
+        impl $wrapper {
+            /// Set the path where the command will be run.
+            pub fn current_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
+                self.cmd.current_dir(path);
                 self
             }
 
@@ -455,15 +467,10 @@ macro_rules! impl_common_helpers {
             pub fn run_fail(&mut self) -> crate::command::CompletedProcess {
                 self.cmd.run_fail()
             }
-
-            /// Set the path where the command will be run.
-            pub fn current_dir<P: AsRef<::std::path::Path>>(&mut self, path: P) -> &mut Self {
-                self.cmd.current_dir(path);
-                self
-            }
         }
     };
 }
 
 use crate::command::{Command, CompletedProcess};
 pub(crate) use impl_common_helpers;
+pub(crate) use impl_common_helpers_without_run;