TestApp

TestApp runs a view headlessly in a test. It drives the real pipeline (reactive runtime, taffy layout, semantic tree and render tree) with a recording renderer and a manual clock. You find nodes the way a user does, by role, name and text, and act on them with Testing Library verbs.

use crownui::prelude::*;
use crowntest::{Role, TestApp, role, text as text_query};
 
fn counter() -> impl View {
    component(|cx| {
        let count = cx.signal(0);
        vstack((
            text(bind(move |rt| format!("Count: {}", count.get(rt)))),
            button("+1").on_click(move |cx, _| count.update(cx, |value| *value += 1)),
        ))
    })
}
 
#[test]
fn clicking_plus_one_counts_up() {
    let mut app = TestApp::new(counter());
    app.click(role(Role::Button).name("+1"));
    assert_eq!(app.text_of(text_query("Count")), "Count: 1");
    insta::assert_snapshot!(app.snapshot());
}

pub struct TestApp<G: GraphicsBackend = RecordingBackend> { /* private */ }
 
pub use semantics::{Query, Role, name, role, text};

Signature#

Add crowntest as a dev-dependency. In the published crownui crate it is crownui::crowntest. Most methods return &mut Self, so actions chain. Every helper panics with a readable message when it fails, because a test should stop at the first wrong step. The constructors new and with_size and the methods frame_snapshot and snapshot exist only on the default RecordingBackend. Everything else works with any backend.

Queries#

pub fn role(role: Role) -> Query
pub fn name(name: impl Into<String>) -> Query
pub fn text(text: impl Into<String>) -> Query
 
impl Query {
    pub fn role(self, role: Role) -> Self;
    pub fn name(self, name: impl Into<String>) -> Self;
    pub fn text(self, text: impl Into<String>) -> Self;
}

Chain parts to narrow a query: role(Role::Button).name("Remove milk"). A query that must find one node panics with CUI0101 when nothing matches and CUI0102 when several do. Both messages list the nearby nodes with their component paths.

crowntest::text has the same name as the text view in the prelude. Import it as text as text_query, or call crowntest::text(..).

Constructors#

new mounts the view in an 800 by 600 window. with_size picks the size, which matters for scroll views and lazy lists.

let mut app = TestApp::with_size(list_view(), 300.0, 200.0);

with_surface renders with a real graphics backend into a surface, such as an offscreen GPU target for screenshots. Pick the backend with the type parameter.

Finding nodes#

SemanticNode has public fields: id, role, name, value, description, states, actions, bounds, children and path. Call exposed_value() to read the value with None for secure nodes.

let switch = app.find(role(Role::Switch).name("Wi-Fi"));
assert_eq!(switch.states.checked, Some(true));
 
assert!(!app.exists(role(Role::Text).name("milk")));
assert_eq!(app.count(role(Role::ListItem)), 3);

Actions#

Each action finds its target, performs a semantic action and renders a frame. An action on a disabled node panics with CUI0106.

• click also moves focus to the node when it is focusable.
• type_text types into the focused node, so click or focus a field first. It panics with CUI0105 on a secure field. Send each character with press_key instead.
• press_key parses a shortcut such as "Enter", "Space", "a" or "Ctrl+S" and sends it to the focused node, or to the root when nothing has focus. Shortcuts registered with .shortcut(..) fire first.
• hold_modifiers keeps modifiers held until the next call, so the next click is a Ctrl-click or a Shift-click.
• scroll scrolls the scroll container around the node by dy logical pixels. The offset clamps to the content.
• drag drags the node to (x, y) in window coordinates.

use crownui::ext::Modifiers;
 
app.click(role(Role::TextField).name("New todo"))
    .type_text("milk")
    .press_key("Enter");
 
app.hold_modifiers(Modifiers { ctrl_key: true, ..Modifiers::NONE })
    .click(role(Role::ListItem).name("report.pdf"))
    .hold_modifiers(Modifiers::NONE);

Raw pointer events#

These send primary-button mouse events through hit testing and the gesture arena, for tests of gestures, drags and long presses. The semantic actions above skip the arena.

let center = app.find(role(Role::Button).name("+1")).bounds.center();
app.pointer_down(center.x, center.y)
    .advance_ms(50)
    .pointer_up(center.x, center.y);

Clock and animation#

The clock only moves when you move it. advance_ms steps it forward and renders every frame on the way, so springs, delays and long presses progress exactly as far as you say. settle advances until every animation has stopped. is_animating reports whether the render tree still has motion in flight.

app.click(role(Role::Switch).name("Wi-Fi"));
assert!(app.is_animating());
app.settle();
assert!(!app.is_animating());

Window#

request_close acts like the compositor's close button. It returns false while a cx.on_close_requested handler prevents the close. take_close_request returns whether the app called cx.close_window() since the last call. deliver sends any raw windowing::WindowEvent, such as KeyDown or Focused(false), and renders a frame.

assert!(!app.request_close());
app.click(role(Role::Button).name("Quit anyway"));
assert!(app.take_close_request());
 
app.set_color_scheme(ColorScheme::Dark).settle();

Snapshots#

snapshot joins the other three under ## semantics, ## layout and ## frame headings. Pass it to insta::assert_snapshot!.

• The semantics part prints one node per line: role, name, value, states in brackets and bounds.
• The layout part prints each element's component path, rectangle and resolved Tailwind-style classes.
• The frame part prints the recorded draw commands: layers, fills with radius and color, and text runs.

Text is measured with a deterministic monospace approximation, so snapshots do not depend on installed fonts. Search one part with contains for a focused assertion.

assert!(app.frame_snapshot().contains("text \"Count: 1\""));
assert!(app.layout_snapshot().contains("kit_badge @24,24"));

Clipboard#

The test app keeps a fake system clipboard. set_clipboard fills it as another app copying would. The app's own copies, pastes and reads wait until you call serve_clipboard, which answers them the way the platform does. clipboard serves pending requests first, then returns what the clipboard holds as (mime type, bytes) pairs.

app.set_clipboard(&[("text/uri-list", b"file:///b")]);
app.click(role(Role::Button).name("Paste")).serve_clipboard();
 
app.click(role(Role::Button).name("Copy"));
assert_eq!(app.clipboard().len(), 3);

Drag and drop#

The first four play a drag from another app over the window. drag_acceptance reports how the window answered, as Some(..) only when the answer changed since the last call. end_drag finishes a drag the app itself started with cx.start_drag.

app.drag_enter(20.0, 20.0, &["text/uri-list"], DndActions::COPY_MOVE);
assert!(matches!(app.drag_acceptance(), Some(Some(_))));
app.drop_data(20.0, 20.0, "text/uri-list", b"file:///a", DndAction::Copy);
 
app.click(role(Role::Button).name("drag"))
    .end_drag(DragOutcome::Dropped(DndAction::Move));

Launcher events#

These play what the CrownOS compositor tells a dock or launcher. They reach cx.on_app_windows, cx.on_app_icon_lifted and cx.on_launch_app.

app.app_windows(AppWindows { app_id: "files".into(), count: 2, focused: true });
app.launch_app("files");

Escape hatches#

ui() reaches the Ui for anything the helpers do not cover, such as node_count(), tools() and call_tool(..). inline() reaches the runtime's InlineApp, which owns the clock and the renderer.

let result = app.ui().call_tool("add", r#"{"amount":5}"#);
assert_eq!(result, Ok("{\"count\":5}".to_string()));

Related#

• Testing walks through a full test suite.
• Errors lists CUI0101 to CUI0106.
• Semantic sets the names and roles queries match.