@daiso-tech/core 0.33.0 → 0.35.0

package/dist/cache/implementations/test-utilities/cache.test-suite.js

@@ -2,14 +2,14 @@
  * @module Cache
  */
 import {} from "vitest";
-import { TypeCacheError, KeyNotFoundCacheError, KeyNotFoundCacheEvent, KeyAddedCacheEvent, KeyDecrementedCacheEvent, KeyFoundCacheEvent, KeyIncrementedCacheEvent, KeyRemovedCacheEvent, KeysClearedCacheEvent, KeyUpdatedCacheEvent, } from "../../../cache/contracts/_module-exports.js";
+import { KeyNotFoundCacheError, TypeCacheError, CACHE_EVENTS, } from "../../../cache/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
 import { TimeSpan } from "../../../utilities/_module-exports.js";
 import { LazyPromise } from "../../../async/_module-exports.js";
 /**
- * The <i>cacheTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICache}</i> with <i>vitest</i>.
+ * The `cacheTestSuite` function simplifies the process of testing your custom implementation of {@link ICache | `ICache`} with `vitest`.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/cache/test-utilities"```
+ * IMPORT_PATH: `"@daiso-tech/core/cache/test-utilities"`
  * @group TestUtilities
  * @example
  * ```ts
@@ -460,113 +460,105 @@ export function cacheTestSuite(settings) {
     });
     describe("Event tests:", () => {
         describe("method: exists", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.exists("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.exists("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
         });
         describe("method: missing", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.missing("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.missing("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
         });
         describe("method: get", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.get("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.get("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
         });
         describe("method: getOr", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.getOr("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.getOr("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
         });
         describe("method: getOrFail", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 try {
@@ -576,279 +568,278 @@ export function cacheTestSuite(settings) {
                     /* Empty */
                 }
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.getOrFail("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
         });
         describe("method: add", () => {
-            test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch AddedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "added") {
+                        event_ = event;
+                    }
                 });
                 const ttl = TimeSpan.fromMilliseconds(20);
                 await cache.add("a", 1, ttl);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyAddedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
-                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
+                expect(event_?.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
                 await unsubscribe();
             });
         });
         describe("method: update", () => {
-            test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
+            test("Should dispatch UpdatedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyUpdatedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "updated") {
+                        event_ = event;
+                    }
                 });
                 await cache.add("a", 1);
                 await cache.update("a", 2);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyUpdatedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(2);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(2);
                 await unsubscribe();
             });
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.update("a", 2);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
         });
         describe("method: put", () => {
-            test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch AddedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "added") {
+                        event_ = event;
+                    }
                 });
                 const ttl = TimeSpan.fromMilliseconds(20);
                 await cache.put("a", 1, ttl);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyAddedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
-                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
+                expect(event_?.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
                 await unsubscribe();
             });
-            test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
+            test("Should dispatch UpdatedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyUpdatedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "updated") {
+                        event_ = event;
+                    }
                 });
                 await cache.put("a", 1);
                 await cache.put("a", 2);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyUpdatedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(2);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(2);
                 await unsubscribe();
             });
         });
         describe("method: remove", () => {
-            test("Should dispatch KeyRemovedCacheEvent when key exists", async () => {
+            test("Should dispatch RemovedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyRemovedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "removed") {
+                        event_ = event;
+                    }
                 });
                 await cache.add("a", 1);
                 await cache.remove("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyRemovedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.remove("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
         });
         describe("method: removeMany", () => {
-            test("Should dispatch KeyRemovedCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch RemovedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyRemovedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "removed") {
+                        event_ = event;
+                    }
                 });
                 await cache.add("a", 1);
                 await cache.removeMany(["a"]);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyRemovedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.removeMany(["a"]);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
         });
         describe("method: getAndRemove", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.getAndRemove("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.getAndRemove("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
-            test("Should dispatch KeyRemovedCacheEvent when key exists", async () => {
+            test("Should dispatch RemovedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyRemovedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "removed") {
+                        event_ = event;
+                    }
                 });
                 await cache.add("a", 1);
                 await cache.getAndRemove("a");
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyRemovedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
         });
         describe("method: getOrAdd", () => {
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.getOrAdd("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
-            test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
+            test("Should dispatch FoundCacheEventt when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
                 await cache.getOrAdd("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
-            test("Should dispatch KeyAddedCacheEvent when key exists", async () => {
+            test("Should dispatch AddedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "added") {
+                        event_ = event;
+                    }
                 });
                 const ttl = TimeSpan.fromMilliseconds(50);
                 await cache.getOrAdd("a", 1, ttl);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyAddedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
-                expect(event_?.fields.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
+                expect(event_?.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
                 await unsubscribe();
             });
         });
         describe("method: increment", () => {
-            test("Should dispatch KeyIncrementedCacheEvent when key exists", async () => {
+            test("Should dispatch IncrementedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyIncrementedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "incremented") {
+                        event_ = event;
+                    }
                 });
                 await cache.add("a", 1);
                 await cache.increment("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyIncrementedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.increment("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
         });
         describe("method: decrement", () => {
-            test("Should dispatch KeyDecrementedCacheEvent when key exists", async () => {
+            test("Should dispatch DecrementedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyDecrementedCacheEvent, (event) => {
-                    event_ = event;
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.WRITTEN, (event) => {
+                    if (event.type === "decremented") {
+                        event_ = event;
+                    }
                 });
                 await cache.add("a", 1);
                 await cache.decrement("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyDecrementedCacheEvent);
-                expect(event_?.fields.key).toBe("a");
-                expect(event_?.fields.value).toBe(1);
+                expect(event_?.key).toBe("a");
+                expect(event_?.value).toBe(1);
                 await unsubscribe();
             });
-            test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch NotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.NOT_FOUND, (event) => {
                     event_ = event;
                 });
                 await cache.decrement("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
-                expect(event_?.fields.key).toBe("a");
+                expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
         });
         describe("method: clear", () => {
-            test("Should dispatch KeysClearedCacheEvent when key doesnt exists", async () => {
+            test("Should dispatch ClearedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cache.subscribe(KeysClearedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(CACHE_EVENTS.CLEARED, (event) => {
                     event_ = event;
                 });
                 await cache.add("a", 1);
@@ -856,8 +847,8 @@ export function cacheTestSuite(settings) {
                 await cache.add("c", 3);
                 await cache.clear();
                 await LazyPromise.delay(DELAY_TIME);
-                expect(event_).toBeInstanceOf(KeysClearedCacheEvent);
                 await unsubscribe();
+                expect(event_).toStrictEqual({});
             });
         });
     });