Merging upstream version 1.70.0+dfsg2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 527 insertions, 0 deletions

diff --git a/vendor/snapbox/src/assert.rs b/vendor/snapbox/src/assert.rs
new file mode 100644
index 000000000..ab87f1554
--- /dev/null
+++ b/vendor/snapbox/src/assert.rs
@@ -0,0 +1,527 @@
+use crate::data::{DataFormat, NormalizeMatches, NormalizeNewlines, NormalizePaths};
+use crate::Action;
+
+/// Snapshot assertion against a file's contents
+///
+/// Useful for one-off assertions with the snapshot stored in a file
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// let actual = "...";
+/// snapbox::Assert::new()
+///     .action_env("SNAPSHOTS")
+///     .matches_path(actual, "tests/fixtures/help_output_is_clean.txt");
+/// ```
+#[derive(Clone, Debug)]
+pub struct Assert {
+    action: Action,
+    action_var: Option<String>,
+    normalize_paths: bool,
+    substitutions: crate::Substitutions,
+    pub(crate) palette: crate::report::Palette,
+    pub(crate) data_format: Option<DataFormat>,
+}
+
+/// # Assertions
+impl Assert {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Check if a value is the same as an expected value
+    ///
+    /// When the content is text, newlines are normalized.
+    ///
+    /// ```rust
+    /// let output = "something";
+    /// let expected = "something";
+    /// snapbox::Assert::new().eq(expected, output);
+    /// ```
+    #[track_caller]
+    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);
+    }
+
+    #[track_caller]
+    fn eq_inner(&self, expected: crate::Data, actual: crate::Data) {
+        let (pattern, actual) = self.normalize_eq(Ok(expected), actual);
+        if let Err(desc) = pattern.and_then(|p| self.try_verify(&p, &actual, None, None)) {
+            panic!("{}: {}", self.palette.error("Eq failed"), desc);
+        }
+    }
+
+    /// Check if a value matches a pattern
+    ///
+    /// Pattern syntax:
+    /// - `...` is a line-wildcard when on a line by itself
+    /// - `[..]` is a character-wildcard when inside a line
+    /// - `[EXE]` matches `.exe` on Windows
+    ///
+    /// Normalization:
+    /// - Newlines
+    /// - `\` to `/`
+    ///
+    /// ```rust
+    /// let output = "something";
+    /// let expected = "so[..]g";
+    /// snapbox::Assert::new().matches(expected, output);
+    /// ```
+    #[track_caller]
+    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);
+    }
+
+    #[track_caller]
+    fn matches_inner(&self, pattern: crate::Data, actual: crate::Data) {
+        let (pattern, actual) = self.normalize_match(Ok(pattern), actual);
+        if let Err(desc) = pattern.and_then(|p| self.try_verify(&p, &actual, None, None)) {
+            panic!("{}: {}", self.palette.error("Match failed"), desc);
+        }
+    }
+
+    /// Check if a value matches the content of a file
+    ///
+    /// When the content is text, newlines are normalized.
+    ///
+    /// ```rust,no_run
+    /// let output = "something";
+    /// let expected_path = "tests/snapshots/output.txt";
+    /// snapbox::Assert::new().eq_path(output, expected_path);
+    /// ```
+    #[track_caller]
+    pub fn eq_path(
+        &self,
+        expected_path: impl AsRef<std::path::Path>,
+        actual: impl Into<crate::Data>,
+    ) {
+        let expected_path = expected_path.as_ref();
+        let actual = actual.into();
+        self.eq_path_inner(expected_path, actual);
+    }
+
+    #[track_caller]
+    fn eq_path_inner(&self, pattern_path: &std::path::Path, actual: crate::Data) {
+        match self.action {
+            Action::Skip => {
+                return;
+            }
+            Action::Ignore | Action::Verify | Action::Overwrite => {}
+        }
+
+        let expected = crate::Data::read_from(pattern_path, self.data_format());
+        let (expected, actual) = self.normalize_eq(expected, actual);
+
+        self.do_action(
+            expected,
+            actual,
+            Some(&crate::path::display_relpath(pattern_path)),
+            Some(&"In-memory"),
+            pattern_path,
+        );
+    }
+
+    /// Check if a value matches the pattern in a file
+    ///
+    /// Pattern syntax:
+    /// - `...` is a line-wildcard when on a line by itself
+    /// - `[..]` is a character-wildcard when inside a line
+    /// - `[EXE]` matches `.exe` on Windows (override with [`Assert::substitutions`])
+    ///
+    /// Normalization:
+    /// - Newlines
+    /// - `\` to `/`
+    ///
+    /// ```rust,no_run
+    /// let output = "something";
+    /// let expected_path = "tests/snapshots/output.txt";
+    /// snapbox::Assert::new().matches_path(expected_path, output);
+    /// ```
+    #[track_caller]
+    pub fn matches_path(
+        &self,
+        pattern_path: impl AsRef<std::path::Path>,
+        actual: impl Into<crate::Data>,
+    ) {
+        let pattern_path = pattern_path.as_ref();
+        let actual = actual.into();
+        self.matches_path_inner(pattern_path, actual);
+    }
+
+    #[track_caller]
+    fn matches_path_inner(&self, pattern_path: &std::path::Path, actual: crate::Data) {
+        match self.action {
+            Action::Skip => {
+                return;
+            }
+            Action::Ignore | Action::Verify | Action::Overwrite => {}
+        }
+
+        let expected = crate::Data::read_from(pattern_path, self.data_format());
+        let (expected, actual) = self.normalize_match(expected, actual);
+
+        self.do_action(
+            expected,
+            actual,
+            Some(&crate::path::display_relpath(pattern_path)),
+            Some(&"In-memory"),
+            pattern_path,
+        );
+    }
+
+    pub(crate) fn normalize_eq(
+        &self,
+        expected: crate::Result<crate::Data>,
+        mut actual: crate::Data,
+    ) -> (crate::Result<crate::Data>, crate::Data) {
+        let expected = expected.map(|d| d.normalize(NormalizeNewlines));
+        // On `expected` being an error, make a best guess
+        let format = expected
+            .as_ref()
+            .map(|d| d.format())
+            .unwrap_or(DataFormat::Text);
+
+        actual = actual.try_coerce(format).normalize(NormalizeNewlines);
+
+        (expected, actual)
+    }
+
+    pub(crate) fn normalize_match(
+        &self,
+        expected: crate::Result<crate::Data>,
+        mut actual: crate::Data,
+    ) -> (crate::Result<crate::Data>, crate::Data) {
+        let expected = expected.map(|d| d.normalize(NormalizeNewlines));
+        // On `expected` being an error, make a best guess
+        let format = expected.as_ref().map(|e| e.format()).unwrap_or_default();
+        actual = actual.try_coerce(format);
+
+        if self.normalize_paths {
+            actual = actual.normalize(NormalizePaths);
+        }
+        // Always normalize new lines
+        actual = actual.normalize(NormalizeNewlines);
+
+        // If expected is not an error normalize matches
+        if let Ok(expected) = expected.as_ref() {
+            actual = actual.normalize(NormalizeMatches::new(&self.substitutions, expected));
+        }
+
+        (expected, actual)
+    }
+
+    #[track_caller]
+    pub(crate) fn do_action(
+        &self,
+        expected: crate::Result<crate::Data>,
+        actual: crate::Data,
+        expected_name: Option<&dyn std::fmt::Display>,
+        actual_name: Option<&dyn std::fmt::Display>,
+        expected_path: &std::path::Path,
+    ) {
+        let result =
+            expected.and_then(|e| self.try_verify(&e, &actual, expected_name, actual_name));
+        if let Err(err) = result {
+            match self.action {
+                Action::Skip => unreachable!("Bailed out earlier"),
+                Action::Ignore => {
+                    use std::io::Write;
+
+                    let _ = writeln!(
+                        std::io::stderr(),
+                        "{}: {}",
+                        self.palette.warn("Ignoring failure"),
+                        err
+                    );
+                }
+                Action::Verify => {
+                    use std::fmt::Write;
+                    let mut buffer = String::new();
+                    write!(&mut buffer, "{}", err).unwrap();
+                    if let Some(action_var) = self.action_var.as_deref() {
+                        writeln!(
+                            &mut buffer,
+                            "{}",
+                            self.palette
+                                .hint(format_args!("Update with {}=overwrite", action_var))
+                        )
+                        .unwrap();
+                    }
+                    panic!("{}", buffer);
+                }
+                Action::Overwrite => {
+                    use std::io::Write;
+
+                    let _ = writeln!(
+                        std::io::stderr(),
+                        "{}: {}",
+                        self.palette.warn("Fixing"),
+                        err
+                    );
+                    actual.write_to(expected_path).unwrap();
+                }
+            }
+        }
+    }
+
+    pub(crate) fn try_verify(
+        &self,
+        expected: &crate::Data,
+        actual: &crate::Data,
+        expected_name: Option<&dyn std::fmt::Display>,
+        actual_name: Option<&dyn std::fmt::Display>,
+    ) -> crate::Result<()> {
+        if expected != actual {
+            let mut buf = String::new();
+            crate::report::write_diff(
+                &mut buf,
+                expected,
+                actual,
+                expected_name,
+                actual_name,
+                self.palette,
+            )
+            .map_err(|e| e.to_string())?;
+            Err(buf.into())
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// # Directory Assertions
+#[cfg(feature = "path")]
+impl Assert {
+    #[track_caller]
+    pub fn subset_eq(
+        &self,
+        expected_root: impl Into<std::path::PathBuf>,
+        actual_root: impl Into<std::path::PathBuf>,
+    ) {
+        let expected_root = expected_root.into();
+        let actual_root = actual_root.into();
+        self.subset_eq_inner(expected_root, actual_root)
+    }
+
+    #[track_caller]
+    fn subset_eq_inner(&self, expected_root: std::path::PathBuf, actual_root: std::path::PathBuf) {
+        match self.action {
+            Action::Skip => {
+                return;
+            }
+            Action::Ignore | Action::Verify | Action::Overwrite => {}
+        }
+
+        let checks: Vec<_> =
+            crate::path::PathDiff::subset_eq_iter_inner(expected_root, actual_root).collect();
+        self.verify(checks);
+    }
+
+    #[track_caller]
+    pub fn subset_matches(
+        &self,
+        pattern_root: impl Into<std::path::PathBuf>,
+        actual_root: impl Into<std::path::PathBuf>,
+    ) {
+        let pattern_root = pattern_root.into();
+        let actual_root = actual_root.into();
+        self.subset_matches_inner(pattern_root, actual_root)
+    }
+
+    #[track_caller]
+    fn subset_matches_inner(
+        &self,
+        expected_root: std::path::PathBuf,
+        actual_root: std::path::PathBuf,
+    ) {
+        match self.action {
+            Action::Skip => {
+                return;
+            }
+            Action::Ignore | Action::Verify | Action::Overwrite => {}
+        }
+
+        let checks: Vec<_> = crate::path::PathDiff::subset_matches_iter_inner(
+            expected_root,
+            actual_root,
+            &self.substitutions,
+        )
+        .collect();
+        self.verify(checks);
+    }
+
+    #[track_caller]
+    fn verify(
+        &self,
+        mut checks: Vec<Result<(std::path::PathBuf, std::path::PathBuf), crate::path::PathDiff>>,
+    ) {
+        if checks.iter().all(Result::is_ok) {
+            for check in checks {
+                let (_expected_path, _actual_path) = check.unwrap();
+                crate::debug!(
+                    "{}: is {}",
+                    _expected_path.display(),
+                    self.palette.info("good")
+                );
+            }
+        } else {
+            checks.sort_by_key(|c| match c {
+                Ok((expected_path, _actual_path)) => Some(expected_path.clone()),
+                Err(diff) => diff.expected_path().map(|p| p.to_owned()),
+            });
+
+            let mut buffer = String::new();
+            let mut ok = true;
+            for check in checks {
+                use std::fmt::Write;
+                match check {
+                    Ok((expected_path, _actual_path)) => {
+                        let _ = writeln!(
+                            &mut buffer,
+                            "{}: is {}",
+                            expected_path.display(),
+                            self.palette.info("good"),
+                        );
+                    }
+                    Err(diff) => {
+                        let _ = diff.write(&mut buffer, self.palette);
+                        match self.action {
+                            Action::Skip => unreachable!("Bailed out earlier"),
+                            Action::Ignore | Action::Verify => {
+                                ok = false;
+                            }
+                            Action::Overwrite => {
+                                if let Err(err) = diff.overwrite() {
+                                    ok = false;
+                                    let path = diff
+                                        .expected_path()
+                                        .expect("always present when overwrite can fail");
+                                    let _ = writeln!(
+                                        &mut buffer,
+                                        "{} to overwrite {}: {}",
+                                        self.palette.error("Failed"),
+                                        path.display(),
+                                        err
+                                    );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if ok {
+                use std::io::Write;
+                let _ = write!(std::io::stderr(), "{}", buffer);
+                match self.action {
+                    Action::Skip => unreachable!("Bailed out earlier"),
+                    Action::Ignore => {
+                        let _ = write!(
+                            std::io::stderr(),
+                            "{}",
+                            self.palette.warn("Ignoring above failures")
+                        );
+                    }
+                    Action::Verify => unreachable!("Something had to fail to get here"),
+                    Action::Overwrite => {
+                        let _ = write!(
+                            std::io::stderr(),
+                            "{}",
+                            self.palette.warn("Overwrote above failures")
+                        );
+                    }
+                }
+            } else {
+                match self.action {
+                    Action::Skip => unreachable!("Bailed out earlier"),
+                    Action::Ignore => unreachable!("Shouldn't be able to fail"),
+                    Action::Verify => {
+                        use std::fmt::Write;
+                        if let Some(action_var) = self.action_var.as_deref() {
+                            writeln!(
+                                &mut buffer,
+                                "{}",
+                                self.palette
+                                    .hint(format_args!("Update with {}=overwrite", action_var))
+                            )
+                            .unwrap();
+                        }
+                    }
+                    Action::Overwrite => {}
+                }
+                panic!("{}", buffer);
+            }
+        }
+    }
+}
+
+/// # Customize Behavior
+impl Assert {
+    /// Override the color palette
+    pub fn palette(mut self, palette: crate::report::Palette) -> Self {
+        self.palette = palette;
+        self
+    }
+
+    /// Read the failure action from an environment variable
+    pub fn action_env(mut self, var_name: &str) -> Self {
+        let action = Action::with_env_var(var_name);
+        self.action = action.unwrap_or(self.action);
+        self.action_var = Some(var_name.to_owned());
+        self
+    }
+
+    /// Override the failure action
+    pub fn action(mut self, action: Action) -> Self {
+        self.action = action;
+        self.action_var = None;
+        self
+    }
+
+    /// Override the default [`Substitutions`][crate::Substitutions]
+    pub fn substitutions(mut self, substitutions: crate::Substitutions) -> Self {
+        self.substitutions = substitutions;
+        self
+    }
+
+    /// Specify whether text should have path separators normalized
+    ///
+    /// The default is normalized
+    pub fn normalize_paths(mut self, yes: bool) -> Self {
+        self.normalize_paths = yes;
+        self
+    }
+
+    /// Specify whether the content should be treated as binary or not
+    ///
+    /// The default is to auto-detect
+    pub fn binary(mut self, yes: bool) -> Self {
+        self.data_format = if yes {
+            Some(DataFormat::Binary)
+        } else {
+            Some(DataFormat::Text)
+        };
+        self
+    }
+
+    pub(crate) fn data_format(&self) -> Option<DataFormat> {
+        self.data_format
+    }
+}
+
+impl Default for Assert {
+    fn default() -> Self {
+        Self {
+            action: Default::default(),
+            action_var: Default::default(),
+            normalize_paths: true,
+            substitutions: Default::default(),
+            palette: crate::report::Palette::auto(),
+            data_format: Default::default(),
+        }
+        .substitutions(crate::Substitutions::with_exe())
+    }
+}