@daiso-tech/core 0.21.0 → 0.22.0

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

@@ -1,13 +1,14 @@
-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";
+import { delay, LazyPromise } from "../../../async/_module";
 export function cacheTestSuite(settings) {
-    const { expect, test, createCacheA, createCacheB, describe, beforeEach } = settings;
+    const { expect, test, createCache, describe, beforeEach } = settings;
     let cacheA;
     let cacheB;
     beforeEach(async () => {
-        cacheA = await createCacheA();
-        cacheB = await createCacheB();
+        const cache = await createCache();
+        cacheA = cache;
+        cacheB = cache.withGroup("b");
     });
     describe("Api tests:", () => {
         const TTL = TimeSpan.fromMilliseconds(50);
@@ -153,32 +154,40 @@ export function cacheTestSuite(settings) {
                 expect(await cacheA.getOr("a", -1)).toBe(1);
             });
             describe("Should return default value when key doesnt exists", () => {
-                test("Eager", async () => {
+                test("Value", async () => {
                     expect(await cacheA.getOr("a", -1)).toBe(-1);
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     expect(await cacheA.getOr("a", () => -1)).toBe(-1);
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     expect(await cacheA.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
+                test("LazyPromise", async () => {
+                    expect(await cacheA.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                });
             });
             describe("Should return default value when key is expired", () => {
-                test("Eager", async () => {
+                test("Value", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     expect(await cacheA.getOr("a", -1)).toBe(-1);
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     expect(await cacheA.getOr("a", () => -1)).toBe(-1);
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     expect(await cacheA.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
+                test("LazyPromise", async () => {
+                    await cacheA.add("a", 1, TTL);
+                    await delay(TTL);
+                    expect(await cacheA.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                });
             });
         });
         describe("method: getOrFail", () => {
@@ -207,19 +216,19 @@ export function cacheTestSuite(settings) {
                 });
             });
             describe("Should return only default values when all keys doesnt exists", () => {
-                test("Eager", async () => {
+                test("Value", async () => {
                     expect(await cacheA.getOrMany({ a: -1, b: -1 })).toEqual({
                         a: -1,
                         b: -1,
                     });
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     expect(await cacheA.getOrMany({ a: () => -1, b: () => -1 })).toEqual({
                         a: -1,
                         b: -1,
                     });
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     expect(await cacheA.getOrMany({
                         a: () => Promise.resolve(-1),
                         b: () => Promise.resolve(-1),
@@ -228,9 +237,18 @@ export function cacheTestSuite(settings) {
                         b: -1,
                     });
                 });
+                test("LazyPromise", async () => {
+                    expect(await cacheA.getOrMany({
+                        a: new LazyPromise(() => Promise.resolve(-1)),
+                        b: new LazyPromise(() => Promise.resolve(-1)),
+                    })).toEqual({
+                        a: -1,
+                        b: -1,
+                    });
+                });
             });
             describe("Should return default value when key is expired", () => {
-                test("Eager", async () => {
+                test("Value", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     expect(await cacheA.getOrMany({
@@ -239,7 +257,7 @@ export function cacheTestSuite(settings) {
                         a: -1,
                     });
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     expect(await cacheA.getOrMany({
@@ -248,7 +266,7 @@ export function cacheTestSuite(settings) {
                         a: -1,
                     });
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     expect(await cacheA.getOrMany({
@@ -257,6 +275,15 @@ export function cacheTestSuite(settings) {
                         a: -1,
                     });
                 });
+                test("LazyPromise", async () => {
+                    await cacheA.add("a", 1, TTL);
+                    await delay(TTL);
+                    expect(await cacheA.getOrMany({
+                        a: new LazyPromise(() => Promise.resolve(-1)),
+                    })).toEqual({
+                        a: -1,
+                    });
+                });
             });
             test("Should return values and default values when some keys exists", async () => {
                 await cacheA.add("a", 1);
@@ -680,38 +707,48 @@ export function cacheTestSuite(settings) {
                 expect(await cacheA.getOrAdd("a", -1)).toBe(1);
             });
             describe("Should persist insertion when key doesnt exists", () => {
-                test("Eager", async () => {
+                test("Value", async () => {
                     await cacheA.getOrAdd("a", -1);
                     expect(await cacheA.get("a")).toBe(-1);
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     await cacheA.getOrAdd("a", () => -1);
                     expect(await cacheA.get("a")).toBe(-1);
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     await cacheA.getOrAdd("a", () => Promise.resolve(-1));
                     expect(await cacheA.get("a")).toBe(-1);
                 });
+                test("LazyPromise", async () => {
+                    await cacheA.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
+                    expect(await cacheA.get("a")).toBe(-1);
+                });
             });
             describe("Should persist insertion when key is expired", () => {
-                test("Eager", async () => {
+                test("Value", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     await cacheA.getOrAdd("a", -1);
                     expect(await cacheA.get("a")).toBe(-1);
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     await cacheA.getOrAdd("a", () => -1);
                     expect(await cacheA.get("a")).toBe(-1);
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await delay(TTL);
                     await cacheA.getOrAdd("a", () => Promise.resolve(-1));
                     expect(await cacheA.get("a")).toBe(-1);
                 });
+                test("LazyPromise", async () => {
+                    await cacheA.add("a", 1, TTL);
+                    await delay(TTL);
+                    await cacheA.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
+                    expect(await cacheA.get("a")).toBe(-1);
+                });
             });
         });
         describe("method: increment", () => {
@@ -802,6 +839,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 +1641,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