2bc41aeb8602
script_dialogs.rs
//! A script's `alert`, `confirm` and `prompt` in the app: the dialog the run waits at, its buttons,
//! Enter and Escape, Stop, another dialog in the way, quitting while it waits, and the same answers
//! given by a run with nobody to ask.
use serde_json::{Value, json};
use vectorcraft_engine::Session;
use crate::dialogs::script_run::{CLOSE_KIND, NOTICE_KIND};
use crate::{VectorcraftApp, dialogs, menus, script_runs};
fn app() -> VectorcraftApp {
let mut app = VectorcraftApp::new(Session::new(), crate::Services::default());
app.run("file.new", json!({})).unwrap();
app.session.prefs.show_external_script_warning = false;
app
}
fn objects(app: &VectorcraftApp) -> usize {
app.session.doc().unwrap().doc.layers.iter().map(|l| l.children().map_or(0, Vec::len)).sum()
}
const DRAW: &str = "vc.run('shape.rectangle', {x:0,y:0,width:10,height:10});";
fn start(app: &mut VectorcraftApp, source: &str) {
menus::run_ui_command(app, "ui.runScript", &json!({"source": source, "name": "d.js"})).unwrap().unwrap();
}
/// Polls the run until it ends, or until its dialog is open (true).
fn until_dialog(app: &mut VectorcraftApp) -> bool {
for _ in 0..10_000 {
if !app.session.script_running() {
return false;
}
script_runs::poll(app);
if app.ui.dialog.as_ref().is_some_and(|d| d.kind == NOTICE_KIND) {
return true;
}
}
panic!("the script neither ended nor opened a dialog");
}
fn answer(app: &mut VectorcraftApp, answer: &str) {
app.ui.dialog.as_mut().unwrap().fields.insert("answer".into(), json!(answer));
dialogs::confirm(app).unwrap();
}
thread_local! {
// One context per test, so frames follow one another as in the app.
static CTX: egui::Context = {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
ctx
};
}
/// One headless frame of the dialog layer and the shortcuts, in a window of `size`. Each key pressed
/// in it is let go in a second frame, as a person lets go of it.
fn frame(app: &mut VectorcraftApp, events: Vec<egui::Event>, size: egui::Vec2) {
let ctx = CTX.with(Clone::clone);
let released: Vec<egui::Event> = events
.iter()
.filter_map(|e| match e {
egui::Event::Key { key, physical_key, modifiers, pressed: true, .. } => {
Some(egui::Event::Key { key: *key, physical_key: *physical_key, pressed: false, repeat: false, modifiers: *modifiers })
}
_ => None,
})
.collect();
let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size));
let pressed = !released.is_empty();
for events in std::iter::once(events).chain(pressed.then_some(released)) {
let mut out = ctx.run_ui(egui::RawInput { events, screen_rect, ..Default::default() }, |ui| {
crate::shortcuts::handle(app, ui.ctx());
dialogs::show(app, ui.ctx());
});
out.textures_delta.clear();
}
}
fn key(k: egui::Key) -> egui::Event {
egui::Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }
}
const WINDOW: egui::Vec2 = egui::vec2(1200.0, 800.0);
fn log(app: &VectorcraftApp) -> Value {
app.session.script_report().unwrap()["log"].clone()
}
#[test]
fn alert_waits_and_stop_rolls_back_first_dialog() {
for stop_with_escape in [false, true] {
let mut app = app();
start(&mut app, &format!("{DRAW} while (1) {{ alert('x'); }}"));
assert!(until_dialog(&mut app));
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.fields["kind"].as_str(), d.fields["message"].as_str(), d.fields["title"].clone()), (Some("alert"), Some("x"), Value::Null));
for _ in 0..5 {
script_runs::poll(&mut app);
}
assert!(app.session.script_running(), "the run waits at the dialog");
assert_eq!(objects(&app), 0);
if stop_with_escape {
frame(&mut app, vec![key(egui::Key::Escape)], WINDOW);
} else {
answer(&mut app, "stop");
}
assert!(app.ui.dialog.is_none());
assert!(!until_dialog(&mut app));
assert_eq!(objects(&app), 0);
assert_eq!(app.ui.status, "The script was stopped and its changes were undone");
assert_eq!(app.session.script_report().unwrap()["dialogs"][0]["answer"], "stop");
}
}
#[test]
fn confirm_enter_uses_no_as_default() {
for (no_as_default, want) in [(true, false), (false, true)] {
let mut app = app();
start(&mut app, &format!("vc.log(confirm('Go?', {no_as_default}));"));
assert!(until_dialog(&mut app));
frame(&mut app, vec![], WINDOW);
frame(&mut app, vec![key(egui::Key::Enter)], WINDOW);
assert!(app.ui.dialog.is_none(), "Enter answers the dialog: noAsDflt {no_as_default}");
assert!(!until_dialog(&mut app));
assert_eq!(log(&app), json!([want]), "noAsDflt {no_as_default}");
}
let mut app = app();
start(&mut app, "vc.log(confirm('Go?'));");
assert!(until_dialog(&mut app));
frame(&mut app, vec![key(egui::Key::Escape)], WINDOW);
assert!(!until_dialog(&mut app));
assert_eq!(log(&app), json!([false]), "Escape is No");
}
#[test]
fn prompt_ok_and_cancel_return_values() {
let mut app = app();
start(&mut app, "vc.log(prompt('Name', 'pre', 'Ask')); vc.log(prompt('Again', 'x'));");
assert!(until_dialog(&mut app));
assert_eq!(dialogs::script_run::notice_heading(app.ui.dialog.as_ref().unwrap()), "Ask");
assert_eq!(app.ui.dialog.as_ref().unwrap().fields["value"], "pre");
app.ui.dialog.as_mut().unwrap().fields.insert("value".into(), json!("typed"));
dialogs::confirm(&mut app).unwrap();
assert!(until_dialog(&mut app));
dialogs::cancel(&mut app);
assert!(!until_dialog(&mut app));
assert_eq!(log(&app), json!(["typed", null]));
let mut app = self::app();
start(&mut app, "vc.log(prompt('Name', ''));");
assert!(until_dialog(&mut app));
let e = {
app.ui.dialog.as_mut().unwrap().fields.insert("answer".into(), json!("yes"));
dialogs::confirm(&mut app).unwrap_err()
};
assert!(e.contains("ok, cancel, stop"), "{e}");
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, NOTICE_KIND, "a wrong answer leaves the dialog open");
answer(&mut app, "ok");
assert!(!until_dialog(&mut app));
assert_eq!(log(&app), json!([""]), "OK with an empty field gives an empty string");
}
#[test]
fn the_dialog_opens_in_the_frame_the_run_waits() {
let mut app = app();
start(&mut app, "alert('x');");
script_runs::poll(&mut app);
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(NOTICE_KIND), "no later frame is drawn while the run waits");
}
#[test]
fn a_prompt_text_past_the_limit_keeps_the_dialog_open() {
let mut app = app();
start(&mut app, "vc.log(prompt('Name', ''));");
assert!(until_dialog(&mut app));
let long = "x".repeat(vectorcraft_engine::script::dialogs::MAX_PROMPT_BYTES + 1);
app.ui.dialog.as_mut().unwrap().fields.insert("value".into(), json!(long));
assert!(dialogs::confirm(&mut app).is_err());
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, NOTICE_KIND, "the refused answer leaves the dialog open");
assert!(app.session.script_dialog().is_some(), "the run still waits");
app.ui.dialog.as_mut().unwrap().fields.insert("value".into(), json!("ok"));
answer(&mut app, "ok");
assert!(!until_dialog(&mut app));
assert_eq!(log(&app), json!(["ok"]));
}
#[test]
fn dialog_wait_survives_another_modal() {
let mut app = app();
start(&mut app, "alert('x');");
script_runs::poll(&mut app);
app.ui.dialog = Some(crate::state::Dialog::new(dialogs::script_run::GROWTH_KIND, json!({})));
let other = app.ui.dialog.clone();
for _ in 0..3 {
script_runs::poll(&mut app);
}
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.clone()), other.map(|d| d.kind), "the open dialog stays");
assert!(app.session.script_running());
app.ui.dialog = None;
assert!(until_dialog(&mut app), "the script's dialog opens once the other one closes");
}
#[test]
fn close_while_notification_waits_abandons_or_resumes() {
let mut app = app();
start(&mut app, &format!("{DRAW} vc.log(prompt('Name', ''));"));
assert!(until_dialog(&mut app));
app.ui.dialog.as_mut().unwrap().fields.insert("value".into(), json!("half"));
dialogs::script_run::ask_to_close(&mut app);
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, CLOSE_KIND);
script_runs::poll(&mut app);
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, CLOSE_KIND, "the run goes on waiting");
dialogs::cancel(&mut app);
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), d.fields["value"].as_str()), (NOTICE_KIND, Some("half")), "Cancel shows the dialog again as it was");
dialogs::script_run::ask_to_close(&mut app);
dialogs::confirm(&mut app).unwrap();
assert!(!app.session.script_running());
assert_eq!(objects(&app), 0);
assert_eq!(app.ui.status, "The script was stopped and its changes were undone");
}
#[test]
fn close_question_ends_with_a_run_stopped_another_way() {
let mut app = app();
start(&mut app, &format!("{DRAW} vc.log(prompt('Name', ''));"));
assert!(until_dialog(&mut app));
dialogs::script_run::ask_to_close(&mut app);
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, CLOSE_KIND);
assert_eq!(app.run("script.stop", json!({})).unwrap()["stopped"], true);
script_runs::poll(&mut app);
assert!(!app.session.script_running());
assert!(app.ui.dialog.is_none(), "the question about a run that has ended closes");
dialogs::cancel(&mut app);
assert!(app.ui.dialog.is_none(), "Cancel does not show the stopped script's dialog again");
assert_eq!(objects(&app), 0);
// Asked to stop, the run no longer waits at its dialog before its next slice ends it.
let mut app = self::app();
start(&mut app, &format!("{DRAW} vc.log(prompt('Name', ''));"));
assert!(until_dialog(&mut app));
dialogs::script_run::ask_to_close(&mut app);
app.run("script.stop", json!({})).unwrap();
dialogs::script_run::settle_close(&mut app);
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, CLOSE_KIND, "the run has not ended yet");
dialogs::cancel(&mut app);
assert!(app.ui.dialog.is_none(), "Cancel does not show a dialog the run no longer waits at");
}
#[test]
fn notification_layout_with_long_text_and_small_window() {
let mut app = app();
let long = "word ".repeat(3_000);
start(&mut app, &format!("alert({long:?} + '\\u0007\\r\\n', 'T\\nitle', true);"));
assert!(until_dialog(&mut app));
for _ in 0..3 {
frame(&mut app, vec![], egui::vec2(320.0, 240.0));
}
assert_eq!(app.ui.dialog.as_ref().unwrap().kind, NOTICE_KIND);
assert_eq!(dialogs::script_run::notice_heading(app.ui.dialog.as_ref().unwrap()), "T\u{240a}itle");
answer(&mut app, "ok");
assert!(!until_dialog(&mut app));
assert_eq!(app.session.script_report().unwrap()["dialogs"][0]["errorIcon"], true);
}
#[test]
fn the_app_and_a_run_with_nobody_to_ask_give_the_same_results() {
let source = "vc.log(confirm('a', true, 'T')); vc.log(prompt('b', 'p')); alert('c', undefined, false); vc.log('done');";
let mut app = app();
start(&mut app, source);
for a in ["yes", "ok", "ok"] {
assert!(until_dialog(&mut app));
answer(&mut app, a);
}
assert!(!until_dialog(&mut app));
let framed = app.session.script_report().unwrap().clone();
let mut s = Session::new();
let given = json!([{"kind": "confirm", "value": true}, {"kind": "prompt", "value": "p"}, {"kind": "alert", "value": "ok"}]);
let headless = s.execute("script.run", &json!({"source": source, "name": "d.js", "answers": given})).unwrap();
assert_eq!(framed["log"], headless["log"]);
assert_eq!(framed["dialogs"], headless["dialogs"]);
assert_eq!(framed["log"], json!([true, "p", "done"]));
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.