/**
 * Adapt the node test interface to the shared testing interface
 */
import { deepStrictEqual, notStrictEqual, strictEqual } from 'node:assert';
import Option from '../option.ts';

export interface ITestBase {
	assertEquivalent(actual: unknown, expected: unknown): void;
	assertExists(actual: unknown): void;
	assertInstanceOf(actual: unknown, expectedType: any): void;
	assertNotEquals(actual: unknown, expected: unknown): void;
	assertEquals(actual: unknown, expected: unknown): void;
	assertTrue(actual: boolean): void;
	assertFalse(actual: boolean): void;
	assertSome<T>(actual: Option<T>): void;
	assertNone<T>(actual: Option<T>): void;
	/**
	 * Convert the nested test object into a test suite for the current runtime
	 */
	testSuite(testObj: any): void;
}

abstract class AbstractTestBase implements Partial<ITestBase> {
	/**
	 * The values (often objects) have all the same property values
	 */
	public static assertEquivalent(actual: unknown, expected: unknown): void {
		return deepStrictEqual(actual, expected);
	}

	/**
	 * The value is not null or undefined
	 */
	public static assertExists(actual: unknown): void {
		return notStrictEqual(actual, undefined);
	}

	/**
	 * `actual` is an object implementing `expectedType`
	 */
	public static assertInstanceOf(actual: unknown, expectedType: any): void {
		return strictEqual(actual instanceof expectedType, true);
	}

	/**
	 * The values are not exactly equal (Different instance, type, value, etc)
	 */
	public static assertNotEquals(actual: unknown, expected: unknown): void {
		return notStrictEqual(actual, expected);
	}

	/**
	 * The values are exactly the same
	 */
	public static assertEquals(actual: unknown, expected: unknown): void {
		return strictEqual(actual, expected);
	}

	/**
	 * The value is true
	 */
	public static assertTrue(actual: boolean): void {
		return strictEqual(actual, true);
	}

	/**
	 * The value is false
	 */
	public static assertFalse(actual: boolean): void {
		return strictEqual(actual, false);
	}

	/**
	 * The value is a `Some` type `Option`
	 */
	public static assertSome<T>(actual: Option<T>): void {
		return AbstractTestBase.assertTrue(actual.isSome());
	}

	/**
	 * The value is a `None` type `Option`
	 */
	public static assertNone<T>(actual: Option<T>): void {
		return AbstractTestBase.assertTrue(actual.isNone());
	}
}

export default AbstractTestBase;