@geekmidas/testkit 0.0.14 → 0.0.16

package/src/aws.ts

@@ -0,0 +1,131 @@
+import type {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  Context,
+} from 'aws-lambda';
+import { vi } from 'vitest';
+
+/**
+ * Shared test utilities for AWS Lambda adapter testing
+ */
+
+/**
+ * Creates a mock AWS Lambda Context for testing
+ */
+export function createMockContext(): Context {
+  return {
+    awsRequestId: 'test-request-id',
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: 'test-function',
+    functionVersion: '1',
+    invokedFunctionArn:
+      'arn:aws:lambda:us-east-1:123456789012:function:test-function',
+    memoryLimitInMB: '128',
+    logGroupName: '/aws/lambda/test-function',
+    logStreamName: '2024/01/01/[$LATEST]abcdef123456',
+    getRemainingTimeInMillis: () => 5000,
+    done: vi.fn(),
+    fail: vi.fn(),
+    succeed: vi.fn(),
+  };
+}
+
+/**
+ * Creates a mock AWS API Gateway V1 (REST API) event for testing
+ */
+export function createMockV1Event(
+  overrides: Partial<APIGatewayProxyEvent> = {},
+): APIGatewayProxyEvent {
+  return {
+    body: null,
+    headers: {
+      'content-type': 'application/json',
+      'user-agent': 'test-agent',
+      host: 'test.example.com',
+    },
+    multiValueHeaders: {},
+    httpMethod: 'GET',
+    isBase64Encoded: false,
+    path: '/test',
+    pathParameters: null,
+    queryStringParameters: null,
+    multiValueQueryStringParameters: null,
+    stageVariables: null,
+    requestContext: {
+      accountId: '123456789012',
+      apiId: 'api-id',
+      authorizer: null,
+      protocol: 'HTTP/1.1',
+      httpMethod: 'GET',
+      path: '/test',
+      stage: 'test',
+      requestId: 'request-id',
+      requestTimeEpoch: 1704067200000,
+      resourceId: 'resource-id',
+      resourcePath: '/test',
+      identity: {
+        accessKey: null,
+        accountId: null,
+        apiKey: null,
+        apiKeyId: null,
+        caller: null,
+        cognitoAuthenticationProvider: null,
+        cognitoAuthenticationType: null,
+        cognitoIdentityId: null,
+        cognitoIdentityPoolId: null,
+        principalOrgId: null,
+        sourceIp: '127.0.0.1',
+        user: null,
+        userAgent: 'test-agent',
+        userArn: null,
+        clientCert: null,
+      },
+    },
+    resource: '/test',
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock AWS API Gateway V2 (HTTP API) event for testing
+ */
+export function createMockV2Event(
+  overrides: Partial<APIGatewayProxyEventV2> = {},
+): APIGatewayProxyEventV2 {
+  return {
+    version: '2.0',
+    routeKey: 'GET /test',
+    rawPath: '/test',
+    rawQueryString: '',
+    headers: {
+      'content-type': 'application/json',
+      'user-agent': 'test-agent',
+      host: 'test.example.com',
+    },
+    requestContext: {
+      accountId: '123456789012',
+      apiId: 'api-id',
+      domainName: 'test.example.com',
+      domainPrefix: 'api',
+      requestId: 'request-id',
+      routeKey: 'GET /test',
+      stage: 'test',
+      time: '01/Jan/2024:00:00:00 +0000',
+      timeEpoch: 1704067200000,
+      http: {
+        method: 'GET',
+        path: '/test',
+        protocol: 'HTTP/1.1',
+        sourceIp: '127.0.0.1',
+        userAgent: 'test-agent',
+      },
+    },
+    body: undefined,
+    pathParameters: undefined,
+    isBase64Encoded: false,
+    stageVariables: undefined,
+    queryStringParameters: undefined,
+    cookies: undefined,
+    ...overrides,
+  };
+}

package/src/logger.ts

@@ -0,0 +1,18 @@
+import type { Logger } from '@geekmidas/logger';
+import { vi } from 'vitest';
+
+/**
+ * Creates a mock Logger for testing
+ */
+export function createMockLogger(): Logger {
+  const logger: Logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn(() => logger),
+  };
+  return logger;
+}

package/src/os/directory.ts

@@ -0,0 +1,21 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { it } from 'vitest';
+
+export const itWithDir = it.extend<DirectoryFixtures>({
+  // This fixture automatically provides a transaction to each test
+  dir: async ({}, use) => {
+    const tempDir = os.tmpdir();
+    const directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();
+    const dir = path.join(tempDir, directoryName);
+    await fs.mkdir(dir, { recursive: true });
+    await use(dir);
+    await fs.rm(dir, { recursive: true, force: true });
+  },
+});
+
+export interface DirectoryFixtures {
+  dir: string;
+}

package/src/os/index.ts

@@ -0,0 +1 @@
+export { itWithDir } from './directory';

package/src/timer.ts

@@ -0,0 +1,3 @@
+export function waitFor(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/__tests__/Factory.spec.cjs

@@ -1,139 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_Factory = require('../Factory-WMhTNZ9S.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
-
-//#region src/__tests__/Factory.spec.ts
-var TestFactory = class extends require_Factory.Factory {
-	async insert(builderName, attrs) {
-		return Promise.resolve({
-			id: 1,
-			...attrs
-		});
-	}
-	async insertMany(count, builderName, attrs) {
-		const results = [];
-		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
-			results.push(await this.insert(builderName, newAttrs));
-		}
-		return results;
-	}
-	seed(seedName, attrs) {
-		return Promise.resolve({
-			seedResult: true,
-			...attrs
-		});
-	}
-};
-(0, vitest.describe)("Factory", () => {
-	(0, vitest.describe)("abstract class functionality", () => {
-		(0, vitest.it)("should be instantiable through concrete implementation", () => {
-			const factory = new TestFactory();
-			(0, vitest.expect)(factory).toBeInstanceOf(require_Factory.Factory);
-			(0, vitest.expect)(factory).toBeInstanceOf(TestFactory);
-		});
-		(0, vitest.it)("should have abstract methods defined", () => {
-			const factory = new TestFactory();
-			(0, vitest.expect)(typeof factory.insert).toBe("function");
-			(0, vitest.expect)(typeof factory.insertMany).toBe("function");
-			(0, vitest.expect)(typeof factory.seed).toBe("function");
-		});
-	});
-	(0, vitest.describe)("createSeed static method", () => {
-		(0, vitest.it)("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory, db) => {
-				return {
-					id: 1,
-					name: "test"
-				};
-			};
-			const result = require_Factory.Factory.createSeed(seedFn);
-			(0, vitest.expect)(result).toBe(seedFn);
-			(0, vitest.expect)(typeof result).toBe("function");
-		});
-		(0, vitest.it)("should work with different seed function signatures", () => {
-			const simpleSeed = () => Promise.resolve({ simple: true });
-			const complexSeed = async (attrs, factory, db) => {
-				return {
-					name: attrs.name,
-					created: true
-				};
-			};
-			const result1 = require_Factory.Factory.createSeed(simpleSeed);
-			const result2 = require_Factory.Factory.createSeed(complexSeed);
-			(0, vitest.expect)(result1).toBe(simpleSeed);
-			(0, vitest.expect)(result2).toBe(complexSeed);
-		});
-	});
-	(0, vitest.describe)("concrete implementation behavior", () => {
-		let factory;
-		(0, vitest.beforeEach)(() => {
-			factory = new TestFactory();
-		});
-		(0, vitest.it)("should implement insert method", async () => {
-			const result = await factory.insert("testBuilder", { name: "test" });
-			(0, vitest.expect)(result).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		(0, vitest.it)("should implement insertMany method", async () => {
-			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
-			(0, vitest.expect)(results).toHaveLength(3);
-			(0, vitest.expect)(results[0]).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		(0, vitest.it)("should implement insertMany with function attributes", async () => {
-			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
-			(0, vitest.expect)(results).toHaveLength(2);
-			(0, vitest.expect)(results[0]).toEqual({
-				id: 1,
-				name: "test0"
-			});
-			(0, vitest.expect)(results[1]).toEqual({
-				id: 1,
-				name: "test1"
-			});
-		});
-		(0, vitest.it)("should implement seed method", async () => {
-			const result = await factory.seed("testSeed", { custom: "value" });
-			(0, vitest.expect)(result).toEqual({
-				seedResult: true,
-				custom: "value"
-			});
-		});
-	});
-	(0, vitest.describe)("type definitions", () => {
-		(0, vitest.it)("should properly type MixedFactoryBuilder", () => {
-			const syncBuilder = (attrs, factory, db) => ({ sync: true });
-			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
-			(0, vitest.expect)(typeof syncBuilder).toBe("function");
-			(0, vitest.expect)(typeof asyncBuilder).toBe("function");
-		});
-		(0, vitest.it)("should properly type FactorySeed", () => {
-			const seed = async (attrs, factory, db) => ({ seeded: true });
-			(0, vitest.expect)(typeof seed).toBe("function");
-		});
-	});
-});
-(0, vitest.describe)("Factory types", () => {
-	(0, vitest.it)("should export MixedFactoryBuilder type", () => {
-		const builder = (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: attrs.name
-			};
-		};
-		(0, vitest.expect)(typeof builder).toBe("function");
-	});
-	(0, vitest.it)("should export FactorySeed type", () => {
-		const seed = async (attrs, factory, db) => {
-			return { created: attrs.count };
-		};
-		(0, vitest.expect)(typeof seed).toBe("function");
-	});
-});
-
-//#endregion

package/dist/__tests__/Factory.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/Factory.spec.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/Factory.spec.mjs

@@ -1,138 +0,0 @@
-import { Factory } from "../Factory-z2m01hMj.mjs";
-import { beforeEach, describe, expect, it } from "vitest";
-
-//#region src/__tests__/Factory.spec.ts
-var TestFactory = class extends Factory {
-	async insert(builderName, attrs) {
-		return Promise.resolve({
-			id: 1,
-			...attrs
-		});
-	}
-	async insertMany(count, builderName, attrs) {
-		const results = [];
-		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
-			results.push(await this.insert(builderName, newAttrs));
-		}
-		return results;
-	}
-	seed(seedName, attrs) {
-		return Promise.resolve({
-			seedResult: true,
-			...attrs
-		});
-	}
-};
-describe("Factory", () => {
-	describe("abstract class functionality", () => {
-		it("should be instantiable through concrete implementation", () => {
-			const factory = new TestFactory();
-			expect(factory).toBeInstanceOf(Factory);
-			expect(factory).toBeInstanceOf(TestFactory);
-		});
-		it("should have abstract methods defined", () => {
-			const factory = new TestFactory();
-			expect(typeof factory.insert).toBe("function");
-			expect(typeof factory.insertMany).toBe("function");
-			expect(typeof factory.seed).toBe("function");
-		});
-	});
-	describe("createSeed static method", () => {
-		it("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory, db) => {
-				return {
-					id: 1,
-					name: "test"
-				};
-			};
-			const result = Factory.createSeed(seedFn);
-			expect(result).toBe(seedFn);
-			expect(typeof result).toBe("function");
-		});
-		it("should work with different seed function signatures", () => {
-			const simpleSeed = () => Promise.resolve({ simple: true });
-			const complexSeed = async (attrs, factory, db) => {
-				return {
-					name: attrs.name,
-					created: true
-				};
-			};
-			const result1 = Factory.createSeed(simpleSeed);
-			const result2 = Factory.createSeed(complexSeed);
-			expect(result1).toBe(simpleSeed);
-			expect(result2).toBe(complexSeed);
-		});
-	});
-	describe("concrete implementation behavior", () => {
-		let factory;
-		beforeEach(() => {
-			factory = new TestFactory();
-		});
-		it("should implement insert method", async () => {
-			const result = await factory.insert("testBuilder", { name: "test" });
-			expect(result).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		it("should implement insertMany method", async () => {
-			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
-			expect(results).toHaveLength(3);
-			expect(results[0]).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		it("should implement insertMany with function attributes", async () => {
-			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
-			expect(results).toHaveLength(2);
-			expect(results[0]).toEqual({
-				id: 1,
-				name: "test0"
-			});
-			expect(results[1]).toEqual({
-				id: 1,
-				name: "test1"
-			});
-		});
-		it("should implement seed method", async () => {
-			const result = await factory.seed("testSeed", { custom: "value" });
-			expect(result).toEqual({
-				seedResult: true,
-				custom: "value"
-			});
-		});
-	});
-	describe("type definitions", () => {
-		it("should properly type MixedFactoryBuilder", () => {
-			const syncBuilder = (attrs, factory, db) => ({ sync: true });
-			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
-			expect(typeof syncBuilder).toBe("function");
-			expect(typeof asyncBuilder).toBe("function");
-		});
-		it("should properly type FactorySeed", () => {
-			const seed = async (attrs, factory, db) => ({ seeded: true });
-			expect(typeof seed).toBe("function");
-		});
-	});
-});
-describe("Factory types", () => {
-	it("should export MixedFactoryBuilder type", () => {
-		const builder = (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: attrs.name
-			};
-		};
-		expect(typeof builder).toBe("function");
-	});
-	it("should export FactorySeed type", () => {
-		const seed = async (attrs, factory, db) => {
-			return { created: attrs.count };
-		};
-		expect(typeof seed).toBe("function");
-	});
-});
-
-//#endregion