@hg-ts/tests 0.5.17 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/tests",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -24,9 +24,9 @@
     "unplugin-swc": "1.5.9"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.17",
-    "@hg-ts/linter": "0.5.17",
-    "@hg-ts/types": "0.5.17",
+    "@hg-ts-config/typescript": "0.5.18",
+    "@hg-ts/linter": "0.5.18",
+    "@hg-ts/types": "0.5.18",
     "@types/node": "22.19.1",
     "@vitest/coverage-v8": "4.0.14",
     "eslint": "9.18.0",

package/src/decorators/decorate-test.ts

@@ -0,0 +1,22 @@
+type TestDecorator = (callback: () => Promise<void>) => Promise<void>;
+
+export function createTestDecorator(decorator: TestDecorator): MethodDecorator {
+	function result(
+		_target: unknown,
+		_key: string,
+		descriptor: TypedPropertyDescriptor<(...args: unknown[]) => Promise<void>>,
+	): TypedPropertyDescriptor<(...args: unknown[]) => Promise<void>> {
+		return {
+			async value(...args: unknown[]): Promise<void> {
+				// eslint-disable-next-line @typescript/no-this-alias
+				const self = this;
+				const method = descriptor.value;
+				if (typeof method === 'function') {
+					await decorator(method.bind(self, ...args));
+				}
+			},
+		};
+	}
+
+	return result as MethodDecorator;
+}

package/src/decorators/describe.decorator.ts

@@ -0,0 +1,10 @@
+import { Runner } from '../runner.js';
+import type { SuiteConstructor } from '../suite.js';
+import { TestOptions } from '../types.js';
+
+export function Describe<T extends SuiteConstructor>(options: TestOptions = {}): TypedClassDecorator<T> {
+	return (target: T): void => {
+		// eslint-disable-next-line @typescript/no-floating-promises
+		Runner.run(target, options);
+	};
+}

package/src/decorators/expect-error.decorator.ts

@@ -0,0 +1,20 @@
+import { expect } from 'vitest';
+import { createTestDecorator } from './decorate-test.js';
+
+export function ExpectException(error?: AnyCLass<any, any[]>): MethodDecorator {
+	return createTestDecorator(async(method: () => Promise<void>) => {
+		let isThrowError = false;
+
+		try {
+			await method();
+		} catch (err: unknown) {
+			isThrowError = true;
+
+			if (error) {
+				expect(err).toBeInstanceOf(error);
+			}
+		} finally {
+			expect(isThrowError).toBeTruthy();
+		}
+	});
+}

package/src/decorators/index.ts

@@ -0,0 +1,3 @@
+export * from './expect-error.decorator.js';
+export * from './describe.decorator.js';
+export * from './test.decorator.js';

package/src/decorators/test.decorator.ts

@@ -0,0 +1,17 @@
+import type { Suite } from '../suite.js';
+import type {
+	MethodName,
+	TestOptions,
+} from '../types.js';
+
+export function Test(options: TestOptions = {}): MethodDecorator {
+	return (
+		target: Object,
+		propertyKey: MethodName,
+	): void => {
+		const suite = target as Suite;
+
+		suite.testsMap ??= new Map();
+		suite.testsMap.set(propertyKey, options);
+	};
+}

package/src/example.test.ts

@@ -0,0 +1,30 @@
+import { expect } from 'vitest';
+import {
+	Describe,
+	ExpectException,
+	Test,
+} from './decorators/index.js';
+import { Suite } from './suite.js';
+
+@Describe()
+export class ExampleTestSuite extends Suite {
+	@Test()
+	public async success(): Promise<void> {
+		expect(true).toBeTruthy();
+	}
+
+	@ExpectException(Error)
+	@Test()
+	public async failed(): Promise<void> {
+		throw new Error('Failed test');
+	}
+
+	@Test({ todo: true })
+	public async todo(): Promise<void> {}
+
+	@Test({ skip: true })
+	public async skip(): Promise<void> {}
+
+	@Test({ only: true })
+	public async only(): Promise<void> {}
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import nock from 'nock';
+
+export { Describe, Test, ExpectException } from './decorators/index.js';
+
+export { Suite } from './suite.js';
+export { expect } from 'vitest';
+
+export { nock };

package/src/runner.ts

@@ -0,0 +1,91 @@
+import {
+	afterAll,
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	SuiteAPI,
+	test,
+	vi,
+} from 'vitest';
+import {
+	Suite,
+	SuiteConstructor,
+} from './suite.js';
+
+import type {
+	MethodName,
+	TestMethod,
+	TestOptions,
+} from './types.js';
+
+export class Runner {
+	public static async run(
+		suiteConstructor: SuiteConstructor,
+		options: TestOptions = {},
+	): Promise<void> {
+		let moddedDescribe: SuiteAPI = describe;
+
+		if (options.only) {
+			moddedDescribe = moddedDescribe.only as SuiteAPI;
+		}
+
+		if (options.todo) {
+			moddedDescribe = moddedDescribe.todo as SuiteAPI;
+		}
+
+		if (options.skip) {
+			moddedDescribe = moddedDescribe.skip as SuiteAPI;
+		}
+
+		moddedDescribe(
+			options.name ?? suiteConstructor.name,
+			this.describe.bind(this, suiteConstructor),
+		);
+	}
+
+	private static describe(suiteConstructor: SuiteConstructor): void {
+		const suite = new suiteConstructor();
+		suite.testsMap = suiteConstructor.prototype.testsMap;
+
+		beforeAll(async() => suite.setUp());
+		afterAll(async() => suite.tearDown());
+
+		beforeEach(async() => {
+			vi.clearAllTimers();
+			vi.clearAllMocks();
+			await suite.beforeEach();
+		});
+		afterEach(async() => suite.afterEach());
+
+		if (!suite.testsMap) {
+			suite.testsMap = new Map();
+		}
+
+		suite.testsMap.forEach((options, methodName) => this.registerTests(suite, options, methodName));
+	}
+
+	private static registerTests(suite: Suite, options: TestOptions, testName: MethodName): void {
+		const { name = testName.toString() } = options;
+
+		const method = this.getTestMethod(suite, testName);
+
+
+		test(name, {
+			only: options.only ?? false,
+			todo: options.todo ?? false,
+			skip: options.skip ?? false,
+		}, method);
+	}
+
+	private static getTestMethod(suite: Suite, methodName: MethodName): TestMethod {
+		const testMethod = ((suite as any)[methodName] as (...args: unknown[]) => Promise<void>).bind(suite);
+		Object.defineProperty(testMethod, 'name', { value: methodName });
+
+		const fieldNameWrapper: any = { [methodName]: testMethod } as const;
+
+		return async(...args: any[]): Promise<void> => {
+			await fieldNameWrapper[methodName](...args);
+		};
+	}
+}

package/src/suite.ts

@@ -0,0 +1,18 @@
+import type {
+	MethodName,
+	TestOptions,
+} from './types.js';
+
+export type SuiteConstructor = new () => Suite;
+
+export abstract class Suite {
+	public testsMap: Map<MethodName, TestOptions> | null;
+
+	public async setUp(): Promise<void> {}
+
+	public async tearDown(): Promise<void> {}
+
+	public async beforeEach(): Promise<void> {}
+
+	public async afterEach(): Promise<void> {}
+}

package/src/types.ts

@@ -0,0 +1,11 @@
+import type { TestContext } from 'node:test';
+
+export type TestMethod = (context: TestContext) => Promise<void>;
+export type MethodName = string | symbol;
+
+export type TestOptions = {
+	name?: string;
+	only?: boolean;
+	skip?: boolean;
+	todo?: boolean;
+};