saccade 0.3.0

Visual-regression CLI for renderers and graphics code, built on NVIDIA FLIP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! CLI adapters for test-runner screenshot files. No test runner is executed.
use crate::agent::CliError;
use clap::{Args, Subcommand};
use std::path::PathBuf;

#[derive(Args)]
pub(crate) struct IngestArgs {
    #[command(subcommand)]
    operation: IngestOperation,
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod containment_tests {
    use super::*;
    use std::path::Path;
    #[test]
    fn manifest_paths_reject_parent_absolute_and_symlink_escape() {
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path().join("run");
        std::fs::create_dir(&root).unwrap();
        let outside = temp.path().join("outside.png");
        std::fs::write(&outside, b"image").unwrap();
        assert!(contained_source(&root, Path::new("../outside.png")).is_err());
        assert!(contained_source(&root, &outside).is_err());
        #[cfg(unix)]
        {
            std::os::unix::fs::symlink(&outside, root.join("link.png")).unwrap();
            assert!(contained_source(&root, Path::new("link.png")).is_err());
        }
    }
}

#[derive(Subcommand)]
enum IngestOperation {
    /// Pair Blender render report category/ref images with category renders.
    Blender {
        root: PathBuf,
        #[arg(long)]
        out: PathBuf,
        #[arg(long)]
        json: bool,
    },
    /// Pair Bevy screenshot-N.png files from two runs.
    Bevy {
        reference: PathBuf,
        capture: PathBuf,
        #[arg(long)]
        out: PathBuf,
        #[arg(long)]
        json: bool,
    },
    /// Pair Unity Graphics Test Framework ReferenceImages and ActualImages.
    Unity {
        assets: PathBuf,
        #[arg(long)]
        out: PathBuf,
        #[arg(long)]
        json: bool,
    },
    /// Read Unreal screenshot comparison result paths from JSON.
    Unreal {
        results: PathBuf,
        #[arg(long)]
        out: PathBuf,
        #[arg(long)]
        json: bool,
    },
    /// Compare expected and actual Playwright screenshot attachments.
    Playwright {
        /// Manifest written by integrations/playwright/reporter.cjs.
        manifest: PathBuf,
        /// New directory for paired inputs and the comparison report.
        #[arg(long)]
        out: PathBuf,
        /// Print the bounded comparison result.
        #[arg(long)]
        json: bool,
        /// FLIP threshold for the comparison.
        #[arg(long)]
        threshold: Option<f64>,
    },
}

pub(crate) fn contained_source(
    root: &std::path::Path,
    relative: &std::path::Path,
) -> Result<PathBuf, CliError> {
    Ok(saccade_core::workflows::ingest::contained_source(
        root, relative,
    )?)
}
pub(crate) fn run(args: IngestArgs, absolute: bool) -> Result<u8, CliError> {
    match args.operation {
        IngestOperation::Blender { root, out, json } => crate::engine_ingest::run(
            crate::engine_ingest::Format::Blender(root),
            &out,
            json,
            absolute,
        ),
        IngestOperation::Bevy {
            reference,
            capture,
            out,
            json,
        } => crate::engine_ingest::run(
            crate::engine_ingest::Format::Bevy(reference, capture),
            &out,
            json,
            absolute,
        ),
        IngestOperation::Unity { assets, out, json } => crate::engine_ingest::run(
            crate::engine_ingest::Format::Unity(assets),
            &out,
            json,
            absolute,
        ),
        IngestOperation::Unreal { results, out, json } => crate::engine_ingest::run(
            crate::engine_ingest::Format::Unreal(results),
            &out,
            json,
            absolute,
        ),
        IngestOperation::Playwright {
            manifest,
            out,
            json,
            threshold,
        } => {
            let result = saccade_core::workflows::ingest::run_playwright(
                &manifest,
                &out,
                threshold,
                absolute,
                crate::signed_approval::policy(),
            )?;
            for warning in &result.warnings {
                eprintln!("{warning}");
            }
            if !json && let Some(coverage) = &result.coverage {
                crate::emit(&format!(
                    "capture coverage: {coverage}; see inventory.json\n"
                ))?;
            }
            crate::emit_run(&result.report, &result.report_dir, json, absolute)?;
            Ok(u8::from(result.report.is_regression() || result.incomplete))
        }
    }
}