@daiso-tech/core 0.39.0 → 0.41.0

package/dist/event-bus/implementations/test-utilities/event-bus.test-suite.js

@@ -1,11 +1,11 @@
 /**
  * @module EventBus
  */
-import {} from "vitest";
+import { vi, } from "vitest";
 import {} from "../../../event-bus/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
-import { TimeSpan } from "../../../utilities/_module-exports.js";
-import { LazyPromise } from "../../../async/_module-exports.js";
+import { Task } from "../../../task/_module-exports.js";
+import { TimeSpan } from "../../../time-span/implementations/_module-exports.js";
 /**
  * The `eventBusTestSuite` function simplifies the process of testing your custom implementation of {@link IEventBus | `IEventBus`} with vitest.
  *
@@ -16,104 +16,36 @@ export function eventBusTestSuite(settings) {
     const { expect, test, describe, createEventBus, beforeEach } = settings;
     const TTL = TimeSpan.fromMilliseconds(50);
     let eventBus;
-    beforeEach(async () => {
-        eventBus = await createEventBus();
-    });
-    describe("method: addListener, removeListener, dispatch", () => {
-        describe("Should be null when listener is added and event is not triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+    describe("Reusable tests:", () => {
+        beforeEach(async () => {
+            eventBus = await createEventBus();
+        });
+        async function delay(time) {
+            await Task.delay(time);
+        }
+        describe("method: addListener, removeListener, dispatch", () => {
+            test("Should not call listener when listener is added and event is not triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.addListener("add", listener);
-                expect(listener.result).toBeNull();
+                expect(listener).toHaveBeenCalledTimes(0);
                 await eventBus.removeListener("add", listener);
             });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.addListener("add", listener);
-                expect(listener.result).toBeNull();
-                await eventBus.removeListener("add", listener);
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.addListener("add", listener);
-                expect(result).toBeNull();
-                await eventBus.removeListener("add", listener);
-            });
-        });
-        describe("Should be AddEvent when listener is added and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+            test("Should call listener 2 times with AddEvent when listener is added and event is triggered 2 times", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.addListener("add", listener);
                 const event = {
                     a: 1,
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
-                await eventBus.removeListener("add", listener);
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.addListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
-                await eventBus.removeListener("add", listener);
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.addListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toEqual(event);
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(2);
+                expect(listener).toHaveBeenCalledWith(event);
                 await eventBus.removeListener("add", listener);
             });
-        });
-        describe("Should be null when listener is removed and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+            test("Should not call listener when listener is removed and event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.addListener("add", listener);
                 await eventBus.removeListener("add", listener);
                 const event = {
@@ -121,172 +53,33 @@ export function eventBusTestSuite(settings) {
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.addListener("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.addListener("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
         });
-    });
-    describe("method: subscribe, dispatch", () => {
-        describe("Should be null when listener is added and event is not triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                expect(listener.result).toBeNull();
-                await unsubscribe();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                expect(listener.result).toBeNull();
-                await unsubscribe();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
+        describe("method: subscribe, dispatch", () => {
+            test("Should not call listener when listener is added and event is not triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 const unsubscribe = await eventBus.subscribe("add", listener);
-                expect(result).toBeNull();
+                expect(listener).toHaveBeenCalledTimes(0);
                 await unsubscribe();
             });
-        });
-        describe("Should be AddEvent when listener is added and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+            test("Should call listener 2 times with AddEvent when listener is added and event is triggered 2 times", async () => {
+                const listener = vi.fn((_event) => { });
                 const unsubscribe = await eventBus.subscribe("add", listener);
                 const event = {
                     a: 1,
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
-                await unsubscribe();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(2);
+                expect(listener).toHaveBeenCalledWith(event);
                 await unsubscribe();
             });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toEqual(event);
-                await unsubscribe();
-            });
-        });
-        describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                await unsubscribe();
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                await unsubscribe();
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
+            test("Should not call listener when listener is removed by unsubscribe and event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 const unsubscribe = await eventBus.subscribe("add", listener);
                 await unsubscribe();
                 const event = {
@@ -294,51 +87,11 @@ export function eventBusTestSuite(settings) {
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toBeNull();
-            });
-        });
-        describe("Should be null when listener is removed by removeListener and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                await eventBus.subscribe("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.subscribe("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
+            test("Should not call listener when listener is removed by removeListener and event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.subscribe("add", listener);
                 await eventBus.removeListener("add", listener);
                 const event = {
@@ -346,185 +99,43 @@ export function eventBusTestSuite(settings) {
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
         });
-    });
-    describe("method: subscribeOnce", () => {
-        describe("Should be null when listener added and event is not triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+        describe("method: subscribeOnce", () => {
+            test("Should not call listener when listener is added and event is not triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.subscribeOnce("add", listener);
-                expect(listener.result).toBeNull();
+                expect(listener).toHaveBeenCalledTimes(0);
             });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.subscribeOnce("add", listener);
-                expect(listener.result).toBeNull();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.subscribeOnce("add", listener);
-                expect(result).toBeNull();
-            });
-        });
-        describe("Should be AddEvent when listener added and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+            test("Should call listener once with AddEvent when listener is added and event is triggered 2 times", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.subscribeOnce("add", listener);
                 const event = {
                     a: 1,
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.subscribeOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledOnce();
+                expect(listener).toHaveBeenCalledWith(event);
             });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
+            test("Should only listen for event once", async () => {
+                const listener = vi.fn(() => { });
                 await eventBus.subscribeOnce("add", listener);
                 const event = {
                     a: 1,
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toEqual(event);
-            });
-        });
-        describe("Should only listen for event once", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    i: 0,
-                    invoke(_event) {
-                        this.i++;
-                    },
-                };
-                await eventBus.subscribeOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.i).toBe(1);
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    i = 0;
-                    invoke(_event) {
-                        this.i++;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.subscribeOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.i).toBe(1);
-            });
-            test("Function listener", async () => {
-                let i = 0;
-                const listener = () => {
-                    i++;
-                };
-                await eventBus.subscribeOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(i).toBe(1);
-            });
-        });
-        describe("Should be null when listener is removed by unsubscribe function and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                const unsubscribe = await eventBus.subscribeOnce("add", listener);
-                await unsubscribe();
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                const unsubscribe = await eventBus.subscribeOnce("add", listener);
-                await unsubscribe();
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledOnce();
             });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
+            test("Should not call listener when listener is removed by unsubscribe function and event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 const unsubscribe = await eventBus.subscribeOnce("add", listener);
                 await unsubscribe();
                 const event = {
@@ -532,51 +143,11 @@ export function eventBusTestSuite(settings) {
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toBeNull();
-            });
-        });
-        describe("Should be null when listener is removed by removeListener method and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                await eventBus.subscribeOnce("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.subscribeOnce("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
+            test("Should not call listener when listener is removed by removeListener method and event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.subscribeOnce("add", listener);
                 await eventBus.removeListener("add", listener);
                 const event = {
@@ -584,133 +155,18 @@ export function eventBusTestSuite(settings) {
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toBeNull();
-            });
-        });
-    });
-    describe("method: listenOnce", () => {
-        describe("Should be null when listener added and event is not triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                await eventBus.listenOnce("add", listener);
-                expect(listener.result).toBeNull();
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.listenOnce("add", listener);
-                expect(listener.result).toBeNull();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.listenOnce("add", listener);
-                expect(result).toBeNull();
-            });
-        });
-        describe("Should be AddEvent when listener added and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
-                await eventBus.listenOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.listenOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toEqual(event);
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.listenOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toEqual(event);
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
         });
-        describe("Should only listen for event once", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    i: 0,
-                    invoke(_event) {
-                        this.i++;
-                    },
-                };
-                await eventBus.listenOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.i).toBe(1);
-            });
-            test("Class instance listener", async () => {
-                class Listener {
-                    i = 0;
-                    invoke(_event) {
-                        this.i++;
-                    }
-                }
-                const listener = new Listener();
+        describe("method: listenOnce", () => {
+            test("Should not call listener when listener is added and event is not triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.listenOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.i).toBe(1);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
-            test("Function listener", async () => {
-                let i = 0;
-                const listener = () => {
-                    i++;
-                };
+            test("Should call listener once with AddEvent when listener is added and event is triggered 2 times", async () => {
+                const listener = vi.fn((_event_AddEvent) => { });
                 await eventBus.listenOnce("add", listener);
                 const event = {
                     a: 1,
@@ -718,18 +174,12 @@ export function eventBusTestSuite(settings) {
                 };
                 await eventBus.dispatch("add", event);
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(i).toBe(1);
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledOnce();
+                expect(listener).toHaveBeenCalledWith(event);
             });
-        });
-        describe("Should be null when listener is removed and event is triggered", () => {
-            test("Object literal listener", async () => {
-                const listener = {
-                    result: null,
-                    invoke(event) {
-                        this.result = event;
-                    },
-                };
+            test("Should not call listener when listener is removed and event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
                 await eventBus.listenOnce("add", listener);
                 await eventBus.removeListener("add", listener);
                 const event = {
@@ -737,67 +187,29 @@ export function eventBusTestSuite(settings) {
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
-            test("Class instance listener", async () => {
-                class Listener {
-                    result = null;
-                    invoke(event) {
-                        this.result = event;
-                    }
-                }
-                const listener = new Listener();
-                await eventBus.listenOnce("add", listener);
-                await eventBus.removeListener("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(listener.result).toBeNull();
+        });
+        describe("method: asPromise", () => {
+            test("Should not call onfulfilled handler when event is not triggered", () => {
+                const listener = vi.fn((_event) => { });
+                eventBus.asPromise("add").then(listener);
+                expect(listener).toHaveBeenCalledTimes(0);
             });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.listenOnce("add", listener);
-                await eventBus.removeListener("add", listener);
+            test("Should call onfulfilled with AddEvent when event is triggered", async () => {
+                const listener = vi.fn((_event) => { });
+                eventBus.asPromise("add").then(listener);
                 const event = {
                     a: 1,
                     b: 2,
                 };
                 await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toBeNull();
+                await delay(TTL);
+                expect(listener).toHaveBeenCalledTimes(1);
+                expect(listener).toHaveBeenCalledWith(event);
             });
         });
     });
-    describe("method: asPromise", () => {
-        test("Should be null when listener added and event is not triggered", () => {
-            let result = null;
-            const listener = (event) => {
-                result = event;
-            };
-            eventBus.asPromise("add").then(listener);
-            expect(result).toBeNull();
-        });
-        test("Should be AddEvent when listener added and event is triggered", async () => {
-            let result = null;
-            const listener = (event) => {
-                result = event;
-            };
-            eventBus.asPromise("add").then(listener);
-            const event = {
-                a: 1,
-                b: 2,
-            };
-            await eventBus.dispatch("add", event);
-            await LazyPromise.delay(TTL);
-            expect(result).toEqual(event);
-        });
-    });
 }
 //# sourceMappingURL=event-bus.test-suite.js.map