Implement missing methods on Command and on CompletedProcess

Author: GuillaumeGomez

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

@@ -71,6 +71,8 @@ impl Command {
     }
 }
 
+crate::impl_common_helpers_without_run!(Command);
+
 impl Deref for Command {
     type Target = StdCommand;
 
@@ -112,6 +114,12 @@ impl CompletedProcess {
         self
     }
 
+    #[track_caller]
+    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());

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

@@ -317,32 +317,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.
@@ -401,6 +376,45 @@ macro_rules! impl_common_helpers {
                 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
+            }
 
             /// Run the constructed command and assert that it is successfully run.
             #[track_caller]
@@ -413,15 +427,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<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;