Binary snapshots

cargo-insta/Cargo.toml

@@ -30,6 +30,7 @@ tempfile = "3.5.0"
 semver = {version = "1.0.7", features = ["serde"]}
 lazy_static = "1.4.0"
 clap = { workspace=true }
+open = "5.1.2"
 
 [dev-dependencies]
 walkdir = "2.3.1"

cargo-insta/src/cli.rs

@@ -6,6 +6,7 @@ use std::{env, fs};
 use std::{io, process};
 
 use console::{set_colors_enabled, style, Key, Term};
+use insta::internals::SnapshotContents;
 use insta::Snapshot;
 use insta::_cargo_insta_support::{
     is_ci, SnapshotPrinter, SnapshotUpdate, TestRunner, ToolConfig, UnreferencedSnapshots,
@@ -321,6 +322,24 @@ fn query_snapshot(
             style("toggle snapshot diff").dim()
         );
 
+        let new_is_binary = new.contents().is_binary();
+        let old_is_binary = old.is_some_and(|o| o.contents().is_binary());
+
+        if new_is_binary || old_is_binary {
+            println!(
+                "  {} open       {}",
+                style("o").cyan().bold(),
+                style(if new_is_binary && old_is_binary {
+                    "open snapshot files in external tool"
+                } else if new_is_binary {
+                    "open new snapshot file in external tool"
+                } else {
+                    "open old snapshot file in external tool"
+                })
+                .dim()
+            );
+        }
+
         loop {
             match term.read_key()? {
                 Key::Char('a') | Key::Enter => return Ok(Operation::Accept),
@@ -334,6 +353,17 @@ fn query_snapshot(
                     *show_diff = !*show_diff;
                     break;
                 }
+                Key::Char('o') => {
+                    if let Some(SnapshotContents::Binary { path, .. }) = old.map(|o| o.contents()) {
+                        open::that_detached(path)?;
+                    }
+
+                    if let SnapshotContents::Binary { path, .. } = new.contents() {
+                        open::that_detached(path)?;
+                    }
+
+                    // there's no break here because there's no need to re-output anything
+                }
                 _ => {}
             }
         }
@@ -1081,8 +1111,8 @@ fn pending_snapshots_cmd(cmd: PendingSnapshotsCommand) -> Result<(), Box<dyn Err
                     SnapshotKey::InlineSnapshot {
                         path: &target_file,
                         line: snapshot_ref.line.unwrap(),
-                        old_snapshot: snapshot_ref.old.as_ref().map(|x| x.contents_str()),
-                        new_snapshot: snapshot_ref.new.contents_str(),
+                        old_snapshot: snapshot_ref.old.as_ref().map(|x| x.contents_str().unwrap()),
+                        new_snapshot: snapshot_ref.new.contents_str().unwrap(),
                         expression: snapshot_ref.new.metadata().expression(),
                     }
                 } else {

cargo-insta/src/container.rs

@@ -216,25 +216,38 @@ impl SnapshotContainer {
             for snapshot in self.snapshots.iter() {
                 match snapshot.op {
                     Operation::Accept => {
-                        let snapshot = Snapshot::from_file(&self.snapshot_path).map_err(|e| {
-                            // If it's an IO error, pass a ContentError back so
-                            // we get a slightly clearer error message
-                            match e.downcast::<std::io::Error>() {
-                                Ok(io_error) => Box::new(ContentError::FileIo(
-                                    *io_error,
-                                    self.snapshot_path.to_path_buf(),
-                                )),
-                                Err(other_error) => other_error,
-                            }
-                        })?;
-                        snapshot.save(&self.target_path)?;
+                        let mut new_snapshot =
+                            Snapshot::from_file(&self.snapshot_path).map_err(|e| {
+                                // If it's an IO error, pass a ContentError back so
+                                // we get a slightly clearer error message
+                                match e.downcast::<std::io::Error>() {
+                                    Ok(io_error) => Box::new(ContentError::FileIo(
+                                        *io_error,
+                                        self.snapshot_path.to_path_buf(),
+                                    )),
+                                    Err(other_error) => other_error,
+                                }
+                            })?;
+                        new_snapshot.save(&self.target_path)?;
                         try_removing_snapshot(&self.snapshot_path);
                     }
                     Operation::Reject => {
                         try_removing_snapshot(&self.snapshot_path);
+
+                        if let insta::internals::SnapshotContents::Binary { path, .. } =
+                            snapshot.new.contents()
+                        {
+                            try_removing_snapshot(path);
+                        }
                     }
                     Operation::Skip => {}
                 }
+
+                if let Operation::Accept | Operation::Reject = snapshot.op {
+                    let snapshot = Snapshot::from_file(&self.target_path).ok();
+
+                    Snapshot::cleanup_extra_files(snapshot.as_ref(), &self.snapshot_path)?;
+                }
             }
         }
         Ok(())

cargo-insta/src/inline.rs

@@ -104,8 +104,12 @@ impl FilePatcher {
             .collect();
 
         // replace lines
-        let snapshot_line_contents =
-            [prefix, snapshot.to_inline(inline.indentation), suffix].join("");
+        let snapshot_line_contents = [
+            prefix,
+            snapshot.to_inline(inline.indentation).unwrap(),
+            suffix,
+        ]
+        .join("");
 
         self.lines.splice(
             inline.start.0..=inline.end.0,

insta/src/content/mod.rs

@@ -22,7 +22,6 @@ use std::fmt;
 pub enum Error {
     FailedParsingYaml(std::path::PathBuf),
     UnexpectedDataType,
-    #[cfg(feature = "_cargo_insta_internal")]
     MissingField,
     #[cfg(feature = "_cargo_insta_internal")]
     FileIo(std::io::Error, std::path::PathBuf),
@@ -37,7 +36,6 @@ impl fmt::Display for Error {
             Error::UnexpectedDataType => {
                 f.write_str("The present data type wasn't what was expected")
             }
-            #[cfg(feature = "_cargo_insta_internal")]
             Error::MissingField => f.write_str("A required field was missing"),
             #[cfg(feature = "_cargo_insta_internal")]
             Error::FileIo(e, p) => {

insta/src/lib.rs

@@ -333,7 +333,9 @@ pub use crate::redaction::{dynamic_redaction, rounded_redaction, sorted_redactio
 pub mod _macro_support {
     pub use crate::content::Content;
     pub use crate::env::get_cargo_workspace;
-    pub use crate::runtime::{assert_snapshot, with_allow_duplicates, AutoName, ReferenceValue};
+    pub use crate::runtime::{
+        assert_snapshot, with_allow_duplicates, AutoName, ReferenceValue, SnapshotValue,
+    };
 
     #[cfg(feature = "serde")]
     pub use crate::serialization::{serialize_value, SerializationFormat, SnapshotLocation};

insta/src/macros.rs

@@ -348,7 +348,35 @@ macro_rules! _assert_snapshot_base {
         $crate::_macro_support::assert_snapshot(
             $name.into(),
             #[allow(clippy::redundant_closure_call)]
-            &$transform(&$value),
+            $crate::_macro_support::SnapshotValue::String(&$transform(&$value)),
+            env!("CARGO_MANIFEST_DIR"),
+            $crate::_function_name!(),
+            module_path!(),
+            file!(),
+            line!(),
+            $debug_expr,
+        )
+        .unwrap()
+    };
+}
+
+#[macro_export]
+macro_rules! assert_binary_snapshot {
+    ($extension:expr, $value:expr $(,)?) => {
+        $crate::assert_binary_snapshot!($extension, $crate::_macro_support::AutoName, $value);
+    };
+
+    ($extension:expr, $name:expr, $value:expr $(,)?) => {
+        $crate::assert_binary_snapshot!($extension, $name, $value, stringify!($value));
+    };
+
+    ($extension:expr, $name:expr, $value:expr, $debug_expr:expr $(,)?) => {
+        $crate::_macro_support::assert_snapshot(
+            $name.into(),
+            $crate::_macro_support::SnapshotValue::Binary {
+                write: &mut $value,
+                extension: $extension,
+            },
             env!("CARGO_MANIFEST_DIR"),
             $crate::_function_name!(),
             module_path!(),