750-snapshot-testing — Snapshot Testing

pub fn assert_snapshot(name: &str, actual: &str) {
    let path = snapshot_path(name);
    
    if !path.exists() || should_update() {
        fs::write(&path, actual)?;
        return;
    }
    
    let expected = fs::read_to_string(&path)?;
    if actual != expected {
        panic!("Snapshot mismatch!\n{}", compute_diff(&expected, &actual));
    }
}

let%expect_test "render report" =
  let report = render_report [("Widget", 10); ("Gadget", 20)] in
  print_string report;
  [%expect {|
    === Sales Report ===
      1. Widget               10
      2. Gadget               20
    ====================
    Total items: 2
    Total qty:   30
  |}]

#![allow(clippy::all)]
//! # Snapshot Testing
//!
//! Expect files pattern for testing complex output (std-only).

use std::env;
use std::fs;
use std::path::Path;

/// Render a sales report
pub fn render_report(data: &[(&str, u32)]) -> String {
    let mut out = String::new();
    out.push_str("=== Sales Report ===\n");
    for (i, (name, qty)) in data.iter().enumerate() {
        out.push_str(&format!("{:3}. {:<20} {}\n", i + 1, name, qty));
    }
    out.push_str("====================\n");
    let total: u32 = data.iter().map(|(_, q)| q).sum();
    out.push_str(&format!("Total items: {}\n", data.len()));
    out.push_str(&format!("Total qty:   {}\n", total));
    out
}

/// Render a JSON-like structure
pub fn render_json_like(keys: &[&str], values: &[i64]) -> String {
    let pairs: Vec<String> = keys
        .iter()
        .zip(values.iter())
        .map(|(k, v)| format!("  \"{}\": {}", k, v))
        .collect();
    format!("{{\n{}\n}}", pairs.join(",\n"))
}

/// Snapshot directory
const SNAPSHOT_DIR: &str = "tests/snapshots";

/// Check if we should update snapshots
pub fn should_update() -> bool {
    env::var("UPDATE_SNAPSHOTS")
        .map(|v| v == "1")
        .unwrap_or(false)
}

/// Get the path to a snapshot file
pub fn snapshot_path(name: &str) -> std::path::PathBuf {
    Path::new(SNAPSHOT_DIR).join(format!("{}.snap", name))
}

/// Assert that `actual` matches the stored snapshot.
///
/// Creates the snapshot on first run; fails on mismatch unless UPDATE_SNAPSHOTS=1.
pub fn assert_snapshot(name: &str, actual: &str) {
    let path = snapshot_path(name);

    if !path.exists() || should_update() {
        fs::create_dir_all(SNAPSHOT_DIR).expect("could not create snapshot dir");
        fs::write(&path, actual).expect("could not write snapshot");
        return;
    }

    let expected = fs::read_to_string(&path).expect("could not read snapshot file");

    let actual_norm = actual.replace("\r\n", "\n");
    let expected_norm = expected.replace("\r\n", "\n");

    if actual_norm != expected_norm {
        let diff = compute_diff(&expected_norm, &actual_norm);
        panic!(
            "Snapshot '{}' mismatch!\n\
             To update: UPDATE_SNAPSHOTS=1 cargo test\n\n\
             Diff:\n{}",
            name, diff
        );
    }
}

/// Compute a simple line-by-line diff
pub fn compute_diff(expected: &str, actual: &str) -> String {
    let exp_lines: Vec<&str> = expected.lines().collect();
    let act_lines: Vec<&str> = actual.lines().collect();
    let mut diff = String::new();
    let max = exp_lines.len().max(act_lines.len());
    for i in 0..max {
        let e = exp_lines.get(i).unwrap_or(&"");
        let a = act_lines.get(i).unwrap_or(&"");
        if e != a {
            diff.push_str(&format!("- {}\n+ {}\n", e, a));
        }
    }
    diff
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_render_report_empty() {
        let report = render_report(&[]);
        assert!(report.contains("=== Sales Report ==="));
        assert!(report.contains("Total items: 0"));
    }

    #[test]
    fn test_render_report_with_data() {
        let data = [("Widget", 10), ("Gadget", 20)];
        let report = render_report(&data);
        assert!(report.contains("Widget"));
        assert!(report.contains("Gadget"));
        assert!(report.contains("Total qty:   30"));
    }

    #[test]
    fn test_render_json_like() {
        let output = render_json_like(&["a", "b"], &[1, 2]);
        assert!(output.contains("\"a\": 1"));
        assert!(output.contains("\"b\": 2"));
    }

    #[test]
    fn test_compute_diff_identical() {
        let diff = compute_diff("hello\nworld", "hello\nworld");
        assert!(diff.is_empty());
    }

    #[test]
    fn test_compute_diff_different() {
        let diff = compute_diff("hello", "world");
        assert!(diff.contains("- hello"));
        assert!(diff.contains("+ world"));
    }

    #[test]
    fn test_snapshot_path() {
        let path = snapshot_path("my_test");
        assert!(path.ends_with("my_test.snap"));
    }
}

(* 750: Snapshot Testing — OCaml manual expect-file pattern *)

let read_file path =
  try
    let ic = open_in path in
    let n = in_channel_length ic in
    let s = Bytes.create n in
    really_input ic s 0 n;
    close_in ic;
    Some (Bytes.to_string s)
  with Sys_error _ -> None

let write_file path content =
  let oc = open_out path in
  output_string oc content;
  close_out oc

(* The function we're snapshot-testing *)
let render_report data =
  let lines = List.mapi (fun i (k, v) ->
    Printf.sprintf "%3d. %-20s %d" (i+1) k v
  ) data in
  "=== Sales Report ===\n"
  ^ String.concat "\n" lines
  ^ "\n==================\n"
  ^ Printf.sprintf "Total: %d items\n" (List.length data)

(* Snapshot assertion *)
let assert_snapshot name actual =
  let path = Printf.sprintf "tests/snapshots/%s.expected" name in
  match read_file path with
  | None ->
    (* First run: create snapshot *)
    (try Unix.mkdir "tests" 0o755 with Unix.Unix_error _ -> ());
    (try Unix.mkdir "tests/snapshots" 0o755 with Unix.Unix_error _ -> ());
    write_file path actual;
    Printf.printf "[snapshot:%s] Created snapshot\n" name
  | Some expected ->
    if actual = expected
    then Printf.printf "[snapshot:%s] OK\n" name
    else begin
      Printf.printf "[snapshot:%s] MISMATCH!\n" name;
      Printf.printf "Expected:\n%s\nActual:\n%s\n" expected actual;
      failwith "snapshot mismatch"
    end

let () =
  let data = [("Apples", 42); ("Bananas", 17); ("Cherries", 99)] in
  let report = render_report data in
  assert_snapshot "sales_report" report;
  Printf.printf "Snapshot tests done!\n"