@daiso-tech/core 0.23.0 → 0.25.0

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

@@ -0,0 +1,1163 @@
+/**
+ * @module EventBus
+ */
+import {} from "vitest";
+import { BaseEvent, } from "../../../event-bus/contracts/_module-exports.js";
+import {} from "../../../utilities/_module-exports.js";
+import { TimeSpan } from "../../../utilities/_module-exports.js";
+import { delay } 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.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/event-bus/implementations/test-utilities"```
+ * @group Test utilities
+ * @example
+ * ```ts
+ * import { describe, test, beforeEach, expect, afterEach } from "vitest";
+ * import type { StartedRedisContainer } from "@testcontainers/redis";
+ * import { RedisContainer } from "@testcontainers/redis";
+ * import Redis from "ioredis";
+ * import { RedisPubSubEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+ * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
+ * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
+ * import { eventBusTestSuite } from "@daiso-tech/core/event-bus/implementations/test-utilities";
+ *
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
+ * describe("class: EventBus", () => {
+ *   let dispatcherClient: Redis;
+ *   let listenerClient: Redis;
+ *   let startedContainer: StartedRedisContainer;
+ *   const serde = new Serde(new SuperJsonSerdeAdapter());
+ *
+ *   beforeEach(async () => {
+ *     startedContainer = await new RedisContainer().start();
+ *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
+ *     listenerClient = new Redis(startedContainer.getConnectionUrl());
+ *   }, TIMEOUT.toMilliseconds());
+ *
+ *   afterEach(async () => {
+ *     await dispatcherClient.quit();
+ *     await listenerClient.quit();
+ *     await startedContainer.stop();
+ *   }, TIMEOUT.toMilliseconds());
+ *
+ *   eventBusTestSuite({
+ *     createEventBus: () =>
+ *       new EventBus(
+ *         new RedisPubSubEventBusAdapter({
+ *           dispatcherClient,
+ *           listenerClient,
+ *           serde,
+ *           rootGroup: "@global"
+ *         })
+ *       ),
+ *     serde,
+ *     test,
+ *     beforeEach,
+ *     expect,
+ *     describe,
+ *   });
+ * });
+ * ```
+ */
+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 () => {
+        const eventBus = await createEventBus();
+        eventBusA = eventBus;
+        eventBusB = eventBus.withGroup("b");
+    });
+    describe("Api tests:", () => {
+        describe("method: addListener, removeListener, dispatch", () => {
+            describe("Should be null when listener is added and event is not triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        handler(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;
+                        handler(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);
+                });
+            });
+            describe("Should be AddEvent when listener is added and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        handler(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);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        handler(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);
+                });
+            });
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        handler(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;
+                        handler(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();
+                });
+            });
+        });
+        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,
+                        handler(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);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        handler(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);
+                });
+                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);
+                });
+            });
+            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,
+                        handler(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;
+                        handler(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);
+                });
+            });
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        handler(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();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        handler(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();
+                });
+            });
+        });
+        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,
+                        handler(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;
+                        handler(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();
+                });
+            });
+            describe("Should be AddEvent when listener is added and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        handler(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();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        handler(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();
+                });
+            });
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        handler(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;
+                        handler(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();
+                });
+            });
+        });
+        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,
+                        handler(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;
+                        handler(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();
+                });
+            });
+            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,
+                        handler(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;
+                        handler(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();
+                });
+            });
+            describe("Should be null when listener removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        resultA: null,
+                        resultB: null,
+                        handler(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();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        resultA = null;
+                        resultB = null;
+                        handler(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);
+                    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,
+                        handler(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        handler(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();
+                });
+            });
+            describe("Should be AddEvent when listener added and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        handler(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);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        handler(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,
+                        handler(_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;
+                        handler(_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);
+                });
+            });
+        });
+        describe("method: asPromise", () => {
+            test("Should be null when listener added and event is not triggered", () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                eventBusA.asPromise(AddEvent).then(listener);
+                expect(result).toBeNull();
+            });
+            test("Should be AddEvent when listener added and event is triggered", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                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(AddEvent);
+            });
+        });
+    });
+    describe("Group tests:", () => {
+        test("method: addListener / dispatch", async () => {
+            let result_a = null;
+            await eventBusA.addListener(AddEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            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(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: addListenerMany / dispatch", async () => {
+            let result_a = null;
+            await eventBusA.addListenerMany([AddEvent], (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            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(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: removeListener / addListener / dispatch", async () => {
+            let result_a = null;
+            await eventBusA.addListener(AddEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            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(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: removeListenerMany / addListener / dispatch", async () => {
+            let result_a = null;
+            await eventBusA.addListener(AddEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            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(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: subscribe / dispatch", async () => {
+            let result_a = null;
+            await eventBusA.subscribe(AddEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            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(AddEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: subscribeMany / dispatch", async () => {
+            let result_a = null;
+            await eventBusA.subscribeMany([AddEvent], (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            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(AddEvent);
+            expect(result_b).toBeNull();
+        });
+    });
+}
+//# sourceMappingURL=event-bus.test-suite.js.map