Skip to content

Commit 103c823

Browse files
epageepage
committed
feat(test): Snapshot .crate validation
1 parent 6bf47d8 commit 103c823

12 files changed

+612
-426
lines changed

‎crates/cargo-test-support/src/compare.rs

Lines changed: 124 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -45,8 +45,11 @@ use crate::cross_compile::try_alternate;
4545
use crate::paths;
4646
use crate::{diff, rustc_host};
4747
use anyhow::{bail, Result};
48+
use snapbox::Data;
49+
use snapbox::IntoData;
4850
use std::fmt;
4951
use std::path::Path;
52+
use std::path::PathBuf;
5053
use std::str;
5154
use url::Url;
5255

@@ -428,46 +431,6 @@ fn substitute_macros(input: &str) -> String {
428431
result
429432
}
430433

431-
/// Compares one string against another, checking that they both match.
432-
///
433-
/// See [Patterns](index.html#patterns) for more information on pattern matching.
434-
///
435-
/// - `description` explains where the output is from (usually "stdout" or "stderr").
436-
/// - `other_output` is other output to display in the error (usually stdout or stderr).
437-
pub(crate) fn match_exact(
438-
expected: &str,
439-
actual: &str,
440-
description: &str,
441-
other_output: &str,
442-
cwd: Option<&Path>,
443-
) -> Result<()> {
444-
let expected = normalize_expected(expected, cwd);
445-
let actual = normalize_actual(actual, cwd);
446-
let e: Vec<_> = expected.lines().map(WildStr::new).collect();
447-
let a: Vec<_> = actual.lines().map(WildStr::new).collect();
448-
if e == a {
449-
return Ok(());
450-
}
451-
let diff = diff::colored_diff(&e, &a);
452-
bail!(
453-
"{} did not match:\n\
454-
{}\n\n\
455-
other output:\n\
456-
{}\n",
457-
description,
458-
diff,
459-
other_output,
460-
);
461-
}
462-
463-
/// Convenience wrapper around [`match_exact`] which will panic on error.
464-
#[track_caller]
465-
pub(crate) fn assert_match_exact(expected: &str, actual: &str) {
466-
if let Err(e) = match_exact(expected, actual, "", "", None) {
467-
crate::panic_error("", e);
468-
}
469-
}
470-
471434
/// Checks that the given string contains the given lines, ignoring the order
472435
/// of the lines.
473436
///
@@ -706,6 +669,127 @@ impl fmt::Debug for WildStr<'_> {
706669
}
707670
}
708671

672+
pub struct InMemoryDir {
673+
files: Vec<(PathBuf, Data)>,
674+
}
675+
676+
impl InMemoryDir {
677+
pub fn paths(&self) -> impl Iterator<Item = &Path> {
678+
self.files.iter().map(|(p, _)| p.as_path())
679+
}
680+
681+
#[track_caller]
682+
pub fn assert_contains(&self, expected: &Self) {
683+
let assert = assert_e2e();
684+
for (path, expected_data) in &expected.files {
685+
let actual_data = self
686+
.files
687+
.iter()
688+
.find_map(|(p, d)| (path == p).then(|| d.clone()))
689+
.unwrap_or_else(|| Data::new());
690+
assert.eq(actual_data, expected_data);
691+
}
692+
}
693+
}
694+
695+
impl<P, D> FromIterator<(P, D)> for InMemoryDir
696+
where
697+
P: Into<std::path::PathBuf>,
698+
D: IntoData,
699+
{
700+
fn from_iter<I: IntoIterator<Item = (P, D)>>(files: I) -> Self {
701+
let files = files
702+
.into_iter()
703+
.map(|(p, d)| (p.into(), d.into_data()))
704+
.collect();
705+
Self { files }
706+
}
707+
}
708+
709+
impl<const N: usize, P, D> From<[(P, D); N]> for InMemoryDir
710+
where
711+
P: Into<PathBuf>,
712+
D: IntoData,
713+
{
714+
fn from(files: [(P, D); N]) -> Self {
715+
let files = files
716+
.into_iter()
717+
.map(|(p, d)| (p.into(), d.into_data()))
718+
.collect();
719+
Self { files }
720+
}
721+
}
722+
723+
impl<P, D> From<std::collections::HashMap<P, D>> for InMemoryDir
724+
where
725+
P: Into<PathBuf>,
726+
D: IntoData,
727+
{
728+
fn from(files: std::collections::HashMap<P, D>) -> Self {
729+
let files = files
730+
.into_iter()
731+
.map(|(p, d)| (p.into(), d.into_data()))
732+
.collect();
733+
Self { files }
734+
}
735+
}
736+
737+
impl<P, D> From<std::collections::BTreeMap<P, D>> for InMemoryDir
738+
where
739+
P: Into<PathBuf>,
740+
D: IntoData,
741+
{
742+
fn from(files: std::collections::BTreeMap<P, D>) -> Self {
743+
let files = files
744+
.into_iter()
745+
.map(|(p, d)| (p.into(), d.into_data()))
746+
.collect();
747+
Self { files }
748+
}
749+
}
750+
751+
impl From<()> for InMemoryDir {
752+
fn from(_files: ()) -> Self {
753+
let files = Vec::new();
754+
Self { files }
755+
}
756+
}
757+
758+
macro_rules! impl_from_tuple_for_dirsnapshot {
759+
($($var:ident $path:ident $data:ident),+) => {
760+
impl<$($path: Into<PathBuf>, $data: IntoData),+> From<($(($path, $data)),+ ,)> for InMemoryDir {
761+
fn from(files: ($(($path, $data)),+,)) -> Self {
762+
let ($($var),+ ,) = files;
763+
let files = [$(($var.0.into(), $var.1.into_data())),+];
764+
files.into()
765+
}
766+
}
767+
};
768+
}
769+
770+
macro_rules! impl_from_tuples_for_dirsnapshot {
771+
($var1:ident $path1:ident $data1:ident, $($var:ident $path:ident $data:ident),+) => {
772+
impl_from_tuples_for_dirsnapshot!(__impl $var1 $path1 $data1; $($var $path $data),+);
773+
};
774+
(__impl $($var:ident $path:ident $data:ident),+; $var1:ident $path1:ident $data1:ident $(,$var2:ident $path2:ident $data2:ident)*) => {
775+
impl_from_tuple_for_dirsnapshot!($($var $path $data),+);
776+
impl_from_tuples_for_dirsnapshot!(__impl $($var $path $data),+, $var1 $path1 $data1; $($var2 $path2 $data2),*);
777+
};
778+
(__impl $($var:ident $path:ident $data:ident),+;) => {
779+
impl_from_tuple_for_dirsnapshot!($($var $path $data),+);
780+
}
781+
}
782+
783+
impl_from_tuples_for_dirsnapshot!(
784+
s1 P1 D1,
785+
s2 P2 D2,
786+
s3 P3 D3,
787+
s4 P4 D4,
788+
s5 P5 D5,
789+
s6 P6 D6,
790+
s7 P7 D7
791+
);
792+
709793
#[cfg(test)]
710794
mod test {
711795
use snapbox::assert_data_eq;

‎crates/cargo-test-support/src/diff.rs

Lines changed: 0 additions & 117 deletions
Original file line numberDiff line numberDiff line change
@@ -16,99 +16,6 @@ pub enum Change<T> {
1616
Keep(usize, usize, T),
1717
}
1818

19-
pub fn diff<'a, T>(a: &'a [T], b: &'a [T]) -> Vec<Change<&'a T>>
20-
where
21-
T: PartialEq,
22-
{
23-
if a.is_empty() && b.is_empty() {
24-
return vec![];
25-
}
26-
let mut diff = vec![];
27-
for (prev_x, prev_y, x, y) in backtrack(&a, &b) {
28-
if x == prev_x {
29-
diff.push(Change::Add(prev_y + 1, &b[prev_y]));
30-
} else if y == prev_y {
31-
diff.push(Change::Remove(prev_x + 1, &a[prev_x]));
32-
} else {
33-
diff.push(Change::Keep(prev_x + 1, prev_y + 1, &a[prev_x]));
34-
}
35-
}
36-
diff.reverse();
37-
diff
38-
}
39-
40-
fn shortest_edit<T>(a: &[T], b: &[T]) -> Vec<Vec<usize>>
41-
where
42-
T: PartialEq,
43-
{
44-
let max = a.len() + b.len();
45-
let mut v = vec![0; 2 * max + 1];
46-
let mut trace = vec![];
47-
for d in 0..=max {
48-
trace.push(v.clone());
49-
for k in (0..=(2 * d)).step_by(2) {
50-
let mut x = if k == 0 || (k != 2 * d && v[max - d + k - 1] < v[max - d + k + 1]) {
51-
// Move down
52-
v[max - d + k + 1]
53-
} else {
54-
// Move right
55-
v[max - d + k - 1] + 1
56-
};
57-
let mut y = x + d - k;
58-
// Step diagonally as far as possible.
59-
while x < a.len() && y < b.len() && a[x] == b[y] {
60-
x += 1;
61-
y += 1;
62-
}
63-
v[max - d + k] = x;
64-
// Return if reached the bottom-right position.
65-
if x >= a.len() && y >= b.len() {
66-
return trace;
67-
}
68-
}
69-
}
70-
panic!("finished without hitting end?");
71-
}
72-
73-
fn backtrack<T>(a: &[T], b: &[T]) -> Vec<(usize, usize, usize, usize)>
74-
where
75-
T: PartialEq,
76-
{
77-
let mut result = vec![];
78-
let mut x = a.len();
79-
let mut y = b.len();
80-
let max = x + y;
81-
for (d, v) in shortest_edit(a, b).iter().enumerate().rev() {
82-
let k = x + d - y;
83-
let prev_k = if k == 0 || (k != 2 * d && v[max - d + k - 1] < v[max - d + k + 1]) {
84-
k + 1
85-
} else {
86-
k - 1
87-
};
88-
let prev_x = v[max - d + prev_k];
89-
let prev_y = (prev_x + d).saturating_sub(prev_k);
90-
while x > prev_x && y > prev_y {
91-
result.push((x - 1, y - 1, x, y));
92-
x -= 1;
93-
y -= 1;
94-
}
95-
if d > 0 {
96-
result.push((prev_x, prev_y, x, y));
97-
}
98-
x = prev_x;
99-
y = prev_y;
100-
}
101-
return result;
102-
}
103-
104-
pub fn colored_diff<'a, T>(a: &'a [T], b: &'a [T]) -> String
105-
where
106-
T: PartialEq + fmt::Display,
107-
{
108-
let changes = diff(a, b);
109-
render_colored_changes(&changes)
110-
}
111-
11219
pub fn render_colored_changes<T: fmt::Display>(changes: &[Change<T>]) -> String {
11320
// anstyle is not very ergonomic, but I don't want to bring in another dependency.
11421
let red = anstyle::AnsiColor::Red.on_default().render();
@@ -140,27 +47,3 @@ pub fn render_colored_changes<T: fmt::Display>(changes: &[Change<T>]) -> String
14047
}
14148
String::from_utf8(buffer.into_inner()).unwrap()
14249
}
143-
144-
#[cfg(test)]
145-
pub fn compare(a: &str, b: &str) {
146-
let a: Vec<_> = a.chars().collect();
147-
let b: Vec<_> = b.chars().collect();
148-
let changes = diff(&a, &b);
149-
let mut result = vec![];
150-
for change in changes {
151-
match change {
152-
Change::Add(_, s) => result.push(*s),
153-
Change::Remove(_, _s) => {}
154-
Change::Keep(_, _, s) => result.push(*s),
155-
}
156-
}
157-
assert_eq!(b, result);
158-
}
159-
160-
#[test]
161-
fn basic_tests() {
162-
compare("", "");
163-
compare("A", "");
164-
compare("", "B");
165-
compare("ABCABBA", "CBABAC");
166-
}

0 commit comments

Comments
 (0)