refactor(snap): Let caller control panicking

epage · Apr 19, 2024 · 9de29a8 · 9de29a8
1 parent 0858005
commit 9de29a8
Show file tree

Hide file tree

Showing 3 changed files with 35 additions and 19 deletions.
diff --git a/crates/snapbox/src/assert.rs b/crates/snapbox/src/assert.rs
@@ -57,24 +57,25 @@ impl Assert {
     pub fn eq(&self, expected: impl Into<crate::Data>, actual: impl Into<crate::Data>) {
         let expected = expected.into();
         let actual = actual.into();
-        self.eq_inner(expected, actual);
+        if let Err(err) = self.eq_inner(expected, actual) {
+            err.panic();
+        }
     }
 
-    #[track_caller]
-    fn eq_inner(&self, expected: crate::Data, actual: crate::Data) {
+    fn eq_inner(&self, expected: crate::Data, actual: crate::Data) -> Result<(), crate::Error> {
         if expected.source().is_none() && actual.source().is_some() {
             panic!("received `(actual, expected)`, expected `(expected, actual)`");
         }
         match self.action {
             Action::Skip => {
-                return;
+                return Ok(());
             }
             Action::Ignore | Action::Verify | Action::Overwrite => {}
         }
 
         let (expected, actual) = self.normalize_eq(expected, actual);
 
-        self.do_action(expected, actual, Some(&"In-memory"));
+        self.do_action(expected, actual, Some(&"In-memory"))
     }
 
     /// Check if a value matches a pattern
@@ -106,24 +107,25 @@ impl Assert {
     pub fn matches(&self, pattern: impl Into<crate::Data>, actual: impl Into<crate::Data>) {
         let pattern = pattern.into();
         let actual = actual.into();
-        self.matches_inner(pattern, actual);
+        if let Err(err) = self.matches_inner(pattern, actual) {
+            err.panic();
+        }
     }
 
-    #[track_caller]
-    fn matches_inner(&self, pattern: crate::Data, actual: crate::Data) {
+    fn matches_inner(&self, pattern: crate::Data, actual: crate::Data) -> Result<(), crate::Error> {
         if pattern.source().is_none() && actual.source().is_some() {
             panic!("received `(actual, expected)`, expected `(expected, actual)`");
         }
         match self.action {
             Action::Skip => {
-                return;
+                return Ok(());
             }
             Action::Ignore | Action::Verify | Action::Overwrite => {}
         }
 
         let (expected, actual) = self.normalize_match(pattern, actual);
 
-        self.do_action(expected, actual, Some(&"In-memory"));
+        self.do_action(expected, actual, Some(&"In-memory"))
     }
 
     pub(crate) fn normalize_eq(
@@ -162,16 +164,15 @@ impl Assert {
         (expected, actual)
     }
 
-    #[track_caller]
     pub(crate) fn do_action(
         &self,
         expected: crate::Data,
         actual: crate::Data,
         actual_name: Option<&dyn std::fmt::Display>,
-    ) {
+    ) -> Result<(), crate::Error> {
         let result = self.try_verify(&expected, &actual, actual_name);
         let Err(err) = result else {
-            return;
+            return Ok(());
         };
         match self.action {
             Action::Skip => unreachable!("Bailed out earlier"),
@@ -184,6 +185,7 @@ impl Assert {
                     self.palette.warn("Ignoring failure"),
                     err
                 );
+                Ok(())
             }
             Action::Verify => {
                 let message = if expected.source().is_none() {
@@ -194,16 +196,17 @@ impl Assert {
                 } else {
                     crate::report::Styled::new(String::new(), Default::default())
                 };
-                panic!("{err}{message}");
+                Err(crate::Error::new(format_args!("{err}{message}")))
             }
             Action::Overwrite => {
                 use std::io::Write;
 
                 if let Some(source) = expected.source() {
                     let _ = writeln!(stderr(), "{}: {}", self.palette.warn("Fixing"), err);
                     actual.write_to(source).unwrap();
+                    Ok(())
                 } else {
-                    panic!("{err}");
+                    Err(crate::Error::new(format_args!("{err}")))
                 }
             }
         }

diff --git a/crates/snapbox/src/cmd.rs b/crates/snapbox/src/cmd.rs
@@ -621,7 +621,9 @@ impl OutputAssert {
     fn stdout_eq_inner(self, expected: crate::Data) -> Self {
         let actual = crate::Data::from(self.output.stdout.as_slice());
         let (pattern, actual) = self.config.normalize_eq(expected, actual);
-        self.config.do_action(pattern, actual, Some(&"stdout"));
+        if let Err(err) = self.config.do_action(pattern, actual, Some(&"stdout")) {
+            err.panic();
+        }
 
         self
     }
@@ -661,7 +663,9 @@ impl OutputAssert {
     fn stdout_matches_inner(self, expected: crate::Data) -> Self {
         let actual = crate::Data::from(self.output.stdout.as_slice());
         let (pattern, actual) = self.config.normalize_match(expected, actual);
-        self.config.do_action(pattern, actual, Some(&"stdout"));
+        if let Err(err) = self.config.do_action(pattern, actual, Some(&"stdout")) {
+            err.panic();
+        }
 
         self
     }
@@ -701,7 +705,9 @@ impl OutputAssert {
     fn stderr_eq_inner(self, expected: crate::Data) -> Self {
         let actual = crate::Data::from(self.output.stderr.as_slice());
         let (pattern, actual) = self.config.normalize_eq(expected, actual);
-        self.config.do_action(pattern, actual, Some(&"stderr"));
+        if let Err(err) = self.config.do_action(pattern, actual, Some(&"stderr")) {
+            err.panic();
+        }
 
         self
     }
@@ -741,7 +747,9 @@ impl OutputAssert {
     fn stderr_matches_inner(self, expected: crate::Data) -> Self {
         let actual = crate::Data::from(self.output.stderr.as_slice());
         let (pattern, actual) = self.config.normalize_match(expected, actual);
-        self.config.do_action(pattern, actual, Some(&"stderr"));
+        if let Err(err) = self.config.do_action(pattern, actual, Some(&"stderr")) {
+            err.panic();
+        }
 
         self
     }

diff --git a/crates/snapbox/src/error.rs b/crates/snapbox/src/error.rs
@@ -15,6 +15,11 @@ impl Error {
             backtrace: Backtrace::new(),
         }
     }
+
+    #[track_caller]
+    pub(crate) fn panic(self) -> ! {
+        panic!("{self}")
+    }
 }
 
 impl PartialEq for Error {