@geekmidas/testkit 3.1.1 → 10.0.0-alpha.0

package/src/__tests__/VitestObjectionTransactionIsolator.spec.ts

@@ -1,138 +0,0 @@
-import { Model } from 'objection';
-import { it as base, describe, expect } from 'vitest';
-
-import { createKnexDb, createTestTablesKnex } from '../../test/helpers';
-import { wrapVitestObjectionTransaction } from '../objection';
-
-// Define Objection models for testing
-class User extends Model {
-	static get tableName() {
-		return 'users';
-	}
-
-	id!: number;
-	name!: string;
-	createdAt!: Date;
-	updatedAt?: Date;
-
-	static get relationMappings() {
-		return {
-			posts: {
-				relation: Model.HasManyRelation,
-				modelClass: Post,
-				join: {
-					from: 'users.id',
-					to: 'posts.user_id',
-				},
-			},
-			comments: {
-				relation: Model.HasManyRelation,
-				modelClass: Comment,
-				join: {
-					from: 'users.id',
-					to: 'comments.user_id',
-				},
-			},
-		};
-	}
-}
-
-class Post extends Model {
-	static get tableName() {
-		return 'posts';
-	}
-
-	id!: number;
-	title!: string;
-	content!: string;
-	userId!: number;
-	published?: boolean;
-	createdAt!: Date;
-	updatedAt?: Date;
-
-	static get relationMappings() {
-		return {
-			user: {
-				relation: Model.BelongsToOneRelation,
-				modelClass: User,
-				join: {
-					from: 'posts.user_id',
-					to: 'users.id',
-				},
-			},
-			comments: {
-				relation: Model.HasManyRelation,
-				modelClass: Comment,
-				join: {
-					from: 'posts.id',
-					to: 'comments.post_id',
-				},
-			},
-		};
-	}
-}
-
-class Comment extends Model {
-	static get tableName() {
-		return 'comments';
-	}
-
-	id!: number;
-	content!: string;
-	postId!: number;
-	userId!: number;
-	createdAt!: Date;
-
-	static get relationMappings() {
-		return {
-			post: {
-				relation: Model.BelongsToOneRelation,
-				modelClass: Post,
-				join: {
-					from: 'comments.post_id',
-					to: 'posts.id',
-				},
-			},
-			user: {
-				relation: Model.BelongsToOneRelation,
-				modelClass: User,
-				join: {
-					from: 'comments.user_id',
-					to: 'users.id',
-				},
-			},
-		};
-	}
-}
-
-// Create database connection
-
-// Create wrapped test with transaction isolation
-const it = wrapVitestObjectionTransaction(base, {
-	connection: createKnexDb,
-	setup: async (trx) => {
-		// Create tables in the transaction
-		await createTestTablesKnex(trx);
-	},
-});
-
-describe('VitestObjectionTransactionIsolator', () => {
-	describe('Transaction Isolation', () => {
-		it('should rollback data after test completes', async ({ trx }) => {
-			// Create a user within the transaction
-			const user = await User.query(trx).insert({
-				name: 'Test User',
-			});
-
-			expect(user).toBeDefined();
-			expect(user.id).toBeDefined();
-			expect(user.name).toBe('Test User');
-
-			// Verify user exists in transaction
-			const foundUser = await User.query(trx).findById(user.id);
-			expect(foundUser).toBeDefined();
-
-			// Data will be rolled back after this test
-		});
-	});
-});

package/src/__tests__/benchmark.spec.ts

@@ -1,140 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	generateCacheKeys,
-	generateIpAddresses,
-	generateTestData,
-	randomIpAddress,
-} from '../benchmark';
-
-describe('generateTestData', () => {
-	it('should generate the specified number of records', () => {
-		const data = generateTestData(5);
-		expect(data).toHaveLength(5);
-	});
-
-	it('should generate records with expected structure', () => {
-		const data = generateTestData(3);
-
-		for (const record of data) {
-			expect(record).toHaveProperty('id');
-			expect(record).toHaveProperty('name');
-			expect(record).toHaveProperty('value');
-			expect(typeof record.id).toBe('string');
-			expect(typeof record.name).toBe('string');
-			expect(typeof record.value).toBe('number');
-		}
-	});
-
-	it('should generate sequential IDs', () => {
-		const data = generateTestData(3);
-		expect(data[0].id).toBe('id-0');
-		expect(data[1].id).toBe('id-1');
-		expect(data[2].id).toBe('id-2');
-	});
-
-	it('should generate sequential names', () => {
-		const data = generateTestData(3);
-		expect(data[0].name).toBe('Item 0');
-		expect(data[1].name).toBe('Item 1');
-		expect(data[2].name).toBe('Item 2');
-	});
-
-	it('should generate random values between 0 and 1000', () => {
-		const data = generateTestData(100);
-
-		for (const record of data) {
-			expect(record.value).toBeGreaterThanOrEqual(0);
-			expect(record.value).toBeLessThan(1000);
-		}
-	});
-
-	it('should return empty array for count 0', () => {
-		const data = generateTestData(0);
-		expect(data).toEqual([]);
-	});
-});
-
-describe('generateCacheKeys', () => {
-	it('should generate the specified number of keys', () => {
-		const keys = generateCacheKeys('test', 5);
-		expect(keys).toHaveLength(5);
-	});
-
-	it('should use the provided prefix', () => {
-		const keys = generateCacheKeys('user', 3);
-		expect(keys[0]).toBe('user:0');
-		expect(keys[1]).toBe('user:1');
-		expect(keys[2]).toBe('user:2');
-	});
-
-	it('should return empty array for count 0', () => {
-		const keys = generateCacheKeys('test', 0);
-		expect(keys).toEqual([]);
-	});
-
-	it('should handle empty prefix', () => {
-		const keys = generateCacheKeys('', 2);
-		expect(keys[0]).toBe(':0');
-		expect(keys[1]).toBe(':1');
-	});
-});
-
-describe('generateIpAddresses', () => {
-	it('should generate the specified number of IPs', () => {
-		const ips = generateIpAddresses(5);
-		expect(ips).toHaveLength(5);
-	});
-
-	it('should use default subnet 192.168.1', () => {
-		const ips = generateIpAddresses(3);
-		expect(ips[0]).toBe('192.168.1.0');
-		expect(ips[1]).toBe('192.168.1.1');
-		expect(ips[2]).toBe('192.168.1.2');
-	});
-
-	it('should use custom subnet', () => {
-		const ips = generateIpAddresses(2, '10.0.0');
-		expect(ips[0]).toBe('10.0.0.0');
-		expect(ips[1]).toBe('10.0.0.1');
-	});
-
-	it('should wrap last octet at 256', () => {
-		const ips = generateIpAddresses(260);
-		expect(ips[0]).toBe('192.168.1.0');
-		expect(ips[255]).toBe('192.168.1.255');
-		expect(ips[256]).toBe('192.168.1.0'); // Wraps around
-		expect(ips[257]).toBe('192.168.1.1');
-	});
-
-	it('should return empty array for count 0', () => {
-		const ips = generateIpAddresses(0);
-		expect(ips).toEqual([]);
-	});
-});
-
-describe('randomIpAddress', () => {
-	it('should generate valid IP address format', () => {
-		const ip = randomIpAddress();
-		const parts = ip.split('.');
-
-		expect(parts).toHaveLength(4);
-
-		for (const part of parts) {
-			const num = Number.parseInt(part, 10);
-			expect(num).toBeGreaterThanOrEqual(0);
-			expect(num).toBeLessThanOrEqual(255);
-		}
-	});
-
-	it('should generate different IPs on multiple calls', () => {
-		const ips = new Set<string>();
-
-		// Generate 10 IPs and check we get at least some variation
-		for (let i = 0; i < 10; i++) {
-			ips.add(randomIpAddress());
-		}
-
-		// With random generation, we should get at least 2 unique IPs
-		expect(ips.size).toBeGreaterThan(1);
-	});
-});

package/src/__tests__/better-auth.spec.ts

@@ -1,21 +0,0 @@
-import { runAdapterTest } from 'better-auth/adapters/test';
-import { afterAll, describe } from 'vitest';
-import { memoryAdapter } from '../better-auth';
-
-describe('Memory Adapter Tests', async () => {
-	afterAll(async () => {
-		// Run DB cleanup here...
-	});
-	const adapter = memoryAdapter({
-		debugLogs: {
-			// If your adapter config allows passing in debug logs, then pass this here.
-			isRunningAdapterTests: true, // This is our super secret flag to let us know to only log debug logs if a test fails.
-		},
-	});
-
-	await runAdapterTest({
-		getAdapter: async (betterAuthOptions = {}) => {
-			return adapter(betterAuthOptions);
-		},
-	});
-});

package/src/__tests__/faker.spec.ts

@@ -1,231 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { faker } from '../faker';
-
-describe('faker', () => {
-	describe('sequence', () => {
-		beforeEach(() => {
-			faker.resetAllSequences();
-		});
-
-		it('should start from 1 for a new sequence', () => {
-			expect(faker.sequence()).toBe(1);
-			expect(faker.sequence('custom')).toBe(1);
-		});
-
-		it('should increment on each call', () => {
-			expect(faker.sequence()).toBe(1);
-			expect(faker.sequence()).toBe(2);
-			expect(faker.sequence()).toBe(3);
-		});
-
-		it('should maintain separate counters for different names', () => {
-			expect(faker.sequence('users')).toBe(1);
-			expect(faker.sequence('posts')).toBe(1);
-			expect(faker.sequence('users')).toBe(2);
-			expect(faker.sequence('posts')).toBe(2);
-			expect(faker.sequence('users')).toBe(3);
-			expect(faker.sequence('posts')).toBe(3);
-		});
-
-		it('should handle concurrent-like sequential calls', () => {
-			const results: number[] = [];
-			for (let i = 0; i < 100; i++) {
-				results.push(faker.sequence('concurrent'));
-			}
-
-			// Check that all values are unique and sequential
-			expect(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');
-			expect(faker.sequence('test')).toBe(3);
-
-			faker.resetSequence('test');
-			expect(faker.sequence('test')).toBe(1);
-		});
-
-		it('should reset a specific sequence to a custom value', () => {
-			faker.sequence('test');
-			faker.resetSequence('test', 10);
-			expect(faker.sequence('test')).toBe(11);
-		});
-
-		it('should create a new sequence if it does not exist', () => {
-			faker.resetSequence('new', 5);
-			expect(faker.sequence('new')).toBe(6);
-		});
-
-		it('should not affect other sequences', () => {
-			faker.sequence('test1');
-			faker.sequence('test1');
-			faker.sequence('test2');
-
-			faker.resetSequence('test1');
-
-			expect(faker.sequence('test1')).toBe(1);
-			expect(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();
-
-			expect(faker.sequence('test1')).toBe(1);
-			expect(faker.sequence('test2')).toBe(1);
-			expect(faker.sequence()).toBe(1);
-		});
-	});
-
-	describe('identifier', () => {
-		beforeEach(() => {
-			faker.resetAllSequences();
-		});
-
-		it('should include sequence number in identifier', () => {
-			const id1 = faker.identifier();
-			const id2 = faker.identifier();
-
-			// Both should be different because of the sequence
-			expect(id1).not.toBe(id2);
-
-			// Should end with sequence numbers
-			expect(id1).toMatch(/1$/);
-			expect(id2).toMatch(/2$/);
-		});
-
-		it('should use custom suffix when provided', () => {
-			const id = faker.identifier('customSuffix');
-			expect(id).toMatch(/\.customSuffix$/);
-		});
-	});
-
-	describe('timestamps', () => {
-		it('should return createdAt and updatedAt dates', () => {
-			const { createdAt, updatedAt } = faker.timestamps();
-
-			expect(createdAt).toBeInstanceOf(Date);
-			expect(updatedAt).toBeInstanceOf(Date);
-			expect(createdAt.getTime()).toBeLessThanOrEqual(updatedAt.getTime());
-			expect(updatedAt.getTime()).toBeLessThanOrEqual(Date.now());
-		});
-
-		it('should have milliseconds set to 0', () => {
-			const { createdAt, updatedAt } = faker.timestamps();
-
-			expect(createdAt.getMilliseconds()).toBe(0);
-			expect(updatedAt.getMilliseconds()).toBe(0);
-		});
-	});
-
-	describe('price', () => {
-		it('should return a number', () => {
-			const result = faker.price();
-			expect(typeof result).toBe('number');
-			expect(result).toBeGreaterThan(0);
-		});
-	});
-
-	describe('coordinates', () => {
-		const center = { lat: 40.7128, lng: -74.006 }; // New York City
-
-		describe('within', () => {
-			it('should generate a coordinate within the given radius', () => {
-				const radius = 1000; // 1km
-				const result = faker.coordinates.within(center, radius);
-
-				expect(result).toHaveProperty('lat');
-				expect(result).toHaveProperty('lng');
-				expect(typeof result.lat).toBe('number');
-				expect(typeof result.lng).toBe('number');
-
-				// Calculate distance using Haversine formula
-				const R = 6378137; // Earth's radius in meters
-				const dLat = ((result.lat - center.lat) * Math.PI) / 180;
-				const dLng = ((result.lng - center.lng) * Math.PI) / 180;
-				const a =
-					Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-					Math.cos((center.lat * Math.PI) / 180) *
-						Math.cos((result.lat * Math.PI) / 180) *
-						Math.sin(dLng / 2) *
-						Math.sin(dLng / 2);
-				const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-				const distance = R * c;
-
-				expect(distance).toBeLessThanOrEqual(radius);
-			});
-
-			it('should generate different coordinates on multiple calls', () => {
-				const radius = 1000;
-				const results = Array.from({ length: 10 }, () =>
-					faker.coordinates.within(center, radius),
-				);
-
-				// Not all results should be identical
-				const uniqueLats = new Set(results.map((r) => r.lat));
-				expect(uniqueLats.size).toBeGreaterThan(1);
-			});
-		});
-
-		describe('outside', () => {
-			it('should generate a coordinate outside the minimum radius', () => {
-				const minRadius = 1000; // 1km
-				const maxRadius = 5000; // 5km
-				const result = faker.coordinates.outside(center, minRadius, maxRadius);
-
-				expect(result).toHaveProperty('lat');
-				expect(result).toHaveProperty('lng');
-				expect(typeof result.lat).toBe('number');
-				expect(typeof result.lng).toBe('number');
-
-				// Calculate distance using Haversine formula
-				const R = 6378137;
-				const dLat = ((result.lat - center.lat) * Math.PI) / 180;
-				const dLng = ((result.lng - center.lng) * Math.PI) / 180;
-				const a =
-					Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-					Math.cos((center.lat * Math.PI) / 180) *
-						Math.cos((result.lat * Math.PI) / 180) *
-						Math.sin(dLng / 2) *
-						Math.sin(dLng / 2);
-				const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-				const distance = R * c;
-
-				expect(distance).toBeGreaterThanOrEqual(minRadius);
-				expect(distance).toBeLessThanOrEqual(maxRadius);
-			});
-
-			it('should generate different coordinates on multiple calls', () => {
-				const results = Array.from({ length: 10 }, () =>
-					faker.coordinates.outside(center, 1000, 5000),
-				);
-
-				const uniqueLats = new Set(results.map((r) => r.lat));
-				expect(uniqueLats.size).toBeGreaterThan(1);
-			});
-
-			it('should normalize longitude to valid range', () => {
-				// Use a center near the antimeridian
-				const pacificCenter = { lat: 0, lng: 179 };
-				const result = faker.coordinates.outside(pacificCenter, 100000, 500000);
-
-				expect(result.lng).toBeGreaterThanOrEqual(-180);
-				expect(result.lng).toBeLessThanOrEqual(180);
-			});
-		});
-	});
-});