add similar library to render diffs from regression test results

Cargo.toml

@@ -41,8 +41,11 @@ erased-serde = "0.4.10"
 
 [dev-dependencies]
 assert_cmd = "2.2.2"
+colored = "3.0.0"
 map-macro = "0.3.0"
+ordered-float = "5.1.0"
 rstest = {version = "0.26.1", default-features = false, features = ["crate-name"]}
+similar = "3.1.0"
 yaml-rust2 = {version = "0.11.0", default-features = false}
 
 [build-dependencies]

tests/regression.rs

@@ -1,8 +1,12 @@
 //! Common code for running regression tests.
 use anyhow::Result;
+use colored::Colorize;
 use float_cmp::approx_eq;
 use itertools::Itertools;
+use ordered_float::NotNan;
+use similar::{Algorithm, DiffOp, DiffTag, capture_diff_slices};
 use std::env;
+use std::fmt::Write as _;
 use std::fs::{File, read_dir};
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
@@ -95,50 +99,151 @@ fn compare_lines(
     let lines1 = read_lines(&output_dir1.join(file_name));
     let lines2 = read_lines(&output_dir2.join(file_name));
 
-    // Check for different number of lines
-    if lines1.len() != lines2.len() {
-        errors.push(format!(
-            "{file_name}: Different number of lines: {} vs {}",
-            lines1.len(),
-            lines2.len()
-        ));
+    // Check whether files differ using the existing field-by-field tolerance rules.
+    let mut has_mismatch = lines1.len() != lines2.len();
+    if !has_mismatch {
+        has_mismatch = lines1
+            .iter()
+            .zip(&lines2)
+            .any(|(line1, line2)| !compare_line(line1, line2));
     }
 
-    // Compare each line
-    for (idx, (line1, line2)) in lines1.into_iter().zip(lines2).enumerate() {
-        let line_num = idx + 1; // (1-based) line number
-        if !compare_line(line_num, &line1, &line2, file_name, errors) {
-            errors.push(format!(
-                "{file_name}: line {line_num}:\n    + \"{line1}\"\n    - \"{line2}\""
-            ));
-        }
+    if has_mismatch {
+        let diff_ops = capture_csv_diff_ops(&lines1, &lines2);
+        let diff = render_diff(&diff_ops, &lines1, &lines2);
+        errors.push(format!("{file_name}: output differs\n{diff}"));
     }
 }
 
-fn compare_line(
-    num: usize,
-    line1: &str,
-    line2: &str,
-    file_name: &str,
-    errors: &mut Vec<String>,
-) -> bool {
+fn compare_line(line1: &str, line2: &str) -> bool {
     let fields1 = line1.split(',').collect_vec();
     let fields2 = line2.split(',').collect_vec();
     if fields1.len() != fields2.len() {
-        errors.push(format!(
-            "{}: line {}: Different number of fields: {} vs {}",
-            file_name,
-            num,
-            fields1.len(),
-            fields2.len()
-        ));
+        return false;
     }
 
-    // Check every field matches
-    fields1.into_iter().zip(fields2).all(|(f1, f2)| {
-        // First try to compare fields as floating-point values, falling back on string comparison
-        try_compare_floats(f1, f2).unwrap_or_else(|| f1 == f2)
-    })
+    fields1
+        .into_iter()
+        .zip(fields2)
+        .all(|(f1, f2)| try_compare_floats(f1, f2).unwrap_or_else(|| f1 == f2))
+}
+
+fn capture_csv_diff_ops(lines1: &[String], lines2: &[String]) -> Vec<DiffOp> {
+    let parsed1 = parse_csv_lines(lines1);
+    let parsed2 = parse_csv_lines(lines2);
+    capture_diff_slices(Algorithm::Myers, &parsed1, &parsed2)
+}
+
+fn has_non_equal_diff_ops(diff_ops: &[DiffOp]) -> bool {
+    diff_ops.iter().any(|op| op.tag() != DiffTag::Equal)
+}
+
+/// Render a line-based diff from `DiffOp`s, including old/new line numbers.
+/// For replaced lines, pairs that are equal under `compare_line` are omitted.
+fn render_diff(diff_ops: &[DiffOp], lines1: &[String], lines2: &[String]) -> String {
+    let mut out = String::new();
+    for op in diff_ops {
+        let (tag, old_range, new_range) = op.as_tag_tuple();
+        match tag {
+            DiffTag::Equal => {}
+            DiffTag::Delete => {
+                for old_idx in old_range {
+                    let _ = writeln!(
+                        out,
+                        "{}",
+                        format!("-L{}: {}", old_idx + 1, lines1[old_idx]).red()
+                    );
+                }
+            }
+            DiffTag::Insert => {
+                for new_idx in new_range {
+                    let _ = writeln!(
+                        out,
+                        "{}",
+                        format!("+L{}: {}", new_idx + 1, lines2[new_idx]).green()
+                    );
+                }
+            }
+            DiffTag::Replace => {
+                let old_start = old_range.start;
+                let new_start = new_range.start;
+                let paired_len = old_range.len().min(new_range.len());
+
+                for idx in 0..paired_len {
+                    let old_idx = old_start + idx;
+                    let new_idx = new_start + idx;
+                    if !compare_line(&lines1[old_idx], &lines2[new_idx]) {
+                        let _ = writeln!(
+                            out,
+                            "{}",
+                            format!("-L{}: {}", old_idx + 1, lines1[old_idx]).red()
+                        );
+                        let _ = writeln!(
+                            out,
+                            "{}",
+                            format!("+L{}: {}", new_idx + 1, lines2[new_idx]).green()
+                        );
+                    }
+                }
+
+                for (old_idx, line) in lines1
+                    .iter()
+                    .enumerate()
+                    .take(old_range.end)
+                    .skip(old_start + paired_len)
+                {
+                    let _ = writeln!(out, "{}", format!("-L{}: {}", old_idx + 1, line).red());
+                }
+                for (new_idx, line) in lines2
+                    .iter()
+                    .enumerate()
+                    .take(new_range.end)
+                    .skip(new_start + paired_len)
+                {
+                    let _ = writeln!(out, "{}", format!("+L{}: {}", new_idx + 1, line).green());
+                }
+            }
+        }
+    }
+
+    out
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct CsvLine(Vec<CsvField>);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum CsvField {
+    Float(NotNan<f64>),
+    Text(String),
+}
+
+fn parse_csv_lines(lines: &[String]) -> Vec<CsvLine> {
+    lines.iter().map(|line| parse_csv_line(line)).collect()
+}
+
+fn parse_csv_line(line: &str) -> CsvLine {
+    CsvLine(line.split(',').map(parse_csv_field).collect())
+}
+
+fn parse_csv_field(field: &str) -> CsvField {
+    if let Some(float) = parse_finite(field) {
+        CsvField::Float(quantise_float(float))
+    } else {
+        CsvField::Text(field.to_string())
+    }
+}
+
+fn quantise_float(value: f64) -> NotNan<f64> {
+    let scaled = value / FLOAT_CMP_TOLERANCE;
+    let quantised = if scaled.is_finite() {
+        scaled.round() * FLOAT_CMP_TOLERANCE
+    } else {
+        value
+    };
+
+    let quantised = if quantised == -0.0 { 0.0 } else { quantised };
+    NotNan::new(quantised).expect("quantised float should always be finite")
 }
 
 /// Parse a string into an `f64`, returning `None` if parsing fails or value is infinite/NaN
@@ -185,3 +290,98 @@ fn read_lines(path: &Path) -> Vec<String> {
         .map_while(Result::ok)
         .collect()
 }
+
+#[test]
+fn tolerated_float_change_yields_no_diff_ops() {
+    let old_lines = vec!["asset,1.00000000001".to_string()];
+    let new_lines = vec!["asset,1.00000000002".to_string()];
+
+    let diff_ops = capture_csv_diff_ops(&old_lines, &new_lines);
+    assert!(!has_non_equal_diff_ops(&diff_ops));
+}
+
+#[test]
+fn parse_csv_lines_normalises_floats_within_tolerance() {
+    let lines1 = vec![
+        "asset_a,1.000000000001,region_1".to_string(),
+        "asset_b,2.5,region_2".to_string(),
+    ];
+    let lines2 = vec![
+        "asset_a,1.000000000002,region_1".to_string(),
+        "asset_b,2.5,region_2".to_string(),
+    ];
+
+    let parsed1 = parse_csv_lines(&lines1);
+    let parsed2 = parse_csv_lines(&lines2);
+
+    assert_eq!(parsed1, parsed2);
+}
+
+#[test]
+fn render_diff_ignores_tolerated_float_changes() {
+    let old_lines = vec![
+        "asset_a,1.00000000001".to_string(),
+        "asset_b,2.0".to_string(),
+    ];
+    let new_lines = vec![
+        "asset_a,1.00000000002".to_string(),
+        "asset_b,3.0".to_string(),
+    ];
+
+    let diff_ops = capture_csv_diff_ops(&old_lines, &new_lines);
+    let diff = render_diff(&diff_ops, &old_lines, &new_lines);
+
+    assert!(!diff.contains("asset_a"));
+    assert!(diff.contains("asset_b,2.0"));
+    assert!(diff.contains("asset_b,3.0"));
+}
+
+#[test]
+fn render_diff_ignores_tolerated_float_differences_one_line_missing() {
+    let old_lines = vec![
+        "asset_a,1.000000000001".to_string(),
+        "asset_b,2.000000000001".to_string(),
+        "asset_c,3.0".to_string(),
+        "asset_d,4.000000000001".to_string(),
+        "asset_e,5.000000000001".to_string(),
+        "asset_f,6.000000000001".to_string(),
+    ];
+    let new_lines = vec![
+        "asset_a,1.000000000002".to_string(),
+        "asset_b,2.000000000002".to_string(),
+        "asset_d,4.000000000002".to_string(),
+        "asset_e,5.000000000002".to_string(),
+        "asset_f,6.000000000002".to_string(),
+    ];
+
+    let diff_ops = capture_csv_diff_ops(&old_lines, &new_lines);
+    let diff = render_diff(&diff_ops, &old_lines, &new_lines);
+
+    assert!(!diff.contains("asset_a"));
+    assert!(!diff.contains("asset_b"));
+    assert!(!diff.contains("asset_d"));
+    assert!(!diff.contains("asset_e"));
+    assert!(!diff.contains("asset_f"));
+    assert!(diff.contains("-L3: asset_c,3.0"));
+    assert!(!diff.contains("asset_c,9.0"));
+}
+
+#[test]
+fn render_diff_ignores_quantisation_boundary_tolerance_case() {
+    let old_lines = vec![
+        "asset_a,25.852906323049822".to_string(),
+        "asset_b,2.0".to_string(),
+    ];
+    let new_lines = vec![
+        "asset_a,25.852906323050078".to_string(),
+        "asset_b,3.0".to_string(),
+    ];
+
+    // `asset_a` differs only within tolerance, while `asset_b` is a real change.
+    let diff_ops = capture_csv_diff_ops(&old_lines, &new_lines);
+    let diff = render_diff(&diff_ops, &old_lines, &new_lines);
+
+    assert!(!diff.contains("asset_a"));
+    assert!(diff.contains("-L2: asset_b,2.0"));
+    assert!(diff.contains("+L2: asset_b,3.0"));
+}