@daiso-tech/core 0.21.0 → 0.22.0

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

@@ -5,12 +5,13 @@ const _module_1 = require("../../../cache/contracts/_module");
 const _module_2 = require("../../../utilities/_module");
 const _module_3 = require("../../../async/_module");
 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 = _module_2.TimeSpan.fromMilliseconds(50);
@@ -156,32 +157,40 @@ 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 _module_3.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 (0, _module_3.delay)(TTL);
                     expect(await cacheA.getOr("a", -1)).toBe(-1);
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await (0, _module_3.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 (0, _module_3.delay)(TTL);
                     expect(await cacheA.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
+                test("LazyPromise", async () => {
+                    await cacheA.add("a", 1, TTL);
+                    await (0, _module_3.delay)(TTL);
+                    expect(await cacheA.getOr("a", new _module_3.LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                });
             });
         });
         describe("method: getOrFail", () => {
@@ -210,19 +219,19 @@ 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),
@@ -231,9 +240,18 @@ function cacheTestSuite(settings) {
                         b: -1,
                     });
                 });
+                test("LazyPromise", async () => {
+                    expect(await cacheA.getOrMany({
+                        a: new _module_3.LazyPromise(() => Promise.resolve(-1)),
+                        b: new _module_3.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 (0, _module_3.delay)(TTL);
                     expect(await cacheA.getOrMany({
@@ -242,7 +260,7 @@ function cacheTestSuite(settings) {
                         a: -1,
                     });
                 });
-                test("Lazy", async () => {
+                test("Function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await (0, _module_3.delay)(TTL);
                     expect(await cacheA.getOrMany({
@@ -251,7 +269,7 @@ function cacheTestSuite(settings) {
                         a: -1,
                     });
                 });
-                test("Async lazy", async () => {
+                test("Async function", async () => {
                     await cacheA.add("a", 1, TTL);
                     await (0, _module_3.delay)(TTL);
                     expect(await cacheA.getOrMany({
@@ -260,6 +278,15 @@ function cacheTestSuite(settings) {
                         a: -1,
                     });
                 });
+                test("LazyPromise", async () => {
+                    await cacheA.add("a", 1, TTL);
+                    await (0, _module_3.delay)(TTL);
+                    expect(await cacheA.getOrMany({
+                        a: new _module_3.LazyPromise(() => Promise.resolve(-1)),
+                    })).toEqual({
+                        a: -1,
+                    });
+                });
             });
             test("Should return values and default values when some keys exists", async () => {
                 await cacheA.add("a", 1);
@@ -683,38 +710,48 @@ 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 _module_3.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 (0, _module_3.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 (0, _module_3.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 (0, _module_3.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 (0, _module_3.delay)(TTL);
+                    await cacheA.getOrAdd("a", new _module_3.LazyPromise(() => Promise.resolve(-1)));
+                    expect(await cacheA.get("a")).toBe(-1);
+                });
             });
         });
         describe("method: increment", () => {
@@ -805,6 +842,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 +1644,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