Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

5.8 KB
Raw Blame
use std::path::PathBuf;

use serde_json::json;
use vectorcraft_engine::Session;

use super::SAVE_COPY;
use crate::{VectorcraftApp, menus};

/// A new, empty folder of its own for test `name`.
fn folder(name: &str) -> PathBuf {
    let dir = std::env::temp_dir().join(format!("vc-ui-document-tools-{name}-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    dir
}

fn app() -> VectorcraftApp {
    let mut app = VectorcraftApp::new(Session::new(), Default::default());
    app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
    app
}

/// Click the Document Tools item `label`.
fn click(app: &mut VectorcraftApp, label: &str) {
    let entries = menus::menu_entries(app);
    let item = entries.iter().find(|e| e.path == ["Object", "Plug-ins", "Document Tools"] && e.label == label).expect(label);
    let (id, p) = menus::click_target(&item.label, item.command.as_deref().unwrap(), &item.params);
    menus::invoke(app, &id, p);
}

fn files(dir: &PathBuf) -> Vec<String> {
    std::fs::read_dir(dir).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect()
}

#[test]
fn save_a_timestamped_copy_writes_beside_the_document() {
    let dir = folder("beside");
    let mut app = app();
    app.run("document.save", json!({"path": dir.join("card.vectorcraft")})).unwrap();
    assert_eq!(menus::menu_entries(&app).iter().find(|e| e.label == "Save a Timestamped Copy").and_then(|e| e.command.as_deref()), Some(SAVE_COPY));
    click(&mut app, "Save a Timestamped Copy");
    let names = files(&dir);
    assert_eq!(names.len(), 2, "{names:?}");
    assert!(names.iter().any(|n| n.starts_with("card_20") && n.ends_with(".vectorcraft")), "{names:?}");
    assert!(app.ui.status.starts_with("Saved "), "{}", app.ui.status);
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn an_unsaved_document_asks_for_a_folder() {
    let dir = folder("picked");
    let mut app = app();
    let picked = dir.to_string_lossy().into_owned();
    app.services.pick_folder = Some(Box::new(move || Some(picked.clone())));
    click(&mut app, "Save a Timestamped Copy");
    assert_eq!(files(&dir).len(), 1);
    assert!(app.session.doc().unwrap().path.is_none(), "the document stays unsaved");
    // No folder picked: nothing written.
    app.services.pick_folder = Some(Box::new(|| None));
    assert_eq!(app.run(SAVE_COPY, json!({})).unwrap_err(), "cancelled");
    assert_eq!(files(&dir).len(), 1);
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn new_symbols_from_layers_and_convert_layers_to_symbols() {
    let mut app = app();
    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 30})).unwrap();
    app.run("layer.new", json!({"name": "Badges"})).unwrap();
    app.run("shape.ellipse", json!({"x": 100, "y": 10, "width": 40, "height": 40})).unwrap();
    let symbols = |app: &VectorcraftApp| app.session.doc().unwrap().doc.symbols.iter().map(|s| s.name.clone()).collect::<Vec<_>>();
    let before = symbols(&app).len();
    click(&mut app, "New Symbols from Layers");
    assert_eq!(symbols(&app).len(), before + 2);
    assert!(symbols(&app).contains(&"Badges".to_string()));
    app.run("edit.undo", json!({})).unwrap();
    click(&mut app, "Convert Layers to Symbols");
    let doc = &app.session.doc().unwrap().doc;
    assert!(
        doc.layers
            .iter()
            .all(|l| matches!(l.children().unwrap()[..], [ref one] if matches!(one.kind, vectorcraft_doc::NodeKind::SymbolInstance { .. })))
    );
}

/// #4920: Export All Open Documents as PDF asks for a folder and writes one PDF per open document,
/// named after each, without replacing a file there, and leaves every document as it was.
#[test]
fn export_all_open_documents_writes_each_to_the_folder_picked() {
    let dir = folder("export-all");
    let mut app = app();
    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 40})).unwrap();
    app.run("document.save", json!({"path": dir.join("card.vectorcraft")})).unwrap();
    app.run("file.new", json!({"width": 200, "height": 100, "name": "card"})).unwrap();
    app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
    let untitled = app.session.doc().unwrap().doc.title.clone();
    let out = dir.join("out");
    std::fs::create_dir_all(&out).unwrap();
    std::fs::write(out.join(format!("{untitled}.pdf")), b"keep").unwrap();
    let picked = out.to_string_lossy().into_owned();
    app.services.pick_folder = Some(Box::new(move || Some(picked.clone())));
    let active = app.session.active_index();
    click(&mut app, "Export All Open Documents as PDF");
    let mut names = files(&out);
    names.sort();
    let mut want = vec!["card.pdf".to_string(), "card-2.pdf".into(), format!("{untitled}.pdf"), format!("{untitled}-2.pdf")];
    want.sort();
    assert_eq!(names, want, "one per document, the taken names numbered");
    assert_eq!(std::fs::read(out.join(format!("{untitled}.pdf"))).unwrap(), b"keep", "no file is replaced");
    assert!(std::fs::read(out.join("card.pdf")).unwrap().starts_with(b"%PDF"));
    assert_eq!(app.session.active_index(), active, "the active document stays active");
    assert!(
        app.session.documents().iter().all(|d| d.path.as_ref().is_none_or(|p| p.ends_with("card.vectorcraft"))),
        "no document takes a copy's path"
    );
    assert!(app.ui.status.starts_with("Exported 3 documents"), "{}", app.ui.status);
    // Cancelled: nothing written.
    app.services.pick_folder = Some(Box::new(|| None));
    assert_eq!(app.run(super::EXPORT_ALL, json!({})).unwrap_err(), "cancelled");
    assert_eq!(files(&out).len(), 4);
    // The engine command refuses a missing folder and an unknown format.
    assert!(app.session.execute(super::EXPORT_ALL, &json!({})).is_err());
    assert!(app.session.execute(super::EXPORT_ALL, &json!({"folder": out, "format": "doc"})).is_err());
    let _ = std::fs::remove_dir_all(&dir);
}