From f73ab22f2dd4fb18f23c687f83ec26ec53bafe11 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABlle=20Huisman?= <danielle@huisman.me>
Date: Thu, 14 Aug 2025 14:36:03 +0200
Subject: [PATCH] feat: add events

---
 Cargo.lock                       |   7 +
 packages/dom/Cargo.toml          |  36 ++++
 packages/dom/src/config.rs       |   1 +
 packages/dom/src/error.rs        |  20 +++
 packages/dom/src/events.rs       | 294 +++++++++++++++++++++++++++++++
 packages/dom/src/lib.rs          |   2 +
 packages/dom/src/types/config.rs |  16 +-
 packages/dom/tests/events.rs     |  75 ++++++++
 8 files changed, 450 insertions(+), 1 deletion(-)
 create mode 100644 packages/dom/src/events.rs
 create mode 100644 packages/dom/tests/events.rs

diff --git a/Cargo.lock b/Cargo.lock
index fcbde29..7c7da66 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -246,6 +246,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -281,6 +287,7 @@ dependencies = [
  "paste",
  "pretty-format",
  "regex",
+ "send_wrapper",
  "thiserror",
  "wasm-bindgen",
  "wasm-bindgen-test",
diff --git a/packages/dom/Cargo.toml b/packages/dom/Cargo.toml
index 9329ab1..24aca69 100644
--- a/packages/dom/Cargo.toml
+++ b/packages/dom/Cargo.toml
@@ -19,11 +19,24 @@ regex.workspace = true
 thiserror.workspace = true
 wasm-bindgen.workspace = true
 web-sys = { workspace = true, features = [
+    "AnimationEvent",
+    "AnimationEventInit",
     "Attr",
+    "ClipboardEvent",
+    "ClipboardEventInit",
     "Comment",
+    "CompositionEvent",
+    "CompositionEventInit",
     "Document",
     "DocumentFragment",
+    "DragEvent",
+    "DragEventInit",
     "Element",
+    "Event",
+    "EventInit",
+    "EventTarget",
+    "FocusEvent",
+    "FocusEventInit",
     "HtmlCollection",
     "HtmlElement",
     "HtmlInputElement",
@@ -31,15 +44,38 @@ web-sys = { workspace = true, features = [
     "HtmlOptionElement",
     "HtmlOptionsCollection",
     "HtmlSelectElement",
+    "InputEvent",
+    "InputEventInit",
+    "KeyboardEvent",
+    "KeyboardEventInit",
+    "MouseEvent",
+    "MouseEventInit",
     "NamedNodeMap",
     "NodeList",
+    "PageTransitionEvent",
+    "PageTransitionEventInit",
+    "PointerEvent",
+    "PointerEventInit",
+    "PopStateEvent",
+    "PopStateEventInit",
+    "ProgressEvent",
+    "ProgressEventInit",
     "Text",
+    "TouchEvent",
+    "TouchEventInit",
+    "TransitionEvent",
+    "TransitionEventInit",
+    "UiEvent",
+    "UiEventInit",
+    "WheelEvent",
+    "WheelEventInit",
     "Window",
 ] }
 
 [dev-dependencies]
 indoc = "2.0.5"
 mockall = "0.13.0"
+send_wrapper = "0.6.0"
 wasm-bindgen-test.workspace = true
 
 [lints.rust]
diff --git a/packages/dom/src/config.rs b/packages/dom/src/config.rs
index 3ac855a..22f176d 100644
--- a/packages/dom/src/config.rs
+++ b/packages/dom/src/config.rs
@@ -9,6 +9,7 @@ use crate::{
 static CONFIG: LazyLock<Arc<Mutex<Config>>> = LazyLock::new(|| {
     Arc::new(Mutex::new(Config {
         test_id_attribute: "data-testid".into(),
+        event_wrapper: Arc::new(|cb| cb()),
         default_hidden: false,
         default_ignore: "script, style".into(),
         show_original_stack_trace: false,
diff --git a/packages/dom/src/error.rs b/packages/dom/src/error.rs
index fa14019..70e7a4c 100644
--- a/packages/dom/src/error.rs
+++ b/packages/dom/src/error.rs
@@ -12,3 +12,23 @@ pub enum QueryError {
     #[error("{0}")]
     Unsupported(String),
 }
+
+#[derive(Debug, Error, PartialEq)]
+pub enum FireEventError {
+    #[error("{0:?}")]
+    JsError(JsValue),
+}
+
+#[derive(Debug, Error, PartialEq)]
+pub enum CreateEventError {
+    #[error("{0:?}")]
+    JsError(JsValue),
+}
+
+#[derive(Debug, Error, PartialEq)]
+pub enum CreateOrFireEventError {
+    #[error(transparent)]
+    Create(#[from] CreateEventError),
+    #[error(transparent)]
+    Fire(#[from] FireEventError),
+}
diff --git a/packages/dom/src/events.rs b/packages/dom/src/events.rs
new file mode 100644
index 0000000..d6c41fb
--- /dev/null
+++ b/packages/dom/src/events.rs
@@ -0,0 +1,294 @@
+use paste::paste;
+use wasm_bindgen::JsValue;
+use web_sys::{
+    AnimationEvent, AnimationEventInit, ClipboardEvent, ClipboardEventInit, CompositionEvent,
+    CompositionEventInit, DragEvent, DragEventInit, Event, EventInit, EventTarget, FocusEvent,
+    FocusEventInit, InputEvent, InputEventInit, KeyboardEvent, KeyboardEventInit, MouseEvent,
+    MouseEventInit, PageTransitionEvent, PageTransitionEventInit, PointerEvent, PointerEventInit,
+    PopStateEvent, PopStateEventInit, ProgressEvent, ProgressEventInit, TouchEvent, TouchEventInit,
+    TransitionEvent, TransitionEventInit, UiEvent, UiEventInit, WheelEvent, WheelEventInit,
+};
+
+use crate::{
+    error::{CreateEventError, CreateOrFireEventError, FireEventError},
+    get_config,
+};
+
+pub fn fire_event<E: EventType>(node: &EventTarget, event: &E) -> Result<bool, FireEventError> {
+    (get_config().event_wrapper)(&|| {
+        node.dispatch_event(event.deref_event())
+            .map_err(FireEventError::JsError)
+    })
+}
+
+pub type DefaultInitFn<E> = dyn Fn(&<E as EventType>::Init);
+
+pub struct CreateEventOptions<'a, E: EventType> {
+    default_init: Option<&'a DefaultInitFn<E>>,
+}
+
+impl<'a, E: EventType> CreateEventOptions<'a, E> {
+    fn default_init(mut self, value: &'a DefaultInitFn<E>) -> Self {
+        self.default_init = Some(value);
+        self
+    }
+}
+
+impl<'a, E: EventType> Default for CreateEventOptions<'a, E> {
+    fn default() -> Self {
+        Self {
+            default_init: Default::default(),
+        }
+    }
+}
+
+pub fn create_event<E: EventType>(
+    event_name: &str,
+    _node: &EventTarget,
+    init: Option<E::Init>,
+    options: CreateEventOptions<E>,
+) -> Result<E, CreateEventError> {
+    let event_init = init.unwrap_or_default();
+
+    if let Some(default_init) = options.default_init {
+        default_init(&event_init);
+    }
+
+    E::new(event_name, &event_init).map_err(CreateEventError::JsError)
+}
+
+pub struct CreateEvent;
+
+pub struct FireEvent;
+
+macro_rules! generate_events {
+    ($( ( $key:ident, $event_name:literal, $event_type:ty, { $( $init_key:ident : $init_value:literal ),* } ), )*) => {
+        paste! {
+            $(
+                fn [<$key default_init>](init: &[<$event_type Init>]) {
+                    $(
+                        if init.[<get_ $init_key>]().is_none() {
+                            init.[<set_ $init_key>]($init_value);
+                        }
+                    )*
+                }
+            )*
+
+            impl CreateEvent {
+                $(
+                    pub fn $key(node: &EventTarget) -> Result<$event_type, CreateEventError> {
+                        create_event($event_name, node, None, CreateEventOptions::default().default_init(&[<$key default_init>]))
+                    }
+
+                    pub fn [<$key _with_init>](node: &EventTarget, init: [<$event_type Init>]) -> Result<$event_type, CreateEventError> {
+                        create_event($event_name, node, Some(init), CreateEventOptions::default().default_init(&[<$key default_init>]))
+                    }
+                )*
+            }
+
+            impl FireEvent {
+                $(
+                    pub fn $key(node: &EventTarget) -> Result<bool, CreateOrFireEventError> {
+                        Ok(fire_event(node, &CreateEvent::$key(node)?)?)
+                    }
+
+                    pub fn [<$key _with_init>](node: &EventTarget, init: [<$event_type Init>]) -> Result<bool, CreateOrFireEventError> {
+                        Ok(fire_event(node, &CreateEvent::[<$key _with_init>](node, init)?)?)
+                    }
+                )*
+            }
+        }
+    };
+}
+
+generate_events!(
+    // Clipboard Events
+    (copy, "copy", ClipboardEvent, {bubbles: true, cancelable: true, composed: true}),
+    (cut, "cut", ClipboardEvent, {bubbles: true, cancelable: true, composed: true}),
+    (paste, "paste", ClipboardEvent, {bubbles: true, cancelable: true, composed: true}),
+    // Composition Events
+    (composition_end, "compositionend", CompositionEvent, {bubbles: true, cancelable: true, composed: true}),
+    (composition_start, "compositionstart", CompositionEvent, {bubbles: true, cancelable: true, composed: true}),
+    (composition_update, "compositionupdate", CompositionEvent, {bubbles: true, cancelable: true, composed: true}),
+    // Keyboard Events
+    (key_down, "keydown", KeyboardEvent, {bubbles: true, cancelable: true, char_code: 0, composed: true}),
+    (key_press, "keypress", KeyboardEvent, {bubbles: true, cancelable: true, char_code: 0, composed: true}),
+    (key_up, "keyup", KeyboardEvent, {bubbles: true, cancelable: true, char_code: 0, composed: true}),
+    // Focus Events
+    (focus, "focus", FocusEvent, {bubbles: false, cancelable: false, composed: true}),
+    (blur, "blur", FocusEvent, {bubbles: false, cancelable: false, composed: true}),
+    (focus_in, "focusin", FocusEvent, {bubbles: true, cancelable: false, composed: true}),
+    (focus_out, "focusout", FocusEvent, {bubbles: true, cancelable: false, composed: true}),
+    // Form Events
+    (change, "change", Event, {bubbles: true, cancelable: false}),
+    (input, "input", InputEvent, {bubbles: true, cancelable: false, composed: true}),
+    (invalid, "invalid", Event, {bubbles: false, cancelable: true}),
+    (submit, "submit", Event, {bubbles: true, cancelable: true}),
+    (reset, "reset", Event, {bubbles: true, cancelable: true}),
+    // Mouse Events
+    (click, "click", MouseEvent, {bubbles: true, cancelable: true, button: 0, composed: true}),
+    (context_menu, "contextmenu", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    (dbl_click, "dblclick", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    (drag, "drag", DragEvent, {bubbles: true, cancelable: true, composed: true}),
+    (drag_end, "dragend", DragEvent, {bubbles: true, cancelable: false, composed: true}),
+    (drag_enter, "dragenter", DragEvent, {bubbles: true, cancelable: true, composed: true}),
+    (drag_exit, "dragexit", DragEvent, {bubbles: true, cancelable: false, composed: true}),
+    (drag_leave, "dragleave", DragEvent, {bubbles: true, cancelable: false, composed: true}),
+    (drag_over, "dragover", DragEvent, {bubbles: true, cancelable: true, composed: true}),
+    (drag_start, "dragstart", DragEvent, {bubbles: true, cancelable: true, composed: true}),
+    (drop, "drop", DragEvent, {bubbles: true, cancelable: true, composed: true}),
+    (mouse_down, "mousedown", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    (mouse_enter, "mouseenter", MouseEvent, {bubbles: false, cancelable: false, composed: true}),
+    (mouse_leave, "mouseleave", MouseEvent, {bubbles: false, cancelable: false, composed: true}),
+    (mouse_move, "mousemove", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    (mouse_out, "mouseout", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    (mouse_over, "mouseover", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    (mouse_up, "mouseup", MouseEvent, {bubbles: true, cancelable: true, composed: true}),
+    // Selection Events
+    (select, "select", Event, {bubbles: true, cancelable: false}),
+    // Touch Events
+    (touch_cancel, "touchcancel", TouchEvent, {bubbles: true, cancelable: false, composed: true}),
+    (touch_end, "touchend", TouchEvent, {bubbles: true, cancelable: true, composed: true}),
+    (touch_move, "touchmove", TouchEvent, {bubbles: true, cancelable: true, composed: true}),
+    (touch_start, "touchstart", TouchEvent, {bubbles: true, cancelable: true, composed: true}),
+    // UI Events
+    (resize, "resize", UiEvent, {bubbles: false, cancelable: false}),
+    (scroll, "scroll", UiEvent, {bubbles: false, cancelable: false}),
+    // Wheel Events
+    (wheel, "wheel", WheelEvent, {bubbles: true, cancelable: true, composed: true}),
+    // Media Events
+    (abort, "abort", Event, {bubbles: false, cancelable: false}),
+    (can_play, "canplay", Event, {bubbles: false, cancelable: false}),
+    (can_play_through, "canplaythrough", Event, {bubbles: false, cancelable: false}),
+    (duration_change, "durationchange", Event, {bubbles: false, cancelable: false}),
+    (emptied, "emptied", Event, {bubbles: false, cancelable: false}),
+    (encrypted, "encrypted", Event, {bubbles: false, cancelable: false}),
+    (ended, "ended", Event, {bubbles: false, cancelable: false}),
+    (loaded_data, "loadeddata", Event, {bubbles: false, cancelable: false}),
+    (loaded_metadata, "loadedmetadata", Event, {bubbles: false, cancelable: false}),
+    (load_start, "loadstart", ProgressEvent, {bubbles: false, cancelable: false}),
+    (pause, "pause", Event, {bubbles: false, cancelable: false}),
+    (play, "play", Event, {bubbles: false, cancelable: false}),
+    (playing, "playing", Event, {bubbles: false, cancelable: false}),
+    (progress, "progress", ProgressEvent, {bubbles: false, cancelable: false}),
+    (rate_change, "ratechange", Event, {bubbles: false, cancelable: false}),
+    (seeked, "seeked", Event, {bubbles: false, cancelable: false}),
+    (seeking, "seeking", Event, {bubbles: false, cancelable: false}),
+    (stalled, "stalled", Event, {bubbles: false, cancelable: false}),
+    (suspend, "suspend", Event, {bubbles: false, cancelable: false}),
+    (time_update, "timeupdate", Event, {bubbles: false, cancelable: false}),
+    (volume_change, "volumechange", Event, {bubbles: false, cancelable: false}),
+    (waiting, "waiting", Event, {bubbles: false, cancelable: false}),
+    // Events
+    // TODO: Load events can be UIEvent or Event depending on what generated them.
+    // This is where this abstraction breaks down.
+    // But the common targets are <img />, <script /> and window.
+    // Neither of these targets receive a UIEvent.
+    (load, "load", Event, {bubbles: false, cancelable: false}),
+    (error, "error", Event, {bubbles: false, cancelable: false}),
+    // Animation Events
+    (animation_start, "animationstart", AnimationEvent, {bubbles: true, cancelable: false}),
+    (animation_end, "animationend", AnimationEvent, {bubbles: true, cancelable: false}),
+    (animation_iteration, "animationiteration", AnimationEvent, {bubbles: true, cancelable: false}),
+    // Transition Events
+    (transition_cancel, "transitioncancel", TransitionEvent, {bubbles: true, cancelable: false}),
+    (transition_end, "transitionend", TransitionEvent, {bubbles: true, cancelable: true}),
+    (transition_run, "transitionrun", TransitionEvent, {bubbles: true, cancelable: false}),
+    (transition_start, "transitionstart", TransitionEvent, {bubbles: true, cancelable: false}),
+    // Pointer events
+    (pointer_over, "pointerover", PointerEvent, {bubbles: true, cancelable: true, composed: true}),
+    (pointer_enter, "pointerenter", PointerEvent, {bubbles: false, cancelable: false}),
+    (pointer_down, "pointerdown", PointerEvent, {bubbles: true, cancelable: true, composed: true}),
+    (pointer_move, "pointermove", PointerEvent, {bubbles: true, cancelable: true, composed: true}),
+    (pointer_up, "pointerup", PointerEvent, {bubbles: true, cancelable: true, composed: true}),
+    (pointer_cancel, "pointercancel", PointerEvent, {bubbles: true, cancelable: false, composed: true}),
+    (pointer_out, "pointerout", PointerEvent, {bubbles: true, cancelable: true, composed: true}),
+    (pointer_leave, "pointerleave", PointerEvent, {bubbles: false, cancelable: false}),
+    (got_pointer_capture, "gotpointercapture", PointerEvent, {bubbles: true, cancelable: false, composed: true}),
+    (lost_pointer_capture, "lostpointercapture", PointerEvent, {bubbles: true, cancelable: false, composed: true}),
+    // History events
+    (pop_state, "popstate", PopStateEvent, {bubbles: true, cancelable: false}),
+    // Window events
+    (offline, "offline", Event, {bubbles: false, cancelable: false}),
+    (online, "online", Event, {bubbles: false, cancelable: false}),
+    (page_hide, "pagehide", PageTransitionEvent, {bubbles: true, cancelable: true}),
+    (page_show, "pageshow", PageTransitionEvent, {bubbles: true, cancelable: true}),
+);
+
+// Aliases
+impl CreateEvent {
+    pub fn double_click(node: &EventTarget) -> Result<MouseEvent, CreateEventError> {
+        CreateEvent::dbl_click(node)
+    }
+
+    pub fn double_click_with_init(
+        node: &EventTarget,
+        init: MouseEventInit,
+    ) -> Result<MouseEvent, CreateEventError> {
+        CreateEvent::dbl_click_with_init(node, init)
+    }
+}
+
+// Aliases
+impl FireEvent {
+    pub fn double_click(node: &EventTarget) -> Result<bool, CreateOrFireEventError> {
+        FireEvent::dbl_click(node)
+    }
+
+    pub fn double_click_with_init(
+        node: &EventTarget,
+        init: MouseEventInit,
+    ) -> Result<bool, CreateOrFireEventError> {
+        FireEvent::dbl_click_with_init(node, init)
+    }
+}
+
+pub trait EventType {
+    type Init: Default;
+
+    fn new(r#type: &str, init: &Self::Init) -> Result<Self, JsValue>
+    where
+        Self: std::marker::Sized;
+
+    fn deref_event(&self) -> &Event;
+}
+
+macro_rules! generate_event_types {
+    ($( ( $event_type:ty, $func:ident ), )*) => {
+        paste! {
+            $(
+                impl EventType for $event_type {
+                    type Init = [<$event_type Init>];
+
+                    fn new(r#type: &str, init: &Self::Init) -> Result<Self, JsValue> {
+                        Self::$func(r#type, init)
+                    }
+
+                    fn deref_event(&self) -> &Event {
+                        self
+                    }
+                }
+            )*
+        }
+    };
+}
+
+generate_event_types!(
+    (AnimationEvent, new_with_event_init_dict),
+    (ClipboardEvent, new_with_event_init_dict),
+    (CompositionEvent, new_with_event_init_dict),
+    (DragEvent, new_with_event_init_dict),
+    (Event, new_with_event_init_dict),
+    (FocusEvent, new_with_focus_event_init_dict),
+    (InputEvent, new_with_event_init_dict),
+    (KeyboardEvent, new_with_keyboard_event_init_dict),
+    (MouseEvent, new_with_mouse_event_init_dict),
+    (PageTransitionEvent, new_with_event_init_dict),
+    (PointerEvent, new_with_event_init_dict),
+    (PopStateEvent, new_with_event_init_dict),
+    (ProgressEvent, new_with_event_init_dict),
+    (TouchEvent, new_with_event_init_dict),
+    (TransitionEvent, new_with_event_init_dict),
+    (UiEvent, new_with_event_init_dict),
+    (WheelEvent, new_with_event_init_dict),
+);
diff --git a/packages/dom/src/lib.rs b/packages/dom/src/lib.rs
index 16f9059..0823b31 100644
--- a/packages/dom/src/lib.rs
+++ b/packages/dom/src/lib.rs
@@ -1,6 +1,7 @@
 mod config;
 mod dom_element_filter;
 mod error;
+mod events;
 mod get_node_text;
 mod get_queries_for_element;
 mod helpers;
@@ -17,6 +18,7 @@ mod wait_for;
 
 pub use config::{configure, get_config};
 pub use error::QueryError;
+pub use events::*;
 pub use get_node_text::*;
 pub use get_queries_for_element::*;
 pub use matches::get_default_normalizer;
diff --git a/packages/dom/src/types/config.rs b/packages/dom/src/types/config.rs
index 3a4daba..8ec2b96 100644
--- a/packages/dom/src/types/config.rs
+++ b/packages/dom/src/types/config.rs
@@ -2,13 +2,17 @@ use std::sync::Arc;
 
 use web_sys::Element;
 
-use crate::error::QueryError;
+use crate::error::{FireEventError, QueryError};
 
 pub type GetElementErrorFn = dyn Fn(Option<String>, Element) -> QueryError + Send + Sync;
 
+pub type EventWrapperFn =
+    dyn Fn(&dyn Fn() -> Result<bool, FireEventError>) -> Result<bool, FireEventError> + Send + Sync;
+
 #[derive(Clone)]
 pub struct Config {
     pub test_id_attribute: String,
+    pub event_wrapper: Arc<EventWrapperFn>,
     // TODO
     /// Default value for the `hidden` option in `by_role` queries.
     pub default_hidden: bool,
@@ -27,6 +31,9 @@ impl Config {
         if let Some(test_id_attribute) = other.test_id_attribute {
             self.test_id_attribute = test_id_attribute;
         }
+        if let Some(event_wrapper) = other.event_wrapper {
+            self.event_wrapper = event_wrapper;
+        }
         if let Some(default_hidden) = other.default_hidden {
             self.default_hidden = default_hidden;
         }
@@ -48,6 +55,7 @@ impl Config {
 #[derive(Clone, Default)]
 pub struct PartialConfig {
     pub test_id_attribute: Option<String>,
+    pub event_wrapper: Option<Arc<EventWrapperFn>>,
     // TODO
     /// Default value for the `hidden` option in `by_role` queries.
     pub default_hidden: Option<bool>,
@@ -67,6 +75,11 @@ impl PartialConfig {
         self
     }
 
+    pub fn event_wrapper(mut self, value: Arc<EventWrapperFn>) -> Self {
+        self.event_wrapper = Some(value);
+        self
+    }
+
     pub fn default_hidden(mut self, value: bool) -> Self {
         self.default_hidden = Some(value);
         self
@@ -97,6 +110,7 @@ impl From<&Config> for PartialConfig {
     fn from(value: &Config) -> Self {
         Self {
             test_id_attribute: Some(value.test_id_attribute.clone()),
+            event_wrapper: Some(value.event_wrapper.clone()),
             default_hidden: Some(value.default_hidden),
             default_ignore: Some(value.default_ignore.clone()),
             show_original_stack_trace: Some(value.show_original_stack_trace),
diff --git a/packages/dom/tests/events.rs b/packages/dom/tests/events.rs
new file mode 100644
index 0000000..aa2a9e6
--- /dev/null
+++ b/packages/dom/tests/events.rs
@@ -0,0 +1,75 @@
+// TODO: Enable `cfg`, disable `expect`.
+// #![cfg(target_arch = "wasm32")]
+#![allow(dead_code)]
+
+mod helpers;
+
+use mockall::automock;
+use send_wrapper::SendWrapper;
+use testing_library_dom::{CreateEventOptions, FireEvent, create_event, fire_event};
+use wasm_bindgen::{JsCast, prelude::Closure};
+use wasm_bindgen_test::{wasm_bindgen_test, wasm_bindgen_test_configure};
+use web_sys::{Event, KeyboardEvent, KeyboardEventInit};
+
+use self::helpers::test_utils::document;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+#[automock]
+trait Spy {
+    fn call_event(&self, event: SendWrapper<Event>);
+
+    fn call_keyboard_event(&self, event: SendWrapper<KeyboardEvent>);
+}
+
+// TODO: More tests.
+
+#[wasm_bindgen_test]
+fn fires_events_on_document() {
+    let document = document();
+
+    let mut mock = MockSpy::new();
+    mock.expect_call_keyboard_event().times(1).return_const(());
+
+    let listener = Closure::<dyn Fn(KeyboardEvent)>::new(move |event| {
+        mock.call_keyboard_event(SendWrapper::new(event));
+    });
+
+    document
+        .add_event_listener_with_callback("keydown", listener.as_ref().unchecked_ref())
+        .expect("Event listener should be added.");
+
+    let init = KeyboardEventInit::new();
+    init.set_key("Escape");
+    FireEvent::key_down_with_init(&document, init).expect("Event should be fired.");
+
+    document
+        .remove_event_listener_with_callback("keydown", listener.as_ref().unchecked_ref())
+        .expect("Event listener should be removed.");
+}
+
+#[wasm_bindgen_test]
+fn can_create_generic_events() {
+    let el = document()
+        .create_element("div")
+        .expect("Element should be created.");
+    let event_name = "my-custom-event";
+
+    let event = create_event::<Event>(event_name, &el, None, CreateEventOptions::default())
+        .expect("Event should be created.");
+    let wrapped_event = SendWrapper::new(event.clone());
+
+    let mut mock = MockSpy::new();
+    mock.expect_call_event()
+        .withf(move |e| **e == *wrapped_event)
+        .times(1)
+        .return_const(());
+
+    let listener = Closure::<dyn Fn(Event)>::new(move |event| {
+        mock.call_event(SendWrapper::new(event));
+    });
+    el.add_event_listener_with_callback(event_name, listener.as_ref().unchecked_ref())
+        .expect("Event listener should be added.");
+
+    fire_event(&el, &event).expect("Event should be fired");
+}