Detecting dead snapshots

Author: spirali

.cargo/config.toml

@@ -1,2 +1,2 @@
 [alias]
-xtask_image_diff_report = "run --package xtask_image_diff_report --"
+xtask-test = "run --package xtask_test --"

Cargo.lock

@@ -6,7 +6,7 @@ members = [
     "examples/tiny_skia_render",
     "examples/swash_render",
     "examples/vello_editor",
-    "xtask_image_diff_report",
+    "xtask_test",
 ]
 
 [workspace.package]

Cargo.toml

@@ -70,6 +70,12 @@ fn is_accept_mode() -> bool {
         .unwrap_or(false)
 }
 
+fn is_generate_all_mode() -> bool {
+    std::env::var("PARLEY_TEST")
+        .map(|x| x.to_ascii_lowercase() == "generate-all")
+        .unwrap_or(false)
+}
+
 pub(crate) fn load_fonts_dir(collection: &mut Collection, path: &Path) -> std::io::Result<()> {
     let paths = std::fs::read_dir(path)?;
     for entry in paths {
@@ -255,6 +261,9 @@ impl TestEnv {
         let snapshot_path = snapshot_dir().join(&image_name);
         let comparison_path = current_imgs_dir().join(&image_name);
 
+        if is_generate_all_mode() {
+            current_img.save_png(&comparison_path).unwrap();
+        }
         if let Err(e) = self.check_images(&current_img, &snapshot_path) {
             if is_accept_mode() {
                 current_img.save_png(&snapshot_path).unwrap();

parley/src/tests/utils/env.rs

@@ -20,5 +20,5 @@ It will update snapshots of the failed tests.
 If you want to create a report with image diffs use:
 
 ```bash
-$ cargo xtask_image_diff_report
+$ cargo xtask-test report
 ```

parley/tests/README.md

@@ -1,5 +1,5 @@
 [package]
-name = "xtask_image_diff_report"
+name = "xtask_test"
 version = "0.1.0"
 edition.workspace = true
 rust-version.workspace = true

xtask_image_diff_report/README.md

@@ -0,0 +1,13 @@
+# xtask-test
+
+For creating a report for failed snapshot tests run:
+
+```commandline
+$ cargo xtask-test report
+```
+
+For showing dead snapshots run:
+
+```commandline
+$ cargo xtask-test dead-snapshots
+```

xtask_image_diff_report/src/main.rs

@@ -0,0 +1,102 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! # `xtask_test`
+//!
+//! xtask with helper utilities for snapshot testing
+
+use image_diff_review::{CompareConfig, Error, ImageDiff, ReportConfig};
+use std::collections::BTreeSet;
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn create_report(
+    current_path: &Path,
+    snapshot_path: &Path,
+    output_path: &Path,
+) -> Result<(), Error> {
+    let mut config = CompareConfig::default();
+    config.set_ignore_left_missing(true);
+
+    let mut image_diff = ImageDiff::default();
+    image_diff.compare_directories(&config, current_path, snapshot_path)?;
+
+    let mut report_config = ReportConfig::default();
+    report_config.set_left_title("Current test");
+    report_config.set_right_title("Snapshot");
+    image_diff.create_report(&report_config, output_path, true)?;
+    Ok(())
+}
+
+fn list_image_dir(dir_path: &Path) -> Result<impl Iterator<Item = PathBuf>, std::io::Error> {
+    Ok(std::fs::read_dir(dir_path)?.filter_map(|entry| {
+        if let Ok(entry) = entry {
+            let path = entry.path();
+            if path
+                .extension()
+                .and_then(OsStr::to_str)
+                .map(|ext| ext == "png")
+                .unwrap_or(false)
+            {
+                Some(path)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }))
+}
+
+fn clean_image_path(dir_path: &Path) -> Result<(), std::io::Error> {
+    list_image_dir(dir_path)?.try_for_each(|path| std::fs::remove_file(&path))
+}
+
+fn detect_dead_snapshots(current_path: &Path, snapshot_path: &Path) -> Result<(), Error> {
+    clean_image_path(current_path)?;
+    let cargo = std::env::var("CARGO").unwrap();
+    Command::new(&cargo)
+        .arg("test")
+        .env("PARLEY_TEST", "generate-all")
+        .status()?;
+
+    let current_imgs: BTreeSet<String> = list_image_dir(current_path)?
+        .map(|r| r.file_name().unwrap().to_string_lossy().to_string())
+        .collect();
+    let snapshot_imgs: BTreeSet<String> = list_image_dir(snapshot_path)?
+        .map(|r| r.file_name().unwrap().to_string_lossy().to_string())
+        .collect();
+    let dead_paths: Vec<String> = snapshot_imgs.difference(&current_imgs).cloned().collect();
+
+    if dead_paths.is_empty() {
+        println!("No dead snapshots detected");
+    } else {
+        println!("========== DEAD SNAPSHOTS ==========");
+        for path in &dead_paths {
+            println!("{}", path);
+        }
+    }
+    clean_image_path(current_path)?;
+    Ok(())
+}
+
+fn main() -> Result<(), Error> {
+    let test_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .join("parley")
+        .join("tests");
+    let current_path = test_dir.join("current");
+    let snapshot_path = test_dir.join("snapshots");
+    match std::env::args().nth(1).as_deref() {
+        Some("clean") => clean_image_path(&current_path)?,
+        Some("report") => {
+            let output_path = test_dir.join("report.html");
+            create_report(&current_path, &snapshot_path, &output_path)?;
+        }
+        Some("dead-snapshots") => detect_dead_snapshots(&current_path, &snapshot_path)?,
+        _ => println!("Invalid command\n\nCommands:\n- clean: Clean 'current' directory\n- report: Create report with image diffs\n- dead-snapshots: print dead snapshots"),
+    }
+    Ok(())
+}