Files
dioxus/packages/desktop/headless_tests/utils.rs
T
Evan AlmloffandJonathan Kelley 20d146d9bd Simplify the launch builder (#2967)
* improve documentation for the fullstack server context

* Add a section about axum integration to the crate root docs

* make serve_dioxus_application accept the cfg builder directly

* remove unused server_fn module

* improve fullstack config docs

* improve documentation for the server function macro

* fix axum router extension link

* Fix doc tests

* Fix launch builder

* Simplify the launch builder

* don't re-export launch in the prelude

* refactor fullstack launch

* Fix fullstack launch builder

* Update static generation with the new builder api

* fix some formatting/overly broad launch replacements

* fix custom menu example

* fix fullstack/static generation examples

* Fix static generation launch

* A few small formatting fixes

* Fix a few doc tests

* implement LaunchConfig for serve configs

* fix fullstack launch with separate web and server launch methods

* fix check with all features

* dont expose inner core module

* clippy and check

* fix readme

---------

Co-authored-by: Jonathan Kelley <jkelleyrtp@gmail.com>
2024-10-10 16:00:58 -07:00

57 lines
1.9 KiB
Rust

#![allow(unused)] // for whatever reason, the compiler is not recognizing the use of these functions
use dioxus::prelude::*;
use dioxus_core::Element;
pub fn check_app_exits(app: fn() -> Element) {
use dioxus_desktop::tao::window::WindowBuilder;
use dioxus_desktop::Config;
// This is a deadman's switch to ensure that the app exits
let should_panic = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
let should_panic_clone = should_panic.clone();
std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_secs(60));
if should_panic_clone.load(std::sync::atomic::Ordering::SeqCst) {
eprintln!("App did not exit in time");
std::process::exit(exitcode::SOFTWARE);
}
});
dioxus::LaunchBuilder::desktop()
.with_cfg(Config::new().with_window(WindowBuilder::new().with_visible(false)))
.launch(app);
// Stop deadman's switch
should_panic.store(false, std::sync::atomic::Ordering::SeqCst);
}
pub static EXPECTED_EVENTS: GlobalSignal<usize> = Signal::global(|| 0);
pub fn mock_event(id: &'static str, value: &'static str) {
mock_event_with_extra(id, value, "");
}
pub fn mock_event_with_extra(id: &'static str, value: &'static str, extra: &'static str) {
use_hook(move || {
EXPECTED_EVENTS.with_mut(|x| *x += 1);
spawn(async move {
// We need to wait for edits to be applied before we can send the event
// Sometimes (windows...) this takes a while
// we should really be running this check when mounted
tokio::time::sleep(std::time::Duration::from_millis(10000)).await;
let js = format!(
r#"
let event = {value};
let element = document.getElementById('{id}');
{extra}
element.dispatchEvent(event);
"#
);
eval(&js).await.unwrap();
});
})
}