@daiso-tech/core 0.20.0 → 0.21.1

package/dist/cjs/cache/implementations/_shared/cache.test-suite.js

@@ -805,6 +805,587 @@ function cacheTestSuite(settings) {
             });
         });
     });
+    describe("Event tests:", () => {
+        const delayTime = _module_2.TimeSpan.fromMilliseconds(50);
+        describe("method: exists", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.exists("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.exists("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: existsMany", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.existsMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.existsMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: missing", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.missing("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.missing("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: missingMany", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.missingMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.missingMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: get", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.get("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.get("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: getMany", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: getOr", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getOr("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOr("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: getOrMany", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getOrMany({ a: 1 });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOrMany({ a: 1 });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: getOrFail", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                try {
+                    await cacheA.getOrFail("a");
+                }
+                catch {
+                }
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOrFail("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+        });
+        describe("method: add", () => {
+            test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = _module_2.TimeSpan.fromMilliseconds(20);
+                await cacheA.add("a", 1, ttl);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                await unsubscribe();
+            });
+        });
+        describe("method: addMany", () => {
+            test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = _module_2.TimeSpan.fromMilliseconds(20);
+                await cacheA.addMany({ a: { value: 1, ttl } });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                await unsubscribe();
+            });
+        });
+        describe("method: update", () => {
+            test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.update("a", 2);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyUpdatedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(2);
+                await unsubscribe();
+            });
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.update("a", 2);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: updateMany", () => {
+            test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.updateMany({ a: 2 });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyUpdatedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(2);
+                await unsubscribe();
+            });
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.updateMany({ a: 2 });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: put", () => {
+            test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = _module_2.TimeSpan.fromMilliseconds(20);
+                await cacheA.put("a", 1, ttl);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                await unsubscribe();
+            });
+            test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.put("a", 1);
+                await cacheA.put("a", 2);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyUpdatedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(2);
+                await unsubscribe();
+            });
+        });
+        describe("method: putMany", () => {
+            test("Should dispatch KeyAddedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = _module_2.TimeSpan.fromMilliseconds(20);
+                await cacheA.putMany({ a: { value: 1, ttl } });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                await unsubscribe();
+            });
+            test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = _module_2.TimeSpan.fromMilliseconds(20);
+                await cacheA.putMany({ a: { value: 1, ttl } });
+                await cacheA.putMany({ a: { value: 2, ttl } });
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyUpdatedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(2);
+                await unsubscribe();
+            });
+        });
+        describe("method: remove", () => {
+            test("Should dispatch KeyRemovedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyRemovedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.remove("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyRemovedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.remove("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: removeMany", () => {
+            test("Should dispatch KeyRemovedCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyRemovedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.removeMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyRemovedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.removeMany(["a"]);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: getAndRemove", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getAndRemove("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getAndRemove("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+            test("Should dispatch KeyRemovedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyRemovedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getAndRemove("a");
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyRemovedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: getOrAdd", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getOrAdd("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOrAdd("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+            test("Should dispatch KeyAddedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = _module_2.TimeSpan.fromMilliseconds(50);
+                await cacheA.getOrAdd("a", 1, ttl);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                await unsubscribe();
+            });
+        });
+        describe("method: increment", () => {
+            test("Should dispatch KeyIncrementedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyIncrementedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.increment("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyIncrementedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.increment("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: decrement", () => {
+            test("Should dispatch KeyDecrementedCacheEvent when key exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyDecrementedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.decrement("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyDecrementedCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                expect(event_?.fields.value).toBe(1);
+                await unsubscribe();
+            });
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.decrement("a", 1);
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeyNotFoundCacheEvent);
+                expect(event_?.fields.key).toBe("a");
+                await unsubscribe();
+            });
+        });
+        describe("method: clear", () => {
+            test("Should dispatch KeysClearedCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(_module_1.KeysClearedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.addMany({
+                    a: { value: 1 },
+                    b: { value: 2 },
+                    c: { value: 3 },
+                });
+                await cacheA.clear();
+                await (0, _module_3.delay)(delayTime);
+                expect(event_).toBeInstanceOf(_module_1.KeysClearedCacheEvent);
+                await unsubscribe();
+            });
+        });
+    });
     describe("Group tests:", () => {
         test("method: exists", async () => {
             await cacheA.put("a", 1);
@@ -1026,6 +1607,96 @@ function cacheTestSuite(settings) {
                 b: 2,
             });
         });
+        test("method: addListener / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListener(_module_1.KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            await cacheB.addListener(_module_1.KeyAddedCacheEvent, (event) => {
+                result_b = event;
+            });
+            await cacheA.add("a", 1);
+            expect(result_a).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: addListenerMany / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListenerMany([_module_1.KeyAddedCacheEvent], (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            await cacheB.addListenerMany([_module_1.KeyAddedCacheEvent], (event) => {
+                result_b = event;
+            });
+            await cacheA.add("a", 1);
+            expect(result_a).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: removeListener / addListener / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListener(_module_1.KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            await cacheB.addListener(_module_1.KeyAddedCacheEvent, listenerB);
+            await cacheB.removeListener(_module_1.KeyAddedCacheEvent, listenerB);
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: removeListenerMany / addListener / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListener(_module_1.KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            await cacheB.addListener(_module_1.KeyAddedCacheEvent, listenerB);
+            await cacheB.removeListenerMany([_module_1.KeyAddedCacheEvent], listenerB);
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: subscribe / dispatch", async () => {
+            let result_a = null;
+            await cacheA.subscribe(_module_1.KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            const unsubscribe = await cacheB.subscribe(_module_1.KeyAddedCacheEvent, listenerB);
+            await unsubscribe();
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: subscribeMany / dispatch", async () => {
+            let result_a = null;
+            await cacheA.subscribeMany([_module_1.KeyAddedCacheEvent], (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            const unsubscribe = await cacheB.subscribeMany([_module_1.KeyAddedCacheEvent], listenerB);
+            await unsubscribe();
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(_module_1.KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
     });
 }
 //# sourceMappingURL=cache.test-suite.js.map