@daiso-tech/core 0.28.0 → 0.29.0

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

@@ -120,7 +120,7 @@ export function eventBusTestSuite(settings) {
                     await eventBusA.removeListener(AddEvent, listener);
                 });
             });
-            describe("Should be null when listener removed and event is triggered", () => {
+            describe("Should be null when listener is removed and event is triggered", () => {
                 test("Object literal listener", async () => {
                     const listener = {
                         result: null,
@@ -320,7 +320,7 @@ export function eventBusTestSuite(settings) {
                     await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
                 });
             });
-            describe("Should be null when listener removed and event is triggered", () => {
+            describe("Should be null when listener is removed and event is triggered", () => {
                 test("Object literal listener", async () => {
                     const listener = {
                         resultA: null,
@@ -496,7 +496,7 @@ export function eventBusTestSuite(settings) {
                     await unsubscribe();
                 });
             });
-            describe("Should be null when listener removed and event is triggered", () => {
+            describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
                 test("Object literal listener", async () => {
                     const listener = {
                         result: null,
@@ -548,6 +548,58 @@ export function eventBusTestSuite(settings) {
                     expect(result).toBeNull();
                 });
             });
+            describe("Should be null when listener is removed by removeListener and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.subscribe(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.subscribe(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.subscribe(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(result).toBeNull();
+                });
+            });
         });
         describe("method: subscribeMany, dispatchMany", () => {
             describe("Should be null when listener is added and event is not triggered", () => {
@@ -696,7 +748,7 @@ export function eventBusTestSuite(settings) {
                     await unsubscribe();
                 });
             });
-            describe("Should be null when listener removed and event is triggered", () => {
+            describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
                 test("Object literal listener", async () => {
                     const listener = {
                         resultA: null,
@@ -781,6 +833,332 @@ export function eventBusTestSuite(settings) {
                     expect(resultB).toBeNull();
                 });
             });
+            describe("Should be null when listener is removed by removeListener 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.subscribeMany([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 LazyPromise.delay(TTL);
+                    expect(listener.resultA).toBeNull();
+                    expect(listener.resultB).toBeNull();
+                });
+                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.subscribeMany([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 LazyPromise.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.subscribeMany([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 LazyPromise.delay(TTL);
+                    expect(resultA).toBeNull();
+                    expect(resultB).toBeNull();
+                });
+            });
+        });
+        describe("method: subscribeOnce", () => {
+            describe("Should be null when listener added and event is not triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.subscribeOnce(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.subscribeOnce(AddEvent, listener);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.subscribeOnce(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,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toEqual(event);
+                    expect(listener.result).toBeInstanceOf(AddEvent);
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.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.subscribeOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.i).toBe(1);
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        i = 0;
+                        invoke(_event) {
+                            this.i++;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.i).toBe(1);
+                });
+                test("Function listener", async () => {
+                    let i = 0;
+                    const listener = () => {
+                        i++;
+                    };
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(i).toBe(1);
+                });
+            });
+            describe("Should be null when listener is removed by unsubscribe function and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    const unsubscribe = await eventBusA.subscribeOnce(AddEvent, listener);
+                    await unsubscribe();
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    const unsubscribe = await eventBusA.subscribeOnce(AddEvent, listener);
+                    await unsubscribe();
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    const unsubscribe = await eventBusA.subscribeOnce(AddEvent, listener);
+                    await unsubscribe();
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(result).toBeNull();
+                });
+            });
+            describe("Should be null when listener is removed by removeListener method and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.subscribeOnce(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(result).toBeNull();
+                });
+            });
         });
         describe("method: listenOnce", () => {
             describe("Should be null when listener added and event is not triggered", () => {
@@ -918,6 +1296,58 @@ export function eventBusTestSuite(settings) {
                     expect(i).toBe(1);
                 });
             });
+            describe("Should be null when listener is removed and event is triggered", () => {
+                test("Object literal listener", async () => {
+                    const listener = {
+                        result: null,
+                        invoke(event) {
+                            this.result = event;
+                        },
+                    };
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Class instance listener", async () => {
+                    class Listener {
+                        result = null;
+                        invoke(event) {
+                            this.result = event;
+                        }
+                    }
+                    const listener = new Listener();
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(listener.result).toBeNull();
+                });
+                test("Function listener", async () => {
+                    let result = null;
+                    const listener = (event) => {
+                        result = event;
+                    };
+                    await eventBusA.listenOnce(AddEvent, listener);
+                    await eventBusA.removeListener(AddEvent, listener);
+                    const event = new AddEvent({
+                        a: 1,
+                        b: 2,
+                    });
+                    await eventBusA.dispatch(event);
+                    await LazyPromise.delay(TTL);
+                    expect(result).toBeNull();
+                });
+            });
         });
         describe("method: asPromise", () => {
             test("Should be null when listener added and event is not triggered", () => {
@@ -1072,6 +1502,25 @@ export function eventBusTestSuite(settings) {
             expect(result_a).toBeInstanceOf(AddEvent);
             expect(result_b).toBeNull();
         });
+        test("method: subscribeOnce", async () => {
+            let result_a = null;
+            await eventBusA.subscribeOnce(AddEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            await eventBusB.subscribeOnce(AddEvent, (event) => {
+                result_b = event;
+            });
+            const event = new AddEvent({
+                a: 1,
+                b: 2,
+            });
+            await eventBusA.dispatch(event);
+            await LazyPromise.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) => {