@daiso-tech/core 0.24.0 → 0.26.0

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

@@ -64,6 +64,12 @@ import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_modul
  */
 export function eventBusTestSuite(settings) {
     const { expect, serde = new Serde(new NoOpSerdeAdapter()), test, describe, createEventBus, beforeEach, } = settings;
+    const TTL = TimeSpan.fromMilliseconds(50);
+    class AddEvent extends BaseEvent {
+    }
+    class SubEvent extends BaseEvent {
+    }
+    serde.registerEvent(AddEvent).registerEvent(SubEvent);
     let eventBusA;
     let eventBusB;
     beforeEach(async () => {
@@ -71,335 +77,1085 @@ export function eventBusTestSuite(settings) {
         eventBusA = eventBus;
         eventBusB = eventBus.withGroup("b");
     });
-    const TTL = TimeSpan.fromMilliseconds(50);
-    class TestEventA extends BaseEvent {
-    }
-    class TestEventB extends BaseEvent {
-    }
-    serde.registerEvent(TestEventA);
-    serde.registerEvent(TestEventB);
     describe("Api tests:", () => {
         describe("method: addListener, removeListener, dispatch", () => {
-            test("Should be null when listener added and event is not triggered", async () => {
-                let result = null;
-                await eventBusA.addListener(TestEventA, (event) => {
-                    result = event;
+            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 eventBusA.addListener(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                    await eventBusA.removeListener(AddEvent, listener);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.addListener(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                    await eventBusA.removeListener(AddEvent, listener);
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.addListener(AddEvent, listener);
+                    expect(result).toBeNull();
+                    await eventBusA.removeListener(AddEvent, listener);
                 });
-                expect(result).toBeNull();
             });
-            test("Should be TestEventA when listener added and event is triggered", async () => {
-                let result = null;
-                await eventBusA.addListener(TestEventA, (event) => {
-                    result = event;
+            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 eventBusA.addListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
+                    await eventBusA.removeListener(AddEvent, listener);
                 });
-                const event = new TestEventA({
-                    type: TestEventA.name,
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.addListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
+                    await eventBusA.removeListener(AddEvent, listener);
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.addListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(result).toEqual(event);
+                    expect(result).toBeInstanceOf(AddEvent);
+                    await eventBusA.removeListener(AddEvent, listener);
                 });
-                await eventBusA.dispatch(event);
-                await delay(TTL);
-                expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(TestEventA);
             });
-            test("Should be null when listener removed and event is triggered", async () => {
-                const event = new TestEventA({
-                    type: TestEventA.name,
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.addListener(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await 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 eventBusA.addListener(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.addListener(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(result).toBeNull();
                 });
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBusA.addListener(TestEventA, listener);
-                await eventBusA.removeListener(TestEventA, listener);
-                await eventBusA.dispatch(event);
-                await delay(TTL);
-                expect(result).toBeNull();
             });
         });
-        describe("method: addListenerMany, removeListenerMany, dispatch", () => {
-            test("Should be null when listener added and event is not triggered", async () => {
-                let result = null;
-                await eventBusA.addListenerMany([TestEventA, TestEventB], (event) => {
-                    result = event;
+        describe("method: addListenerMany, removeListenerMany, dispatchMany", () => {
+            describe("Should be null when listener is added and event is not triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        },
+                    };
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
                 });
-                expect(result).toBeNull();
-            });
-            test("Should be BaseEvent when listener added and event is triggered", async () => {
-                const event_1 = new TestEventA({
-                    type: TestEventA.name,
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
                 });
-                const event_2 = new TestEventB({
-                    type: TestEventB.name,
+                test("Function listener", async () => {
+                    let resultA = null;
+                    let resultB = null;
+                    const listener = (event) => {
+                        if (event instanceof AddEvent) {
+                            resultA = event;
+                        }
+                        if (event instanceof SubEvent) {
+                            resultB = event;
+                        }
+                    };
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    expect(resultA).toBeNull();
+                    expect(resultB).toBeNull();
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
                 });
-                let result_1 = null;
-                let result_2 = null;
-                await eventBusA.addListenerMany([TestEventA, TestEventB], (eventObj) => {
-                    if (eventObj instanceof TestEventA) {
-                        result_1 = eventObj;
-                    }
-                    if (eventObj instanceof TestEventB) {
-                        result_2 = eventObj;
+            });
+            describe("Should be AddEvent and SubEvent when listener is added and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        },
+                    };
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toEqual(addEvent);
+                    expect(listener.resultA).toBeInstanceOf(AddEvent);
+                    expect(listener.resultB).toEqual(subEvent);
+                    expect(listener.resultB).toBeInstanceOf(SubEvent);
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        }
                     }
+                    const listener = new Listener();
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toEqual(addEvent);
+                    expect(listener.resultA).toBeInstanceOf(AddEvent);
+                    expect(listener.resultB).toEqual(subEvent);
+                    expect(listener.resultB).toBeInstanceOf(SubEvent);
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+                });
+                test("Function listener", async () => {
+                    let resultA = null;
+                    let resultB = null;
+                    const listener = (event) => {
+                        if (event instanceof AddEvent) {
+                            resultA = event;
+                        }
+                        if (event instanceof SubEvent) {
+                            resultB = event;
+                        }
+                    };
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(resultA).toEqual(addEvent);
+                    expect(resultA).toBeInstanceOf(AddEvent);
+                    expect(resultB).toEqual(subEvent);
+                    expect(resultB).toBeInstanceOf(SubEvent);
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
                 });
-                await eventBusA.dispatchMany([event_1, event_2]);
-                await delay(TTL);
-                expect(result_1).toEqual(event_1);
-                expect(result_1).toBeInstanceOf(TestEventA);
-                expect(result_2).toEqual(event_2);
-                expect(result_2).toBeInstanceOf(TestEventB);
             });
-            test("Should be null when listener removed and event is triggered", async () => {
-                const event_A = new TestEventA({
-                    type: TestEventA.name,
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        },
+                    };
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
                 });
-                const event_B = new TestEventB({
-                    type: TestEventB.name,
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let resultA = null;
+                    let resultB = null;
+                    const listener = (event) => {
+                        if (event instanceof AddEvent) {
+                            resultA = event;
+                        }
+                        if (event instanceof SubEvent) {
+                            resultB = event;
+                        }
+                    };
+                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
+                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(resultA).toBeNull();
+                    expect(resultB).toBeNull();
                 });
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                await eventBusA.addListenerMany([TestEventA, TestEventB], listener);
-                await eventBusA.removeListenerMany([TestEventA, TestEventB], listener);
-                await eventBusA.dispatchMany([event_A, event_B]);
-                await delay(TTL);
-                expect(result).toBeNull();
             });
         });
-        describe("method: subscribe", () => {
-            test("Should be null when listener added and event is not triggered", async () => {
-                let result = null;
-                await eventBusA.subscribe(TestEventA, (event) => {
-                    result = event;
+        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 eventBusA.subscribe(AddEvent, 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 eventBusA.subscribe(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                    await unsubscribe();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
+                    expect(result).toBeNull();
+                    await unsubscribe();
                 });
-                expect(result).toBeNull();
             });
-            test("Should be TestEventA when listener added and event is triggered", async () => {
-                const event = new TestEventA({
-                    type: TestEventA.name,
+            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 eventBusA.subscribe(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
+                    await unsubscribe();
                 });
-                let result = null;
-                await eventBusA.subscribe(TestEventA, (event) => {
-                    result = event;
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
+                    await unsubscribe();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(result).toEqual(event);
+                    expect(result).toBeInstanceOf(AddEvent);
+                    await unsubscribe();
                 });
-                await delay(TTL);
-                await eventBusA.dispatch(event);
-                expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(TestEventA);
             });
-            test("Should be null when listener removed and event is triggered", async () => {
-                const event = new TestEventA({
-                    type: TestEventA.name,
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
+                    await unsubscribe();
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await 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 eventBusA.subscribe(AddEvent, listener);
+                    await unsubscribe();
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
+                    await unsubscribe();
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(result).toBeNull();
                 });
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                const unsubscribe = await eventBusA.subscribe(TestEventA, listener);
-                await unsubscribe();
-                await eventBusA.dispatch(event);
-                await delay(TTL);
-                expect(result).toBeNull();
             });
         });
-        describe("method: subscribeMany", () => {
-            test("Should be null when listener added and event is not triggered", async () => {
-                let result = null;
-                await eventBusA.subscribeMany([TestEventA, TestEventB], (event) => {
-                    result = event;
+        describe("method: subscribeMany, dispatchMany", () => {
+            describe("Should be null when listener is added and event is not triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        },
+                    };
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                    await unsubscribe();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        }
+                    }
+                    const listener = new Listener();
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                    await unsubscribe();
+                });
+                test("Function listener", async () => {
+                    let resultA = null;
+                    let resultB = null;
+                    const listener = (event) => {
+                        if (event instanceof AddEvent) {
+                            resultA = event;
+                        }
+                        if (event instanceof SubEvent) {
+                            resultB = event;
+                        }
+                    };
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    expect(resultA).toBeNull();
+                    expect(resultB).toBeNull();
+                    await unsubscribe();
                 });
-                expect(result).toBeNull();
             });
-            test("Should be BaseEvent when listener added and event is triggered", async () => {
-                const event_1 = new TestEventA({
-                    type: TestEventA.name,
+            describe("Should be AddEvent and SubEvent when listener is added and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        },
+                    };
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toEqual(addEvent);
+                    expect(listener.resultA).toBeInstanceOf(AddEvent);
+                    expect(listener.resultB).toEqual(subEvent);
+                    expect(listener.resultB).toBeInstanceOf(SubEvent);
+                    await unsubscribe();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        }
+                    }
+                    const listener = new Listener();
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toEqual(addEvent);
+                    expect(listener.resultA).toBeInstanceOf(AddEvent);
+                    expect(listener.resultB).toEqual(subEvent);
+                    expect(listener.resultB).toBeInstanceOf(SubEvent);
+                    await unsubscribe();
+                });
+                test("Function listener", async () => {
+                    let resultA = null;
+                    let resultB = null;
+                    const listener = (event) => {
+                        if (event instanceof AddEvent) {
+                            resultA = event;
+                        }
+                        if (event instanceof SubEvent) {
+                            resultB = event;
+                        }
+                    };
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(resultA).toEqual(addEvent);
+                    expect(resultA).toBeInstanceOf(AddEvent);
+                    expect(resultB).toEqual(subEvent);
+                    expect(resultB).toBeInstanceOf(SubEvent);
+                    await unsubscribe();
                 });
-                const event_2 = new TestEventB({
-                    type: TestEventB.name,
+            });
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        },
+                    };
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    await unsubscribe();
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
                 });
-                let result_1 = null;
-                let result_2 = null;
-                await eventBusA.subscribeMany([TestEventA, TestEventB], (eventObj) => {
-                    if (eventObj instanceof TestEventA) {
-                        result_1 = eventObj;
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        invoke(event) {
+                            if (event instanceof AddEvent) {
+                                this.resultA = event;
+                            }
+                            if (event instanceof SubEvent) {
+                                this.resultB = event;
+                            }
+                        }
                     }
-                    if (eventObj instanceof TestEventB) {
-                        result_2 = eventObj;
+                    const listener = new Listener();
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    await unsubscribe();
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let resultA = null;
+                    let resultB = null;
+                    const listener = (event) => {
+                        if (event instanceof AddEvent) {
+                            resultA = event;
+                        }
+                        if (event instanceof SubEvent) {
+                            resultB = event;
+                        }
+                    };
+                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
+                    await unsubscribe();
+                    const addEvent = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    const subEvent = new SubEvent({
+                        c: 1,
+                        d: 2,
+                    });
+                    await eventBusA.dispatchMany([addEvent, subEvent]);
+                    await delay(TTL);
+                    expect(resultA).toBeNull();
+                    expect(resultB).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 eventBusA.listenOnce(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
                     }
+                    const listener = new Listener();
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    expect(result).toBeNull();
                 });
-                await delay(TTL);
-                await eventBusA.dispatchMany([event_1, event_2]);
-                expect(result_1).toEqual(event_1);
-                expect(result_1).toBeInstanceOf(TestEventA);
-                expect(result_2).toEqual(event_2);
-                expect(result_2).toBeInstanceOf(TestEventB);
             });
-            test("Should be null when listener removed and event is triggered", async () => {
-                const event_A = new TestEventA({
-                    type: TestEventA.name,
+            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 eventBusA.listenOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
                 });
-                const event_B = new TestEventB({
-                    type: TestEventB.name,
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await 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 eventBusA.listenOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(result).toEqual(event);
+                    expect(result).toBeInstanceOf(AddEvent);
+                });
+            });
+            describe("Should only listen for event once", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        i: 0,
+                        invoke(_event) {
+                            this.i++;
+                        },
+                    };
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await eventBusA.dispatch(event);
+                    await 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 eventBusA.listenOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(listener.i).toBe(1);
+                });
+                test("Function listener", async () => {
+                    let i = 0;
+                    const listener = () => {
+                        i++;
+                    };
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await eventBusA.dispatch(event);
+                    await delay(TTL);
+                    expect(i).toBe(1);
                 });
-                let result = null;
-                const listener = (event) => {
-                    result = event;
-                };
-                const unsubscribe = await eventBusA.subscribeMany([TestEventA, TestEventB], listener);
-                await unsubscribe();
-                await eventBusA.dispatchMany([event_A, event_B]);
-                await delay(TTL);
-                expect(result).toBeNull();
             });
         });
-        describe("method: listenOnce", () => {
-            test("Should be null when listener added and event is not triggered", async () => {
+        describe("method: asPromise", () => {
+            test("Should be null when listener added and event is not triggered", () => {
                 let result = null;
-                await eventBusA.listenOnce(TestEventA, (event) => {
+                const listener = (event) => {
                     result = event;
-                });
+                };
+                eventBusA.asPromise(AddEvent).then(listener);
                 expect(result).toBeNull();
             });
-            test("Should be TestEventA when listener added and event is triggered", async () => {
-                const event = new TestEventA({
-                    type: TestEventA.name,
-                });
+            test("Should be AddEvent when listener added and event is triggered", async () => {
                 let result = null;
-                await eventBusA.listenOnce(TestEventA, (event) => {
+                const listener = (event) => {
                     result = event;
+                };
+                eventBusA.asPromise(AddEvent).then(listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
                 await eventBusA.dispatch(event);
                 await delay(TTL);
                 expect(result).toEqual(event);
-                expect(result).toBeInstanceOf(TestEventA);
-            });
-            test("Should only listen for event once", async () => {
-                const event = new TestEventA({
-                    type: TestEventA.name,
-                });
-                let i = 0;
-                await eventBusA.listenOnce(TestEventA, () => {
-                    i++;
-                });
-                await eventBusA.dispatch(event);
-                await eventBusA.dispatch(event);
-                await delay(TTL);
-                expect(i).toBe(1);
+                expect(result).toBeInstanceOf(AddEvent);
             });
         });
     });
     describe("Group tests:", () => {
         test("method: addListener / dispatch", async () => {
-            const event = new TestEventA({
-                type: TestEventA.name,
-            });
             let result_a = null;
-            await eventBusA.addListener(TestEventA, (event) => {
+            await eventBusA.addListener(AddEvent, (event) => {
                 result_a = event;
             });
             let result_b = null;
-            await eventBusB.addListener(TestEventA, (event) => {
+            await eventBusB.addListener(AddEvent, (event) => {
                 result_b = event;
             });
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
             await eventBusA.dispatch(event);
+            await delay(TTL);
             expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(TestEventA);
+            expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
         test("method: addListenerMany / dispatch", async () => {
-            const event = new TestEventA({
-                type: "type",
-            });
             let result_a = null;
-            await eventBusA.addListenerMany([TestEventA], (event) => {
+            await eventBusA.addListenerMany([AddEvent], (event) => {
                 result_a = event;
             });
             let result_b = null;
-            await eventBusB.addListenerMany([TestEventA], (event) => {
+            await eventBusB.addListenerMany([AddEvent], (event) => {
                 result_b = event;
             });
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
             await eventBusA.dispatch(event);
+            await delay(TTL);
             expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(TestEventA);
+            expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
         test("method: removeListener / addListener / dispatch", async () => {
-            const event = new TestEventA({
-                type: TestEventA.name,
-            });
             let result_a = null;
-            await eventBusA.addListener(TestEventA, (event) => {
+            await eventBusA.addListener(AddEvent, (event) => {
                 result_a = event;
             });
             let result_b = null;
             const listenerB = (event) => {
                 result_b = event;
             };
-            await eventBusB.addListener(TestEventA, listenerB);
-            await eventBusB.removeListener(TestEventA, listenerB);
+            await eventBusB.addListener(AddEvent, listenerB);
+            await eventBusB.removeListener(AddEvent, listenerB);
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
             await eventBusA.dispatch(event);
             await eventBusB.dispatch(event);
+            await delay(TTL);
             expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(TestEventA);
+            expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
         test("method: removeListenerMany / addListener / dispatch", async () => {
-            const event = new TestEventA({
-                type: TestEventA.name,
-            });
             let result_a = null;
-            await eventBusA.addListener(TestEventA, (event) => {
+            await eventBusA.addListener(AddEvent, (event) => {
                 result_a = event;
             });
             let result_b = null;
             const listenerB = (event) => {
                 result_b = event;
             };
-            await eventBusB.addListener(TestEventA, listenerB);
-            await eventBusB.removeListenerMany([TestEventA], listenerB);
+            await eventBusB.addListener(AddEvent, listenerB);
+            await eventBusB.removeListenerMany([AddEvent], listenerB);
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
             await eventBusA.dispatch(event);
             await eventBusB.dispatch(event);
+            await delay(TTL);
             expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(TestEventA);
+            expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
         test("method: subscribe / dispatch", async () => {
-            const event = new TestEventA({
-                type: TestEventA.name,
-            });
             let result_a = null;
-            await eventBusA.subscribe(TestEventA, (event) => {
+            await eventBusA.subscribe(AddEvent, (event) => {
                 result_a = event;
             });
             let result_b = null;
             const listenerB = (event) => {
                 result_b = event;
             };
-            const unsubscribe = await eventBusB.subscribe(TestEventA, listenerB);
+            const unsubscribe = await eventBusB.subscribe(AddEvent, listenerB);
             await unsubscribe();
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
             await eventBusA.dispatch(event);
             await eventBusB.dispatch(event);
+            await delay(TTL);
             expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(TestEventA);
+            expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
         test("method: subscribeMany / dispatch", async () => {
-            const event = new TestEventA({
-                type: TestEventA.name,
-            });
             let result_a = null;
-            await eventBusA.subscribeMany([TestEventA], (event) => {
+            await eventBusA.subscribeMany([AddEvent], (event) => {
                 result_a = event;
             });
             let result_b = null;
             const listenerB = (event) => {
                 result_b = event;
             };
-            const unsubscribe = await eventBusB.subscribeMany([TestEventA], listenerB);
+            const unsubscribe = await eventBusB.subscribeMany([AddEvent], listenerB);
             await unsubscribe();
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
             await eventBusA.dispatch(event);
             await eventBusB.dispatch(event);
+            await delay(TTL);
+            expect(result_a).toEqual(event);
+            expect(result_a).toBeInstanceOf(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: listenOnce", async () => {
+            let result_a = null;
+            await eventBusA.listenOnce(AddEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            await eventBusB.listenOnce(AddEvent, (event) => {
+                result_b = event;
+            });
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
+            await eventBusA.dispatch(event);
+            await delay(TTL);
+            expect(result_a).toEqual(event);
+            expect(result_a).toBeInstanceOf(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: asPromise", async () => {
+            let result_a = null;
+            eventBusA.asPromise(AddEvent).then((event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            eventBusB.asPromise(AddEvent).then((event) => {
+                result_b = event;
+            });
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
+            await eventBusA.dispatch(event);
+            await delay(TTL);
             expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(TestEventA);
+            expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
     });