@geekmidas/testkit 0.0.4 → 0.0.5

package/dist/__tests__/ObjectionFactory.spec.cjs

@@ -1,9 +1,8 @@
-const require_chunk = require('../chunk-DWy1uDak.cjs');
+const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-DREHoms3.cjs');
 const require_ObjectionFactory = require('../ObjectionFactory-BlkzSEqo.cjs');
-const require_dist = require('../dist-DE3gAxQI.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-CFuzUeY6.cjs');
-const require_helpers = require('../helpers-C2NH7xcz.cjs');
+const require_helpers = require('../helpers-DKEBHABj.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
 const objection = require_chunk.__toESM(require("objection"));
 
 //#region src/__tests__/ObjectionFactory.spec.ts
@@ -40,12 +39,12 @@ var Comment = class extends objection.Model {
 	userId;
 	createdAt;
 };
-require_dist.describe.skip("ObjectionFactory", () => {
+vitest.describe.skip("ObjectionFactory", () => {
 	let factory;
 	let db;
 	let trx;
 	let cleanup;
-	require_dist.beforeAll(async () => {
+	(0, vitest.beforeAll)(async () => {
 		const setup = await require_helpers.setupKnexTest();
 		db = setup.db;
 		trx = setup.trx;
@@ -54,19 +53,19 @@ require_dist.describe.skip("ObjectionFactory", () => {
 		Post.knex(trx);
 		Comment.knex(trx);
 	});
-	require_dist.afterAll(async () => {
+	(0, vitest.afterAll)(async () => {
 		await cleanup();
 	});
-	require_dist.describe("constructor", () => {
-		require_dist.it("should create an ObjectionFactory instance", () => {
+	(0, vitest.describe)("constructor", () => {
+		(0, vitest.it)("should create an ObjectionFactory instance", () => {
 			const builders = {};
 			const seeds = {};
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-			require_vi_bdSIJ99Y.globalExpect(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
+			(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
 		});
 	});
-	require_dist.describe("insert method", () => {
-		require_dist.it("should call builder and insert the record", async () => {
+	(0, vitest.describe)("insert method", () => {
+		(0, vitest.it)("should call builder and insert the record", async () => {
 			const userBuilder = async (attrs$1, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs$1.name || "Default Name",
@@ -83,12 +82,12 @@ require_dist.describe.skip("ObjectionFactory", () => {
 				email: "john@example.com"
 			};
 			const result = await factory.insert("user", attrs);
-			require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(result.name).toBe("John Doe");
-			require_vi_bdSIJ99Y.globalExpect(result.email).toBe("john@example.com");
-			require_vi_bdSIJ99Y.globalExpect(result.id).toBeDefined();
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("John Doe");
+			(0, vitest.expect)(result.email).toBe("john@example.com");
+			(0, vitest.expect)(result.id).toBeDefined();
 		});
-		require_dist.it("should use empty object as default attributes", async () => {
+		(0, vitest.it)("should use empty object as default attributes", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: "Default Name",
@@ -101,15 +100,15 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
 			const result = await factory.insert("user");
-			require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(result.name).toBe("Default Name");
-			require_vi_bdSIJ99Y.globalExpect(result.id).toBeDefined();
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Default Name");
+			(0, vitest.expect)(result.id).toBeDefined();
 		});
-		require_dist.it("should throw error for non-existent factory", async () => {
+		(0, vitest.it)("should throw error for non-existent factory", async () => {
 			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-			await require_vi_bdSIJ99Y.globalExpect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
+			await (0, vitest.expect)(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
 		});
-		require_dist.it("should handle builder that returns a promise", async () => {
+		(0, vitest.it)("should handle builder that returns a promise", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				await new Promise((resolve) => setTimeout(resolve, 10));
 				return User.fromJson({
@@ -123,12 +122,12 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
 			const result = await factory.insert("user", { name: "Jane" });
-			require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(result.name).toBe("Jane");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Jane");
 		});
 	});
-	require_dist.describe("insertMany method", () => {
-		require_dist.it("should insert multiple records with same attributes", async () => {
+	(0, vitest.describe)("insertMany method", () => {
+		(0, vitest.it)("should insert multiple records with same attributes", async () => {
 			const userBuilder = async (attrs$1, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs$1.name || "Default Name",
@@ -142,14 +141,14 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
 			const attrs = { name: "User" };
 			const results = await factory.insertMany(3, "user", attrs);
-			require_vi_bdSIJ99Y.globalExpect(results).toHaveLength(3);
+			(0, vitest.expect)(results).toHaveLength(3);
 			results.forEach((result) => {
-				require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-				require_vi_bdSIJ99Y.globalExpect(result.name).toBe("User");
-				require_vi_bdSIJ99Y.globalExpect(result.id).toBeDefined();
+				(0, vitest.expect)(result).toBeInstanceOf(User);
+				(0, vitest.expect)(result.name).toBe("User");
+				(0, vitest.expect)(result.id).toBeDefined();
 			});
 		});
-		require_dist.it("should insert multiple records with dynamic attributes", async () => {
+		(0, vitest.it)("should insert multiple records with dynamic attributes", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs.name || "Default Name",
@@ -163,15 +162,15 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
 			const attrsFn = (idx) => ({ name: `User ${idx}` });
 			const results = await factory.insertMany(2, "user", attrsFn);
-			require_vi_bdSIJ99Y.globalExpect(results).toHaveLength(2);
-			require_vi_bdSIJ99Y.globalExpect(results[0].name).toBe("User 0");
-			require_vi_bdSIJ99Y.globalExpect(results[1].name).toBe("User 1");
+			(0, vitest.expect)(results).toHaveLength(2);
+			(0, vitest.expect)(results[0].name).toBe("User 0");
+			(0, vitest.expect)(results[1].name).toBe("User 1");
 			results.forEach((result) => {
-				require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-				require_vi_bdSIJ99Y.globalExpect(result.id).toBeDefined();
+				(0, vitest.expect)(result).toBeInstanceOf(User);
+				(0, vitest.expect)(result.id).toBeDefined();
 			});
 		});
-		require_dist.it("should use empty object as default attributes for insertMany", async () => {
+		(0, vitest.it)("should use empty object as default attributes for insertMany", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: "Default Name",
@@ -184,20 +183,20 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
 			const results = await factory.insertMany(2, "user");
-			require_vi_bdSIJ99Y.globalExpect(results).toHaveLength(2);
+			(0, vitest.expect)(results).toHaveLength(2);
 			results.forEach((result) => {
-				require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-				require_vi_bdSIJ99Y.globalExpect(result.name).toBe("Default Name");
-				require_vi_bdSIJ99Y.globalExpect(result.id).toBeDefined();
+				(0, vitest.expect)(result).toBeInstanceOf(User);
+				(0, vitest.expect)(result.name).toBe("Default Name");
+				(0, vitest.expect)(result.id).toBeDefined();
 			});
 		});
-		require_dist.it("should throw error for non-existent builder in insertMany", async () => {
+		(0, vitest.it)("should throw error for non-existent builder in insertMany", async () => {
 			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-			await require_vi_bdSIJ99Y.globalExpect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
+			await (0, vitest.expect)(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
 		});
 	});
-	require_dist.describe("seed method", () => {
-		require_dist.it("should execute seed function", async () => {
+	(0, vitest.describe)("seed method", () => {
+		(0, vitest.it)("should execute seed function", async () => {
 			const userBuilder = async (attrs$1, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs$1.name || "Default Name",
@@ -219,12 +218,12 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
 			const attrs = { name: "Super Admin" };
 			const result = await factory.seed("createAdmin", attrs);
-			require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(result.name).toBe("Super Admin");
-			require_vi_bdSIJ99Y.globalExpect(result.role).toBe("admin");
-			require_vi_bdSIJ99Y.globalExpect(result.id).toBeDefined();
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Super Admin");
+			(0, vitest.expect)(result.role).toBe("admin");
+			(0, vitest.expect)(result.id).toBeDefined();
 		});
-		require_dist.it("should use empty object as default attributes for seed", async () => {
+		(0, vitest.it)("should use empty object as default attributes for seed", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: "Default Admin",
@@ -244,15 +243,15 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			const seeds = { createAdmin: createAdminSeed };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
 			const result = await factory.seed("createAdmin");
-			require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(result.name).toBe("Default Admin");
-			require_vi_bdSIJ99Y.globalExpect(result.role).toBe("admin");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Default Admin");
+			(0, vitest.expect)(result.role).toBe("admin");
 		});
-		require_dist.it("should throw error for non-existent seed", () => {
+		(0, vitest.it)("should throw error for non-existent seed", () => {
 			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-			require_vi_bdSIJ99Y.globalExpect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
+			(0, vitest.expect)(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
 		});
-		require_dist.it("should pass factory and db to seed function", async () => {
+		(0, vitest.it)("should pass factory and db to seed function", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs.name || "Test User",
@@ -264,19 +263,19 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			};
 			const builders = { user: userBuilder };
 			const complexSeed = async (attrs, passedFactory, passedDb) => {
-				require_vi_bdSIJ99Y.globalExpect(passedFactory).toBe(factory);
-				require_vi_bdSIJ99Y.globalExpect(passedDb).toBe(trx);
+				(0, vitest.expect)(passedFactory).toBe(factory);
+				(0, vitest.expect)(passedDb).toBe(trx);
 				return await passedFactory.insert("user", { name: `Complex ${attrs.data}` });
 			};
 			const seeds = { complexSeed };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
 			const result = await factory.seed("complexSeed", { data: "test" });
-			require_vi_bdSIJ99Y.globalExpect(result).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(result.name).toBe("Complex test");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Complex test");
 		});
 	});
-	require_dist.describe("createSeed static method", () => {
-		require_dist.it("should return the seed function unchanged", () => {
+	(0, vitest.describe)("createSeed static method", () => {
+		(0, vitest.it)("should return the seed function unchanged", () => {
 			const seedFn = async (attrs, factory$1, db$1) => {
 				return {
 					id: 1,
@@ -284,37 +283,37 @@ require_dist.describe.skip("ObjectionFactory", () => {
 				};
 			};
 			const result = require_ObjectionFactory.ObjectionFactory.createSeed(seedFn);
-			require_vi_bdSIJ99Y.globalExpect(result).toBe(seedFn);
+			(0, vitest.expect)(result).toBe(seedFn);
 		});
 	});
-	require_dist.describe("error handling", () => {
-		require_dist.it("should handle builder errors gracefully", async () => {
+	(0, vitest.describe)("error handling", () => {
+		(0, vitest.it)("should handle builder errors gracefully", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				throw new Error("Builder failed");
 			};
 			const builders = { user: userBuilder };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			await require_vi_bdSIJ99Y.globalExpect(factory.insert("user")).rejects.toThrow("Builder failed");
+			await (0, vitest.expect)(factory.insert("user")).rejects.toThrow("Builder failed");
 		});
-		require_dist.it("should handle invalid model data gracefully", async () => {
+		(0, vitest.it)("should handle invalid model data gracefully", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({ invalidField: "invalid" });
 			};
 			const builders = { user: userBuilder };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			await require_vi_bdSIJ99Y.globalExpect(factory.insert("user")).rejects.toThrow();
+			await (0, vitest.expect)(factory.insert("user")).rejects.toThrow();
 		});
-		require_dist.it("should handle seed function errors gracefully", async () => {
+		(0, vitest.it)("should handle seed function errors gracefully", async () => {
 			const failingSeed = async (attrs, factory$1, db$1) => {
 				throw new Error("Seed failed");
 			};
 			const seeds = { failingSeed };
 			factory = new require_ObjectionFactory.ObjectionFactory({}, seeds, trx);
-			await require_vi_bdSIJ99Y.globalExpect(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
+			await (0, vitest.expect)(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
 		});
 	});
-	require_dist.describe("type safety and integration", () => {
-		require_dist.it("should work with typed builders and seeds", async () => {
+	(0, vitest.describe)("type safety and integration", () => {
+		(0, vitest.it)("should work with typed builders and seeds", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs.name || "Default User",
@@ -334,12 +333,12 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			const seeds = { admin: adminSeed };
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-			require_vi_bdSIJ99Y.globalExpect(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
+			(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
 			const admin = await factory.seed("admin", { isSuper: true });
-			require_vi_bdSIJ99Y.globalExpect(admin).toBeInstanceOf(User);
-			require_vi_bdSIJ99Y.globalExpect(admin.name).toBe("Admin");
+			(0, vitest.expect)(admin).toBeInstanceOf(User);
+			(0, vitest.expect)(admin.name).toBe("Admin");
 		});
-		require_dist.it("should handle complex builder scenarios", async () => {
+		(0, vitest.it)("should handle complex builder scenarios", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
 				return User.fromJson({
 					name: attrs.name || "Default User",
@@ -376,10 +375,10 @@ require_dist.describe.skip("ObjectionFactory", () => {
 			};
 			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
 			const post = await factory.insert("post", { title: "Test Post" });
-			require_vi_bdSIJ99Y.globalExpect(post).toBeInstanceOf(Post);
-			require_vi_bdSIJ99Y.globalExpect(post.title).toBe("Test Post");
-			require_vi_bdSIJ99Y.globalExpect(post.userId).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(typeof post.userId).toBe("number");
+			(0, vitest.expect)(post).toBeInstanceOf(Post);
+			(0, vitest.expect)(post.title).toBe("Test Post");
+			(0, vitest.expect)(post.userId).toBeDefined();
+			(0, vitest.expect)(typeof post.userId).toBe("number");
 		});
 	});
 });

package/dist/__tests__/ObjectionFactory.spec.mjs

@@ -1,8 +1,7 @@
-import { afterAll, beforeAll, describe, it } from "../dist-BM2KvLG1.mjs";
-import "../Factory-D52Lsc6Z.mjs";
-import { ObjectionFactory } from "../ObjectionFactory-CFrtXe7i.mjs";
-import { globalExpect } from "../vi.bdSIJ99Y-BgRxGeO2.mjs";
-import { setupKnexTest } from "../helpers-CukcFAU9.mjs";
+import "../Factory-DlzMkMzb.mjs";
+import { ObjectionFactory } from "../ObjectionFactory-ChuX8sZN.mjs";
+import { setupKnexTest } from "../helpers-BfuX-cjN.mjs";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { Model } from "objection";
 
 //#region src/__tests__/ObjectionFactory.spec.ts
@@ -61,7 +60,7 @@ describe.skip("ObjectionFactory", () => {
 			const builders = {};
 			const seeds = {};
 			factory = new ObjectionFactory(builders, seeds, trx);
-			globalExpect(factory).toBeInstanceOf(ObjectionFactory);
+			expect(factory).toBeInstanceOf(ObjectionFactory);
 		});
 	});
 	describe("insert method", () => {
@@ -82,10 +81,10 @@ describe.skip("ObjectionFactory", () => {
 				email: "john@example.com"
 			};
 			const result = await factory.insert("user", attrs);
-			globalExpect(result).toBeInstanceOf(User);
-			globalExpect(result.name).toBe("John Doe");
-			globalExpect(result.email).toBe("john@example.com");
-			globalExpect(result.id).toBeDefined();
+			expect(result).toBeInstanceOf(User);
+			expect(result.name).toBe("John Doe");
+			expect(result.email).toBe("john@example.com");
+			expect(result.id).toBeDefined();
 		});
 		it("should use empty object as default attributes", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
@@ -100,13 +99,13 @@ describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			factory = new ObjectionFactory(builders, {}, trx);
 			const result = await factory.insert("user");
-			globalExpect(result).toBeInstanceOf(User);
-			globalExpect(result.name).toBe("Default Name");
-			globalExpect(result.id).toBeDefined();
+			expect(result).toBeInstanceOf(User);
+			expect(result.name).toBe("Default Name");
+			expect(result.id).toBeDefined();
 		});
 		it("should throw error for non-existent factory", async () => {
 			factory = new ObjectionFactory({}, {}, trx);
-			await globalExpect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
+			await expect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
 		});
 		it("should handle builder that returns a promise", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
@@ -122,8 +121,8 @@ describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			factory = new ObjectionFactory(builders, {}, trx);
 			const result = await factory.insert("user", { name: "Jane" });
-			globalExpect(result).toBeInstanceOf(User);
-			globalExpect(result.name).toBe("Jane");
+			expect(result).toBeInstanceOf(User);
+			expect(result.name).toBe("Jane");
 		});
 	});
 	describe("insertMany method", () => {
@@ -141,11 +140,11 @@ describe.skip("ObjectionFactory", () => {
 			factory = new ObjectionFactory(builders, {}, trx);
 			const attrs = { name: "User" };
 			const results = await factory.insertMany(3, "user", attrs);
-			globalExpect(results).toHaveLength(3);
+			expect(results).toHaveLength(3);
 			results.forEach((result) => {
-				globalExpect(result).toBeInstanceOf(User);
-				globalExpect(result.name).toBe("User");
-				globalExpect(result.id).toBeDefined();
+				expect(result).toBeInstanceOf(User);
+				expect(result.name).toBe("User");
+				expect(result.id).toBeDefined();
 			});
 		});
 		it("should insert multiple records with dynamic attributes", async () => {
@@ -162,12 +161,12 @@ describe.skip("ObjectionFactory", () => {
 			factory = new ObjectionFactory(builders, {}, trx);
 			const attrsFn = (idx) => ({ name: `User ${idx}` });
 			const results = await factory.insertMany(2, "user", attrsFn);
-			globalExpect(results).toHaveLength(2);
-			globalExpect(results[0].name).toBe("User 0");
-			globalExpect(results[1].name).toBe("User 1");
+			expect(results).toHaveLength(2);
+			expect(results[0].name).toBe("User 0");
+			expect(results[1].name).toBe("User 1");
 			results.forEach((result) => {
-				globalExpect(result).toBeInstanceOf(User);
-				globalExpect(result.id).toBeDefined();
+				expect(result).toBeInstanceOf(User);
+				expect(result.id).toBeDefined();
 			});
 		});
 		it("should use empty object as default attributes for insertMany", async () => {
@@ -183,16 +182,16 @@ describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			factory = new ObjectionFactory(builders, {}, trx);
 			const results = await factory.insertMany(2, "user");
-			globalExpect(results).toHaveLength(2);
+			expect(results).toHaveLength(2);
 			results.forEach((result) => {
-				globalExpect(result).toBeInstanceOf(User);
-				globalExpect(result.name).toBe("Default Name");
-				globalExpect(result.id).toBeDefined();
+				expect(result).toBeInstanceOf(User);
+				expect(result.name).toBe("Default Name");
+				expect(result.id).toBeDefined();
 			});
 		});
 		it("should throw error for non-existent builder in insertMany", async () => {
 			factory = new ObjectionFactory({}, {}, trx);
-			await globalExpect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
+			await expect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
 		});
 	});
 	describe("seed method", () => {
@@ -218,10 +217,10 @@ describe.skip("ObjectionFactory", () => {
 			factory = new ObjectionFactory(builders, seeds, trx);
 			const attrs = { name: "Super Admin" };
 			const result = await factory.seed("createAdmin", attrs);
-			globalExpect(result).toBeInstanceOf(User);
-			globalExpect(result.name).toBe("Super Admin");
-			globalExpect(result.role).toBe("admin");
-			globalExpect(result.id).toBeDefined();
+			expect(result).toBeInstanceOf(User);
+			expect(result.name).toBe("Super Admin");
+			expect(result.role).toBe("admin");
+			expect(result.id).toBeDefined();
 		});
 		it("should use empty object as default attributes for seed", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
@@ -243,13 +242,13 @@ describe.skip("ObjectionFactory", () => {
 			const seeds = { createAdmin: createAdminSeed };
 			factory = new ObjectionFactory(builders, seeds, trx);
 			const result = await factory.seed("createAdmin");
-			globalExpect(result).toBeInstanceOf(User);
-			globalExpect(result.name).toBe("Default Admin");
-			globalExpect(result.role).toBe("admin");
+			expect(result).toBeInstanceOf(User);
+			expect(result.name).toBe("Default Admin");
+			expect(result.role).toBe("admin");
 		});
 		it("should throw error for non-existent seed", () => {
 			factory = new ObjectionFactory({}, {}, trx);
-			globalExpect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
+			expect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
 		});
 		it("should pass factory and db to seed function", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
@@ -263,15 +262,15 @@ describe.skip("ObjectionFactory", () => {
 			};
 			const builders = { user: userBuilder };
 			const complexSeed = async (attrs, passedFactory, passedDb) => {
-				globalExpect(passedFactory).toBe(factory);
-				globalExpect(passedDb).toBe(trx);
+				expect(passedFactory).toBe(factory);
+				expect(passedDb).toBe(trx);
 				return await passedFactory.insert("user", { name: `Complex ${attrs.data}` });
 			};
 			const seeds = { complexSeed };
 			factory = new ObjectionFactory(builders, seeds, trx);
 			const result = await factory.seed("complexSeed", { data: "test" });
-			globalExpect(result).toBeInstanceOf(User);
-			globalExpect(result.name).toBe("Complex test");
+			expect(result).toBeInstanceOf(User);
+			expect(result.name).toBe("Complex test");
 		});
 	});
 	describe("createSeed static method", () => {
@@ -283,7 +282,7 @@ describe.skip("ObjectionFactory", () => {
 				};
 			};
 			const result = ObjectionFactory.createSeed(seedFn);
-			globalExpect(result).toBe(seedFn);
+			expect(result).toBe(seedFn);
 		});
 	});
 	describe("error handling", () => {
@@ -293,7 +292,7 @@ describe.skip("ObjectionFactory", () => {
 			};
 			const builders = { user: userBuilder };
 			factory = new ObjectionFactory(builders, {}, trx);
-			await globalExpect(factory.insert("user")).rejects.toThrow("Builder failed");
+			await expect(factory.insert("user")).rejects.toThrow("Builder failed");
 		});
 		it("should handle invalid model data gracefully", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
@@ -301,7 +300,7 @@ describe.skip("ObjectionFactory", () => {
 			};
 			const builders = { user: userBuilder };
 			factory = new ObjectionFactory(builders, {}, trx);
-			await globalExpect(factory.insert("user")).rejects.toThrow();
+			await expect(factory.insert("user")).rejects.toThrow();
 		});
 		it("should handle seed function errors gracefully", async () => {
 			const failingSeed = async (attrs, factory$1, db$1) => {
@@ -309,7 +308,7 @@ describe.skip("ObjectionFactory", () => {
 			};
 			const seeds = { failingSeed };
 			factory = new ObjectionFactory({}, seeds, trx);
-			await globalExpect(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
+			await expect(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
 		});
 	});
 	describe("type safety and integration", () => {
@@ -333,10 +332,10 @@ describe.skip("ObjectionFactory", () => {
 			const builders = { user: userBuilder };
 			const seeds = { admin: adminSeed };
 			factory = new ObjectionFactory(builders, seeds, trx);
-			globalExpect(factory).toBeInstanceOf(ObjectionFactory);
+			expect(factory).toBeInstanceOf(ObjectionFactory);
 			const admin = await factory.seed("admin", { isSuper: true });
-			globalExpect(admin).toBeInstanceOf(User);
-			globalExpect(admin.name).toBe("Admin");
+			expect(admin).toBeInstanceOf(User);
+			expect(admin.name).toBe("Admin");
 		});
 		it("should handle complex builder scenarios", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {
@@ -375,10 +374,10 @@ describe.skip("ObjectionFactory", () => {
 			};
 			factory = new ObjectionFactory(builders, {}, trx);
 			const post = await factory.insert("post", { title: "Test Post" });
-			globalExpect(post).toBeInstanceOf(Post);
-			globalExpect(post.title).toBe("Test Post");
-			globalExpect(post.userId).toBeDefined();
-			globalExpect(typeof post.userId).toBe("number");
+			expect(post).toBeInstanceOf(Post);
+			expect(post.title).toBe("Test Post");
+			expect(post.userId).toBeDefined();
+			expect(typeof post.userId).toBe("number");
 		});
 	});
 });