Guard and preserve behavior forms across document lifecycle
This commit is contained in:
@@ -0,0 +1,398 @@
|
||||
use super::*;
|
||||
use crate::behavior::{self, states};
|
||||
use oa_core::source_project::ProjectLimits;
|
||||
|
||||
struct Fixture {
|
||||
app: App,
|
||||
machine: Id,
|
||||
source: Id,
|
||||
target: Id,
|
||||
work: Id,
|
||||
}
|
||||
|
||||
fn fixture() -> Fixture {
|
||||
let mut project = Project::empty();
|
||||
let owner = project
|
||||
.add_element(Kind::System, Layer::Sa, "System", None)
|
||||
.unwrap();
|
||||
let machine = project
|
||||
.add_element(
|
||||
Kind::StateMachine,
|
||||
Layer::Sa,
|
||||
"Operating modes",
|
||||
Some(owner),
|
||||
)
|
||||
.unwrap();
|
||||
let region = project
|
||||
.add_element(Kind::Region, Layer::Sa, "Operation", Some(machine))
|
||||
.unwrap();
|
||||
let source = project
|
||||
.add_element(Kind::State, Layer::Sa, "Ready", Some(region))
|
||||
.unwrap();
|
||||
let target = project
|
||||
.add_element(Kind::State, Layer::Sa, "Waiting", Some(region))
|
||||
.unwrap();
|
||||
let work = project
|
||||
.add_element(Kind::Function, Layer::Sa, "Monitor connection", None)
|
||||
.unwrap();
|
||||
let mut app = App::with_project(project);
|
||||
send(&mut app, Message::Select(source));
|
||||
send(&mut app, Message::Page(Page::Behavior));
|
||||
Fixture {
|
||||
app,
|
||||
machine,
|
||||
source,
|
||||
target,
|
||||
work,
|
||||
}
|
||||
}
|
||||
|
||||
fn send(app: &mut App, message: Message) {
|
||||
// Do not poll returned I/O tasks: these tests exercise the App transaction
|
||||
// boundary without displaying a file dialog or writing to the filesystem.
|
||||
let _ = app.update(message);
|
||||
}
|
||||
|
||||
fn state_event(app: &mut App, event: states::Event) {
|
||||
send(app, Message::Behavior(behavior::Event::States(event)));
|
||||
}
|
||||
|
||||
fn choice(app: &App, id: Id) -> Choice {
|
||||
Choice {
|
||||
id,
|
||||
label: app.project().named(id).into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn start_transition(fixture: &mut Fixture, complete: bool) {
|
||||
let Fixture {
|
||||
app,
|
||||
machine,
|
||||
source,
|
||||
target,
|
||||
work,
|
||||
} = fixture;
|
||||
state_event(
|
||||
app,
|
||||
states::Event::Start(*machine, states::Tool::Transition, *source),
|
||||
);
|
||||
for event in [
|
||||
states::Event::Name("Wait for recovery".into()),
|
||||
states::Event::Trigger(choice(app, *work)),
|
||||
states::Event::Effect(choice(app, *work)),
|
||||
states::Event::TriggerNotes("A monitor result".into()),
|
||||
states::Event::Guard("connection unavailable".into()),
|
||||
states::Event::EffectNotes("Record the timeout".into()),
|
||||
states::Event::Timed(true),
|
||||
states::Event::TimeKind("At".into()),
|
||||
states::Event::Expression("12:30 UTC".into()),
|
||||
] {
|
||||
state_event(app, event);
|
||||
}
|
||||
if complete {
|
||||
let target = choice(app, *target);
|
||||
state_event(app, states::Event::Target(target));
|
||||
}
|
||||
assert_eq!(app.behavior.pending_owner(), Some(*machine));
|
||||
}
|
||||
|
||||
fn assert_typed_transition(app: &App, source: Id, target: Id, work: Id) {
|
||||
assert_eq!(app.project().relations.len(), 1);
|
||||
let relation = app.project().relations.values().next().unwrap();
|
||||
assert_eq!(relation.name, "Wait for recovery");
|
||||
let RelationBody::StateTransition {
|
||||
source: actual_source,
|
||||
target: actual_target,
|
||||
triggers,
|
||||
effects,
|
||||
trigger,
|
||||
guard,
|
||||
effect,
|
||||
..
|
||||
} = &relation.body
|
||||
else {
|
||||
panic!("Expected the prepared state transition");
|
||||
};
|
||||
assert_eq!((*actual_source, *actual_target), (source, target));
|
||||
assert_eq!(effects, &[work]);
|
||||
assert_eq!(trigger, "A monitor result");
|
||||
assert_eq!(guard, "connection unavailable");
|
||||
assert_eq!(effect, "Record the timeout");
|
||||
assert_eq!(triggers.len(), 2);
|
||||
assert_eq!(triggers[0], work);
|
||||
assert!(matches!(
|
||||
app.project().elements[&triggers[1]].shared(),
|
||||
Some(SharedBody::Event {
|
||||
body: EventBody::Time { kind: TimeEventKind::At, expression }
|
||||
}) if expression == "12:30 UTC"
|
||||
));
|
||||
assert_eq!(
|
||||
app.project()
|
||||
.elements
|
||||
.values()
|
||||
.filter(|e| e.kind() == Kind::Event)
|
||||
.count(),
|
||||
1,
|
||||
"Retry must not leave a time event from the rejected transaction"
|
||||
);
|
||||
assert_eq!(
|
||||
source_project::compile_bundle(app.document.bundle(), LIMITS)
|
||||
.unwrap()
|
||||
.decoded
|
||||
.project,
|
||||
*app.project()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn source_writeback_failure_keeps_typed_behavior_form_for_repair_and_one_undo() {
|
||||
let mut fixture = fixture();
|
||||
let bundle = fixture.app.document.bundle().clone();
|
||||
let mut limits = ProjectLimits::default();
|
||||
limits.model.max_source_bytes = bundle.files.values().map(String::len).sum::<usize>() + 2000;
|
||||
fixture.app.document = Document::from_bundle(bundle.clone(), limits).unwrap();
|
||||
fixture.app.sync();
|
||||
let before = fixture.app.document.snapshot();
|
||||
start_transition(&mut fixture, true);
|
||||
let app = &mut fixture.app;
|
||||
state_event(app, states::Event::Name("Transition".repeat(1024)));
|
||||
let prepared = app
|
||||
.behavior
|
||||
.prepare_pending(app.project())
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert!(execute_batch(app.project(), &[prepared]).is_ok());
|
||||
|
||||
state_event(app, states::Event::Submit);
|
||||
assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
|
||||
assert_eq!(app.source_workspace.bundle(), bundle);
|
||||
assert_eq!(app.document.revision(), 0);
|
||||
assert!(!app.document.can_undo());
|
||||
assert!(app.behavior.has_pending());
|
||||
assert!(app.dirty());
|
||||
assert!(!app.source_dirty());
|
||||
|
||||
state_event(app, states::Event::Name("Wait for recovery".into()));
|
||||
state_event(app, states::Event::Submit);
|
||||
assert!(!app.behavior.has_pending());
|
||||
assert_typed_transition(app, fixture.source, fixture.target, fixture.work);
|
||||
assert_eq!(app.document.revision(), 1);
|
||||
assert_eq!(app.source_workspace.bundle(), *app.document.bundle());
|
||||
let generated_files: Vec<_> = app
|
||||
.document
|
||||
.bundle()
|
||||
.files
|
||||
.iter()
|
||||
.filter(|(path, _)| !bundle.files.contains_key(*path))
|
||||
.map(|(path, text)| (path.clone(), text.clone()))
|
||||
.collect();
|
||||
assert!(
|
||||
!generated_files.is_empty(),
|
||||
"The time event creates a source file"
|
||||
);
|
||||
send(app, Message::Undo);
|
||||
assert_eq!(app.document.bundle(), &bundle);
|
||||
assert_eq!(app.project(), &before.decoded.project);
|
||||
assert_eq!(
|
||||
source_workspace::reachable(&app.source_workspace.bundle()).unwrap(),
|
||||
bundle
|
||||
);
|
||||
assert_eq!(
|
||||
app.source_workspace.reachable,
|
||||
bundle.files.keys().cloned().collect::<BTreeSet<_>>()
|
||||
);
|
||||
// Undo restores the accepted bundle exactly. Workspace retains clean buffers
|
||||
// from removed includes so the user may inspect or explicitly close them.
|
||||
for (path, text) in generated_files {
|
||||
assert!(!app.source_workspace.reachable.contains(&path));
|
||||
let detached = &app.source_workspace.files[&path];
|
||||
assert_eq!(detached.text, text);
|
||||
assert!(!detached.dirty());
|
||||
}
|
||||
assert!(!app.source_workspace.detached_dirty());
|
||||
assert!(!app.document.can_undo());
|
||||
assert!(!app.dirty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incomplete_behavior_form_is_dirty_close_save_retains_it_and_cancel_allows_switching() {
|
||||
let mut fixture = fixture();
|
||||
let before = fixture.app.document.snapshot();
|
||||
start_transition(&mut fixture, false);
|
||||
let app = &mut fixture.app;
|
||||
assert!(!app.document.dirty());
|
||||
assert!(app.dirty());
|
||||
assert!(app.title().contains(" *"));
|
||||
let window = window::Id::unique();
|
||||
send(app, Message::Request(Pending::Close(window)));
|
||||
assert!(matches!(app.pending, Some(Pending::Close(id)) if id == window));
|
||||
send(app, Message::SaveAndContinue);
|
||||
assert!(app.behavior.has_pending());
|
||||
assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
|
||||
assert!(app.pending.is_none());
|
||||
assert!(!app.continue_after_save);
|
||||
assert!(!app.busy);
|
||||
assert!(app.file_prompt.is_none());
|
||||
assert_eq!(app.page, Page::Behavior);
|
||||
|
||||
state_event(app, states::Event::Cancel);
|
||||
assert!(!app.behavior.has_pending());
|
||||
assert!(!app.dirty());
|
||||
send(app, Message::Page(Page::Text));
|
||||
assert_eq!(app.page, Page::Text);
|
||||
send(app, Message::Select(fixture.target));
|
||||
assert_eq!(app.selected, fixture.target);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_prepares_behavior_before_opening_destination_and_cancel_keeps_one_undo() {
|
||||
let mut fixture = fixture();
|
||||
let before = fixture.app.document.snapshot();
|
||||
start_transition(&mut fixture, true);
|
||||
let app = &mut fixture.app;
|
||||
send(app, Message::Save(true));
|
||||
assert!(!app.behavior.has_pending());
|
||||
assert_typed_transition(app, fixture.source, fixture.target, fixture.work);
|
||||
assert_eq!(app.document.revision(), 1);
|
||||
assert!(
|
||||
app.document.dirty(),
|
||||
"Choosing a destination is not a successful disk save"
|
||||
);
|
||||
assert!(app.file_prompt.is_some() || app.busy);
|
||||
if app.file_prompt.is_some() {
|
||||
send(app, Message::CancelFile);
|
||||
} else {
|
||||
send(app, Message::SavePath(None));
|
||||
}
|
||||
assert!(!app.busy);
|
||||
assert!(app.document.dirty());
|
||||
send(app, Message::Undo);
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
assert_eq!(app.project(), &before.decoded.project);
|
||||
assert!(!app.document.can_undo());
|
||||
assert!(!app.dirty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pending_behavior_blocks_navigation_property_edits_and_model_history() {
|
||||
let mut fixture = fixture();
|
||||
let before = fixture.app.document.snapshot();
|
||||
start_transition(&mut fixture, true);
|
||||
let app = &mut fixture.app;
|
||||
let properties = app.draft.as_ref().unwrap().materialize().unwrap();
|
||||
for message in [
|
||||
Message::Page(Page::Diagram),
|
||||
Message::Page(Page::Catalog),
|
||||
Message::Page(Page::Text),
|
||||
Message::Page(Page::Guide),
|
||||
Message::Layer(Layer::Oa),
|
||||
Message::Select(fixture.target),
|
||||
Message::Explore(Some(fixture.target)),
|
||||
Message::BrowseGroup(crate::explorer::Group::Work),
|
||||
Message::Field("/name".into(), "Overwrite properties".into()),
|
||||
Message::Command(Command::Rename(fixture.source, "Overwrite model".into())),
|
||||
Message::ConfirmDelete,
|
||||
Message::Undo,
|
||||
Message::Redo,
|
||||
Message::ShortcutUndo(false),
|
||||
Message::SourceForSelection,
|
||||
Message::SourceNavigation(crate::source_navigation::Event::Open(false)),
|
||||
] {
|
||||
send(app, message);
|
||||
assert_eq!(app.page, Page::Behavior);
|
||||
assert_eq!(app.selected, fixture.source);
|
||||
assert_eq!(app.layer, Layer::Sa);
|
||||
assert_eq!(app.behavior.pending_owner(), Some(fixture.machine));
|
||||
assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
|
||||
assert_eq!(
|
||||
app.draft.as_ref().unwrap().materialize().unwrap(),
|
||||
properties
|
||||
);
|
||||
assert!(!app.source_dirty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn passive_behavior_canvas_events_do_not_apply_property_drafts() {
|
||||
let mut fixture = fixture();
|
||||
let app = &mut fixture.app;
|
||||
let before = app.document.snapshot();
|
||||
send(
|
||||
app,
|
||||
Message::Field("/name".into(), "Unapplied state name".into()),
|
||||
);
|
||||
assert!(app.draft_dirty());
|
||||
for event in [
|
||||
behavior::Event::States(states::Event::Viewport(iced::Size::new(900., 600.))),
|
||||
behavior::Event::States(states::Event::Zoom(0.7)),
|
||||
behavior::Event::States(states::Event::Fit),
|
||||
behavior::Event::Topology(behavior::topology::Event::Viewport(iced::Size::new(
|
||||
900., 600.,
|
||||
))),
|
||||
behavior::Event::Topology(behavior::topology::Event::Zoom(0.7)),
|
||||
behavior::Event::Topology(behavior::topology::Event::Fit),
|
||||
] {
|
||||
send(app, Message::Behavior(event));
|
||||
assert!(Arc::ptr_eq(&before, &app.document.snapshot()));
|
||||
assert!(app.draft_dirty());
|
||||
assert!(!app.behavior.has_pending());
|
||||
assert_eq!(app.source_workspace.bundle(), before.bundle);
|
||||
assert!(!app.document.can_undo());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pending_behavior_blocks_source_creation_and_source_history_replay() {
|
||||
for redo in [false, true] {
|
||||
let mut fixture = fixture();
|
||||
let app = &mut fixture.app;
|
||||
let baseline = app.source_workspace.bundle();
|
||||
let edited = format!(
|
||||
"{}\n// Source draft that must stay in history.\n",
|
||||
app.source_workspace.text()
|
||||
);
|
||||
send(app, Message::SourceEdit(text_editor::Action::SelectAll));
|
||||
send(
|
||||
app,
|
||||
Message::SourceEdit(text_editor::Action::Edit(text_editor::Edit::Paste(
|
||||
Arc::new(edited),
|
||||
))),
|
||||
);
|
||||
send(
|
||||
app,
|
||||
if redo {
|
||||
Message::SourceUndo
|
||||
} else {
|
||||
Message::RevertSource
|
||||
},
|
||||
);
|
||||
assert!(!app.source_dirty());
|
||||
start_transition(&mut fixture, true);
|
||||
let app = &mut fixture.app;
|
||||
send(
|
||||
app,
|
||||
if redo {
|
||||
Message::SourceRedo
|
||||
} else {
|
||||
Message::SourceUndo
|
||||
},
|
||||
);
|
||||
assert_eq!(
|
||||
app.source_workspace.bundle(),
|
||||
baseline,
|
||||
"Source history must not create a competing draft"
|
||||
);
|
||||
send(app, Message::SourceNewPath("queued.arcadia".into()));
|
||||
send(app, Message::SourceCreateFile);
|
||||
assert_eq!(
|
||||
app.source_workspace.bundle(),
|
||||
baseline,
|
||||
"A queued create-file action must not create a competing draft"
|
||||
);
|
||||
assert!(!app.source_dirty());
|
||||
assert_eq!(app.behavior.pending_owner(), Some(fixture.machine));
|
||||
state_event(app, states::Event::Submit);
|
||||
assert!(!app.behavior.has_pending());
|
||||
assert_typed_transition(app, fixture.source, fixture.target, fixture.work);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user