@geekmidas/testkit 0.0.3 → 0.0.4

package/dist/__tests__/PostgresMigrator.spec.mjs

@@ -0,0 +1,256 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it } from "../dist-BM2KvLG1.mjs";
+import { PostgresMigrator } from "../PostgresMigrator-DqeuPy-e.mjs";
+import { globalExpect, vi } from "../vi.bdSIJ99Y-BgRxGeO2.mjs";
+import { createTestDatabase } from "../helpers-CukcFAU9.mjs";
+import { Client } from "pg";
+
+//#region src/__tests__/PostgresMigrator.spec.ts
+var TestPostgresMigrator = class extends 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);
+	}
+};
+describe("PostgresMigrator", () => {
+	let testDbName;
+	let cleanupDb;
+	let consoleSpy;
+	beforeAll(async () => {
+		testDbName = `test_postgres_migrator_${Date.now()}`;
+		cleanupDb = await createTestDatabase(testDbName);
+	});
+	beforeEach(() => {
+		consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+	});
+	afterEach(() => {
+		consoleSpy.mockRestore();
+	});
+	afterAll(async () => {
+		await cleanupDb();
+	});
+	describe("constructor", () => {
+		it("should create a PostgresMigrator instance", () => {
+			const migrator = new TestPostgresMigrator(`postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`);
+			globalExpect(migrator).toBeInstanceOf(PostgresMigrator);
+		});
+	});
+	describe("start method", () => {
+		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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(migrationRan).toBe(true);
+			globalExpect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${newDbName}`);
+			globalExpect(typeof cleanup).toBe("function");
+			await cleanup();
+		});
+		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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(migrationRan).toBe(true);
+			globalExpect(typeof cleanup).toBe("function");
+		});
+		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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(typeof cleanup).toBe("function");
+			await cleanup();
+		});
+		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 globalExpect(migrator.start()).rejects.toThrow("Migration failed");
+			globalExpect(migrator.migrateCalled).toBe(true);
+			const cleanupClient = new 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();
+			}
+		});
+		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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(typeof cleanup).toBe("function");
+			const checkClient = new 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]);
+			globalExpect(beforeResult.rowCount).toBe(1);
+			await checkClient.end();
+			await cleanup();
+			const checkClient2 = new 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]);
+			globalExpect(afterResult.rowCount).toBe(0);
+			await checkClient2.end();
+		});
+	});
+	describe("database creation", () => {
+		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 globalExpect(migrator.start()).rejects.toThrow();
+		});
+		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 globalExpect(migrator.start).rejects.toThrow();
+		});
+	});
+	describe("URI parsing", () => {
+		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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(typeof cleanup).toBe("function");
+			await cleanup();
+		});
+	});
+	describe("error handling", () => {
+		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 globalExpect(migrator.start()).rejects.toThrow("Custom migration error");
+			const cleanupClient = new 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();
+			}
+		});
+		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 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 globalExpect(cleanup()).rejects.toThrow();
+		});
+	});
+	describe("abstract method", () => {
+		it("should require concrete implementation of migrate method", () => {
+			const migrator = new TestPostgresMigrator(`postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`);
+			globalExpect(typeof migrator.migrate).toBe("function");
+		});
+	});
+	describe("integration scenarios", () => {
+		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 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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${integrationDbName}`);
+			const verifyClient = new 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'
+      `);
+			globalExpect(tableResult.rowCount).toBe(1);
+			await verifyClient.end();
+			await cleanup();
+		});
+		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();
+			globalExpect(migrator.migrateCalled).toBe(true);
+			globalExpect(typeof cleanup).toBe("function");
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/faker.spec.cjs

@@ -0,0 +1,115 @@
+const require_faker = require('../faker-h6CkRloU.cjs');
+const require_dist = require('../dist-DE3gAxQI.cjs');
+const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-CFuzUeY6.cjs');
+
+//#region src/__tests__/faker.spec.ts
+require_dist.describe("faker", () => {
+	require_dist.describe("sequence", () => {
+		require_dist.beforeEach(() => {
+			require_faker.faker.resetAllSequences();
+		});
+		require_dist.it("should start from 1 for a new sequence", () => {
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence()).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("custom")).toBe(1);
+		});
+		require_dist.it("should increment on each call", () => {
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence()).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence()).toBe(2);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence()).toBe(3);
+		});
+		require_dist.it("should maintain separate counters for different names", () => {
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("users")).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("posts")).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("users")).toBe(2);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("posts")).toBe(2);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("users")).toBe(3);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("posts")).toBe(3);
+		});
+		require_dist.it("should handle concurrent-like sequential calls", () => {
+			const results = [];
+			for (let i = 0; i < 100; i++) results.push(require_faker.faker.sequence("concurrent"));
+			require_vi_bdSIJ99Y.globalExpect(results).toEqual(Array.from({ length: 100 }, (_, i) => i + 1));
+		});
+	});
+	require_dist.describe("resetSequence", () => {
+		require_dist.beforeEach(() => {
+			require_faker.faker.resetAllSequences();
+		});
+		require_dist.it("should reset a specific sequence to 0", () => {
+			require_faker.faker.sequence("test");
+			require_faker.faker.sequence("test");
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test")).toBe(3);
+			require_faker.faker.resetSequence("test");
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test")).toBe(1);
+		});
+		require_dist.it("should reset a specific sequence to a custom value", () => {
+			require_faker.faker.sequence("test");
+			require_faker.faker.resetSequence("test", 10);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test")).toBe(11);
+		});
+		require_dist.it("should create a new sequence if it does not exist", () => {
+			require_faker.faker.resetSequence("new", 5);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("new")).toBe(6);
+		});
+		require_dist.it("should not affect other sequences", () => {
+			require_faker.faker.sequence("test1");
+			require_faker.faker.sequence("test1");
+			require_faker.faker.sequence("test2");
+			require_faker.faker.resetSequence("test1");
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test1")).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test2")).toBe(2);
+		});
+	});
+	require_dist.describe("resetAllSequences", () => {
+		require_dist.it("should reset all sequences", () => {
+			require_faker.faker.sequence("test1");
+			require_faker.faker.sequence("test1");
+			require_faker.faker.sequence("test2");
+			require_faker.faker.sequence("test2");
+			require_faker.faker.sequence("test2");
+			require_faker.faker.resetAllSequences();
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test1")).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence("test2")).toBe(1);
+			require_vi_bdSIJ99Y.globalExpect(require_faker.faker.sequence()).toBe(1);
+		});
+	});
+	require_dist.describe("identifier", () => {
+		require_dist.beforeEach(() => {
+			require_faker.faker.resetAllSequences();
+		});
+		require_dist.it("should include sequence number in identifier", () => {
+			const id1 = require_faker.faker.identifier();
+			const id2 = require_faker.faker.identifier();
+			require_vi_bdSIJ99Y.globalExpect(id1).not.toBe(id2);
+			require_vi_bdSIJ99Y.globalExpect(id1).toMatch(/1$/);
+			require_vi_bdSIJ99Y.globalExpect(id2).toMatch(/2$/);
+		});
+		require_dist.it("should use custom suffix when provided", () => {
+			const id = require_faker.faker.identifier("customSuffix");
+			require_vi_bdSIJ99Y.globalExpect(id).toMatch(/\.customSuffix$/);
+		});
+	});
+	require_dist.describe("timestamps", () => {
+		require_dist.it("should return createdAt and updatedAt dates", () => {
+			const { createdAt, updatedAt } = require_faker.faker.timestamps();
+			require_vi_bdSIJ99Y.globalExpect(createdAt).toBeInstanceOf(Date);
+			require_vi_bdSIJ99Y.globalExpect(updatedAt).toBeInstanceOf(Date);
+			require_vi_bdSIJ99Y.globalExpect(createdAt.getTime()).toBeLessThanOrEqual(updatedAt.getTime());
+			require_vi_bdSIJ99Y.globalExpect(updatedAt.getTime()).toBeLessThanOrEqual((/* @__PURE__ */ new Date()).getTime());
+		});
+		require_dist.it("should have milliseconds set to 0", () => {
+			const { createdAt, updatedAt } = require_faker.faker.timestamps();
+			require_vi_bdSIJ99Y.globalExpect(createdAt.getMilliseconds()).toBe(0);
+			require_vi_bdSIJ99Y.globalExpect(updatedAt.getMilliseconds()).toBe(0);
+		});
+	});
+	require_dist.describe("price", () => {
+		require_dist.it("should return a number", () => {
+			const result = require_faker.faker.price();
+			require_vi_bdSIJ99Y.globalExpect(typeof result).toBe("number");
+			require_vi_bdSIJ99Y.globalExpect(result).toBeGreaterThan(0);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/faker.spec.mjs

@@ -0,0 +1,115 @@
+import { beforeEach, describe, it } from "../dist-BM2KvLG1.mjs";
+import { faker } from "../faker-cGCFcrj2.mjs";
+import { globalExpect } from "../vi.bdSIJ99Y-BgRxGeO2.mjs";
+
+//#region src/__tests__/faker.spec.ts
+describe("faker", () => {
+	describe("sequence", () => {
+		beforeEach(() => {
+			faker.resetAllSequences();
+		});
+		it("should start from 1 for a new sequence", () => {
+			globalExpect(faker.sequence()).toBe(1);
+			globalExpect(faker.sequence("custom")).toBe(1);
+		});
+		it("should increment on each call", () => {
+			globalExpect(faker.sequence()).toBe(1);
+			globalExpect(faker.sequence()).toBe(2);
+			globalExpect(faker.sequence()).toBe(3);
+		});
+		it("should maintain separate counters for different names", () => {
+			globalExpect(faker.sequence("users")).toBe(1);
+			globalExpect(faker.sequence("posts")).toBe(1);
+			globalExpect(faker.sequence("users")).toBe(2);
+			globalExpect(faker.sequence("posts")).toBe(2);
+			globalExpect(faker.sequence("users")).toBe(3);
+			globalExpect(faker.sequence("posts")).toBe(3);
+		});
+		it("should handle concurrent-like sequential calls", () => {
+			const results = [];
+			for (let i = 0; i < 100; i++) results.push(faker.sequence("concurrent"));
+			globalExpect(results).toEqual(Array.from({ length: 100 }, (_, i) => i + 1));
+		});
+	});
+	describe("resetSequence", () => {
+		beforeEach(() => {
+			faker.resetAllSequences();
+		});
+		it("should reset a specific sequence to 0", () => {
+			faker.sequence("test");
+			faker.sequence("test");
+			globalExpect(faker.sequence("test")).toBe(3);
+			faker.resetSequence("test");
+			globalExpect(faker.sequence("test")).toBe(1);
+		});
+		it("should reset a specific sequence to a custom value", () => {
+			faker.sequence("test");
+			faker.resetSequence("test", 10);
+			globalExpect(faker.sequence("test")).toBe(11);
+		});
+		it("should create a new sequence if it does not exist", () => {
+			faker.resetSequence("new", 5);
+			globalExpect(faker.sequence("new")).toBe(6);
+		});
+		it("should not affect other sequences", () => {
+			faker.sequence("test1");
+			faker.sequence("test1");
+			faker.sequence("test2");
+			faker.resetSequence("test1");
+			globalExpect(faker.sequence("test1")).toBe(1);
+			globalExpect(faker.sequence("test2")).toBe(2);
+		});
+	});
+	describe("resetAllSequences", () => {
+		it("should reset all sequences", () => {
+			faker.sequence("test1");
+			faker.sequence("test1");
+			faker.sequence("test2");
+			faker.sequence("test2");
+			faker.sequence("test2");
+			faker.resetAllSequences();
+			globalExpect(faker.sequence("test1")).toBe(1);
+			globalExpect(faker.sequence("test2")).toBe(1);
+			globalExpect(faker.sequence()).toBe(1);
+		});
+	});
+	describe("identifier", () => {
+		beforeEach(() => {
+			faker.resetAllSequences();
+		});
+		it("should include sequence number in identifier", () => {
+			const id1 = faker.identifier();
+			const id2 = faker.identifier();
+			globalExpect(id1).not.toBe(id2);
+			globalExpect(id1).toMatch(/1$/);
+			globalExpect(id2).toMatch(/2$/);
+		});
+		it("should use custom suffix when provided", () => {
+			const id = faker.identifier("customSuffix");
+			globalExpect(id).toMatch(/\.customSuffix$/);
+		});
+	});
+	describe("timestamps", () => {
+		it("should return createdAt and updatedAt dates", () => {
+			const { createdAt, updatedAt } = faker.timestamps();
+			globalExpect(createdAt).toBeInstanceOf(Date);
+			globalExpect(updatedAt).toBeInstanceOf(Date);
+			globalExpect(createdAt.getTime()).toBeLessThanOrEqual(updatedAt.getTime());
+			globalExpect(updatedAt.getTime()).toBeLessThanOrEqual((/* @__PURE__ */ new Date()).getTime());
+		});
+		it("should have milliseconds set to 0", () => {
+			const { createdAt, updatedAt } = faker.timestamps();
+			globalExpect(createdAt.getMilliseconds()).toBe(0);
+			globalExpect(updatedAt.getMilliseconds()).toBe(0);
+		});
+	});
+	describe("price", () => {
+		it("should return a number", () => {
+			const result = faker.price();
+			globalExpect(typeof result).toBe("number");
+			globalExpect(result).toBeGreaterThan(0);
+		});
+	});
+});
+
+//#endregion