1use std::cell::RefCell;
15use std::future::Future;
16use std::pin::Pin;
17use std::rc::Rc;
18
19use day_spec::Cap;
20
21use crate::AnyPiece;
22
23#[derive(Clone, Debug, PartialEq, Eq)]
25pub struct Fail(pub String);
26
27impl std::fmt::Display for Fail {
28 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29 f.write_str(&self.0)
30 }
31}
32
33impl From<String> for Fail {
34 fn from(s: String) -> Self {
35 Fail(s)
36 }
37}
38
39impl From<&str> for Fail {
40 fn from(s: &str) -> Self {
41 Fail(s.to_owned())
42 }
43}
44
45pub type TestResult = Result<(), Fail>;
47
48#[derive(Clone, Debug, PartialEq)]
51pub enum DriveOp {
52 Tap(String),
53 Input(String, String),
54 Toggle(String, bool),
55 SetValue(String, f64),
56 Select(String, usize),
57 Focus(String),
58 Submit(String),
59 Navigate(String),
60 WaitIdle,
61 Pause(f64),
62 Shot(String),
64 AssertText(String, String),
65 AssertVisible(String),
66 AssertMissing(String),
67 AssertHidden(String),
69 Hover(String, Option<(f64, f64)>),
71 HoverLeave(String),
73 Pan(String, f64, f64),
75 Pinch(String, f64),
77 Rotate(String, f64),
79 Drag(String, (f64, f64), (f64, f64)),
81 TapAt(String, f64, f64),
83 Key(Option<String>, String),
85 AssertAnnounced(String),
87 AssertValue(String, f64),
88 AssertOn(String, bool),
90 AssertFocused(String, bool),
91 AssertRoute(String),
92 A11yAudit(Option<String>),
93 AssertNative(String, NativeExpect),
95 AssertFrame(String, FrameExpect),
97 SamplePixel(String, f64, f64, String),
99 AssertOpenedUrl(String),
101 Activate(String, usize),
103 Reorder(String, usize, usize),
105 DeleteRow(String, usize),
107 SwipeRow(String, usize, bool, usize),
110 ScrollTo(String, String),
112 Expand(String, String, bool),
114 NavBack,
116 TreeMove(String, String, Option<String>, Option<usize>),
118 ContextMenu(String, String),
120 Menu(String),
122 ToolbarPress(String),
124 ToolbarToggle(String, bool),
126 DialogScripted(bool),
128 AssertPresented(Option<String>),
130 Respond(Option<usize>),
132 RespondText(String),
134}
135
136#[derive(Clone, Debug, Default, PartialEq)]
139pub struct FrameExpect {
140 pub width: Option<f64>,
141 pub height: Option<f64>,
142 pub x: Option<f64>,
143 pub y: Option<f64>,
144 pub relative_to: Option<String>,
146 pub tolerance: Option<f64>,
148}
149
150#[derive(Clone, Debug, Default, PartialEq)]
153pub struct NativeExpect {
154 pub text: Option<String>,
156 pub number: Option<f64>,
158 pub checked: Option<bool>,
160 pub enabled: Option<bool>,
162 pub visible: Option<bool>,
164}
165
166pub type OpFuture = Pin<Box<dyn Future<Output = TestResult>>>;
168
169pub trait DriveBackend {
173 fn run(&self, op: DriveOp) -> OpFuture;
174}
175
176#[derive(Clone)]
179pub struct Drive {
180 backend: Rc<dyn DriveBackend>,
181}
182
183impl Drive {
184 pub fn new(backend: Rc<dyn DriveBackend>) -> Self {
186 Drive { backend }
187 }
188
189 fn op(&self, op: DriveOp) -> OpFuture {
190 self.backend.run(op)
191 }
192
193 pub fn tap(&self, id: &str) -> OpFuture {
194 self.op(DriveOp::Tap(id.into()))
195 }
196 pub fn input(&self, id: &str, text: &str) -> OpFuture {
198 self.op(DriveOp::Input(id.into(), text.into()))
199 }
200 pub fn toggle(&self, id: &str, on: bool) -> OpFuture {
201 self.op(DriveOp::Toggle(id.into(), on))
202 }
203 pub fn set_value(&self, id: &str, value: f64) -> OpFuture {
204 self.op(DriveOp::SetValue(id.into(), value))
205 }
206 pub fn select(&self, id: &str, index: usize) -> OpFuture {
207 self.op(DriveOp::Select(id.into(), index))
208 }
209 pub fn focus(&self, id: &str) -> OpFuture {
210 self.op(DriveOp::Focus(id.into()))
211 }
212 pub fn submit(&self, id: &str) -> OpFuture {
213 self.op(DriveOp::Submit(id.into()))
214 }
215 pub fn navigate(&self, route: &str) -> OpFuture {
216 self.op(DriveOp::Navigate(route.into()))
217 }
218 pub fn wait_idle(&self) -> OpFuture {
220 self.op(DriveOp::WaitIdle)
221 }
222 pub fn pause(&self, secs: f64) -> OpFuture {
223 self.op(DriveOp::Pause(secs))
224 }
225 pub fn shot(&self, name: &str) -> OpFuture {
227 self.op(DriveOp::Shot(name.into()))
228 }
229 pub fn assert_text(&self, id: &str, text: &str) -> OpFuture {
230 self.op(DriveOp::AssertText(id.into(), text.into()))
231 }
232 pub fn assert_visible(&self, id: &str) -> OpFuture {
233 self.op(DriveOp::AssertVisible(id.into()))
234 }
235 pub fn assert_missing(&self, id: &str) -> OpFuture {
236 self.op(DriveOp::AssertMissing(id.into()))
237 }
238 pub fn hover(&self, id: &str, at: Option<(f64, f64)>) -> OpFuture {
240 self.op(DriveOp::Hover(id.into(), at))
241 }
242 pub fn hover_leave(&self, id: &str) -> OpFuture {
244 self.op(DriveOp::HoverLeave(id.into()))
245 }
246 pub fn pan(&self, id: &str, dx: f64, dy: f64) -> OpFuture {
248 self.op(DriveOp::Pan(id.into(), dx, dy))
249 }
250 pub fn pinch(&self, id: &str, scale: f64) -> OpFuture {
252 self.op(DriveOp::Pinch(id.into(), scale))
253 }
254 pub fn rotate(&self, id: &str, rotation: f64) -> OpFuture {
256 self.op(DriveOp::Rotate(id.into(), rotation))
257 }
258 pub fn drag(&self, id: &str, from: (f64, f64), to: (f64, f64)) -> OpFuture {
260 self.op(DriveOp::Drag(id.into(), from, to))
261 }
262 pub fn tap_at(&self, id: &str, x: f64, y: f64) -> OpFuture {
264 self.op(DriveOp::TapAt(id.into(), x, y))
265 }
266 pub fn key(&self, id: Option<&str>, key: &str) -> OpFuture {
269 self.op(DriveOp::Key(id.map(str::to_owned), key.into()))
270 }
271 pub fn assert_announced(&self, text: &str) -> OpFuture {
273 self.op(DriveOp::AssertAnnounced(text.into()))
274 }
275 pub fn assert_hidden(&self, id: &str) -> OpFuture {
278 self.op(DriveOp::AssertHidden(id.into()))
279 }
280 pub fn assert_value(&self, id: &str, value: f64) -> OpFuture {
281 self.op(DriveOp::AssertValue(id.into(), value))
282 }
283 pub fn assert_on(&self, id: &str, on: bool) -> OpFuture {
285 self.op(DriveOp::AssertOn(id.into(), on))
286 }
287 pub fn assert_focused(&self, id: &str, focused: bool) -> OpFuture {
288 self.op(DriveOp::AssertFocused(id.into(), focused))
289 }
290 pub fn assert_route(&self, route: &str) -> OpFuture {
291 self.op(DriveOp::AssertRoute(route.into()))
292 }
293 pub fn a11y_audit(&self, id: Option<&str>) -> OpFuture {
296 self.op(DriveOp::A11yAudit(id.map(str::to_owned)))
297 }
298
299 pub fn assert_native(&self, id: &str, expect: NativeExpect) -> OpFuture {
304 self.op(DriveOp::AssertNative(id.into(), expect))
305 }
306 pub fn assert_frame(&self, id: &str, expect: FrameExpect) -> OpFuture {
308 self.op(DriveOp::AssertFrame(id.into(), expect))
309 }
310 pub fn assert_size(&self, id: &str, width: f64, height: f64) -> OpFuture {
312 self.assert_frame(
313 id,
314 FrameExpect {
315 width: Some(width),
316 height: Some(height),
317 ..Default::default()
318 },
319 )
320 }
321 pub fn sample_pixel(&self, id: &str, x: f64, y: f64, color: &str) -> OpFuture {
324 self.op(DriveOp::SamplePixel(id.into(), x, y, color.into()))
325 }
326 pub fn assert_opened_url(&self, url: &str) -> OpFuture {
329 self.op(DriveOp::AssertOpenedUrl(url.into()))
330 }
331 pub fn assert_enabled(&self, id: &str, enabled: bool) -> OpFuture {
333 self.assert_native(
334 id,
335 NativeExpect {
336 enabled: Some(enabled),
337 ..Default::default()
338 },
339 )
340 }
341
342 pub fn activate(&self, id: &str, index: usize) -> OpFuture {
344 self.op(DriveOp::Activate(id.into(), index))
345 }
346 pub fn reorder(&self, id: &str, from: usize, to: usize) -> OpFuture {
348 self.op(DriveOp::Reorder(id.into(), from, to))
349 }
350 pub fn delete_row(&self, id: &str, row: usize) -> OpFuture {
352 self.op(DriveOp::DeleteRow(id.into(), row))
353 }
354 pub fn swipe_row(&self, id: &str, row: usize, leading: bool, action: usize) -> OpFuture {
356 self.op(DriveOp::SwipeRow(id.into(), row, leading, action))
357 }
358 pub fn scroll_to(&self, id: &str, edge: &str) -> OpFuture {
360 self.op(DriveOp::ScrollTo(id.into(), edge.into()))
361 }
362 pub fn expand(&self, id: &str, row: &str, expanded: bool) -> OpFuture {
364 self.op(DriveOp::Expand(id.into(), row.into(), expanded))
365 }
366 pub fn nav_back(&self) -> OpFuture {
368 self.op(DriveOp::NavBack)
369 }
370 pub fn tree_move(
373 &self,
374 id: &str,
375 row: &str,
376 parent: Option<&str>,
377 index: Option<usize>,
378 ) -> OpFuture {
379 self.op(DriveOp::TreeMove(
380 id.into(),
381 row.into(),
382 parent.map(str::to_owned),
383 index,
384 ))
385 }
386
387 pub fn context_menu(&self, id: &str, item: &str) -> OpFuture {
390 self.op(DriveOp::ContextMenu(id.into(), item.into()))
391 }
392 pub fn menu(&self, item_id: &str) -> OpFuture {
394 self.op(DriveOp::Menu(item_id.into()))
395 }
396 pub fn toolbar_press(&self, item: &str) -> OpFuture {
398 self.op(DriveOp::ToolbarPress(item.into()))
399 }
400 pub fn toolbar_toggle(&self, item: &str, on: bool) -> OpFuture {
402 self.op(DriveOp::ToolbarToggle(item.into(), on))
403 }
404 pub fn dialogs_scripted(&self, scripted: bool) -> OpFuture {
408 self.op(DriveOp::DialogScripted(scripted))
409 }
410 pub fn assert_presented(&self, title: Option<&str>) -> OpFuture {
412 self.op(DriveOp::AssertPresented(title.map(str::to_owned)))
413 }
414 pub fn respond(&self, button: Option<usize>) -> OpFuture {
417 self.op(DriveOp::Respond(button))
418 }
419
420 pub fn respond_text(&self, text: &str) -> OpFuture {
422 self.op(DriveOp::RespondText(text.into()))
423 }
424
425 pub fn check(&self, ok: bool, what: &str) -> TestResult {
427 if ok { Ok(()) } else { Err(Fail(what.into())) }
428 }
429 pub fn check_eq<T: PartialEq + std::fmt::Debug>(&self, got: T, want: T) -> TestResult {
431 if got == want {
432 Ok(())
433 } else {
434 Err(Fail(format!("{got:?} ≠ expected {want:?}")))
435 }
436 }
437}
438
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
441pub enum TestKind {
442 Gui,
443 Headless,
444}
445
446type Body = Rc<dyn Fn(Drive) -> Pin<Box<dyn Future<Output = TestResult>>>>;
447
448#[derive(Clone)]
452pub struct Case {
453 name: String,
454 kind: TestKind,
455 proves: Vec<String>,
456 requires: Vec<Cap>,
457 requires_support: Vec<(String, fn() -> day_spec::Support)>,
459 page: Option<Rc<dyn Fn() -> AnyPiece>>,
460 shots: Vec<String>,
461 body: Option<Body>,
462 timeout_secs: Option<f64>,
463}
464
465impl Default for Case {
466 fn default() -> Self {
467 Case::new()
468 }
469}
470
471impl Case {
472 pub fn new() -> Self {
474 Case {
475 name: String::new(),
476 kind: TestKind::Gui,
477 proves: Vec::new(),
478 requires: Vec::new(),
479 requires_support: Vec::new(),
480 page: None,
481 shots: Vec::new(),
482 body: None,
483 timeout_secs: None,
484 }
485 }
486 pub fn headless() -> Self {
488 Case {
489 kind: TestKind::Headless,
490 ..Case::new()
491 }
492 }
493 pub fn timeout(mut self, secs: f64) -> Self {
496 self.timeout_secs = Some(secs);
497 self
498 }
499 pub fn proves(mut self, kind: &str) -> Self {
502 self.proves.push(format!("kind:{kind}"));
503 self
504 }
505 pub fn proves_cap(mut self, cap: Cap) -> Self {
507 self.proves.push(format!("cap:{cap:?}"));
508 self
509 }
510 pub fn proves_modifier(mut self, modifier: &str) -> Self {
512 self.proves.push(format!("modifier:{modifier}"));
513 self
514 }
515 pub fn proves_duty(mut self, duty: &str) -> Self {
517 self.proves.push(format!("duty:{duty}"));
518 self
519 }
520 pub fn requires(mut self, cap: Cap) -> Self {
523 self.requires.push(cap);
524 self
525 }
526 pub fn requires_support(mut self, what: &str, support: fn() -> day_spec::Support) -> Self {
530 self.requires_support.push((what.to_owned(), support));
531 self
532 }
533 pub fn missing_support(&self) -> Option<String> {
535 self.requires_support
536 .iter()
537 .find(|(_, f)| f() == day_spec::Support::Unsupported)
538 .map(|(what, _)| what.clone())
539 }
540 pub fn page<P: crate::Piece>(mut self, page: impl Fn() -> P + 'static) -> Self {
542 self.page = Some(Rc::new(move || AnyPiece::new(page())));
543 self
544 }
545 pub fn shot(mut self, name: &str) -> Self {
547 self.shots.push(name.into());
548 self
549 }
550 pub fn drive<F>(mut self, body: impl Fn(Drive) -> F + 'static) -> Self
554 where
555 F: Future<Output = TestResult> + 'static,
556 {
557 self.body = Some(Rc::new(move |d| Box::pin(body(d))));
558 self
559 }
560 pub fn run<F>(self, body: impl Fn(Drive) -> F + 'static) -> Self
562 where
563 F: Future<Output = TestResult> + 'static,
564 {
565 self.drive(body)
566 }
567
568 pub fn name(&self) -> &str {
571 &self.name
572 }
573 pub fn timeout_secs(&self) -> Option<f64> {
575 self.timeout_secs
576 }
577 pub fn kind(&self) -> TestKind {
578 self.kind
579 }
580 pub fn proves_keys(&self) -> &[String] {
582 &self.proves
583 }
584 pub fn requirements(&self) -> &[Cap] {
585 &self.requires
586 }
587 pub fn shots(&self) -> &[String] {
589 &self.shots
590 }
591 pub fn build_page(&self) -> Option<AnyPiece> {
593 self.page.as_ref().map(|p| p())
594 }
595 pub fn run_body(&self, drive: Drive) -> Pin<Box<dyn Future<Output = TestResult>>> {
597 match &self.body {
598 Some(body) => body(drive),
599 None => Box::pin(async { Ok(()) }),
600 }
601 }
602}
603
604#[derive(Clone, Copy)]
607pub struct TestFn {
608 ident: &'static str,
609 build: fn() -> Case,
610}
611
612impl TestFn {
613 pub const fn new(ident: &'static str, build: fn() -> Case) -> Self {
615 TestFn { ident, build }
616 }
617 pub fn name(&self) -> String {
619 let last = self.ident.rsplit("::").next().unwrap_or(self.ident);
620 last.trim().replace('_', "-")
621 }
622 pub fn case(&self) -> Case {
624 let mut case = (self.build)();
625 case.name = self.name();
626 case
627 }
628}
629
630mod registry;
631pub use registry::validate_registry;
632#[cfg(target_arch = "wasm32")]
633pub use registry::{Registration, install_web_registry};
634
635#[cfg(not(target_arch = "wasm32"))]
637#[linkme::distributed_slice]
638pub static TESTS: [TestFn];
639
640type HostNotify = Rc<dyn Fn()>;
642
643day_reactive::tls_slots! {
644 conformance;
645 static RUNTIME: RefCell<Vec<TestFn>> = const { RefCell::new(Vec::new()) };
646 static ACTIVE: RefCell<Option<Case>> = const { RefCell::new(None) };
649 static HOST: RefCell<Option<HostNotify>> = const { RefCell::new(None) };
651 static PAGE_PANIC: RefCell<Option<String>> = const { RefCell::new(None) };
653 static OPENED: RefCell<Option<Vec<String>>> = const { RefCell::new(None) };
655 static ANNOUNCED: RefCell<Option<Vec<String>>> = const { RefCell::new(None) };
657}
658
659pub fn set_intercepting_urls(on: bool) {
663 OPENED.with(|o| *o.borrow_mut() = on.then(Vec::new));
664 ANNOUNCED.with(|a| *a.borrow_mut() = on.then(Vec::new));
665}
666
667pub fn note_announcement(text: &str) {
671 ANNOUNCED.with(|a| {
672 if let Some(list) = a.borrow_mut().as_mut() {
673 list.push(text.to_owned());
674 }
675 });
676}
677
678pub fn announcements() -> Vec<String> {
680 ANNOUNCED.with(|a| a.borrow().clone().unwrap_or_default())
681}
682
683pub fn intercept_open_url(url: &str) -> bool {
685 OPENED.with(|o| match o.borrow_mut().as_mut() {
686 Some(list) => {
687 list.push(url.to_owned());
688 true
689 }
690 None => false,
691 })
692}
693
694pub fn opened_urls() -> Vec<String> {
696 OPENED.with(|o| o.borrow().clone().unwrap_or_default())
697}
698
699pub fn register(test: TestFn) {
701 RUNTIME.with(|r| {
702 let mut r = r.borrow_mut();
703 if !r.iter().any(|t| std::ptr::fn_addr_eq(t.build, test.build)) {
704 r.push(test);
705 }
706 });
707}
708
709pub fn tests() -> Vec<TestFn> {
711 let mut all: Vec<TestFn> = Vec::new();
712 all.extend(registry::compiled_tests());
713 RUNTIME.with(|r| {
714 for t in r.borrow().iter() {
715 if !all.iter().any(|a| std::ptr::fn_addr_eq(a.build, t.build)) {
716 all.push(*t);
717 }
718 }
719 });
720 all
721}
722
723pub fn cases() -> Vec<Case> {
725 let mut cases: Vec<Case> = tests().iter().map(TestFn::case).collect();
726 cases.sort_by(|a, b| a.name.cmp(&b.name));
727 cases
728}
729
730pub fn set_active(case: Case) -> bool {
733 ACTIVE.with(|a| *a.borrow_mut() = Some(case));
734 PAGE_PANIC.with(|p| *p.borrow_mut() = None);
735 notify_host()
736}
737
738pub fn clear_active() {
740 ACTIVE.with(|a| *a.borrow_mut() = None);
741 notify_host();
742}
743
744fn notify_host() -> bool {
745 let host = HOST.with(|h| h.borrow().clone());
746 match host {
747 Some(rebuild) => {
748 rebuild();
749 true
750 }
751 None => false,
752 }
753}
754
755pub fn active() -> Option<Case> {
757 ACTIVE.with(|a| a.borrow().clone())
758}
759
760pub fn set_host(rebuild: Option<Rc<dyn Fn()>>) {
763 HOST.with(|h| *h.borrow_mut() = rebuild);
764}
765
766pub fn note_page_panic(message: String) {
768 PAGE_PANIC.with(|p| *p.borrow_mut() = Some(message));
769}
770
771pub fn take_page_panic() -> Option<String> {
773 PAGE_PANIC.with(|p| p.borrow_mut().take())
774}
775
776pub fn panic_message(payload: &(dyn std::any::Any + Send)) -> String {
778 if let Some(s) = payload.downcast_ref::<&str>() {
779 (*s).to_owned()
780 } else if let Some(s) = payload.downcast_ref::<String>() {
781 s.clone()
782 } else {
783 "a panic with no message".to_owned()
784 }
785}
786
787pub fn case_named(name: &str) -> Option<Case> {
790 tests()
791 .into_iter()
792 .find(|t| t.name() == name)
793 .map(|t| t.case())
794}