@geekmidas/testkit 0.0.2 → 0.0.4

package/dist/__tests__/ObjectionFactory.spec.mjs

@@ -0,0 +1,386 @@
+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 { Model } from "objection";
+
+//#region src/__tests__/ObjectionFactory.spec.ts
+var User = class extends Model {
+	static get tableName() {
+		return "users";
+	}
+	id;
+	name;
+	email;
+	role;
+	createdAt;
+	updatedAt;
+};
+var Post = class extends Model {
+	static get tableName() {
+		return "posts";
+	}
+	id;
+	title;
+	content;
+	userId;
+	published;
+	createdAt;
+	updatedAt;
+};
+var Comment = class extends Model {
+	static get tableName() {
+		return "comments";
+	}
+	id;
+	content;
+	postId;
+	userId;
+	createdAt;
+};
+describe.skip("ObjectionFactory", () => {
+	let factory;
+	let db;
+	let trx;
+	let cleanup;
+	beforeAll(async () => {
+		const setup = await setupKnexTest();
+		db = setup.db;
+		trx = setup.trx;
+		cleanup = setup.cleanup;
+		User.knex(trx);
+		Post.knex(trx);
+		Comment.knex(trx);
+	});
+	afterAll(async () => {
+		await cleanup();
+	});
+	describe("constructor", () => {
+		it("should create an ObjectionFactory instance", () => {
+			const builders = {};
+			const seeds = {};
+			factory = new ObjectionFactory(builders, seeds, trx);
+			globalExpect(factory).toBeInstanceOf(ObjectionFactory);
+		});
+	});
+	describe("insert method", () => {
+		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 ObjectionFactory(builders, {}, trx);
+			const attrs = {
+				name: "John Doe",
+				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();
+		});
+		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 ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user");
+			globalExpect(result).toBeInstanceOf(User);
+			globalExpect(result.name).toBe("Default Name");
+			globalExpect(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");
+		});
+		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 ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user", { name: "Jane" });
+			globalExpect(result).toBeInstanceOf(User);
+			globalExpect(result.name).toBe("Jane");
+		});
+	});
+	describe("insertMany method", () => {
+		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 ObjectionFactory(builders, {}, trx);
+			const attrs = { name: "User" };
+			const results = await factory.insertMany(3, "user", attrs);
+			globalExpect(results).toHaveLength(3);
+			results.forEach((result) => {
+				globalExpect(result).toBeInstanceOf(User);
+				globalExpect(result.name).toBe("User");
+				globalExpect(result.id).toBeDefined();
+			});
+		});
+		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 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");
+			results.forEach((result) => {
+				globalExpect(result).toBeInstanceOf(User);
+				globalExpect(result.id).toBeDefined();
+			});
+		});
+		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 ObjectionFactory(builders, {}, trx);
+			const results = await factory.insertMany(2, "user");
+			globalExpect(results).toHaveLength(2);
+			results.forEach((result) => {
+				globalExpect(result).toBeInstanceOf(User);
+				globalExpect(result.name).toBe("Default Name");
+				globalExpect(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");
+		});
+	});
+	describe("seed method", () => {
+		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 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();
+		});
+		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 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");
+		});
+		it("should throw error for non-existent seed", () => {
+			factory = new ObjectionFactory({}, {}, trx);
+			globalExpect(() => 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) => {
+				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) => {
+				globalExpect(passedFactory).toBe(factory);
+				globalExpect(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");
+		});
+	});
+	describe("createSeed static method", () => {
+		it("should return the seed function unchanged", () => {
+			const seedFn = async (attrs, factory$1, db$1) => {
+				return {
+					id: 1,
+					name: "test"
+				};
+			};
+			const result = ObjectionFactory.createSeed(seedFn);
+			globalExpect(result).toBe(seedFn);
+		});
+	});
+	describe("error handling", () => {
+		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 ObjectionFactory(builders, {}, trx);
+			await globalExpect(factory.insert("user")).rejects.toThrow("Builder failed");
+		});
+		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 ObjectionFactory(builders, {}, trx);
+			await globalExpect(factory.insert("user")).rejects.toThrow();
+		});
+		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 ObjectionFactory({}, seeds, trx);
+			await globalExpect(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
+		});
+	});
+	describe("type safety and integration", () => {
+		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 ObjectionFactory(builders, seeds, trx);
+			globalExpect(factory).toBeInstanceOf(ObjectionFactory);
+			const admin = await factory.seed("admin", { isSuper: true });
+			globalExpect(admin).toBeInstanceOf(User);
+			globalExpect(admin.name).toBe("Admin");
+		});
+		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 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");
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/PostgresMigrator.spec.cjs

@@ -0,0 +1,257 @@
+const require_chunk = require('../chunk-DWy1uDak.cjs');
+const require_PostgresMigrator = require('../PostgresMigrator-eqyAFSf-.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 pg = require_chunk.__toESM(require("pg"));
+
+//#region src/__tests__/PostgresMigrator.spec.ts
+var TestPostgresMigrator = class extends require_PostgresMigrator.PostgresMigrator {
+	migrateCalled = false;
+	migrateError;
+	customMigrations = [];
+	async migrate() {
+		this.migrateCalled = true;
+		if (this.migrateError) throw this.migrateError;
+		for (const migration of this.customMigrations) await migration();
+	}
+	addMigration(migration) {
+		this.customMigrations.push(migration);
+	}
+};
+require_dist.describe("PostgresMigrator", () => {
+	let testDbName;
+	let cleanupDb;
+	let consoleSpy;
+	require_dist.beforeAll(async () => {
+		testDbName = `test_postgres_migrator_${Date.now()}`;
+		cleanupDb = await require_helpers.createTestDatabase(testDbName);
+	});
+	require_dist.beforeEach(() => {
+		consoleSpy = require_vi_bdSIJ99Y.vi.spyOn(console, "log").mockImplementation(() => {});
+	});
+	require_dist.afterEach(() => {
+		consoleSpy.mockRestore();
+	});
+	require_dist.afterAll(async () => {
+		await cleanupDb();
+	});
+	require_dist.describe("constructor", () => {
+		require_dist.it("should create a PostgresMigrator instance", () => {
+			const migrator = new TestPostgresMigrator(`postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`);
+			require_vi_bdSIJ99Y.globalExpect(migrator).toBeInstanceOf(require_PostgresMigrator.PostgresMigrator);
+		});
+	});
+	require_dist.describe("start method", () => {
+		require_dist.it("should create database, migrate, and return cleanup function", async () => {
+			const newDbName = `test_start_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			let migrationRan = false;
+			migrator.addMigration(async () => {
+				migrationRan = true;
+			});
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(migrationRan).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${newDbName}`);
+			require_vi_bdSIJ99Y.globalExpect(typeof cleanup).toBe("function");
+			await cleanup();
+		});
+		require_dist.it("should handle existing database", async () => {
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			let migrationRan = false;
+			migrator.addMigration(async () => {
+				migrationRan = true;
+			});
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(migrationRan).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof cleanup).toBe("function");
+		});
+		require_dist.it("should handle URI with query parameters", async () => {
+			const queryDbName = `test_query_params_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${queryDbName}?ssl=false&timeout=30`;
+			const migrator = new TestPostgresMigrator(uri);
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof cleanup).toBe("function");
+			await cleanup();
+		});
+		require_dist.it("should clean up connections even if migration fails", async () => {
+			const failDbName = `test_fail_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${failDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			migrator.migrateError = new Error("Migration failed");
+			await require_vi_bdSIJ99Y.globalExpect(migrator.start()).rejects.toThrow("Migration failed");
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			const cleanupClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			try {
+				await cleanupClient.connect();
+				await cleanupClient.query(`DROP DATABASE IF EXISTS "${failDbName}"`);
+			} finally {
+				await cleanupClient.end();
+			}
+		});
+		require_dist.it("should return cleanup function that drops database", async () => {
+			const cleanupDbName = `test_cleanup_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${cleanupDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof cleanup).toBe("function");
+			const checkClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await checkClient.connect();
+			const beforeResult = await checkClient.query(`SELECT * FROM pg_catalog.pg_database WHERE datname = $1`, [cleanupDbName]);
+			require_vi_bdSIJ99Y.globalExpect(beforeResult.rowCount).toBe(1);
+			await checkClient.end();
+			await cleanup();
+			const checkClient2 = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await checkClient2.connect();
+			const afterResult = await checkClient2.query(`SELECT * FROM pg_catalog.pg_database WHERE datname = $1`, [cleanupDbName]);
+			require_vi_bdSIJ99Y.globalExpect(afterResult.rowCount).toBe(0);
+			await checkClient2.end();
+		});
+	});
+	require_dist.describe("database creation", () => {
+		require_dist.it("should handle connection errors gracefully", async () => {
+			const badDbName = `test_bad_connection_${Date.now()}`;
+			const uri = `postgresql://invalid_user:invalid_pass@localhost:5432/${badDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			await require_vi_bdSIJ99Y.globalExpect(migrator.start()).rejects.toThrow();
+		});
+		require_dist.it("should handle invalid database names", async () => {
+			const invalidDbName = "test-invalid-db-name!";
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${invalidDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			await require_vi_bdSIJ99Y.globalExpect(migrator.start).rejects.toThrow();
+		});
+	});
+	require_dist.describe("URI parsing", () => {
+		require_dist.it("should parse different URI formats correctly", async () => {
+			const testDbName$1 = `test_uri_parsing_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName$1}`;
+			const migrator = new TestPostgresMigrator(uri);
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof cleanup).toBe("function");
+			await cleanup();
+		});
+	});
+	require_dist.describe("error handling", () => {
+		require_dist.it("should propagate migration errors", async () => {
+			const errorDbName = `test_migration_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${errorDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			const migrationError = new Error("Custom migration error");
+			migrator.migrateError = migrationError;
+			await require_vi_bdSIJ99Y.globalExpect(migrator.start()).rejects.toThrow("Custom migration error");
+			const cleanupClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			try {
+				await cleanupClient.connect();
+				await cleanupClient.query(`DROP DATABASE IF EXISTS "${errorDbName}"`);
+			} finally {
+				await cleanupClient.end();
+			}
+		});
+		require_dist.it("should handle cleanup errors gracefully", async () => {
+			const cleanupErrorDbName = `test_cleanup_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${cleanupErrorDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			const cleanup = await migrator.start();
+			const adminClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await adminClient.connect();
+			await adminClient.query(`DROP DATABASE IF EXISTS "${cleanupErrorDbName}"`);
+			await adminClient.end();
+			await require_vi_bdSIJ99Y.globalExpect(cleanup()).rejects.toThrow();
+		});
+	});
+	require_dist.describe("abstract method", () => {
+		require_dist.it("should require concrete implementation of migrate method", () => {
+			const migrator = new TestPostgresMigrator(`postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`);
+			require_vi_bdSIJ99Y.globalExpect(typeof migrator.migrate).toBe("function");
+		});
+	});
+	require_dist.describe("integration scenarios", () => {
+		require_dist.it("should handle complete workflow", async () => {
+			const integrationDbName = `test_integration_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${integrationDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			migrator.addMigration(async () => {
+				const client = new pg.Client({
+					host: "localhost",
+					port: 5432,
+					user: "geekmidas",
+					password: "geekmidas",
+					database: integrationDbName
+				});
+				await client.connect();
+				await client.query(`
+          CREATE TABLE IF NOT EXISTS test_table (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255) NOT NULL
+          )
+        `);
+				await client.end();
+			});
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${integrationDbName}`);
+			const verifyClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: integrationDbName
+			});
+			await verifyClient.connect();
+			const tableResult = await verifyClient.query(`
+        SELECT table_name FROM information_schema.tables 
+        WHERE table_schema = 'public' AND table_name = 'test_table'
+      `);
+			require_vi_bdSIJ99Y.globalExpect(tableResult.rowCount).toBe(1);
+			await verifyClient.end();
+			await cleanup();
+		});
+		require_dist.it("should handle database that already exists and cleanup", async () => {
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+			const cleanup = await migrator.start();
+			require_vi_bdSIJ99Y.globalExpect(migrator.migrateCalled).toBe(true);
+			require_vi_bdSIJ99Y.globalExpect(typeof cleanup).toBe("function");
+		});
+	});
+});
+
+//#endregion