Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix(filter): When checking unordered arrays, check normalized values #368

Merged
merged 4 commits into from
Oct 4, 2024
Merged

fix(filter): When checking unordered arrays, check normalized values #368

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
5e1959b
refactor(filter): Be consistent in terms
epage Oct 4, 2024
41dfc2b
refactor(filter): Extract unordered array normalization
epage Oct 4, 2024
764b80c
refactor(filter): Short-circuit unordered array normalization
epage Oct 4, 2024
bfbb99f
fix(filter): When checking unordered arrays, check normalized values
epage Oct 4, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
186 changes: 106 additions & 80 deletions crates/snapbox/src/filter/pattern.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -272,34 +272,7 @@ fn normalize_value_to_unordered_redactions(
*act = normalize_str_to_unordered_redactions(act, exp, substitutions);
}
(Array(act), Array(exp)) => {
let mut actual_values = std::mem::take(act);
let mut expected_values = exp.clone();
let mut elided = false;
expected_values.retain(|expected_value| {
let mut matched = false;
if expected_value == VALUE_WILDCARD {
matched = true;
elided = true;
} else {
actual_values.retain(|actual_value| {
if !matched && actual_value == expected_value {
matched = true;
false
} else {
true
}
});
}
if matched {
act.push(expected_value.clone());
}
!matched
});
if !elided {
for actual_value in actual_values {
act.push(actual_value);
}
}
*act = normalize_array_to_unordered_redactions(act, exp, substitutions);
}
(Object(act), Object(exp)) => {
let has_key_wildcard =
Expand All @@ -324,6 +297,55 @@ fn normalize_value_to_unordered_redactions(
}
}

#[cfg(feature = "structured-data")]
fn normalize_array_to_unordered_redactions(
actual: &[serde_json::Value],
expected: &[serde_json::Value],
substitutions: &Redactions,
) -> Vec<serde_json::Value> {
if actual == expected {
return actual.to_owned();
}

let mut normalized: Vec<serde_json::Value> = Vec::new();
let mut actual_values = actual.to_owned();
let mut expected_values = expected.to_owned();
let mut elided = false;
expected_values.retain(|expected_value| {
let mut matched = false;
if expected_value == VALUE_WILDCARD {
matched = true;
elided = true;
} else {
actual_values.retain(|actual_value| {
let mut normalized_actual_value = actual_value.clone();
normalize_value_to_unordered_redactions(
&mut normalized_actual_value,
expected_value,
substitutions,
);
if !matched && normalized_actual_value == *expected_value {
matched = true;
false
} else {
true
}
});
}
if matched {
normalized.push(expected_value.clone());
}
!matched
});
if !elided {
for actual_value in actual_values {
normalized.push(actual_value);
}
}

normalized
}

fn normalize_str_to_unordered_redactions(
actual: &str,
expected: &str,
Expand Down Expand Up @@ -454,120 +476,124 @@ fn normalize_value_to_redactions(

#[cfg(feature = "structured-data")]
fn normalize_array_to_redactions(
input: &[serde_json::Value],
pattern: &[serde_json::Value],
actual: &[serde_json::Value],
expected: &[serde_json::Value],
redactions: &Redactions,
) -> Vec<serde_json::Value> {
if input == pattern {
return input.to_vec();
if actual == expected {
return actual.to_vec();
}

let mut normalized: Vec<serde_json::Value> = Vec::new();
let mut input_index = 0;
let mut pattern = pattern.iter().peekable();
while let Some(pattern_elem) = pattern.next() {
if pattern_elem == VALUE_WILDCARD {
let Some(next_pattern_elem) = pattern.peek() else {
let mut actual_index = 0;
let mut expected = expected.iter().peekable();
while let Some(expected_elem) = expected.next() {
if expected_elem == VALUE_WILDCARD {
let Some(next_expected_elem) = expected.peek() else {
// Stop as elide consumes to end
normalized.push(pattern_elem.clone());
input_index = input.len();
normalized.push(expected_elem.clone());
actual_index = actual.len();
break;
};
let Some(index_offset) = input[input_index..].iter().position(|next_input_elem| {
let mut next_input_elem = next_input_elem.clone();
normalize_value_to_redactions(&mut next_input_elem, next_pattern_elem, redactions);
next_input_elem == **next_pattern_elem
let Some(index_offset) = actual[actual_index..].iter().position(|next_actual_elem| {
let mut next_actual_elem = next_actual_elem.clone();
normalize_value_to_redactions(
&mut next_actual_elem,
next_expected_elem,
redactions,
);
next_actual_elem == **next_expected_elem
}) else {
// Give up as we can't find where the elide ends
break;
};
normalized.push(pattern_elem.clone());
input_index += index_offset;
normalized.push(expected_elem.clone());
actual_index += index_offset;
} else {
let Some(input_elem) = input.get(input_index) else {
let Some(actual_elem) = actual.get(actual_index) else {
// Give up as we have no more content to check
break;
};

input_index += 1;
let mut normalized_elem = input_elem.clone();
normalize_value_to_redactions(&mut normalized_elem, pattern_elem, redactions);
actual_index += 1;
let mut normalized_elem = actual_elem.clone();
normalize_value_to_redactions(&mut normalized_elem, expected_elem, redactions);
normalized.push(normalized_elem);
}
}

normalized.extend(input[input_index..].iter().cloned());
normalized.extend(actual[actual_index..].iter().cloned());
normalized
}

fn normalize_str_to_redactions(input: &str, pattern: &str, redactions: &Redactions) -> String {
if input == pattern {
return input.to_owned();
fn normalize_str_to_redactions(actual: &str, expected: &str, redactions: &Redactions) -> String {
if actual == expected {
return actual.to_owned();
}

let mut normalized: Vec<&str> = Vec::new();
let mut input_index = 0;
let input_lines: Vec<_> = crate::utils::LinesWithTerminator::new(input).collect();
let mut pattern_lines = crate::utils::LinesWithTerminator::new(pattern).peekable();
while let Some(pattern_line) = pattern_lines.next() {
if is_line_elide(pattern_line) {
let Some(next_pattern_line) = pattern_lines.peek() else {
let mut actual_index = 0;
let actual_lines: Vec<_> = crate::utils::LinesWithTerminator::new(actual).collect();
let mut expected_lines = crate::utils::LinesWithTerminator::new(expected).peekable();
while let Some(expected_line) = expected_lines.next() {
if is_line_elide(expected_line) {
let Some(next_expected_line) = expected_lines.peek() else {
// Stop as elide consumes to end
normalized.push(pattern_line);
input_index = input_lines.len();
normalized.push(expected_line);
actual_index = actual_lines.len();
break;
};
let Some(index_offset) =
input_lines[input_index..]
actual_lines[actual_index..]
.iter()
.position(|next_input_line| {
line_matches(next_input_line, next_pattern_line, redactions)
.position(|next_actual_line| {
line_matches(next_actual_line, next_expected_line, redactions)
})
else {
// Give up as we can't find where the elide ends
break;
};
normalized.push(pattern_line);
input_index += index_offset;
normalized.push(expected_line);
actual_index += index_offset;
} else {
let Some(input_line) = input_lines.get(input_index) else {
let Some(actual_line) = actual_lines.get(actual_index) else {
// Give up as we have no more content to check
break;
};

if line_matches(input_line, pattern_line, redactions) {
input_index += 1;
normalized.push(pattern_line);
if line_matches(actual_line, expected_line, redactions) {
actual_index += 1;
normalized.push(expected_line);
} else {
// Skip this line and keep processing
input_index += 1;
normalized.push(input_line);
actual_index += 1;
normalized.push(actual_line);
}
}
}

normalized.extend(input_lines[input_index..].iter().copied());
normalized.extend(actual_lines[actual_index..].iter().copied());
normalized.join("")
}

fn is_line_elide(line: &str) -> bool {
line == "...\n" || line == "..."
}

fn line_matches(mut input: &str, pattern: &str, redactions: &Redactions) -> bool {
if input == pattern {
fn line_matches(mut actual: &str, expected: &str, redactions: &Redactions) -> bool {
if actual == expected {
return true;
}

let pattern = redactions.clear(pattern);
let mut sections = pattern.split("[..]").peekable();
let expected = redactions.clear(expected);
let mut sections = expected.split("[..]").peekable();
while let Some(section) = sections.next() {
if let Some(remainder) = input.strip_prefix(section) {
if let Some(remainder) = actual.strip_prefix(section) {
if let Some(next_section) = sections.peek() {
if next_section.is_empty() {
input = "";
actual = "";
} else if let Some(restart_index) = remainder.find(next_section) {
input = &remainder[restart_index..];
actual = &remainder[restart_index..];
}
} else {
return remainder.is_empty();
Expand Down
Loading