@geekmidas/testkit 0.0.3 → 0.0.5

package/dist/__tests__/ObjectionFactory.spec.cjs

@@ -0,0 +1,386 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
+require('../Factory-DREHoms3.cjs');
+const require_ObjectionFactory = require('../ObjectionFactory-BlkzSEqo.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
+var User = class extends objection.Model {
+	static get tableName() {
+		return "users";
+	}
+	id;
+	name;
+	email;
+	role;
+	createdAt;
+	updatedAt;
+};
+var Post = class extends objection.Model {
+	static get tableName() {
+		return "posts";
+	}
+	id;
+	title;
+	content;
+	userId;
+	published;
+	createdAt;
+	updatedAt;
+};
+var Comment = class extends objection.Model {
+	static get tableName() {
+		return "comments";
+	}
+	id;
+	content;
+	postId;
+	userId;
+	createdAt;
+};
+vitest.describe.skip("ObjectionFactory", () => {
+	let factory;
+	let db;
+	let trx;
+	let cleanup;
+	(0, vitest.beforeAll)(async () => {
+		const setup = await require_helpers.setupKnexTest();
+		db = setup.db;
+		trx = setup.trx;
+		cleanup = setup.cleanup;
+		User.knex(trx);
+		Post.knex(trx);
+		Comment.knex(trx);
+	});
+	(0, vitest.afterAll)(async () => {
+		await cleanup();
+	});
+	(0, vitest.describe)("constructor", () => {
+		(0, vitest.it)("should create an ObjectionFactory instance", () => {
+			const builders = {};
+			const seeds = {};
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
+			(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
+		});
+	});
+	(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",
+					email: attrs$1.email || `user${Date.now()}@example.com`,
+					role: attrs$1.role || "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const attrs = {
+				name: "John Doe",
+				email: "john@example.com"
+			};
+			const result = await factory.insert("user", attrs);
+			(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();
+		});
+		(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",
+					email: `user${Date.now()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Default Name");
+			(0, vitest.expect)(result.id).toBeDefined();
+		});
+		(0, vitest.it)("should throw error for non-existent factory", async () => {
+			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
+			await (0, vitest.expect)(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
+		});
+		(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({
+					name: attrs.name || "Default Name",
+					email: `async${Date.now()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user", { name: "Jane" });
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Jane");
+		});
+	});
+	(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",
+					email: `user${Date.now()}-${Math.random()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const attrs = { name: "User" };
+			const results = await factory.insertMany(3, "user", attrs);
+			(0, vitest.expect)(results).toHaveLength(3);
+			results.forEach((result) => {
+				(0, vitest.expect)(result).toBeInstanceOf(User);
+				(0, vitest.expect)(result.name).toBe("User");
+				(0, vitest.expect)(result.id).toBeDefined();
+			});
+		});
+		(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",
+					email: `user${Date.now()}-${Math.random()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const attrsFn = (idx) => ({ name: `User ${idx}` });
+			const results = await factory.insertMany(2, "user", attrsFn);
+			(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) => {
+				(0, vitest.expect)(result).toBeInstanceOf(User);
+				(0, vitest.expect)(result.id).toBeDefined();
+			});
+		});
+		(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",
+					email: `user${Date.now()}-${Math.random()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const results = await factory.insertMany(2, "user");
+			(0, vitest.expect)(results).toHaveLength(2);
+			results.forEach((result) => {
+				(0, vitest.expect)(result).toBeInstanceOf(User);
+				(0, vitest.expect)(result.name).toBe("Default Name");
+				(0, vitest.expect)(result.id).toBeDefined();
+			});
+		});
+		(0, vitest.it)("should throw error for non-existent builder in insertMany", async () => {
+			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
+			await (0, vitest.expect)(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
+		});
+	});
+	(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",
+					email: attrs$1.email || `admin${Date.now()}@example.com`,
+					role: "admin",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			const createAdminSeed = async (attrs$1, factory$1, db$1) => {
+				return await factory$1.insert("user", {
+					name: attrs$1.name || "Admin User",
+					email: "admin@example.com",
+					role: "admin"
+				});
+			};
+			const seeds = { createAdmin: createAdminSeed };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
+			const attrs = { name: "Super Admin" };
+			const result = await factory.seed("createAdmin", attrs);
+			(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();
+		});
+		(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",
+					email: `admin${Date.now()}@example.com`,
+					role: "admin",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			const createAdminSeed = async (attrs, factory$1, db$1) => {
+				return await factory$1.insert("user", {
+					name: "Default Admin",
+					role: "admin"
+				});
+			};
+			const seeds = { createAdmin: createAdminSeed };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
+			const result = await factory.seed("createAdmin");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Default Admin");
+			(0, vitest.expect)(result.role).toBe("admin");
+		});
+		(0, vitest.it)("should throw error for non-existent seed", () => {
+			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
+			(0, vitest.expect)(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
+		});
+		(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",
+					email: `test${Date.now()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = { user: userBuilder };
+			const complexSeed = async (attrs, passedFactory, passedDb) => {
+				(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" });
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Complex test");
+		});
+	});
+	(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,
+					name: "test"
+				};
+			};
+			const result = require_ObjectionFactory.ObjectionFactory.createSeed(seedFn);
+			(0, vitest.expect)(result).toBe(seedFn);
+		});
+	});
+	(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 (0, vitest.expect)(factory.insert("user")).rejects.toThrow("Builder failed");
+		});
+		(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 (0, vitest.expect)(factory.insert("user")).rejects.toThrow();
+		});
+		(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 (0, vitest.expect)(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
+		});
+	});
+	(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",
+					email: attrs.email || `user${Date.now()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const adminSeed = async (attrs, factory$1, db$1) => {
+				return factory$1.insert("user", {
+					name: "Admin",
+					email: "admin@example.com",
+					role: "admin"
+				});
+			};
+			const builders = { user: userBuilder };
+			const seeds = { admin: adminSeed };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
+			(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
+			const admin = await factory.seed("admin", { isSuper: true });
+			(0, vitest.expect)(admin).toBeInstanceOf(User);
+			(0, vitest.expect)(admin.name).toBe("Admin");
+		});
+		(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",
+					email: attrs.email || `user${Date.now()}@example.com`,
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const postBuilder = async (attrs, factory$1, db$1) => {
+				if (!attrs.userId) {
+					const user = await factory$1.insert("user");
+					return Post.fromJson({
+						title: attrs.title || "Default Post",
+						content: attrs.content || "Default content",
+						userId: user.id,
+						published: attrs.published || false,
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					});
+				}
+				return Post.fromJson({
+					title: attrs.title || "Default Post",
+					content: attrs.content || "Default content",
+					userId: attrs.userId,
+					published: attrs.published || false,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			};
+			const builders = {
+				user: userBuilder,
+				post: postBuilder
+			};
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const post = await factory.insert("post", { title: "Test Post" });
+			(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");
+		});
+	});
+});
+
+//#endregion