@gjsify/unit 0.0.2

package/src/index.spec.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect, assert, beforeEach, afterEach } from '@gjsify/unit';
+
+export default async () => {
+
+	await describe('assert', async () => {
+
+		await it('should consider truthy values as valid', async () => {
+			assert(true);
+			assert(1);
+			assert({});
+			assert([]);
+		});
+	})
+
+	await describe('beforeEach', async () => {
+
+		let foo = '';
+		let count = 0;
+		let countAfter = 0;
+
+		beforeEach(async () => {
+			console.log("beforeEach");
+			foo = 'bar';
+			++count;
+		});
+
+		afterEach(async () => {
+			console.log("afterEach");
+			--countAfter;
+		});
+
+		await it('foo should be "bar"', async () => {
+			expect(foo).toBe('bar');
+			foo = 'override me again'
+		});
+
+		await it('foo should be "bar" again', async () => {
+			expect(foo).toBe('bar');
+		});
+
+		await it('count should be 3 again', async () => {
+			expect(count).toBe(3);
+		});
+
+		await it('countAfter should be -3', async () => {
+			expect(countAfter).toBe(-3);
+		});
+	});
+
+	await describe('expect::to', async () => {
+		await it('should be possible to validate expectations by callback', async () => {
+			expect(3).to(function(actualValue) {
+				return actualValue === 3;
+			});
+		});
+
+		await it('should be possible to invalidate expectations by callback', async () => {
+			expect(3).not.to(function(actualValue) {
+				return actualValue === 5;
+			});
+		});
+	});
+
+	await describe('expect::toBe', async () => {
+		var obj = {};
+		var obj2 = {};
+
+		await it('should compare using ===', async () => {
+			expect(true).toBe(true);
+			expect(false).toBe(false);
+			expect('test').toBe('test');
+			expect(obj).toBe(obj);
+		});
+
+		await it('should compare using !==', async () => {
+			expect(true).not.toBe(false);
+			expect(true).not.toBe(1);
+			expect(false).not.toBe(true);
+			expect(false).not.toBe(0);
+			expect('test').not.toBe('test2');
+			expect(obj).not.toBe(obj2);
+		});
+	});
+
+	await describe('expect::toEqual', async () => {
+		var obj = {};
+		var obj2 = {};
+
+		await it('should compare using ==', async () => {
+			expect(true).toEqual(true);
+			expect(true).toEqual(1);
+			expect(false).toEqual(false);
+			expect(false).toEqual(0);
+			expect('test').toEqual('test');
+			expect(obj).toEqual(obj);
+		});
+
+		await it('should compare using !=', async () => {
+			expect(true).not.toEqual(false);
+			expect(false).not.toEqual(true);
+			expect('test').not.toEqual('test2');
+			expect(obj).not.toEqual(obj2);
+		});
+	});
+
+	await describe('expect::toMatch', async () => {
+		await it('should consider matching regular expressions as valid', async () => {
+			expect('test').toMatch(/test/);
+			expect('test').toMatch(/est/);
+			expect('test').toMatch('test');
+		});
+
+		await it('should consider non matching regular expressions as invalid', async () => {
+			expect('test').not.toMatch(/tester/);
+		});
+	});
+
+	await describe('expect::toBeDefined', async () => {
+		var obj = {key: 'value'};
+
+		await it('should consider defined values as valid', async () => {
+			expect(obj.key).toBeDefined();
+		});
+
+		await it('should consider undefined values as invalid', async () => {
+			expect((obj as any).invalidKey).not.toBeDefined();
+		});
+	});
+
+	await describe('expect::toBeUndefined', async () => {
+		var obj = {key: 'value'};
+
+		await it('should consider undefined values as valid', async () => {
+			expect((obj as any).invalidKey).toBeUndefined();
+		});
+
+		await it('should consider defined values as invalid', async () => {
+			expect(obj.key).not.toBeUndefined();
+		});
+	});
+
+	await describe('expect::toBeNull', async () => {
+		await it('should consider null values as valid', async () => {
+			expect(null).toBeNull();
+		});
+
+		await it('should consider non null values as invalid', async () => {
+			expect(0).not.toBeNull();
+			expect(false).not.toBeNull();
+			expect('').not.toBeNull();
+			expect('null').not.toBeNull();
+			expect(undefined).not.toBeNull();
+			expect({}).not.toBeNull();
+		});
+	});
+
+	await describe('expect::toBeTruthy', async () => {
+		await it('should consider truthy values as valid', async () => {
+			expect(true).toBeTruthy();
+			expect(1).toBeTruthy();
+			expect({}).toBeTruthy();
+			expect([]).toBeTruthy();
+		});
+
+		await it('should consider non truthy values as invalid', async () => {
+			expect(false).not.toBeTruthy();
+			expect(0).not.toBeTruthy();
+			expect('').not.toBeTruthy();
+			expect(null).not.toBeTruthy();
+			expect(undefined).not.toBeTruthy();
+		});
+	});
+
+	await describe('expect::toBeFalsy', async () => {
+		await it('should consider truthy values as valid', async () => {
+			expect(false).toBeFalsy();
+			expect(0).toBeFalsy();
+			expect('').toBeFalsy();
+			expect(null).toBeFalsy();
+			expect(undefined).toBeFalsy();
+		});
+
+		await it('should consider non truthy values as invalid', async () => {
+			expect(true).not.toBeFalsy();
+			expect(1).not.toBeFalsy();
+			expect({}).not.toBeFalsy();
+			expect([]).not.toBeFalsy();
+		});
+	});
+
+	await describe('expect::toContain', async () => {
+		var testArray = [1, 'a'];
+
+		await it('should consider array containing a value as valid', async () => {
+			expect(testArray).toContain(1);
+			expect(testArray).toContain('a');
+		});
+
+		await it('should consider arrays not containing a value as invalid', async () => {
+			expect(testArray).not.toContain(0);
+			expect(testArray).not.toContain('b');
+		});
+	});
+
+	await describe('expect::toBeLessThan', async () => {
+		await it('should consider greater values as valid', async () => {
+			expect(1).toBeLessThan(2);
+			expect(1).toBeLessThan(200);
+		});
+
+		await it('should consider equal values as invalid', async () => {
+			expect(1).not.toBeLessThan(1);
+		});
+
+		await it('should consider smaller values as invalid', async () => {
+			expect(1).not.toBeLessThan(0);
+			expect(1).not.toBeLessThan(-5);
+		});
+	});
+
+	await describe('expect::toBeGreaterThan', async () => {
+		await it('should consider smaller values as valid', async () => {
+			expect(2).toBeGreaterThan(1);
+			expect(2).toBeGreaterThan(0);
+			expect(2).toBeGreaterThan(-5);
+		});
+
+		await it('should consider equal values as invalid', async () => {
+			expect(1).not.toBeGreaterThan(1);
+		});
+
+		await it('should consider greater values as invalid', async () => {
+			expect(1).not.toBeGreaterThan(2);
+			expect(1).not.toBeGreaterThan(200);
+		});
+	});
+
+	await describe('expect::toBeCloseTo', async () => {
+		var pi = 3.1415926, e = 2.78;
+
+		await it('should consider close numbers as valid', async () => {
+			expect(pi).toBeCloseTo(e, 0);
+		});
+
+		await it('should consider non close numbers as invalid', async () => {
+			expect(pi).not.toBeCloseTo(e, 2);
+		});
+	});
+
+	await describe('expect::toBeCloseTo', async () => {
+		function throwException() {	throw {}; }
+		function dontThrowException() {}
+
+		await it('should consider functions throwing an exception as valid', async () => {
+			expect(throwException).toThrow();
+		});
+
+		await it('should consider functions not throwing an exception as invalid', async () => {
+			expect(dontThrowException).not.toThrow();
+		});
+	});
+}

package/src/index.ts

@@ -0,0 +1,425 @@
+// Based on https://github.com/philipphoffmann/gjsunit
+
+import "@girs/gjs";
+
+import type GLib from 'gi://GLib?version=2.0';
+export * from './spy.js';
+import nodeAssert from 'assert';
+
+const mainloop: GLib.MainLoop | undefined = (globalThis as any)?.imports?.mainloop;
+
+let countTestsOverall = 0;
+let countTestsFailed = 0;
+let countTestsIgnored = 0;
+let runtime = '';
+
+const RED = '\x1B[31m';
+const GREEN = '\x1B[32m';
+const BLUE = '\x1b[34m';
+const GRAY = '\x1B[90m';
+const RESET = '\x1B[39m';
+
+export interface Namespaces {
+	[key: string]: () => (Promise<void>) | Namespaces;
+}
+
+export type Callback = () => Promise<void>;
+
+export type Runtime = 'Gjs' | 'Deno' | 'Node.js' | 'Unknown' | 'Browser';
+
+// Makes this work on Gjs and Node.js
+export const print = globalThis.print || console.log;
+
+class MatcherFactory {
+
+	public not: MatcherFactory;
+
+	constructor(protected readonly actualValue: any, protected readonly positive: boolean, negated?: MatcherFactory) {
+		if(negated) {
+			this.not = negated;
+		} else {
+			this.not = new MatcherFactory(actualValue, !positive, this);
+		}
+	}
+
+	triggerResult(success: boolean, msg: string) {
+		if( (success && !this.positive) ||
+			(!success && this.positive) ) {
+			++countTestsFailed;
+			throw new Error(msg);
+		}
+	}
+
+	to(callback: (actualValue: any) => boolean) {
+		this.triggerResult(callback(this.actualValue),
+			`      Expected callback to validate`
+		);
+	}
+
+	toBe(expectedValue: any) {
+		this.triggerResult(this.actualValue === expectedValue,
+			`      Expected values to match using ===\n` +
+			`      Expected: ${expectedValue} (${typeof expectedValue})\n` +
+			`      Actual: ${this.actualValue} (${typeof this.actualValue})`
+		);
+	}
+
+	toEqual(expectedValue: any) {
+		this.triggerResult(this.actualValue == expectedValue,
+			`      Expected values to match using ==\n` +
+			`      Expected: ${expectedValue} (${typeof expectedValue})\n` +
+			`      Actual: ${this.actualValue} (${typeof this.actualValue})`
+		);
+	}
+
+	toEqualArray(expectedValue: Array<any> | Uint8Array) {
+
+		let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
+
+		for (let i = 0; i < this.actualValue.length; i++) {
+			const actualVal = this.actualValue[i];
+			const expectedVal = expectedValue[i];
+			success = actualVal == expectedVal;
+			if(!success) break;
+		}
+
+		this.triggerResult(success,
+			`      Expected array items to match using ==\n` +
+			`      Expected: ${expectedValue} (${typeof expectedValue})\n` +
+			`      Actual: ${this.actualValue} (${typeof this.actualValue})`
+		);
+	}
+
+	toMatch(expectedValue: any) {
+		if(typeof this.actualValue.match !== 'function') {
+			throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
+		}
+		this.triggerResult(!!this.actualValue.match(expectedValue),
+			'      Expected values to match using regular expression\n' +
+			'      Expression: ' + expectedValue + '\n' +
+			'      Actual: ' + this.actualValue
+		);
+	}
+
+	toBeDefined() {
+		this.triggerResult(typeof this.actualValue !== 'undefined',
+			`      Expected value to be defined`
+		);
+	}
+
+	toBeUndefined() {
+		this.triggerResult(typeof this.actualValue === 'undefined',
+			`      Expected value to be undefined`
+		);
+	}
+
+	toBeNull() {
+		this.triggerResult(this.actualValue === null,
+			`      Expected value to be null`
+		);
+	}
+
+	toBeTruthy() {
+		this.triggerResult(this.actualValue as unknown as boolean,
+			`      Expected value to be truthy`
+		);
+	}
+
+	toBeFalsy() {
+		this.triggerResult(!this.actualValue,
+			`      Expected value to be falsy`
+		);
+	}
+
+	toContain(needle: any) {
+		this.triggerResult(this.actualValue instanceof Array && this.actualValue.indexOf(needle) !== -1,
+			`      Expected ` + this.actualValue + ` to contain ` + needle
+		);
+	}
+	toBeLessThan(greaterValue: number) {
+		this.triggerResult(this.actualValue < greaterValue,
+			`      Expected ` + this.actualValue + ` to be less than ` + greaterValue
+		);
+	}
+	toBeGreaterThan(smallerValue: number) {
+		this.triggerResult(this.actualValue > smallerValue,
+			`      Expected ` + this.actualValue + ` to be greater than ` + smallerValue
+		);
+	}
+	toBeCloseTo(expectedValue: number, precision: number) {
+		const shiftHelper = Math.pow(10, precision);
+		this.triggerResult(Math.round((this.actualValue as unknown as number) * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper,
+			`      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue
+		);
+	}
+	toThrow(ErrorType?: typeof Error) {
+		let errorMessage = ''; 
+		let didThrow = false;
+		let typeMatch = true;
+		try {
+			this.actualValue();
+			didThrow = false;
+		}
+		catch(e) {
+			errorMessage = e.message || '';
+			didThrow = true;
+			if(ErrorType) {
+				typeMatch = (e instanceof ErrorType)
+			}
+		}
+		const functionName = this.actualValue.name || typeof this.actualValue === 'function' ? "[anonymous function]" : this.actualValue.toString();
+		this.triggerResult(didThrow,
+			`      Expected ${functionName} to ${this.positive ? 'throw' : 'not throw'} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ''}`
+		);
+
+		if(ErrorType) {
+			this.triggerResult(typeMatch,
+				`      Expected Error type '${ErrorType.name}', but the error is not an instance of it`
+			);
+		}
+	}
+}
+
+export const describe = async function(moduleName: string, callback: Callback) {
+	print('\n' + moduleName);
+
+	await callback();
+
+	// Reset after and before callbacks
+	beforeEachCb = null;
+	afterEachCb = null;
+};
+
+const runtimeMatch = async function(onRuntime: Runtime[], version?: string) {
+
+	const currRuntime = (await getRuntime());
+
+	const foundRuntime = onRuntime.find((r) => currRuntime.includes(r));
+
+	if (!foundRuntime) {
+		return {
+			matched: false
+		}
+	}
+
+	if(typeof version === 'string') {
+		// TODO allow version wildcards like 16.x.x
+		if(!currRuntime.includes(version)) {
+			return {
+				matched: false
+			}
+		}
+	}
+
+	return {
+		matched: true,
+		runtime: foundRuntime,
+		version: version,
+	}
+}
+
+// TODO add support for Browser
+/** E.g on('Deno', () {  it(...) }) */
+export const on = async function(onRuntime: Runtime | Runtime[], version: string | Callback, callback?: Callback) {
+
+	if(typeof onRuntime === 'string') {
+		onRuntime = [onRuntime];
+	}
+
+	if(typeof version === 'function') {
+		callback = version;
+		version = undefined;
+	}
+
+	const { matched } = await runtimeMatch(onRuntime, version as string | undefined);
+
+	if(!matched) {
+		++countTestsIgnored;
+		return;
+	}
+
+	print(`\nOn ${onRuntime.join(', ')}${version ? ' ' + version : ''}`);
+
+	await callback();
+}
+
+let beforeEachCb: Callback | undefined | null;
+let afterEachCb: Callback | undefined | null;
+
+export const beforeEach = function (callback?: Callback) {
+	beforeEachCb = callback;
+}
+
+export const afterEach = function (callback?: Callback) {
+	afterEachCb = callback;
+}
+
+
+export const it = async function(expectation: string, callback: () => void | Promise<void>) {
+	try {
+		if(typeof beforeEachCb === 'function') {
+			await beforeEachCb();
+		}
+		
+		await callback();
+
+		if(typeof afterEachCb === 'function') {
+			await afterEachCb();
+		}
+
+		print(`  ${GREEN}✔${RESET} ${GRAY}${expectation}${RESET}`);
+	}
+	catch(e) {
+		print(`  ${RED}❌${RESET} ${GRAY}${expectation}${RESET}`);
+		print(`${RED}${e.message}${RESET}`);
+		if (e.stack) print(e.stack);
+	}
+}
+
+export const expect = function(actualValue: any) {
+	++countTestsOverall;
+
+	const expecter = new MatcherFactory(actualValue, true);
+
+	return expecter;
+}
+
+export const assert = function(success: any, message?: string | Error) {
+	++countTestsOverall;
+
+	if(!success) {
+		++countTestsFailed;
+	}
+
+	nodeAssert(success, message);
+}
+
+assert.strictEqual = function<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T {
+	++countTestsOverall;
+	try {
+		nodeAssert.strictEqual(actual, expected, message);
+	} catch (error) {
+		++countTestsFailed;
+		throw error
+	}
+}
+
+assert.throws = function(promiseFn: () => unknown, ...args: any[]) {
+	++countTestsOverall;
+	let error: any;
+	try {
+		promiseFn();
+	} catch (e) {
+		error = e;
+	}
+
+	if(!error) ++countTestsFailed;
+
+	nodeAssert.throws(() => { if(error) throw error }, args[0], args[1])
+};
+
+assert.deepStrictEqual = function<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T {
+	++countTestsOverall;
+	try {
+		nodeAssert.deepStrictEqual(actual, expected, message);
+	} catch (error) {
+		++countTestsFailed;
+		throw error
+	}
+}
+
+// TODO wrap more assert methods
+
+const runTests = async function(namespaces: Namespaces) {
+	// recursively check the test directory for executable tests
+	for( const subNamespace in namespaces ) {
+		const namespace = namespaces[subNamespace];
+		// execute any test functions
+		if(typeof namespace === 'function' ) {
+			await namespace();
+		}
+		// descend into subfolders and objects
+		else if( typeof namespace === 'object' ) {
+			await runTests(namespace);
+		}
+	}
+}
+
+const printResult = () => {
+
+	if( countTestsIgnored ) {
+		// some tests ignored
+		print(`\n${BLUE}✔ ${countTestsIgnored} ignored test${ countTestsIgnored > 1 ? 's' : ''}${RESET}`);
+	}
+
+	if( countTestsFailed ) {
+		// some tests failed
+		print(`\n${RED}❌ ${countTestsFailed} of ${countTestsOverall} tests failed${RESET}`);
+	}
+	else {
+		// all tests okay
+		print(`\n${GREEN}✔ ${countTestsOverall} completed${RESET}`);
+	}
+}
+
+const getRuntime = async () => {
+	if(runtime && runtime !== 'Unknown') {
+		return runtime;
+	}
+
+	if(globalThis.Deno?.version?.deno) {
+		return 'Deno ' + globalThis.Deno?.version?.deno;
+	} else {
+		let process = globalThis.process;
+
+		if(!process) {
+			try {
+				process = await import('process');
+			} catch (error) {
+				console.error(error)
+				console.warn(error.message);
+				runtime = 'Unknown'
+			}
+		}
+
+		if(process?.versions?.gjs) {
+			runtime = 'Gjs ' + process.versions.gjs;
+		} else if (process?.versions?.node) {
+			runtime = 'Node.js ' + process.versions.node;
+		}
+	}
+	return runtime || 'Unknown';
+}
+
+const printRuntime = async () => {
+	const runtime = await getRuntime()
+	print(`\nRunning on ${runtime}`);	
+}
+
+export const run = async (namespaces: Namespaces) => {
+
+	printRuntime()
+	.then(async () => {
+		return runTests(namespaces)
+		.then(() => {
+			printResult();
+			print();
+			mainloop?.quit();
+		})
+	});
+
+	// Run the GJS mainloop for async operations
+	mainloop?.run();
+}
+
+export default {
+	run,
+	assert,
+	expect,
+	it,
+	afterEach,
+	beforeEach,
+	on,
+	describe,
+	print,	
+}