@geekmidas/testkit 0.0.8 → 0.0.9

package/dist/__tests__/PostgresObjectionMigrator.spec.cjs

@@ -0,0 +1,432 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
+require('../PostgresMigrator-BtAWdLss.cjs');
+const require_PostgresObjectionMigrator = require('../PostgresObjectionMigrator-B88aTT0m.cjs');
+const require_helpers = require('../helpers-CNMBePuj.cjs');
+const pg = require_chunk.__toESM(require("pg"));
+const vitest = require_chunk.__toESM(require("vitest"));
+const knex = require_chunk.__toESM(require("knex"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_path = require_chunk.__toESM(require("node:path"));
+
+//#region src/__tests__/PostgresObjectionMigrator.spec.ts
+(0, vitest.describe)("PostgresObjectionMigrator", () => {
+	let testDbName;
+	let cleanupDb;
+	let consoleSpy;
+	let consoleErrorSpy;
+	let testMigrationsDir;
+	(0, vitest.beforeAll)(async () => {
+		testDbName = `test_postgres_objection_migrator_${Date.now()}`;
+		cleanupDb = await require_helpers.createTestDatabase(testDbName);
+		testMigrationsDir = node_path.default.join(process.cwd(), "test-migrations", Date.now().toString());
+		await node_fs.promises.mkdir(testMigrationsDir, { recursive: true });
+		await node_fs.promises.writeFile(node_path.default.join(testMigrationsDir, "001_create_users.js"), `
+exports.up = function(knex) {
+  return knex.schema.createTable('users', function(table) {
+    table.increments('id').primary();
+    table.string('name');
+    table.string('email').unique();
+    table.timestamps(true, true);
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTable('users');
+};
+`);
+		await node_fs.promises.writeFile(node_path.default.join(testMigrationsDir, "002_create_posts.js"), `
+exports.up = function(knex) {
+  return knex.schema.createTable('posts', function(table) {
+    table.increments('id').primary();
+    table.string('title');
+    table.text('content');
+    table.integer('user_id').unsigned().references('id').inTable('users');
+    table.timestamps(true, true);
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTable('posts');
+};
+`);
+	});
+	(0, vitest.beforeEach)(() => {
+		consoleSpy = vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+		consoleErrorSpy = vitest.vi.spyOn(console, "error").mockImplementation(() => {});
+	});
+	(0, vitest.afterEach)(() => {
+		consoleSpy.mockRestore();
+		consoleErrorSpy.mockRestore();
+	});
+	(0, vitest.afterAll)(async () => {
+		await cleanupDb();
+		await node_fs.promises.rm(testMigrationsDir, {
+			recursive: true,
+			force: true
+		});
+	});
+	(0, vitest.describe)("constructor", () => {
+		(0, vitest.it)("should create a PostgresObjectionMigrator instance", () => {
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+				knex: knexInstance
+			});
+			(0, vitest.expect)(migrator).toBeInstanceOf(require_PostgresObjectionMigrator.PostgresObjectionMigrator);
+			knexInstance.destroy();
+		});
+	});
+	(0, vitest.describe)("migrate method", () => {
+		(0, vitest.it)("should run migrations to latest", async () => {
+			const newDbName = `test_migrate_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${newDbName}`);
+			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith(vitest.expect.stringContaining("Applied batch"));
+			const verifyClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: newDbName
+			});
+			await verifyClient.connect();
+			const tablesResult = await verifyClient.query(`
+        SELECT table_name FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name IN ('users', 'posts')
+        ORDER BY table_name
+      `);
+			(0, vitest.expect)(tablesResult.rows).toEqual([{ table_name: "posts" }, { table_name: "users" }]);
+			await verifyClient.end();
+			await cleanup();
+		});
+		(0, vitest.it)("should handle no pending migrations", async () => {
+			const newDbName = `test_no_pending_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance1 = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator1 = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance1
+			});
+			const cleanup = await migrator1.start();
+			consoleSpy.mockClear();
+			const knexInstance2 = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator2 = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance2
+			});
+			await migrator2.migrate();
+			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith("No pending migrations to apply");
+			await cleanup();
+		});
+		(0, vitest.it)("should handle migration errors", async () => {
+			const newDbName = `test_migration_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const badMigrationsDir = node_path.default.join(process.cwd(), "bad-migrations", Date.now().toString());
+			await node_fs.promises.mkdir(badMigrationsDir, { recursive: true });
+			await node_fs.promises.writeFile(node_path.default.join(badMigrationsDir, "001_bad_migration.js"), `
+exports.up = function(knex) {
+  throw new Error('Migration failed on purpose');
+};
+
+exports.down = function(knex) {
+  return Promise.resolve();
+};
+`);
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: badMigrationsDir }
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			await (0, vitest.expect)(migrator.start()).rejects.toThrow("Migration failed on purpose");
+			(0, vitest.expect)(consoleErrorSpy).toHaveBeenCalledWith("Failed to apply migrations:", vitest.expect.any(Error));
+			await node_fs.promises.rm(badMigrationsDir, {
+				recursive: true,
+				force: true
+			});
+			const cleanupClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${newDbName}"`);
+			await cleanupClient.end();
+		});
+		(0, vitest.it)("should destroy knex connection after migration", async () => {
+			const newDbName = `test_destroy_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const destroySpy = vitest.vi.spyOn(knexInstance, "destroy");
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			(0, vitest.expect)(destroySpy).toHaveBeenCalled();
+			await cleanup();
+		});
+	});
+	(0, vitest.describe)("rollback method", () => {
+		(0, vitest.it)("should rollback last migration batch", async () => {
+			const newDbName = `test_rollback_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance1 = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator1 = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance1
+			});
+			const cleanup = await migrator1.start();
+			consoleSpy.mockClear();
+			const knexInstance2 = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator2 = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance2
+			});
+			await migrator2.rollback();
+			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith(vitest.expect.stringContaining("Rolled back batch"));
+			const verifyClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: newDbName
+			});
+			await verifyClient.connect();
+			const tablesResult = await verifyClient.query(`
+        SELECT table_name FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name IN ('users', 'posts')
+      `);
+			(0, vitest.expect)(tablesResult.rows).toEqual([]);
+			await verifyClient.end();
+			await cleanup();
+		});
+		(0, vitest.it)("should handle no migrations to rollback", async () => {
+			const newDbName = `test_no_rollback_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const createClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await createClient.connect();
+			await createClient.query(`CREATE DATABASE "${newDbName}"`);
+			await createClient.end();
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			await migrator.rollback();
+			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith("No migrations to rollback");
+			const cleanupClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${newDbName}"`);
+			await cleanupClient.end();
+		});
+		(0, vitest.it)("should handle rollback errors", async () => {
+			const newDbName = `test_rollback_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			await (0, vitest.expect)(migrator.rollback()).rejects.toThrow();
+			(0, vitest.expect)(consoleErrorSpy).toHaveBeenCalledWith("Failed to rollback migrations:", vitest.expect.any(Error));
+			await knexInstance.destroy();
+		});
+	});
+	(0, vitest.describe)("status method", () => {
+		(0, vitest.it)("should return migration status", async () => {
+			const newDbName = `test_status_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance1 = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator1 = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance1
+			});
+			const cleanup = await migrator1.start();
+			const knexInstance2 = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator2 = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance2
+			});
+			const status = await migrator2.status();
+			(0, vitest.expect)(status).toHaveProperty("completed");
+			(0, vitest.expect)(status).toHaveProperty("pending");
+			(0, vitest.expect)(Array.isArray(status.completed)).toBe(true);
+			(0, vitest.expect)(Array.isArray(status.pending)).toBe(true);
+			await cleanup();
+		});
+		(0, vitest.it)("should destroy connection after getting status", async () => {
+			const newDbName = `test_status_destroy_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const destroySpy = vitest.vi.spyOn(knexInstance, "destroy");
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const createClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await createClient.connect();
+			await createClient.query(`CREATE DATABASE "${newDbName}"`);
+			await createClient.end();
+			await migrator.status();
+			(0, vitest.expect)(destroySpy).toHaveBeenCalled();
+			const cleanupClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${newDbName}"`);
+			await cleanupClient.end();
+		});
+	});
+	(0, vitest.describe)("integration scenarios", () => {
+		(0, vitest.it)("should handle complete workflow with complex migrations", async () => {
+			const integrationDbName = `test_integration_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${integrationDbName}`;
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			const testClient = new pg.Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: integrationDbName
+			});
+			await testClient.connect();
+			const userResult = await testClient.query(`INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id`, ["Test User", "test@example.com"]);
+			const userId = userResult.rows[0].id;
+			await testClient.query(`INSERT INTO posts (title, content, user_id) VALUES ($1, $2, $3)`, [
+				"Test Post",
+				"This is a test post",
+				userId
+			]);
+			const postResult = await testClient.query(`SELECT * FROM posts WHERE user_id = $1`, [userId]);
+			(0, vitest.expect)(postResult.rowCount).toBe(1);
+			(0, vitest.expect)(postResult.rows[0].title).toBe("Test Post");
+			await testClient.end();
+			await cleanup();
+		});
+		(0, vitest.it)("should work with transaction-based tests", async () => {
+			const transactionDbName = `test_transaction_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${transactionDbName}`;
+			const knexInstance = (0, knex.default)({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new require_PostgresObjectionMigrator.PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			const testKnex = (0, knex.default)({
+				client: "pg",
+				connection: uri
+			});
+			await testKnex.transaction(async (trx) => {
+				await trx("users").insert({
+					name: "Transaction User",
+					email: "trx@example.com"
+				});
+				const users$1 = await trx("users").select("*");
+				(0, vitest.expect)(users$1.length).toBeGreaterThan(0);
+				throw new Error("Rollback transaction");
+			}).catch(() => {});
+			const users = await testKnex("users").select("*");
+			(0, vitest.expect)(users.length).toBe(0);
+			await testKnex.destroy();
+			await cleanup();
+		});
+	});
+});
+
+//#endregion