@daiso-tech/core 0.20.0 → 0.21.1

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

@@ -1,4 +1,4 @@
-import { KeyNotFoundCacheError, TypeCacheError, } from "../../../cache/contracts/_module";
+import { KeyNotFoundCacheError, KeyNotFoundCacheEvent, KeyFoundCacheEvent, TypeCacheError, KeyAddedCacheEvent, KeyUpdatedCacheEvent, KeyRemovedCacheEvent, KeysClearedCacheEvent, KeyIncrementedCacheEvent, KeyDecrementedCacheEvent, } from "../../../cache/contracts/_module";
 import { TimeSpan } from "../../../utilities/_module";
 import { delay } from "../../../async/_module";
 export function cacheTestSuite(settings) {
@@ -802,6 +802,587 @@ export function cacheTestSuite(settings) {
             });
         });
     });
+    describe("Event tests:", () => {
+        const delayTime = TimeSpan.fromMilliseconds(50);
+        describe("method: exists", () => {
+            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+                let event_ = null;
+                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.exists("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.exists("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.existsMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.existsMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.missing("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.missing("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.missingMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.missingMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.get("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.get("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getOr("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOr("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getOrMany({ a: 1 });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOrMany({ a: 1 });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                try {
+                    await cacheA.getOrFail("a");
+                }
+                catch {
+                }
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOrFail("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = TimeSpan.fromMilliseconds(20);
+                await cacheA.add("a", 1, ttl);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = TimeSpan.fromMilliseconds(20);
+                await cacheA.addMany({ a: { value: 1, ttl } });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.update("a", 2);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.update("a", 2);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.updateMany({ a: 2 });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.updateMany({ a: 2 });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = TimeSpan.fromMilliseconds(20);
+                await cacheA.put("a", 1, ttl);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.put("a", 1);
+                await cacheA.put("a", 2);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = TimeSpan.fromMilliseconds(20);
+                await cacheA.putMany({ a: { value: 1, ttl } });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyUpdatedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = TimeSpan.fromMilliseconds(20);
+                await cacheA.putMany({ a: { value: 1, ttl } });
+                await cacheA.putMany({ a: { value: 2, ttl } });
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyRemovedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.remove("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.remove("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyRemovedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.removeMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.removeMany(["a"]);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getAndRemove("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getAndRemove("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyRemovedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getAndRemove("a");
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.getOrAdd("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.getOrAdd("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyAddedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                const ttl = TimeSpan.fromMilliseconds(50);
+                await cacheA.getOrAdd("a", 1, ttl);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyIncrementedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.increment("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.increment("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyDecrementedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.add("a", 1);
+                await cacheA.decrement("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeyNotFoundCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.decrement("a", 1);
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(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(KeysClearedCacheEvent, (event) => {
+                    event_ = event;
+                });
+                await cacheA.addMany({
+                    a: { value: 1 },
+                    b: { value: 2 },
+                    c: { value: 3 },
+                });
+                await cacheA.clear();
+                await delay(delayTime);
+                expect(event_).toBeInstanceOf(KeysClearedCacheEvent);
+                await unsubscribe();
+            });
+        });
+    });
     describe("Group tests:", () => {
         test("method: exists", async () => {
             await cacheA.put("a", 1);
@@ -1023,6 +1604,96 @@ export function cacheTestSuite(settings) {
                 b: 2,
             });
         });
+        test("method: addListener / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListener(KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            await cacheB.addListener(KeyAddedCacheEvent, (event) => {
+                result_b = event;
+            });
+            await cacheA.add("a", 1);
+            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: addListenerMany / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListenerMany([KeyAddedCacheEvent], (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            await cacheB.addListenerMany([KeyAddedCacheEvent], (event) => {
+                result_b = event;
+            });
+            await cacheA.add("a", 1);
+            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: removeListener / addListener / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListener(KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            await cacheB.addListener(KeyAddedCacheEvent, listenerB);
+            await cacheB.removeListener(KeyAddedCacheEvent, listenerB);
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: removeListenerMany / addListener / dispatch", async () => {
+            let result_a = null;
+            await cacheA.addListener(KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            await cacheB.addListener(KeyAddedCacheEvent, listenerB);
+            await cacheB.removeListenerMany([KeyAddedCacheEvent], listenerB);
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: subscribe / dispatch", async () => {
+            let result_a = null;
+            await cacheA.subscribe(KeyAddedCacheEvent, (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            const unsubscribe = await cacheB.subscribe(KeyAddedCacheEvent, listenerB);
+            await unsubscribe();
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
+        test("method: subscribeMany / dispatch", async () => {
+            let result_a = null;
+            await cacheA.subscribeMany([KeyAddedCacheEvent], (event) => {
+                result_a = event;
+            });
+            let result_b = null;
+            const listenerB = (event) => {
+                result_b = event;
+            };
+            const unsubscribe = await cacheB.subscribeMany([KeyAddedCacheEvent], listenerB);
+            await unsubscribe();
+            await cacheA.add("a", 1);
+            await cacheB.add("a", 1);
+            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
+            expect(result_b).toBeNull();
+        });
     });
 }
 //# sourceMappingURL=cache.test-suite.js.map