@daiso-tech/core 0.39.0 → 0.40.0

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

@@ -1,7 +1,7 @@
 /**
  * @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";
@@ -20,775 +20,181 @@ export function eventBusTestSuite(settings) {
         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;
-                    },
-                };
-                await eventBus.addListener("add", listener);
-                expect(listener.result).toBeNull();
-                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;
-                    },
-                };
-                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 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;
-                    },
-                };
-                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("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();
-            });
+        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).toHaveBeenCalledTimes(0);
+            await eventBus.removeListener("add", listener);
+        });
+        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 eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledTimes(2);
+            expect(listener).toHaveBeenCalledWith(event);
+            await eventBus.removeListener("add", listener);
+        });
+        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 = {
+                a: 1,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await LazyPromise.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;
-                };
-                const unsubscribe = await eventBus.subscribe("add", listener);
-                expect(result).toBeNull();
-                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;
-                    },
-                };
-                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 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;
-                };
-                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(result).toBeNull();
-            });
+        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(listener).toHaveBeenCalledTimes(0);
+            await unsubscribe();
+        });
+        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 eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledTimes(2);
+            expect(listener).toHaveBeenCalledWith(event);
+            await unsubscribe();
+        });
+        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 = {
+                a: 1,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledTimes(0);
         });
-        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();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    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(result).toBeNull();
-            });
+        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 = {
+                a: 1,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await LazyPromise.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;
-                    },
-                };
-                await eventBus.subscribeOnce("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.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;
-                    },
-                };
-                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);
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBus.subscribeOnce("add", listener);
-                const event = {
-                    a: 1,
-                    b: 2,
-                };
-                await eventBus.dispatch("add", event);
-                await LazyPromise.delay(TTL);
-                expect(result).toEqual(event);
-            });
+        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).toHaveBeenCalledTimes(0);
+        });
+        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 eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledOnce();
+            expect(listener).toHaveBeenCalledWith(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);
-            });
+        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 eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledOnce();
         });
-        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();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    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(result).toBeNull();
-            });
+        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 = {
+                a: 1,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledTimes(0);
         });
-        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();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    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(result).toBeNull();
-            });
+        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 = {
+                a: 1,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledTimes(0);
         });
     });
     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);
-            });
-        });
-        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();
-                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("Function listener", async () => {
-                let i = 0;
-                const listener = () => {
-                    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(i).toBe(1);
-            });
+        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);
+            expect(listener).toHaveBeenCalledTimes(0);
+        });
+        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,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await eventBus.dispatch("add", event);
+            await LazyPromise.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;
-                    },
-                };
-                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();
-            });
-            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();
-            });
-            test("Function listener", async () => {
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                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(result).toBeNull();
-            });
+        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 = {
+                a: 1,
+                b: 2,
+            };
+            await eventBus.dispatch("add", event);
+            await LazyPromise.delay(TTL);
+            expect(listener).toHaveBeenCalledTimes(0);
         });
     });
     describe("method: asPromise", () => {
-        test("Should be null when listener added and event is not triggered", () => {
-            let result = null;
-            const listener = (event) => {
-                result = event;
-            };
+        test("Should not call onfulfilled handler when event is not triggered", () => {
+            const listener = vi.fn((_event) => { });
             eventBus.asPromise("add").then(listener);
-            expect(result).toBeNull();
+            expect(listener).toHaveBeenCalledTimes(0);
         });
-        test("Should be AddEvent when listener added and event is triggered", async () => {
-            let result = null;
-            const listener = (event) => {
-                result = event;
-            };
+        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,
@@ -796,7 +202,8 @@ export function eventBusTestSuite(settings) {
             };
             await eventBus.dispatch("add", event);
             await LazyPromise.delay(TTL);
-            expect(result).toEqual(event);
+            expect(listener).toHaveBeenCalledTimes(1);
+            expect(listener).toHaveBeenCalledWith(event);
         });
     });
 }