vectorcraft/crates/engine/src/tests/linkwatch.rs

//! Linked files changing while their document is open (`link_watch`): `links.updateChanged`,
//! and the background look following Preferences → File Handling → Update Links.

use std::sync::atomic::Ordering;

use serde_json::{Value, json};

use crate::tests_links::{BLUE, Folder, RED, centre_colour, place, png, session};
use crate::*;

/// Write `bytes` to `path`, dated 2 s after the file it replaces so its modification time moves
/// even on coarse file systems.
fn save(path: &str, bytes: &[u8]) {
    let stamp = std::fs::metadata(path).unwrap().modified().unwrap();
    std::fs::write(path, bytes).unwrap();
    let later = std::fs::FileTimes::new().set_modified(stamp + std::time::Duration::from_secs(2));
    std::fs::OpenOptions::new().write(true).open(path).unwrap().set_times(later).unwrap();
}

fn colour(s: &Session) -> [u8; 3] {
    centre_colour(&s.doc().unwrap().doc)
}

/// One background look, waited for.
fn look(s: &mut Session) -> Value {
    s.start_link_scan();
    s.wait_link_scan();
    s.poll_link_scan().expect("a look ran").unwrap()
}

#[test]
fn update_changed_reads_changed_files_again_once() {
    let dir = Folder::new("watch-update");
    let path = dir.file("art.png");
    std::fs::write(&path, png(40, 40, RED)).unwrap();
    let mut s = session();
    let id = place(&mut s, &path);
    // First look: remembered, nothing to read.
    assert_eq!(s.execute("links.updateChanged", &json!({})).unwrap()["updated"], json!([]));
    save(&path, &png(40, 40, BLUE));
    assert_eq!(s.execute("links.updateChanged", &json!({})).unwrap()["updated"], json!([id.0]));
    assert_eq!(colour(&s), BLUE);
    // Undoing it is respected: the link stays modified until the file changes again.
    s.execute("edit.undo", &json!({})).unwrap();
    assert_eq!(colour(&s), RED);
    assert_eq!(s.execute("links.updateChanged", &json!({})).unwrap()["updated"], json!([]));
    assert_eq!(s.execute("links.check", &json!({})).unwrap()["modified"], 1);
}

#[test]
fn a_background_look_follows_update_links() {
    for (mode, key) in [("automatically", "updated"), ("askWhenModified", "ask"), ("manually", "modified")] {
        let dir = Folder::new(&format!("watch-{mode}"));
        let path = dir.file("art.png");
        std::fs::write(&path, png(40, 40, RED)).unwrap();
        let mut s = session();
        s.prefs.update_links = mode.into();
        let id = place(&mut s, &path);
        assert_eq!(look(&mut s), json!({"updated": [], "ask": [], "modified": []}), "{mode}");
        save(&path, &png(40, 40, BLUE));
        let r = look(&mut s);
        assert_eq!(r[key], json!([id.0]), "{mode}: {r}");
        assert_eq!(colour(&s), if mode == "automatically" { BLUE } else { RED }, "{mode}");
        // Acted on once: the next look finds nothing new.
        assert_eq!(look(&mut s), json!({"updated": [], "ask": [], "modified": []}), "{mode}");
        assert!(s.link_scan.is_none());
    }
}

#[test]
fn a_file_still_being_written_is_tried_again() {
    let dir = Folder::new("watch-partial");
    let path = dir.file("art.png");
    std::fs::write(&path, png(40, 40, RED)).unwrap();
    let mut s = session();
    s.prefs.update_links = "automatically".into();
    let id = place(&mut s, &path);
    look(&mut s);
    // Another app has only written the start of the file so far.
    let full = png(40, 40, BLUE);
    save(&path, &full[..16]);
    assert_eq!(look(&mut s)["updated"], json!([]));
    assert_eq!(colour(&s), RED, "the last good pixels stay");
    save(&path, &full);
    assert_eq!(look(&mut s)["updated"], json!([id.0]));
    assert_eq!(colour(&s), BLUE);
}

#[test]
fn a_look_whose_worker_ended_without_stamps_does_not_stop_later_looks() {
    let dir = Folder::new("watch-unwound");
    let path = dir.file("art.png");
    std::fs::write(&path, png(40, 40, RED)).unwrap();
    let mut s = session();
    s.prefs.update_links = "automatically".into();
    let id = place(&mut s, &path);
    look(&mut s);
    let scan = link_watch::LinkScan::default();
    s.link_scan = Some(scan.clone());
    // Still running: the look stays in flight.
    assert!(s.poll_link_scan().is_none());
    assert!(s.link_scan.is_some(), "a look still running stays");
    let worker = std::thread::spawn(move || {
        let _ended = link_watch::Ended(scan);
        panic!("the look's worker unwinds");
    });
    assert!(worker.join().is_err());
    assert!(s.poll_link_scan().is_none(), "there are no stamps to apply");
    assert!(s.link_scan.is_none(), "the look ended");
    save(&path, &png(40, 40, BLUE));
    assert_eq!(look(&mut s)["updated"], json!([id.0]));
    assert_eq!(colour(&s), BLUE);
}

#[test]
fn a_look_that_stores_its_stamps_between_the_polls_reads_keeps_them() {
    let dir = Folder::new("watch-stored");
    let path = dir.file("art.png");
    std::fs::write(&path, png(40, 40, RED)).unwrap();
    let mut s = session();
    s.prefs.update_links = "automatically".into();
    let id = place(&mut s, &path);
    look(&mut s);
    let uid = s.doc().unwrap().uid;
    let stamps: Vec<_> = link_watch::linked_files(&s.doc().unwrap().doc).into_iter().map(|(p, ids)| (p, ids, Some((1, 1)))).collect();
    let scan = link_watch::LinkScan::default();
    s.link_scan = Some(scan.clone());
    // The worker takes its turn after the slot is read and before the flag is, if the slot is free.
    let ended = link_watch::ended_without_stamps(&scan, |flag| {
        if let Ok(mut slot) = scan.0.try_lock() {
            *slot = Some((uid, stamps.clone()));
            flag.store(true, Ordering::SeqCst);
        }
        flag.load(Ordering::SeqCst)
    });
    assert!(!ended, "the worker waits for the poll, so the look has not ended without stamps");
    // The worker's turn comes once the poll has let go of the slot.
    let worker = std::thread::spawn({
        let scan = scan.clone();
        move || {
            let _ended = link_watch::Ended(scan.clone());
            *scan.0.lock().unwrap() = Some((uid, stamps));
        }
    });
    worker.join().unwrap();
    assert_eq!(s.poll_link_scan().expect("the stamps are applied").unwrap()["updated"], json!([id.0]));
    assert!(s.link_scan.is_none());
}

#[test]
fn a_change_during_a_script_waits_for_the_script_to_end() {
    let dir = Folder::new("watch-script");
    let path = dir.file("art.png");
    std::fs::write(&path, png(40, 40, RED)).unwrap();
    let mut s = session();
    s.prefs.update_links = "automatically".into();
    let id = place(&mut s, &path);
    look(&mut s);
    save(&path, &png(40, 40, BLUE));
    s.start_link_scan();
    s.wait_link_scan();
    s.script_frames = true;
    s.execute("script.run", &json!({"source": "while (true) {}"})).unwrap();
    assert!(s.poll_link_scan().is_none(), "the finished look waits");
    assert!(s.script_abandon());
    assert_eq!(s.poll_link_scan().expect("the stamps are applied").unwrap()["updated"], json!([id.0]));
    assert_eq!(colour(&s), BLUE);
}

#[test]
fn a_change_during_a_drag_waits_for_the_drag_to_end() {
    let dir = Folder::new("watch-drag");
    let path = dir.file("art.png");
    std::fs::write(&path, png(40, 40, RED)).unwrap();
    let mut s = session();
    s.prefs.update_links = "automatically".into();
    let id = place(&mut s, &path);
    look(&mut s);
    s.begin_interaction("Move").unwrap();
    save(&path, &png(40, 40, BLUE));
    // The preview would throw the update away, so it is not applied (nor its stamp kept).
    assert_eq!(look(&mut s), json!({"updated": [], "ask": [], "modified": []}));
    s.cancel_interaction().unwrap();
    assert_eq!(look(&mut s)["updated"], json!([id.0]));
    assert_eq!(colour(&s), BLUE);
}