photocraft/crates/engine/tests/it/average_smart.rs

//! Exercise Average through the smart-filter renderer, not an imported cache.
use photocraft_doc::LayerContent;
use photocraft_engine::{Session, filters, smart_cmds};
use photocraft_geom::Rect;
use photocraft_raster::Surface;
use serde_json::json;

fn image(s: &Session) -> Surface {
    let d = s.active().unwrap();
    let l = d.doc.layer(d.active_layer.unwrap()).unwrap();
    match &l.content {
        LayerContent::Raster(r) => r.clone(),
        LayerContent::Smart(sm) => sm.cache.clone().unwrap(),
        _ => panic!("expected pixels"),
    }
}

fn input(depth: u32) -> Session {
    let mut s = Session::new();
    s.execute("file.new", json!({"width": 16, "height": 16, "depth": depth})).unwrap();
    s.execute("layer.new.layer", json!({})).unwrap();
    let d = s.active_mut().unwrap();
    let l = std::sync::Arc::make_mut(&mut d.doc).layer_mut(d.active_layer.unwrap()).unwrap();
    let surf = l.surface_mut().unwrap();
    for y in 0..16 {
        for x in 0..16 {
            surf.write_region(Rect::new(x, y, x + 1, y + 1), if x < 8 { &[1.0, 0.0, 0.0, 1.0] } else { &[0.0, 0.0, 1.0, 1.0] });
        }
    }
    s
}

fn purple(surf: &Surface) {
    for p in surf.read_region(Rect::new(0, 0, 16, 16)).as_chunks::<4>().0 {
        assert!((p[0] - 0.5).abs() <= 1.0 / 255.0, "{p:?}");
        assert_eq!(p[1], 0.0);
        assert!((p[2] - 0.5).abs() <= 1.0 / 255.0, "{p:?}");
        assert_eq!(p[3], 1.0);
    }
}

#[test]
fn average_stored_filter_executes() {
    for depth in [8, 16, 32] {
        let s = input(depth);
        let bounds = s.active().unwrap().doc.bounds();
        let out = filters::apply_filter_to_surface("filter.blur.average", &json!({}), &image(&s), bounds, None, bounds)
            .unwrap()
            .expect("Average must be executable, not treated as an unknown filter");
        purple(&out);
    }
}

#[test]
fn average_smart_command_rerenders_and_undoes() {
    for depth in [8, 16, 32] {
        let mut s = input(depth);
        s.execute("filter.convertForSmartFilters", json!({})).unwrap();
        let before = image(&s);
        let steps = s.active().unwrap().history.past_len();
        assert!(s.is_enabled("filter.blur.average"));
        s.execute("filter.blur.average", json!({})).unwrap();
        assert_eq!(s.active().unwrap().history.past_len(), steps + 1);
        purple(&image(&s));
        assert!(s.undo());
        assert_eq!(image(&s), before);
        assert!(s.redo());
        purple(&image(&s));
        s.execute("layer.smartFilter.setVisible", json!({"index": 0, "visible": false})).unwrap();
        assert_eq!(image(&s), before);
        s.execute("layer.smartFilter.setVisible", json!({"index": 0, "visible": true})).unwrap();
        let d = s.active_mut().unwrap();
        let snapshot = d.doc.clone();
        let layer = std::sync::Arc::make_mut(&mut d.doc).layer_mut(d.active_layer.unwrap()).unwrap();
        if let LayerContent::Smart(sm) = &mut layer.content {
            assert_eq!(sm.smart_filters.len(), 1);
            assert_eq!(sm.smart_filters[0].command, "filter.blur.average");
            sm.cache = None;
        }
        smart_cmds::purge_stack_cache();
        assert!(smart_cmds::refresh_layer(&snapshot, layer).unwrap());
        purple(&image(&s));
    }
}

#[test]
fn average_rejects_bad_params_without_an_edit() {
    let mut s = input(8);
    let before = image(&s);
    let steps = s.active().unwrap().history.past_len();
    for params in [json!("bad"), json!({"unknown": 1}), json!({"layer": -1}), json!({"target": false})] {
        assert!(s.execute("filter.blur.average", params).is_err());
        assert_eq!(image(&s), before);
        assert_eq!(s.active().unwrap().history.past_len(), steps);
    }
}

/// Optional local oracle: generate a 16×16 red/blue Smart Object in Photoshop, apply Average,
/// save as PSD, then set PHOTOCRAFT_AVERAGE_PSD to that file. Never accept cached pixels as proof.
#[test]
#[ignore = "requires a locally generated Photoshop Average PSD; see docs/average-filter.md"]
fn average_photoshop_psd_rerenders_from_source() {
    let path = std::env::var("PHOTOCRAFT_AVERAGE_PSD").expect("set PHOTOCRAFT_AVERAGE_PSD");
    let bytes = std::fs::read(&path).unwrap();
    let mut doc = photocraft_io::import(&path, &bytes).unwrap().document;
    let snapshot = doc.clone();
    let ids: Vec<_> = snapshot
        .walk()
        .into_iter()
        .filter_map(|(_, _, l)| match &l.content {
            LayerContent::Smart(sm) if sm.smart_filters.iter().any(|f| f.command == "filter.blur.average") => Some(l.id),
            _ => None,
        })
        .collect();
    assert_eq!(ids.len(), 1);
    let layer = doc.layer_mut(ids[0]).unwrap();
    if let LayerContent::Smart(sm) = &mut layer.content {
        sm.cache = None;
    }
    smart_cmds::purge_stack_cache();
    assert!(smart_cmds::refresh_layer(&snapshot, layer).unwrap());
    let LayerContent::Smart(sm) = &layer.content else { panic!("expected smart object") };
    purple(sm.cache.as_ref().unwrap());
}