@daiso-tech/core 0.33.0 → 0.35.0

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

@@ -2,26 +2,19 @@
  * @module EventBus
  */
 import {} from "vitest";
-import { BaseEvent, } from "../../../event-bus/contracts/_module-exports.js";
+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 { Serde } from "../../../serde/implementations/derivables/_module-exports.js";
-import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_module-exports.js";
 /**
- * The <i>eventBusTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBus}</i> with vitest.
+ * The `eventBusTestSuite` function simplifies the process of testing your custom implementation of {@link IEventBus | `IEventBus`} with vitest.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/event-bus/test-utilities"```
+ * IMPORT_PATH: `"@daiso-tech/core/event-bus/test-utilities"`
  * @group TestUtilities
  */
 export function eventBusTestSuite(settings) {
-    const { expect, serde = new Serde(new NoOpSerdeAdapter()), test, describe, createEventBus, beforeEach, } = settings;
+    const { expect, test, describe, createEventBus, beforeEach } = settings;
     const TTL = TimeSpan.fromMilliseconds(50);
-    class AddEvent extends BaseEvent {
-    }
-    class SubEvent extends BaseEvent {
-    }
-    serde.registerEvent(AddEvent).registerEvent(SubEvent);
     let eventBus;
     beforeEach(async () => {
         eventBus = await createEventBus();
@@ -35,9 +28,9 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.addListener(AddEvent, listener);
+                await eventBus.addListener("add", listener);
                 expect(listener.result).toBeNull();
-                await eventBus.removeListener(AddEvent, listener);
+                await eventBus.removeListener("add", listener);
             });
             test("Class instance listener", async () => {
                 class Listener {
@@ -47,18 +40,18 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.addListener(AddEvent, listener);
+                await eventBus.addListener("add", listener);
                 expect(listener.result).toBeNull();
-                await eventBus.removeListener(AddEvent, listener);
+                await eventBus.removeListener("add", listener);
             });
             test("Function listener", async () => {
                 let result = null;
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.addListener(AddEvent, listener);
+                await eventBus.addListener("add", listener);
                 expect(result).toBeNull();
-                await eventBus.removeListener(AddEvent, listener);
+                await eventBus.removeListener("add", listener);
             });
         });
         describe("Should be AddEvent when listener is added and event is triggered", () => {
@@ -69,16 +62,15 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.addListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.addListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
-                await eventBus.removeListener(AddEvent, listener);
+                await eventBus.removeListener("add", listener);
             });
             test("Class instance listener", async () => {
                 class Listener {
@@ -88,32 +80,30 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.addListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.addListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
-                await eventBus.removeListener(AddEvent, listener);
+                await eventBus.removeListener("add", listener);
             });
             test("Function listener", async () => {
                 let result = null;
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.addListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.addListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(AddEvent);
-                await eventBus.removeListener(AddEvent, listener);
+                await eventBus.removeListener("add", listener);
             });
         });
         describe("Should be null when listener is removed and event is triggered", () => {
@@ -124,13 +114,13 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.addListener(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.addListener("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -142,13 +132,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.addListener(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.addListener("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -157,13 +147,13 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.addListener(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.addListener("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toBeNull();
             });
@@ -178,7 +168,7 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribe("add", listener);
                 expect(listener.result).toBeNull();
                 await unsubscribe();
             });
@@ -190,7 +180,7 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribe("add", listener);
                 expect(listener.result).toBeNull();
                 await unsubscribe();
             });
@@ -199,7 +189,7 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribe("add", listener);
                 expect(result).toBeNull();
                 await unsubscribe();
             });
@@ -212,15 +202,14 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
-                const event = new AddEvent({
+                const unsubscribe = await eventBus.subscribe("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
                 await unsubscribe();
             });
             test("Class instance listener", async () => {
@@ -231,15 +220,14 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
-                const event = new AddEvent({
+                const unsubscribe = await eventBus.subscribe("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
                 await unsubscribe();
             });
             test("Function listener", async () => {
@@ -247,15 +235,14 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
-                const event = new AddEvent({
+                const unsubscribe = await eventBus.subscribe("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(AddEvent);
                 await unsubscribe();
             });
         });
@@ -267,13 +254,13 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribe("add", listener);
                 await unsubscribe();
-                const event = new AddEvent({
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -285,13 +272,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribe("add", listener);
                 await unsubscribe();
-                const event = new AddEvent({
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -300,13 +287,13 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribe("add", listener);
                 await unsubscribe();
-                const event = new AddEvent({
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toBeNull();
             });
@@ -319,13 +306,13 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.subscribe(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribe("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -337,13 +324,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.subscribe(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribe("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -352,13 +339,13 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.subscribe(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribe("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toBeNull();
             });
@@ -373,7 +360,7 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
+                await eventBus.subscribeOnce("add", listener);
                 expect(listener.result).toBeNull();
             });
             test("Class instance listener", async () => {
@@ -384,7 +371,7 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.subscribeOnce(AddEvent, listener);
+                await eventBus.subscribeOnce("add", listener);
                 expect(listener.result).toBeNull();
             });
             test("Function listener", async () => {
@@ -392,7 +379,7 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
+                await eventBus.subscribeOnce("add", listener);
                 expect(result).toBeNull();
             });
         });
@@ -404,15 +391,14 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
             });
             test("Class instance listener", async () => {
                 class Listener {
@@ -422,30 +408,28 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.subscribeOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
             });
             test("Function listener", async () => {
                 let result = null;
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(AddEvent);
             });
         });
         describe("Should only listen for event once", () => {
@@ -456,13 +440,13 @@ export function eventBusTestSuite(settings) {
                         this.i++;
                     },
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.i).toBe(1);
             });
@@ -474,13 +458,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.subscribeOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.i).toBe(1);
             });
@@ -489,13 +473,13 @@ export function eventBusTestSuite(settings) {
                 const listener = () => {
                     i++;
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(i).toBe(1);
             });
@@ -508,13 +492,13 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribeOnce("add", listener);
                 await unsubscribe();
-                const event = new AddEvent({
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -526,13 +510,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribeOnce("add", listener);
                 await unsubscribe();
-                const event = new AddEvent({
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -541,13 +525,13 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
+                const unsubscribe = await eventBus.subscribeOnce("add", listener);
                 await unsubscribe();
-                const event = new AddEvent({
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toBeNull();
             });
@@ -560,13 +544,13 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -578,13 +562,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.subscribeOnce(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -593,13 +577,13 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.subscribeOnce(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.subscribeOnce("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toBeNull();
             });
@@ -614,7 +598,7 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.listenOnce(AddEvent, listener);
+                await eventBus.listenOnce("add", listener);
                 expect(listener.result).toBeNull();
             });
             test("Class instance listener", async () => {
@@ -625,7 +609,7 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.listenOnce(AddEvent, listener);
+                await eventBus.listenOnce("add", listener);
                 expect(listener.result).toBeNull();
             });
             test("Function listener", async () => {
@@ -633,7 +617,7 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.listenOnce(AddEvent, listener);
+                await eventBus.listenOnce("add", listener);
                 expect(result).toBeNull();
             });
         });
@@ -645,15 +629,14 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.listenOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
             });
             test("Class instance listener", async () => {
                 class Listener {
@@ -663,30 +646,28 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.listenOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toEqual(event);
-                expect(listener.result).toBeInstanceOf(AddEvent);
             });
             test("Function listener", async () => {
                 let result = null;
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.listenOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(AddEvent);
             });
         });
         describe("Should only listen for event once", () => {
@@ -697,13 +678,13 @@ export function eventBusTestSuite(settings) {
                         this.i++;
                     },
                 };
-                await eventBus.listenOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.i).toBe(1);
             });
@@ -715,13 +696,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.listenOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.i).toBe(1);
             });
@@ -730,13 +711,13 @@ export function eventBusTestSuite(settings) {
                 const listener = () => {
                     i++;
                 };
-                await eventBus.listenOnce(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(i).toBe(1);
             });
@@ -749,13 +730,13 @@ export function eventBusTestSuite(settings) {
                         this.result = event;
                     },
                 };
-                await eventBus.listenOnce(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -767,13 +748,13 @@ export function eventBusTestSuite(settings) {
                     }
                 }
                 const listener = new Listener();
-                await eventBus.listenOnce(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(listener.result).toBeNull();
             });
@@ -782,13 +763,13 @@ export function eventBusTestSuite(settings) {
                 const listener = (event) => {
                     result = event;
                 };
-                await eventBus.listenOnce(AddEvent, listener);
-                await eventBus.removeListener(AddEvent, listener);
-                const event = new AddEvent({
+                await eventBus.listenOnce("add", listener);
+                await eventBus.removeListener("add", listener);
+                const event = {
                     a: 1,
                     b: 2,
-                });
-                await eventBus.dispatch(event);
+                };
+                await eventBus.dispatch("add", event);
                 await LazyPromise.delay(TTL);
                 expect(result).toBeNull();
             });
@@ -800,7 +781,7 @@ export function eventBusTestSuite(settings) {
             const listener = (event) => {
                 result = event;
             };
-            eventBus.asPromise(AddEvent).then(listener);
+            eventBus.asPromise("add").then(listener);
             expect(result).toBeNull();
         });
         test("Should be AddEvent when listener added and event is triggered", async () => {
@@ -808,15 +789,14 @@ export function eventBusTestSuite(settings) {
             const listener = (event) => {
                 result = event;
             };
-            eventBus.asPromise(AddEvent).then(listener);
-            const event = new AddEvent({
+            eventBus.asPromise("add").then(listener);
+            const event = {
                 a: 1,
                 b: 2,
-            });
-            await eventBus.dispatch(event);
+            };
+            await eventBus.dispatch("add", event);
             await LazyPromise.delay(TTL);
             expect(result).toEqual(event);
-            expect(result).toBeInstanceOf(AddEvent);
         });
     });
 }