@geekmidas/cache 0.0.4 → 0.0.6

package/dist/__tests__/cache.spec.cjs

@@ -1,55 +1,55 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_memory = require('../memory-n6Iosq6J.cjs');
-const require_upstash = require('../upstash-0RolGx7m.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
+require('../src-C7d6HaTp.cjs');
+const require_memory = require('../memory-Csy6J-Ak.cjs');
+const require_upstash = require('../upstash-u8Hs4sZG.cjs');
+const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-B-qkABPq.cjs');
 
 //#region src/__tests__/cache.spec.ts
-(0, vitest.describe)("Cache Interface", () => {
-	(0, vitest.describe)("interface compliance", () => {
-		(0, vitest.it)("InMemoryCache should implement Cache interface", () => {
+require_vi_bdSIJ99Y.describe("Cache Interface", () => {
+	require_vi_bdSIJ99Y.describe("interface compliance", () => {
+		require_vi_bdSIJ99Y.it("InMemoryCache should implement Cache interface", () => {
 			const cache = new require_memory.InMemoryCache();
-			(0, vitest.expect)(typeof cache.get).toBe("function");
-			(0, vitest.expect)(typeof cache.set).toBe("function");
-			(0, vitest.expect)(typeof cache.delete).toBe("function");
+			require_vi_bdSIJ99Y.globalExpect(typeof cache.get).toBe("function");
+			require_vi_bdSIJ99Y.globalExpect(typeof cache.set).toBe("function");
+			require_vi_bdSIJ99Y.globalExpect(typeof cache.delete).toBe("function");
 		});
-		(0, vitest.it)("UpstashCache should implement Cache interface", () => {
+		require_vi_bdSIJ99Y.it("UpstashCache should implement Cache interface", () => {
 			const cache = new require_upstash.UpstashCache("http://localhost:8079", "example_token");
-			(0, vitest.expect)(typeof cache.get).toBe("function");
-			(0, vitest.expect)(typeof cache.set).toBe("function");
-			(0, vitest.expect)(typeof cache.delete).toBe("function");
+			require_vi_bdSIJ99Y.globalExpect(typeof cache.get).toBe("function");
+			require_vi_bdSIJ99Y.globalExpect(typeof cache.set).toBe("function");
+			require_vi_bdSIJ99Y.globalExpect(typeof cache.delete).toBe("function");
 		});
 	});
-	(0, vitest.describe)("method signatures", () => {
-		(0, vitest.it)("should have correct get method signature", () => {
+	require_vi_bdSIJ99Y.describe("method signatures", () => {
+		require_vi_bdSIJ99Y.it("should have correct get method signature", () => {
 			const cache = new require_memory.InMemoryCache();
 			const getResult = cache.get("test");
-			(0, vitest.expect)(getResult).toBeInstanceOf(Promise);
+			require_vi_bdSIJ99Y.globalExpect(getResult).toBeInstanceOf(Promise);
 		});
-		(0, vitest.it)("should have correct set method signature", () => {
+		require_vi_bdSIJ99Y.it("should have correct set method signature", () => {
 			const cache = new require_memory.InMemoryCache();
 			const setResult = cache.set("test", "value");
-			(0, vitest.expect)(setResult).toBeInstanceOf(Promise);
+			require_vi_bdSIJ99Y.globalExpect(setResult).toBeInstanceOf(Promise);
 		});
-		(0, vitest.it)("should have correct delete method signature", () => {
+		require_vi_bdSIJ99Y.it("should have correct delete method signature", () => {
 			const cache = new require_memory.InMemoryCache();
 			const deleteResult = cache.delete("test");
-			(0, vitest.expect)(deleteResult).toBeInstanceOf(Promise);
+			require_vi_bdSIJ99Y.globalExpect(deleteResult).toBeInstanceOf(Promise);
 		});
 	});
-	(0, vitest.describe)("generic type support", () => {
-		(0, vitest.it)("should support string types", async () => {
+	require_vi_bdSIJ99Y.describe("generic type support", () => {
+		require_vi_bdSIJ99Y.it("should support string types", async () => {
 			const cache = new require_memory.InMemoryCache();
 			await cache.set("key", "value");
 			const result = await cache.get("key");
-			(0, vitest.expect)(typeof result === "string" || result === void 0).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof result === "string" || result === void 0).toBe(true);
 		});
-		(0, vitest.it)("should support number types", async () => {
+		require_vi_bdSIJ99Y.it("should support number types", async () => {
 			const cache = new require_memory.InMemoryCache();
 			await cache.set("key", 42);
 			const result = await cache.get("key");
-			(0, vitest.expect)(typeof result === "number" || result === void 0).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof result === "number" || result === void 0).toBe(true);
 		});
-		(0, vitest.it)("should support object types", async () => {
+		require_vi_bdSIJ99Y.it("should support object types", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const user = {
 				id: 1,
@@ -57,9 +57,9 @@ const vitest = require_chunk.__toESM(require("vitest"));
 			};
 			await cache.set("user", user);
 			const result = await cache.get("user");
-			(0, vitest.expect)(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
 		});
-		(0, vitest.it)("should support union types", async () => {
+		require_vi_bdSIJ99Y.it("should support union types", async () => {
 			const cache = new require_memory.InMemoryCache();
 			await cache.set("string", "text");
 			await cache.set("number", 42);
@@ -67,9 +67,9 @@ const vitest = require_chunk.__toESM(require("vitest"));
 			const stringResult = await cache.get("string");
 			const numberResult = await cache.get("number");
 			const booleanResult = await cache.get("boolean");
-			(0, vitest.expect)(stringResult).toBe("text");
-			(0, vitest.expect)(numberResult).toBe(42);
-			(0, vitest.expect)(booleanResult).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(stringResult).toBe("text");
+			require_vi_bdSIJ99Y.globalExpect(numberResult).toBe(42);
+			require_vi_bdSIJ99Y.globalExpect(booleanResult).toBe(true);
 		});
 	});
 });

package/dist/__tests__/cache.spec.mjs

@@ -1,38 +1,39 @@
-import { InMemoryCache } from "../memory-NQi0XmZ2.mjs";
-import { UpstashCache } from "../upstash-CTY-M8vR.mjs";
-import { describe, expect, it } from "vitest";
+import { describe, globalExpect, it } from "../vi.bdSIJ99Y-CB5havZF.mjs";
+import "../src-DVpoP03o.mjs";
+import { InMemoryCache } from "../memory-QDTnSEX5.mjs";
+import { UpstashCache } from "../upstash-CXy_duOa.mjs";
 
 //#region src/__tests__/cache.spec.ts
 describe("Cache Interface", () => {
 	describe("interface compliance", () => {
 		it("InMemoryCache should implement Cache interface", () => {
 			const cache = new InMemoryCache();
-			expect(typeof cache.get).toBe("function");
-			expect(typeof cache.set).toBe("function");
-			expect(typeof cache.delete).toBe("function");
+			globalExpect(typeof cache.get).toBe("function");
+			globalExpect(typeof cache.set).toBe("function");
+			globalExpect(typeof cache.delete).toBe("function");
 		});
 		it("UpstashCache should implement Cache interface", () => {
 			const cache = new UpstashCache("http://localhost:8079", "example_token");
-			expect(typeof cache.get).toBe("function");
-			expect(typeof cache.set).toBe("function");
-			expect(typeof cache.delete).toBe("function");
+			globalExpect(typeof cache.get).toBe("function");
+			globalExpect(typeof cache.set).toBe("function");
+			globalExpect(typeof cache.delete).toBe("function");
 		});
 	});
 	describe("method signatures", () => {
 		it("should have correct get method signature", () => {
 			const cache = new InMemoryCache();
 			const getResult = cache.get("test");
-			expect(getResult).toBeInstanceOf(Promise);
+			globalExpect(getResult).toBeInstanceOf(Promise);
 		});
 		it("should have correct set method signature", () => {
 			const cache = new InMemoryCache();
 			const setResult = cache.set("test", "value");
-			expect(setResult).toBeInstanceOf(Promise);
+			globalExpect(setResult).toBeInstanceOf(Promise);
 		});
 		it("should have correct delete method signature", () => {
 			const cache = new InMemoryCache();
 			const deleteResult = cache.delete("test");
-			expect(deleteResult).toBeInstanceOf(Promise);
+			globalExpect(deleteResult).toBeInstanceOf(Promise);
 		});
 	});
 	describe("generic type support", () => {
@@ -40,13 +41,13 @@ describe("Cache Interface", () => {
 			const cache = new InMemoryCache();
 			await cache.set("key", "value");
 			const result = await cache.get("key");
-			expect(typeof result === "string" || result === void 0).toBe(true);
+			globalExpect(typeof result === "string" || result === void 0).toBe(true);
 		});
 		it("should support number types", async () => {
 			const cache = new InMemoryCache();
 			await cache.set("key", 42);
 			const result = await cache.get("key");
-			expect(typeof result === "number" || result === void 0).toBe(true);
+			globalExpect(typeof result === "number" || result === void 0).toBe(true);
 		});
 		it("should support object types", async () => {
 			const cache = new InMemoryCache();
@@ -56,7 +57,7 @@ describe("Cache Interface", () => {
 			};
 			await cache.set("user", user);
 			const result = await cache.get("user");
-			expect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
+			globalExpect(result === void 0 || typeof result === "object" && "id" in result && "name" in result).toBe(true);
 		});
 		it("should support union types", async () => {
 			const cache = new InMemoryCache();
@@ -66,9 +67,9 @@ describe("Cache Interface", () => {
 			const stringResult = await cache.get("string");
 			const numberResult = await cache.get("number");
 			const booleanResult = await cache.get("boolean");
-			expect(stringResult).toBe("text");
-			expect(numberResult).toBe(42);
-			expect(booleanResult).toBe(true);
+			globalExpect(stringResult).toBe("text");
+			globalExpect(numberResult).toBe(42);
+			globalExpect(booleanResult).toBe(true);
 		});
 	});
 });

package/dist/__tests__/integration.spec.cjs

@@ -1,31 +1,31 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_memory = require('../memory-n6Iosq6J.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
+require('../src-C7d6HaTp.cjs');
+const require_memory = require('../memory-Csy6J-Ak.cjs');
+const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-B-qkABPq.cjs');
 
 //#region src/__tests__/integration.spec.ts
-(0, vitest.describe)("Cache Integration Tests", () => {
+require_vi_bdSIJ99Y.describe("Cache Integration Tests", () => {
 	let memoryCache;
-	(0, vitest.beforeEach)(() => {
+	require_vi_bdSIJ99Y.beforeEach(() => {
 		memoryCache = new require_memory.InMemoryCache();
 	});
-	(0, vitest.describe)("cross-cache behavior consistency", () => {
+	require_vi_bdSIJ99Y.describe("cross-cache behavior consistency", () => {
 		const testCases = [{
 			name: "InMemoryCache",
 			cache: () => new require_memory.InMemoryCache()
 		}];
 		testCases.forEach(({ name, cache }) => {
-			(0, vitest.describe)(name, () => {
+			require_vi_bdSIJ99Y.describe(name, () => {
 				let cacheInstance;
-				(0, vitest.beforeEach)(() => {
+				require_vi_bdSIJ99Y.beforeEach(() => {
 					cacheInstance = cache();
 				});
-				(0, vitest.it)("should handle basic CRUD operations", async () => {
+				require_vi_bdSIJ99Y.it("should handle basic CRUD operations", async () => {
 					await cacheInstance.set("user:1", {
 						id: 1,
 						name: "John"
 					});
 					const user = await cacheInstance.get("user:1");
-					(0, vitest.expect)(user).toEqual({
+					require_vi_bdSIJ99Y.globalExpect(user).toEqual({
 						id: 1,
 						name: "John"
 					});
@@ -34,15 +34,15 @@ const vitest = require_chunk.__toESM(require("vitest"));
 						name: "Jane"
 					});
 					const updatedUser = await cacheInstance.get("user:1");
-					(0, vitest.expect)(updatedUser).toEqual({
+					require_vi_bdSIJ99Y.globalExpect(updatedUser).toEqual({
 						id: 1,
 						name: "Jane"
 					});
 					await cacheInstance.delete("user:1");
 					const deletedUser = await cacheInstance.get("user:1");
-					(0, vitest.expect)(deletedUser).toBeUndefined();
+					require_vi_bdSIJ99Y.globalExpect(deletedUser).toBeUndefined();
 				});
-				(0, vitest.it)("should handle concurrent operations", async () => {
+				require_vi_bdSIJ99Y.it("should handle concurrent operations", async () => {
 					const operations = [
 						cacheInstance.set("key1", "value1"),
 						cacheInstance.set("key2", "value2"),
@@ -54,13 +54,13 @@ const vitest = require_chunk.__toESM(require("vitest"));
 						cacheInstance.get("key2"),
 						cacheInstance.get("key3")
 					]);
-					(0, vitest.expect)(results).toEqual([
+					require_vi_bdSIJ99Y.globalExpect(results).toEqual([
 						"value1",
 						"value2",
 						"value3"
 					]);
 				});
-				(0, vitest.it)("should handle data type preservation", async () => {
+				require_vi_bdSIJ99Y.it("should handle data type preservation", async () => {
 					const testData = {
 						string: "hello",
 						number: 42,
@@ -75,31 +75,31 @@ const vitest = require_chunk.__toESM(require("vitest"));
 					};
 					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
 					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					(0, vitest.expect)(results[0]).toBe("hello");
-					(0, vitest.expect)(results[1]).toBe(42);
-					(0, vitest.expect)(results[2]).toBe(true);
-					(0, vitest.expect)(results[3]).toEqual({ nested: true });
-					(0, vitest.expect)(results[4]).toEqual([
+					require_vi_bdSIJ99Y.globalExpect(results[0]).toBe("hello");
+					require_vi_bdSIJ99Y.globalExpect(results[1]).toBe(42);
+					require_vi_bdSIJ99Y.globalExpect(results[2]).toBe(true);
+					require_vi_bdSIJ99Y.globalExpect(results[3]).toEqual({ nested: true });
+					require_vi_bdSIJ99Y.globalExpect(results[4]).toEqual([
 						1,
 						2,
 						3
 					]);
-					(0, vitest.expect)(results[5]).toBeNull();
+					require_vi_bdSIJ99Y.globalExpect(results[5]).toBeNull();
 				});
-				(0, vitest.it)("should handle key isolation", async () => {
+				require_vi_bdSIJ99Y.it("should handle key isolation", async () => {
 					await cacheInstance.set("user:1", "User One");
 					await cacheInstance.set("user:2", "User Two");
 					await cacheInstance.set("session:1", "Session One");
 					await cacheInstance.delete("user:1");
-					(0, vitest.expect)(await cacheInstance.get("user:1")).toBeUndefined();
-					(0, vitest.expect)(await cacheInstance.get("user:2")).toBe("User Two");
-					(0, vitest.expect)(await cacheInstance.get("session:1")).toBe("Session One");
+					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
+					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
+					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
 				});
 			});
 		});
 	});
-	(0, vitest.describe)("cache migration scenarios", () => {
-		(0, vitest.it)("should support migrating data between cache implementations", async () => {
+	require_vi_bdSIJ99Y.describe("cache migration scenarios", () => {
+		require_vi_bdSIJ99Y.it("should support migrating data between cache implementations", async () => {
 			const sourceCache = new require_memory.InMemoryCache();
 			const targetCache = new require_memory.InMemoryCache();
 			const testData = {
@@ -124,12 +124,12 @@ const vitest = require_chunk.__toESM(require("vitest"));
 			}
 			for (const [key, expectedValue] of Object.entries(testData)) {
 				const migratedValue = await targetCache.get(key);
-				(0, vitest.expect)(migratedValue).toEqual(expectedValue);
+				require_vi_bdSIJ99Y.globalExpect(migratedValue).toEqual(expectedValue);
 			}
 		});
 	});
-	(0, vitest.describe)("cache abstraction patterns", () => {
-		(0, vitest.it)("should support cache factory pattern", async () => {
+	require_vi_bdSIJ99Y.describe("cache abstraction patterns", () => {
+		require_vi_bdSIJ99Y.it("should support cache factory pattern", async () => {
 			const createCache = (type) => {
 				switch (type) {
 					case "memory": return new require_memory.InMemoryCache();
@@ -143,13 +143,13 @@ const vitest = require_chunk.__toESM(require("vitest"));
 				name: "John"
 			});
 			await sessionCache.set("session:abc", "active");
-			(0, vitest.expect)(await userCache.get("user:1")).toEqual({
+			require_vi_bdSIJ99Y.globalExpect(await userCache.get("user:1")).toEqual({
 				id: 1,
 				name: "John"
 			});
-			(0, vitest.expect)(await sessionCache.get("session:abc")).toBe("active");
+			require_vi_bdSIJ99Y.globalExpect(await sessionCache.get("session:abc")).toBe("active");
 		});
-		(0, vitest.it)("should support cache wrapper pattern", async () => {
+		require_vi_bdSIJ99Y.it("should support cache wrapper pattern", async () => {
 			class LoggingCache {
 				logs = [];
 				constructor(underlying) {
@@ -177,28 +177,28 @@ const vitest = require_chunk.__toESM(require("vitest"));
 			await loggingCache.get("test");
 			await loggingCache.delete("test");
 			const logs = loggingCache.getLogs();
-			(0, vitest.expect)(logs).toEqual([
+			require_vi_bdSIJ99Y.globalExpect(logs).toEqual([
 				"SET test",
 				"GET test",
 				"DELETE test"
 			]);
 		});
 	});
-	(0, vitest.describe)("performance and stress tests", () => {
-		(0, vitest.it)("should handle large number of operations", async () => {
+	require_vi_bdSIJ99Y.describe("performance and stress tests", () => {
+		require_vi_bdSIJ99Y.it("should handle large number of operations", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const operationCount = 1e3;
 			const insertPromises = Array.from({ length: operationCount }, (_, i) => cache.set(`key:${i}`, i));
 			await Promise.all(insertPromises);
 			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
 			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) (0, vitest.expect)(results[i]).toBe(i);
+			for (let i = 0; i < operationCount; i++) require_vi_bdSIJ99Y.globalExpect(results[i]).toBe(i);
 			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
 			await Promise.all(deletePromises);
 			const postDeleteRead = await cache.get("key:0");
-			(0, vitest.expect)(postDeleteRead).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(postDeleteRead).toBeUndefined();
 		});
-		(0, vitest.it)("should handle large objects efficiently", async () => {
+		require_vi_bdSIJ99Y.it("should handle large objects efficiently", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const largeObject = {
 				id: 1,
@@ -215,19 +215,19 @@ const vitest = require_chunk.__toESM(require("vitest"));
 			await cache.set("large-object", largeObject);
 			const result = await cache.get("large-object");
 			const endTime = Date.now();
-			(0, vitest.expect)(result).toEqual(largeObject);
-			(0, vitest.expect)(endTime - startTime).toBeLessThan(100);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(largeObject);
+			require_vi_bdSIJ99Y.globalExpect(endTime - startTime).toBeLessThan(100);
 		});
 	});
-	(0, vitest.describe)("error scenarios", () => {
-		(0, vitest.it)("should handle operations after errors gracefully", async () => {
+	require_vi_bdSIJ99Y.describe("error scenarios", () => {
+		require_vi_bdSIJ99Y.it("should handle operations after errors gracefully", async () => {
 			const cache = new require_memory.InMemoryCache();
 			await cache.set("valid-key", "valid-value");
-			(0, vitest.expect)(await cache.get("valid-key")).toBe("valid-value");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("valid-key")).toBe("valid-value");
 			await cache.set("another-key", "another-value");
-			(0, vitest.expect)(await cache.get("another-key")).toBe("another-value");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("another-key")).toBe("another-value");
 			await cache.delete("valid-key");
-			(0, vitest.expect)(await cache.get("valid-key")).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("valid-key")).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/integration.spec.mjs

@@ -1,5 +1,6 @@
-import { InMemoryCache } from "../memory-NQi0XmZ2.mjs";
-import { beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe, globalExpect, it } from "../vi.bdSIJ99Y-CB5havZF.mjs";
+import "../src-DVpoP03o.mjs";
+import { InMemoryCache } from "../memory-QDTnSEX5.mjs";
 
 //#region src/__tests__/integration.spec.ts
 describe("Cache Integration Tests", () => {
@@ -24,7 +25,7 @@ describe("Cache Integration Tests", () => {
 						name: "John"
 					});
 					const user = await cacheInstance.get("user:1");
-					expect(user).toEqual({
+					globalExpect(user).toEqual({
 						id: 1,
 						name: "John"
 					});
@@ -33,13 +34,13 @@ describe("Cache Integration Tests", () => {
 						name: "Jane"
 					});
 					const updatedUser = await cacheInstance.get("user:1");
-					expect(updatedUser).toEqual({
+					globalExpect(updatedUser).toEqual({
 						id: 1,
 						name: "Jane"
 					});
 					await cacheInstance.delete("user:1");
 					const deletedUser = await cacheInstance.get("user:1");
-					expect(deletedUser).toBeUndefined();
+					globalExpect(deletedUser).toBeUndefined();
 				});
 				it("should handle concurrent operations", async () => {
 					const operations = [
@@ -53,7 +54,7 @@ describe("Cache Integration Tests", () => {
 						cacheInstance.get("key2"),
 						cacheInstance.get("key3")
 					]);
-					expect(results).toEqual([
+					globalExpect(results).toEqual([
 						"value1",
 						"value2",
 						"value3"
@@ -74,25 +75,25 @@ describe("Cache Integration Tests", () => {
 					};
 					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
 					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					expect(results[0]).toBe("hello");
-					expect(results[1]).toBe(42);
-					expect(results[2]).toBe(true);
-					expect(results[3]).toEqual({ nested: true });
-					expect(results[4]).toEqual([
+					globalExpect(results[0]).toBe("hello");
+					globalExpect(results[1]).toBe(42);
+					globalExpect(results[2]).toBe(true);
+					globalExpect(results[3]).toEqual({ nested: true });
+					globalExpect(results[4]).toEqual([
 						1,
 						2,
 						3
 					]);
-					expect(results[5]).toBeNull();
+					globalExpect(results[5]).toBeNull();
 				});
 				it("should handle key isolation", async () => {
 					await cacheInstance.set("user:1", "User One");
 					await cacheInstance.set("user:2", "User Two");
 					await cacheInstance.set("session:1", "Session One");
 					await cacheInstance.delete("user:1");
-					expect(await cacheInstance.get("user:1")).toBeUndefined();
-					expect(await cacheInstance.get("user:2")).toBe("User Two");
-					expect(await cacheInstance.get("session:1")).toBe("Session One");
+					globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
+					globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
+					globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
 				});
 			});
 		});
@@ -123,7 +124,7 @@ describe("Cache Integration Tests", () => {
 			}
 			for (const [key, expectedValue] of Object.entries(testData)) {
 				const migratedValue = await targetCache.get(key);
-				expect(migratedValue).toEqual(expectedValue);
+				globalExpect(migratedValue).toEqual(expectedValue);
 			}
 		});
 	});
@@ -142,11 +143,11 @@ describe("Cache Integration Tests", () => {
 				name: "John"
 			});
 			await sessionCache.set("session:abc", "active");
-			expect(await userCache.get("user:1")).toEqual({
+			globalExpect(await userCache.get("user:1")).toEqual({
 				id: 1,
 				name: "John"
 			});
-			expect(await sessionCache.get("session:abc")).toBe("active");
+			globalExpect(await sessionCache.get("session:abc")).toBe("active");
 		});
 		it("should support cache wrapper pattern", async () => {
 			class LoggingCache {
@@ -176,7 +177,7 @@ describe("Cache Integration Tests", () => {
 			await loggingCache.get("test");
 			await loggingCache.delete("test");
 			const logs = loggingCache.getLogs();
-			expect(logs).toEqual([
+			globalExpect(logs).toEqual([
 				"SET test",
 				"GET test",
 				"DELETE test"
@@ -191,11 +192,11 @@ describe("Cache Integration Tests", () => {
 			await Promise.all(insertPromises);
 			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
 			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) expect(results[i]).toBe(i);
+			for (let i = 0; i < operationCount; i++) globalExpect(results[i]).toBe(i);
 			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
 			await Promise.all(deletePromises);
 			const postDeleteRead = await cache.get("key:0");
-			expect(postDeleteRead).toBeUndefined();
+			globalExpect(postDeleteRead).toBeUndefined();
 		});
 		it("should handle large objects efficiently", async () => {
 			const cache = new InMemoryCache();
@@ -214,19 +215,19 @@ describe("Cache Integration Tests", () => {
 			await cache.set("large-object", largeObject);
 			const result = await cache.get("large-object");
 			const endTime = Date.now();
-			expect(result).toEqual(largeObject);
-			expect(endTime - startTime).toBeLessThan(100);
+			globalExpect(result).toEqual(largeObject);
+			globalExpect(endTime - startTime).toBeLessThan(100);
 		});
 	});
 	describe("error scenarios", () => {
 		it("should handle operations after errors gracefully", async () => {
 			const cache = new InMemoryCache();
 			await cache.set("valid-key", "valid-value");
-			expect(await cache.get("valid-key")).toBe("valid-value");
+			globalExpect(await cache.get("valid-key")).toBe("valid-value");
 			await cache.set("another-key", "another-value");
-			expect(await cache.get("another-key")).toBe("another-value");
+			globalExpect(await cache.get("another-key")).toBe("another-value");
 			await cache.delete("valid-key");
-			expect(await cache.get("valid-key")).toBeUndefined();
+			globalExpect(await cache.get("valid-key")).toBeUndefined();
 		});
 	});
 });