Skip to content

Commit 5b84fc9

Browse files
epageepage
committed
feat(test): Snapshot .crate validation
1 parent 5c25f7a commit 5b84fc9

12 files changed

+630
-426
lines changed

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

+142-40
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,145 @@ 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+
use std::fmt::Write as _;
684+
let assert = assert_e2e();
685+
let mut errs = String::new();
686+
for (path, expected_data) in &expected.files {
687+
let actual_data = self
688+
.files
689+
.iter()
690+
.find_map(|(p, d)| (path == p).then(|| d.clone()))
691+
.unwrap_or_else(|| Data::new());
692+
if let Err(err) =
693+
assert.try_eq(Some(&path.display()), actual_data, expected_data.clone())
694+
{
695+
let _ = write!(&mut errs, "{err}");
696+
}
697+
}
698+
if !errs.is_empty() {
699+
panic!("{errs}")
700+
}
701+
}
702+
}
703+
704+
impl<P, D> FromIterator<(P, D)> for InMemoryDir
705+
where
706+
P: Into<std::path::PathBuf>,
707+
D: IntoData,
708+
{
709+
fn from_iter<I: IntoIterator<Item = (P, D)>>(files: I) -> Self {
710+
let files = files
711+
.into_iter()
712+
.map(|(p, d)| (p.into(), d.into_data()))
713+
.collect();
714+
Self { files }
715+
}
716+
}
717+
718+
impl<const N: usize, P, D> From<[(P, D); N]> for InMemoryDir
719+
where
720+
P: Into<PathBuf>,
721+
D: IntoData,
722+
{
723+
fn from(files: [(P, D); N]) -> Self {
724+
let files = files
725+
.into_iter()
726+
.map(|(p, d)| (p.into(), d.into_data()))
727+
.collect();
728+
Self { files }
729+
}
730+
}
731+
732+
impl<P, D> From<std::collections::HashMap<P, D>> for InMemoryDir
733+
where
734+
P: Into<PathBuf>,
735+
D: IntoData,
736+
{
737+
fn from(files: std::collections::HashMap<P, D>) -> Self {
738+
let files = files
739+
.into_iter()
740+
.map(|(p, d)| (p.into(), d.into_data()))
741+
.collect();
742+
Self { files }
743+
}
744+
}
745+
746+
impl<P, D> From<std::collections::BTreeMap<P, D>> for InMemoryDir
747+
where
748+
P: Into<PathBuf>,
749+
D: IntoData,
750+
{
751+
fn from(files: std::collections::BTreeMap<P, D>) -> Self {
752+
let files = files
753+
.into_iter()
754+
.map(|(p, d)| (p.into(), d.into_data()))
755+
.collect();
756+
Self { files }
757+
}
758+
}
759+
760+
impl From<()> for InMemoryDir {
761+
fn from(_files: ()) -> Self {
762+
let files = Vec::new();
763+
Self { files }
764+
}
765+
}
766+
767+
/// Create an `impl _ for InMemoryDir` for a generic tuple
768+
///
769+
/// Must pass in names for each tuple parameter for
770+
/// - internal variable name
771+
/// - `Path` type
772+
/// - `Data` type
773+
macro_rules! impl_from_tuple_for_inmemorydir {
774+
($($var:ident $path:ident $data:ident),+) => {
775+
impl<$($path: Into<PathBuf>, $data: IntoData),+> From<($(($path, $data)),+ ,)> for InMemoryDir {
776+
fn from(files: ($(($path, $data)),+,)) -> Self {
777+
let ($($var),+ ,) = files;
778+
let files = [$(($var.0.into(), $var.1.into_data())),+];
779+
files.into()
780+
}
781+
}
782+
};
783+
}
784+
785+
/// Extend `impl_from_tuple_for_inmemorydir`` to generate for the specified tuple and all smaller
786+
/// tuples
787+
macro_rules! impl_from_tuples_for_inmemorydir {
788+
($var1:ident $path1:ident $data1:ident, $($var:ident $path:ident $data:ident),+) => {
789+
impl_from_tuples_for_inmemorydir!(__impl $var1 $path1 $data1; $($var $path $data),+);
790+
};
791+
(__impl $($var:ident $path:ident $data:ident),+; $var1:ident $path1:ident $data1:ident $(,$var2:ident $path2:ident $data2:ident)*) => {
792+
impl_from_tuple_for_inmemorydir!($($var $path $data),+);
793+
impl_from_tuples_for_inmemorydir!(__impl $($var $path $data),+, $var1 $path1 $data1; $($var2 $path2 $data2),*);
794+
};
795+
(__impl $($var:ident $path:ident $data:ident),+;) => {
796+
impl_from_tuple_for_inmemorydir!($($var $path $data),+);
797+
}
798+
}
799+
800+
// Generate for tuples of size `1..=7`
801+
impl_from_tuples_for_inmemorydir!(
802+
s1 P1 D1,
803+
s2 P2 D2,
804+
s3 P3 D3,
805+
s4 P4 D4,
806+
s5 P5 D5,
807+
s6 P6 D6,
808+
s7 P7 D7
809+
);
810+
709811
#[cfg(test)]
710812
mod test {
711813
use snapbox::assert_data_eq;

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

-117
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)