Review nested message kind groups with exact timer scope
This commit is contained in:
@@ -0,0 +1,691 @@
|
||||
use super::{tests::*, *};
|
||||
use crate::{app::App, document::Document};
|
||||
use serde_json::json;
|
||||
|
||||
fn fixture(oa_kind: MessageKind, sa_kind: MessageKind) -> (Project, Id, Id, Id) {
|
||||
let mut p = Project::empty();
|
||||
let mut ids = vec![];
|
||||
for (layer, message_kind) in [(Layer::Oa, oa_kind), (Layer::Sa, sa_kind)] {
|
||||
let scenario = p
|
||||
.add_element(Kind::Scenario, layer, "Scenario", None)
|
||||
.unwrap();
|
||||
let id = p
|
||||
.add_element(Kind::Occurrence, layer, "Message", Some(scenario))
|
||||
.unwrap();
|
||||
*p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
|
||||
body: OccurrenceBody::Exchange {
|
||||
exchange: None,
|
||||
sender: None,
|
||||
receiver: None,
|
||||
message_kind,
|
||||
reply_to: None,
|
||||
values: vec![],
|
||||
},
|
||||
precondition: "retain precondition".into(),
|
||||
postcondition: "retain postcondition".into(),
|
||||
};
|
||||
p.elements
|
||||
.get_mut(&scenario)
|
||||
.unwrap()
|
||||
.steps_mut()
|
||||
.unwrap()
|
||||
.push(id);
|
||||
ids.push(id);
|
||||
}
|
||||
let trace = add_trace(&mut p, ids[0], ids[1], "Message-kind review");
|
||||
(p, ids[0], ids[1], trace)
|
||||
}
|
||||
fn timer(value: &str) -> MessageKind {
|
||||
MessageKind::Timer {
|
||||
expression: value.into(),
|
||||
}
|
||||
}
|
||||
fn path(layer: &str) -> String {
|
||||
format!("/body/{layer}/Shared/Occurrence/body/Exchange/message_kind")
|
||||
}
|
||||
fn set_kind(p: &mut Project, id: Id, kind: MessageKind) {
|
||||
let Some(SharedBody::Occurrence {
|
||||
body: OccurrenceBody::Exchange { message_kind, .. },
|
||||
..
|
||||
}) = p.elements.get_mut(&id).unwrap().shared_mut()
|
||||
else {
|
||||
panic!()
|
||||
};
|
||||
*message_kind = kind;
|
||||
}
|
||||
fn seed_history(p: &mut Project, trace: Id) {
|
||||
let t = &p.traces[&trace];
|
||||
let baseline = TraceBaseline {
|
||||
oa: p.properties(t.oa).unwrap(),
|
||||
sa: p.properties(t.sa).unwrap(),
|
||||
semantic: Some(SemanticBaseline {
|
||||
facets: [message_kind::selector(), message_kind::timer_selector()]
|
||||
.iter()
|
||||
.map(|selector| capture_facet(p, t.oa, t.sa, selector).unwrap())
|
||||
.collect(),
|
||||
}),
|
||||
};
|
||||
p.traces.get_mut(&trace).unwrap().baseline = Some(baseline);
|
||||
}
|
||||
fn acknowledged(app: &App) -> BTreeSet<FacetSelector> {
|
||||
state(app).plan.as_ref().unwrap().reviews[0]
|
||||
.acknowledged
|
||||
.iter()
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
fn failures(app: &App) -> String {
|
||||
state(app)
|
||||
.error
|
||||
.iter()
|
||||
.chain(state(app).plan.iter().flat_map(|p| &p.conflicts))
|
||||
.cloned()
|
||||
.collect::<Vec<_>>()
|
||||
.join("; ")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_take_full_timer_and_scalar_candidate_are_one_source_history_change_both_directions()
|
||||
{
|
||||
for reverse in [false, true] {
|
||||
let expression = " after β ≥ 5 s\n\tkeep exact whitespace ";
|
||||
let (p, oa, sa, trace) = if reverse {
|
||||
fixture(MessageKind::Asynchronous, timer(expression))
|
||||
} else {
|
||||
fixture(timer(expression), MessageKind::Asynchronous)
|
||||
};
|
||||
let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
|
||||
let mut app = App::with_project(p);
|
||||
let mut bundle = app.document.bundle().clone();
|
||||
bundle
|
||||
.files
|
||||
.get_mut(&bundle.entry)
|
||||
.unwrap()
|
||||
.insert_str(0, "// Keep the engineering review rationale.\r\n");
|
||||
app.document.apply_bundle(bundle).unwrap();
|
||||
let before = app.document.snapshot();
|
||||
let revision = app.document.revision();
|
||||
start(&mut app, source);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::TakeSource,
|
||||
);
|
||||
decide(
|
||||
&mut app,
|
||||
FacetSelector::Header(HeaderFacet::Name),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input("/name".into(), "Reviewed message".into()),
|
||||
);
|
||||
assert!(state(&app).can_apply(), "{:?}", state(&app).error);
|
||||
assert_eq!(
|
||||
acknowledged(&app),
|
||||
BTreeSet::from([
|
||||
message_kind::selector(),
|
||||
message_kind::timer_selector(),
|
||||
FacetSelector::Header(HeaderFacet::Name)
|
||||
])
|
||||
);
|
||||
assert!(
|
||||
state(&app).plan.as_ref().unwrap().reviews[0]
|
||||
.retired
|
||||
.is_empty()
|
||||
);
|
||||
assert!(state(&app).plan.as_ref().unwrap().impacts.is_empty());
|
||||
let expected = state(&app).proposed.clone().unwrap();
|
||||
assert_eq!(
|
||||
message_kind::value(&expected, target),
|
||||
Some(&timer(expression))
|
||||
);
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
apply(&mut app);
|
||||
assert_eq!(app.project(), &expected);
|
||||
assert_eq!(app.document.revision(), revision + 1);
|
||||
assert_eq!(
|
||||
app.project().elements[&source],
|
||||
before.decoded.project.elements[&source]
|
||||
);
|
||||
let saved = app.document.bundle().clone();
|
||||
assert!(saved.files[&saved.entry].starts_with("// Keep the engineering review rationale."));
|
||||
assert_eq!(
|
||||
Document::from_bundle(saved.clone(), source_project::ProjectLimits::default())
|
||||
.unwrap()
|
||||
.snapshot()
|
||||
.decoded
|
||||
.project,
|
||||
expected
|
||||
);
|
||||
let facts = &app.project().traces[&trace]
|
||||
.baseline
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.semantic
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.facets;
|
||||
assert_eq!(facts.len(), 3);
|
||||
let _ = app.update(Message::Undo);
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
let _ = app.update(Message::Redo);
|
||||
assert_eq!(app.document.bundle(), &saved);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_candidate_timer_switches_preserve_both_drafts_and_overlap_is_explicit() {
|
||||
let (p, oa, _, _) = fixture(MessageKind::Asynchronous, timer("original target"));
|
||||
let mut app = App::with_project(p);
|
||||
let before = app.document.snapshot();
|
||||
let kind = path("Sa");
|
||||
let expression = format!("{kind}/Timer/expression");
|
||||
start(&mut app, oa);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::timer_selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input(expression.clone(), "independent scalar timer".into()),
|
||||
);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
assert_eq!(state(&app).decisions.len(), 2);
|
||||
assert!(!state(&app).can_apply());
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input(expression.clone(), " group β timer\n\t ".into()),
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Text(expression.clone(), text_editor::Action::SelectAll),
|
||||
);
|
||||
let cursor = state(&app).message_draft.as_ref().unwrap().inputs[&expression]
|
||||
.editor
|
||||
.cursor();
|
||||
let selection = state(&app).message_draft.as_ref().unwrap().inputs[&expression]
|
||||
.editor
|
||||
.selection();
|
||||
send(
|
||||
&mut app,
|
||||
Event::Variant(kind.clone(), json!("Asynchronous")),
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Variant(kind, json!({"Timer":{"expression":""}})),
|
||||
);
|
||||
assert_eq!(
|
||||
state(&app).message_draft.as_ref().unwrap().inputs[&expression].raw,
|
||||
" group β timer\n\t "
|
||||
);
|
||||
assert_eq!(
|
||||
state(&app).message_draft.as_ref().unwrap().inputs[&expression]
|
||||
.editor
|
||||
.cursor(),
|
||||
cursor
|
||||
);
|
||||
assert_eq!(
|
||||
state(&app).message_draft.as_ref().unwrap().inputs[&expression]
|
||||
.editor
|
||||
.selection(),
|
||||
selection
|
||||
);
|
||||
assert_eq!(
|
||||
state(&app).draft.as_ref().unwrap().inputs[&expression].raw,
|
||||
"independent scalar timer"
|
||||
);
|
||||
assert!(!state(&app).can_apply());
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
// The visible overlap-resolution actions only change the explicitly chosen
|
||||
// decision. Neither independent candidate buffer is discarded.
|
||||
send(&mut app, Event::Decide(message_kind::selector(), None));
|
||||
assert!(state(&app).can_apply());
|
||||
send(
|
||||
&mut app,
|
||||
Event::Decide(message_kind::timer_selector(), None),
|
||||
);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
assert!(state(&app).can_apply(), "{:?}", state(&app).error);
|
||||
assert_eq!(
|
||||
acknowledged(&app),
|
||||
BTreeSet::from([message_kind::selector(), message_kind::timer_selector()])
|
||||
);
|
||||
let _ = state(&app).view(app.project());
|
||||
let expected = state(&app).proposed.clone().unwrap();
|
||||
apply(&mut app);
|
||||
assert_eq!(app.project(), &expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_keep_historical_switch_retires_timer_and_completed_no_switch_rejects() {
|
||||
let (mut p, oa, sa, trace) = fixture(timer("old OA"), timer("old SA"));
|
||||
seed_history(&mut p, trace);
|
||||
set_kind(&mut p, oa, MessageKind::Asynchronous);
|
||||
set_kind(&mut p, sa, MessageKind::Asynchronous);
|
||||
let mut app = App::with_project(p);
|
||||
start(&mut app, oa);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::KeepTarget,
|
||||
);
|
||||
assert!(state(&app).can_apply(), "{:?}", state(&app).error);
|
||||
assert_eq!(
|
||||
acknowledged(&app),
|
||||
BTreeSet::from([message_kind::selector()])
|
||||
);
|
||||
assert_eq!(
|
||||
state(&app).plan.as_ref().unwrap().reviews[0].retired,
|
||||
vec![message_kind::timer_selector()]
|
||||
);
|
||||
apply(&mut app);
|
||||
assert_eq!(
|
||||
app.project().traces[&trace]
|
||||
.baseline
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.semantic
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.facets
|
||||
.len(),
|
||||
1
|
||||
);
|
||||
start(&mut app, oa);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::KeepTarget,
|
||||
);
|
||||
assert!(!state(&app).can_apply());
|
||||
assert!(
|
||||
failures(&app).contains("No constructor switch"),
|
||||
"{}",
|
||||
failures(&app)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_reply_and_reference_take_require_explicit_call_mapping_both_directions() {
|
||||
for reverse in [false, true] {
|
||||
let (mut p, oa, sa, _) = if reverse {
|
||||
fixture(MessageKind::Asynchronous, MessageKind::Reply)
|
||||
} else {
|
||||
fixture(MessageKind::Reply, MessageKind::Asynchronous)
|
||||
};
|
||||
let (source, target, layer) = if reverse {
|
||||
(sa, oa, "Oa")
|
||||
} else {
|
||||
(oa, sa, "Sa")
|
||||
};
|
||||
let mut calls = vec![];
|
||||
for message in [oa, sa] {
|
||||
let scenario = p.elements[&message].parent.unwrap();
|
||||
let layer = p.elements[&message].layer();
|
||||
let call = p
|
||||
.add_element(Kind::Occurrence, layer, "Correlated call", Some(scenario))
|
||||
.unwrap();
|
||||
*p.elements.get_mut(&call).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
|
||||
body: OccurrenceBody::Exchange {
|
||||
exchange: None,
|
||||
sender: None,
|
||||
receiver: None,
|
||||
message_kind: MessageKind::Call,
|
||||
reply_to: None,
|
||||
values: vec![],
|
||||
},
|
||||
precondition: String::new(),
|
||||
postcondition: String::new(),
|
||||
};
|
||||
p.elements
|
||||
.get_mut(&scenario)
|
||||
.unwrap()
|
||||
.steps_mut()
|
||||
.unwrap()
|
||||
.insert(0, call);
|
||||
if message == source {
|
||||
let Some(SharedBody::Occurrence {
|
||||
body: OccurrenceBody::Exchange { reply_to, .. },
|
||||
..
|
||||
}) = p.elements.get_mut(&message).unwrap().shared_mut()
|
||||
else {
|
||||
panic!()
|
||||
};
|
||||
*reply_to = Some(call);
|
||||
}
|
||||
calls.push(call);
|
||||
}
|
||||
let target_call = if reverse { calls[0] } else { calls[1] };
|
||||
let mut app = App::with_project(p);
|
||||
let before = app.document.snapshot();
|
||||
start(&mut app, source);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(&mut app, Event::Variant(path(layer), json!("Reply")));
|
||||
decide(
|
||||
&mut app,
|
||||
FacetSelector::Occurrence(OccurrenceFacet::ReplyTo),
|
||||
SemanticDecision::TakeSource,
|
||||
);
|
||||
assert!(!state(&app).can_apply());
|
||||
assert!(
|
||||
failures(&app).contains("reference counterparts"),
|
||||
"{}",
|
||||
failures(&app)
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::ReferenceOa(Choice {
|
||||
id: calls[0],
|
||||
label: "OA call".into(),
|
||||
}),
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::ReferenceSa(Choice {
|
||||
id: calls[1],
|
||||
label: "SA call".into(),
|
||||
}),
|
||||
);
|
||||
send(&mut app, Event::AddReference);
|
||||
assert!(state(&app).can_apply(), "{}", failures(&app));
|
||||
assert_eq!(
|
||||
acknowledged(&app),
|
||||
BTreeSet::from([
|
||||
message_kind::selector(),
|
||||
FacetSelector::Occurrence(OccurrenceFacet::ReplyTo)
|
||||
])
|
||||
);
|
||||
let final_value =
|
||||
serde_json::to_value(&state(&app).proposed.as_ref().unwrap().elements[&target])
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
final_value.pointer(&format!(
|
||||
"/body/{layer}/Shared/Occurrence/body/Exchange/reply_to"
|
||||
)),
|
||||
Some(&json!(target_call))
|
||||
);
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
apply(&mut app);
|
||||
assert_eq!(
|
||||
message_kind::value(app.project(), target),
|
||||
Some(&MessageKind::Reply)
|
||||
);
|
||||
for call in calls {
|
||||
assert_eq!(
|
||||
app.project().elements[&call],
|
||||
before.decoded.project.elements[&call]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_candidate_closed_kinds_are_core_validated_in_both_directions() {
|
||||
for reverse in [false, true] {
|
||||
for kind in [
|
||||
MessageKind::Asynchronous,
|
||||
MessageKind::Call,
|
||||
MessageKind::Reply,
|
||||
MessageKind::Create,
|
||||
MessageKind::Delete,
|
||||
timer("after 2 s"),
|
||||
] {
|
||||
let (p, oa, sa, _) = fixture(MessageKind::Asynchronous, MessageKind::Asynchronous);
|
||||
let (source, target, layer) = if reverse {
|
||||
(sa, oa, "Oa")
|
||||
} else {
|
||||
(oa, sa, "Sa")
|
||||
};
|
||||
let mut app = App::with_project(p);
|
||||
start(&mut app, source);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Variant(path(layer), serde_json::to_value(&kind).unwrap()),
|
||||
);
|
||||
assert!(state(&app).can_apply(), "{kind:?}: {}", failures(&app));
|
||||
assert_eq!(
|
||||
message_kind::value(state(&app).proposed.as_ref().unwrap(), target),
|
||||
Some(&kind)
|
||||
);
|
||||
assert_eq!(
|
||||
acknowledged(&app).contains(&message_kind::timer_selector()),
|
||||
matches!(kind, MessageKind::Timer { .. })
|
||||
);
|
||||
assert!(state(&app).plan.as_ref().unwrap().impacts.is_empty());
|
||||
}
|
||||
}
|
||||
let (mut p, oa, _, _) = fixture(MessageKind::Asynchronous, MessageKind::Asynchronous);
|
||||
let mut review = State::new(&p, oa).unwrap();
|
||||
let Some(SharedBody::Occurrence { body, .. }) = p.elements.get_mut(&oa).unwrap().shared_mut()
|
||||
else {
|
||||
panic!()
|
||||
};
|
||||
*body = OccurrenceBody::Action {
|
||||
action: None,
|
||||
lifeline: None,
|
||||
};
|
||||
review.refresh(&p);
|
||||
assert!(
|
||||
!review.editable(&p, &message_kind::selector()),
|
||||
"An externally changed outer occurrence requires its own constructor review"
|
||||
);
|
||||
review.update(
|
||||
&p,
|
||||
Event::Decide(message_kind::selector(), Some(SemanticDecision::Candidate)),
|
||||
);
|
||||
assert!(review.decisions.is_empty());
|
||||
assert!(!review.can_apply());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_timer_does_not_erase_exchange_without_its_own_selected_decision() {
|
||||
let (mut p, oa, sa, _) = fixture(MessageKind::Asynchronous, MessageKind::Asynchronous);
|
||||
let sender = p
|
||||
.add_element(Kind::Function, Layer::Sa, "Sender", None)
|
||||
.unwrap();
|
||||
let receiver = p
|
||||
.add_element(Kind::Function, Layer::Sa, "Receiver", None)
|
||||
.unwrap();
|
||||
let exchange = p.relate(
|
||||
RelationKind::FunctionalExchange,
|
||||
"Message exchange",
|
||||
sender,
|
||||
receiver,
|
||||
);
|
||||
let Some(SharedBody::Occurrence {
|
||||
body: OccurrenceBody::Exchange {
|
||||
exchange: selected, ..
|
||||
},
|
||||
..
|
||||
}) = p.elements.get_mut(&sa).unwrap().shared_mut()
|
||||
else {
|
||||
panic!()
|
||||
};
|
||||
*selected = Some(exchange);
|
||||
let mut app = App::with_project(p);
|
||||
let before = app.document.snapshot();
|
||||
start(&mut app, oa);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Variant(path("Sa"), json!({"Timer":{"expression":"after 2 s"}})),
|
||||
);
|
||||
assert!(!state(&app).can_apply());
|
||||
assert!(
|
||||
failures(&app).contains("timer_contract"),
|
||||
"{}",
|
||||
failures(&app)
|
||||
);
|
||||
assert_eq!(state(&app).decisions.len(), 1);
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
decide(
|
||||
&mut app,
|
||||
FacetSelector::Occurrence(OccurrenceFacet::Exchange),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Shape(
|
||||
"/body/Sa/Shared/Occurrence/body/Exchange/exchange".into(),
|
||||
Value::Null,
|
||||
),
|
||||
);
|
||||
assert!(state(&app).can_apply(), "{}", failures(&app));
|
||||
assert_eq!(
|
||||
acknowledged(&app),
|
||||
BTreeSet::from([
|
||||
message_kind::selector(),
|
||||
message_kind::timer_selector(),
|
||||
FacetSelector::Occurrence(OccurrenceFacet::Exchange)
|
||||
])
|
||||
);
|
||||
assert!(state(&app).plan.as_ref().unwrap().impacts.is_empty());
|
||||
apply(&mut app);
|
||||
assert_eq!(
|
||||
app.project().relations[&exchange],
|
||||
before.decoded.project.relations[&exchange]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_initial_equal_take_acknowledges_only_kind_and_checks_authored_timer_agreement() {
|
||||
let (p, oa, sa, _) = fixture(timer("source timer"), timer("target timer"));
|
||||
let mut app = App::with_project(p);
|
||||
start(&mut app, oa);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::TakeSource,
|
||||
);
|
||||
decide(
|
||||
&mut app,
|
||||
FacetSelector::Header(HeaderFacet::Name),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(&mut app, Event::Input("/name".into(), "Final name".into()));
|
||||
assert!(state(&app).can_apply(), "{:?}", state(&app).error);
|
||||
assert_eq!(
|
||||
message_kind::value(state(&app).proposed.as_ref().unwrap(), sa),
|
||||
Some(&timer("target timer"))
|
||||
);
|
||||
assert!(!acknowledged(&app).contains(&message_kind::timer_selector()));
|
||||
let expression = format!("{}/Timer/expression", path("Sa"));
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input(expression.clone(), "authored group timer".into()),
|
||||
);
|
||||
assert!(
|
||||
!state(&app).can_apply(),
|
||||
"An unchanged initial kind cannot silently authorize a timer edit"
|
||||
);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::timer_selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input(expression.clone(), "different scalar timer".into()),
|
||||
);
|
||||
assert!(!state(&app).can_apply());
|
||||
assert!(
|
||||
state(&app)
|
||||
.error
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.contains("different timer values")
|
||||
);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input(expression, "authored group timer".into()),
|
||||
);
|
||||
assert!(state(&app).can_apply(), "{:?}", state(&app).error);
|
||||
assert!(acknowledged(&app).contains(&message_kind::timer_selector()));
|
||||
assert_eq!(
|
||||
message_kind::value(state(&app).proposed.as_ref().unwrap(), sa),
|
||||
Some(&timer("authored group timer"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_group_rejects_protected_edits_stale_plan_and_source_failure_without_losing_timer() {
|
||||
for source_failure in [false, true] {
|
||||
let (p, oa, _, _) = fixture(MessageKind::Asynchronous, timer("target"));
|
||||
let mut app = App::with_project(p);
|
||||
if source_failure {
|
||||
let bundle = app.document.bundle().clone();
|
||||
let mut limits = source_project::ProjectLimits::default();
|
||||
limits.model.max_source_bytes =
|
||||
bundle.files.values().map(String::len).sum::<usize>() + 10;
|
||||
app.document = Document::from_bundle(bundle, limits).unwrap();
|
||||
}
|
||||
start(&mut app, oa);
|
||||
decide(
|
||||
&mut app,
|
||||
message_kind::selector(),
|
||||
SemanticDecision::Candidate,
|
||||
);
|
||||
let expression = format!("{}/Timer/expression", path("Sa"));
|
||||
let raw = "retain exact timer β\n".repeat(40);
|
||||
send(&mut app, Event::Input(expression.clone(), raw.clone()));
|
||||
assert!(state(&app).can_apply(), "{:?}", state(&app).error);
|
||||
send(
|
||||
&mut app,
|
||||
Event::Input("/name".into(), "Unselected protected scope".into()),
|
||||
);
|
||||
assert!(!state(&app).can_apply());
|
||||
assert!(
|
||||
state(&app)
|
||||
.error
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.contains("selected review")
|
||||
);
|
||||
send(&mut app, Event::Preview);
|
||||
assert!(state(&app).can_apply());
|
||||
if !source_failure {
|
||||
app.document
|
||||
.execute(Command::Rename(oa, "External source edit".into()))
|
||||
.unwrap();
|
||||
}
|
||||
let before = app.document.snapshot();
|
||||
let revision = app.document.revision();
|
||||
apply(&mut app);
|
||||
assert!(state(&app).error.is_some());
|
||||
assert_eq!(state(&app).decisions.len(), 1);
|
||||
assert_eq!(
|
||||
state(&app).message_draft.as_ref().unwrap().inputs[&expression].raw,
|
||||
raw
|
||||
);
|
||||
assert_eq!(app.document.bundle(), &before.bundle);
|
||||
assert_eq!(app.document.revision(), revision);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user