use day_core::conformance::{Case, Drive, TestFn};
use day_mock::MockToolkit;
use day_pieces::Decorate;
use day_script::conformance::{Outcome, RunReport, ShotPolicy};
use day_script::{Reply, Step};
use day_spec::{Size, WindowOptions};
fn boot() -> day_mock::MockProbe {
boot_with(|| {
day_core::AnyPiece::new(day_pieces::test_host(day_pieces::conformance::test_pages))
})
}
fn boot_with(root: impl FnOnce() -> day_core::AnyPiece + 'static) -> day_mock::MockProbe {
day_core::uninstall_tree();
let (mock, probe) = MockToolkit::new();
probe.set_native_behavior(20);
probe.state.borrow_mut().native_window_tabs = true;
probe.set_native_list_items(true);
day_core::launch_with(
mock,
WindowOptions {
title: "conformance".into(),
size: Size::new(400.0, 600.0),
..Default::default()
},
root,
);
probe
}
fn run(filter: &[&str]) -> RunReport {
run_with(filter, Some(0.0))
}
fn run_with(filter: &[&str], case_timeout_secs: Option<f64>) -> RunReport {
let step = Step::RunTests {
filter: filter
.iter()
.map(std::string::ToString::to_string)
.collect(),
shots: ShotPolicy::Never,
timeout_secs: None,
case_timeout_secs,
};
for _ in 0..100 {
let reply: Reply = day_script::step(step.clone());
if reply.ok {
let data = reply.data.expect("a finished run answers its report");
return serde_json::from_value(data).expect("the report decodes");
}
assert!(reply.retryable, "{:?}", reply.error);
}
panic!("the run never finished");
}
#[test]
fn every_built_in_case_passes_on_the_mock() {
let _probe = boot();
let listing = day_script::step(Step::Tests)
.data
.expect("tests lists the registry");
let names: Vec<&str> = listing
.as_array()
.expect("a list")
.iter()
.filter_map(|t| t.get("name").and_then(|n| n.as_str()))
.collect();
assert!(names.contains(&"button-press"), "{names:?}");
let report = run(&[]);
assert_eq!(report.tests.len(), names.len());
let failed: Vec<String> = report
.tests
.iter()
.filter(|t| t.verdict != "pass")
.map(|t| {
format!(
"{}: {} {}",
t.name,
t.verdict,
t.message.clone().or(t.reason.clone()).unwrap_or_default()
)
})
.collect();
assert!(failed.is_empty(), "{failed:#?}");
}
#[test]
fn a_filter_selects_by_glob() {
let _probe = boot();
let report = run(&["text-field-*"]);
let names: Vec<&str> = report.tests.iter().map(|t| t.name.as_str()).collect();
assert_eq!(
names,
[
"text-field-binding",
"text-field-disabled",
"text-field-max-length",
"text-field-read-only",
"text-field-secure",
"text-field-submit"
]
);
assert!(
report.tests.iter().all(|t| t.verdict == "pass"),
"{report:?}"
);
}
fn only(report: &RunReport, name: &str) -> Outcome {
let found: Vec<&Outcome> = report.tests.iter().filter(|t| t.name == name).collect();
assert_eq!(found.len(), 1, "{report:?}");
found[0].clone()
}
fn panics_in_its_drive() -> Case {
Case::new()
.page(|| day_pieces::label("here").id(day_core::id!(pd_label)))
.drive(|d: Drive| async move {
d.assert_text("pd_label", "here").await?;
panic!("the drive gave up");
})
}
fn panics_in_its_page() -> Case {
Case::new()
.page(|| -> day_pieces::Label { panic!("no page today") })
.drive(|_d: Drive| async move { Ok(()) })
}
fn panics_headless() -> Case {
Case::headless().run(|_t: Drive| async move { panic!("headless boom") })
}
fn never_finishes() -> Case {
Case::headless().timeout(0.05).run(|_t: Drive| async move {
std::future::pending::<day_core::conformance::TestResult>().await
})
}
fn shares_a_name() -> Case {
Case::headless()
}
mod elsewhere {
pub fn shares_a_name() -> day_core::conformance::Case {
day_core::conformance::Case::headless()
}
}
#[test]
fn a_panic_fails_its_case_and_the_run_goes_on() {
let _probe = boot();
for t in [
TestFn::new("panics_in_its_drive", panics_in_its_drive),
TestFn::new("panics_in_its_page", panics_in_its_page),
TestFn::new("panics_headless", panics_headless),
] {
day_core::conformance::register(t);
}
let report = run(&["panics-*", "button-press"]);
let drive = only(&report, "panics-in-its-drive");
assert_eq!(drive.verdict, "fail");
assert!(
drive
.message
.as_deref()
.unwrap_or("")
.contains("the drive gave up"),
"{drive:?}"
);
let page = only(&report, "panics-in-its-page");
assert_eq!(page.verdict, "fail");
assert!(
page.message
.as_deref()
.unwrap_or("")
.contains("no page today"),
"{page:?}"
);
let headless = only(&report, "panics-headless");
assert!(
headless
.message
.as_deref()
.unwrap_or("")
.contains("headless boom"),
"{headless:?}"
);
assert_eq!(only(&report, "button-press").verdict, "pass");
}
#[test]
fn a_case_past_its_limit_fails_as_timed_out() {
let _probe = boot();
day_core::conformance::register(TestFn::new("never_finishes", never_finishes));
let report = run_with(&["never-finishes"], None);
let t = only(&report, "never-finishes");
assert_eq!(t.verdict, "fail");
assert!(
t.message.as_deref().unwrap_or("").contains("timed out"),
"{t:?}"
);
}
#[test]
fn two_tests_with_one_name_both_fail() {
let _probe = boot();
day_core::conformance::register(TestFn::new("shares_a_name", shares_a_name));
day_core::conformance::register(TestFn::new(
"elsewhere::shares_a_name",
elsewhere::shares_a_name,
));
let report = run(&["shares-a-name"]);
assert_eq!(report.tests.len(), 2, "{report:?}");
assert!(
report.tests.iter().all(|t| t.verdict == "fail"),
"{report:?}"
);
}
#[test]
fn a_gui_case_needs_a_test_host() {
let _probe = boot_with(|| day_core::AnyPiece::new(day_pieces::label("no host here")));
let report = run(&["button-press"]);
let t = only(&report, "button-press");
assert_eq!(t.verdict, "fail");
assert!(
t.message.as_deref().unwrap_or("").contains("test host"),
"{t:?}"
);
}
#[test]
fn test_names_come_from_the_function() {
assert_eq!(
TestFn::new("button_press", shares_a_name).name(),
"button-press"
);
assert_eq!(
TestFn::new("a :: b :: text_field_secure", shares_a_name).name(),
"text-field-secure"
);
}
fn reads_what_the_mock_cannot() -> Case {
Case::new()
.page(|| day_pieces::label("here").id(day_core::id!(unread_label)))
.drive(|d: Drive| async move {
d.assert_native(
"unread_label",
day_core::conformance::NativeExpect {
visible: Some(true),
..Default::default()
},
)
.await
})
}
#[test]
fn a_native_field_the_toolkit_cannot_read_is_recorded_not_failed() {
let _probe = boot();
day_core::conformance::register(TestFn::new(
"reads_what_the_mock_cannot",
reads_what_the_mock_cannot,
));
let t = only(
&run(&["reads-what-the-mock-cannot"]),
"reads-what-the-mock-cannot",
);
assert_eq!(t.verdict, "pass", "{t:?}");
assert_eq!(t.native_unread, ["unread_label visible"]);
let report = run(&["button-*", "text-field-*", "toggle-*", "slider-*"]);
for t in &report.tests {
assert!(t.native_unread.is_empty(), "{t:?}");
}
}
#[test]
fn picker_selection_rejects_invalid_indices_without_changing_selection() {
let _probe = boot_with(|| {
day_core::AnyPiece::new(
day_pieces::picker(
day_reactive::Signal::new(0usize),
[(0usize, "First"), (1, "Second")],
)
.id(day_core::id!(picker_bounds)),
)
});
for index in [-1, 2, 999] {
let reply = day_script::step(Step::Select {
id: "picker_bounds".into(),
index,
if_present: false,
});
assert!(!reply.ok && !reply.retryable, "{reply:?}");
assert!(reply.error.unwrap().contains("out of range for 2 options"));
}
let current: Step = serde_json::from_value(serde_json::json!({
"op": "assert_text", "id": "picker_bounds", "text": "First"
}))
.unwrap();
assert!(day_script::step(current).ok);
assert!(
day_script::step(Step::Select {
id: "picker_bounds".into(),
index: 1,
if_present: false,
})
.ok
);
let current: Step = serde_json::from_value(serde_json::json!({
"op": "assert_text", "id": "picker_bounds", "text": "Second"
}))
.unwrap();
assert!(day_script::step(current).ok);
}
#[test]
fn a_disabled_menu_item_is_retried_not_failed() {
use day_pieces::Decorate;
let enabled = day_reactive::Signal::global(false);
let _probe = boot_with(move || {
day_core::AnyPiece::new(
day_pieces::label("Host")
.context_menu(move || {
vec![
day_pieces::menu_item("Go")
.enabled(move || enabled.get())
.action(|| {})
.id(day_core::id!(go_item)),
]
})
.id(day_core::id!(menu_host)),
)
});
let choose: Step = serde_json::from_value(serde_json::json!({
"op": "context_menu", "id": "menu_host", "item_id": "go_item"
}))
.unwrap();
let reply = day_script::step(choose.clone());
assert!(!reply.ok && reply.retryable, "{reply:?}");
enabled.set(true);
day_reactive::flush_sync();
assert!(day_script::step(choose).ok);
}
#[test]
fn the_animation_cases_catch_a_faulty_animator() {
use day_mock::AnimFlaw;
const CASES: [&str; 8] = [
"animation-autoreverse-plays-back",
"animation-background-passes-between",
"animation-delay-holds-the-start",
"animation-frame-passes-between",
"animation-repeat-plays-every-cycle",
"animation-repeats-forever-until-set",
"animation-retargets-from-the-value-shown",
"animation-spring-overshoots-and-settles",
];
let probe = boot();
let verdicts = |flaw: Option<AnimFlaw>| -> Vec<(String, bool)> {
probe.set_animation_flaw(flaw);
let report = run(&["animation-*"]);
let names: Vec<&str> = report.tests.iter().map(|t| t.name.as_str()).collect();
for case in CASES {
assert!(names.contains(&case), "{case} did not run: {names:?}");
}
report
.tests
.iter()
.filter(|t| CASES.contains(&t.name.as_str()))
.map(|t| {
assert!(
t.native_unread.is_empty(),
"{}: {:?}",
t.name,
t.native_unread
);
(t.name.clone(), t.verdict == "pass")
})
.collect()
};
let failed = |flaw: AnimFlaw| -> Vec<String> {
verdicts(Some(flaw))
.into_iter()
.filter(|(_, passed)| !passed)
.map(|(name, _)| name)
.collect()
};
let faithful = verdicts(None);
assert!(faithful.iter().all(|(_, passed)| *passed), "{faithful:?}");
assert_eq!(
failed(AnimFlaw::IgnoresDelay),
["animation-delay-holds-the-start"]
);
assert_eq!(
failed(AnimFlaw::IgnoresRepeat),
[
"animation-autoreverse-plays-back",
"animation-repeat-plays-every-cycle",
"animation-repeats-forever-until-set",
]
);
assert_eq!(
failed(AnimFlaw::IgnoresAutoreverse),
[
"animation-autoreverse-plays-back",
"animation-repeats-forever-until-set",
]
);
assert_eq!(
failed(AnimFlaw::FlattensSprings),
["animation-spring-overshoots-and-settles"]
);
assert_eq!(
failed(AnimFlaw::SnapsBackground),
["animation-background-passes-between"]
);
assert_eq!(failed(AnimFlaw::Instant), CASES);
probe.set_animation_flaw(None);
}
#[test]
fn the_mock_records_and_plays_requested_animations() {
use day_mock::AnimProperty;
use day_spec::AnimSpec;
let level = day_reactive::Signal::global(1.0);
let probe = boot_with(move || {
day_core::AnyPiece::new(
day_pieces::rectangle()
.frame(40.0, 40.0)
.id(day_core::id!(faded))
.opacity(level),
)
});
let spec = AnimSpec::linear(400).delay(200).repeat(1, true);
day_core::with_animation(spec, || level.set(0.0));
let layer = {
let state = probe.state.borrow();
let (id, widget) = state
.widgets
.iter()
.find(|(_, w)| !w.animations.is_empty())
.expect("a widget was asked to animate");
let asked = widget.animations[0];
assert_eq!((asked.property, asked.spec), (AnimProperty::Opacity, spec));
assert_eq!(widget.opacity, Some(0.0), "the model value is the target");
day_mock::MockHandle(*id)
};
let shown = |ms: u32| {
probe.advance(ms);
probe.widget(layer).shown_opacity()
};
assert!((shown(100) - 1.0).abs() < 1e-9, "held through the delay");
assert!((shown(300) - 0.5).abs() < 1e-9, "half way out");
assert!((shown(400) - 0.5).abs() < 1e-9, "half way back");
assert!((shown(300) - 0.0).abs() < 1e-9, "at rest on the target");
day_core::with_animation(spec, || level.set(1.0));
level.set(0.25);
day_reactive::flush_sync();
assert!((shown(0) - 0.25).abs() < 1e-9);
}