@everyonesoftware/common 4.0.0 → 6.0.0

package/outputs/testIndex.d.ts

@@ -0,0 +1,428 @@
+import { S as SyncResult, P as PromiseAsyncResult, k as Type, I as Iterable, f as JavascriptIterable, C as CharacterWriteStream } from './characterWriteStream-DUlG_bx_.js';
+
+/**
+ * A type that can be used to make assertions during a test.
+ */
+declare abstract class Test {
+    /**
+     * Fail the current test with the provided message.
+     * @param message The message that explains why this test failed.
+     */
+    abstract fail(message: string): never;
+    /**
+     * Assert that the provided value is undefined;
+     * @param value The value to check.
+     */
+    assertUndefined(value: unknown): asserts value is undefined;
+    /**
+     * Assert that the provided value is undefined.
+     * @param test The current {@link Test}.
+     * @param value The value to check.
+     */
+    static assertUndefined(test: Test, value: unknown): asserts value is undefined;
+    /**
+     * Assert that the provided value is not undefined;
+     * @param value The value to check.
+     */
+    assertNotUndefined<T>(value: T): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined.
+     * @param test The current {@link Test}.
+     * @param value The value to check.
+     */
+    static assertNotUndefined<T>(test: Test, value: unknown): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is null.
+     * @param value The value to check.
+     */
+    assertNull(value: unknown): asserts value is null;
+    /**
+     * Assert that the provided value is null.
+     * @param value The value to check.
+     */
+    static assertNull(test: Test, value: unknown): asserts value is null;
+    /**
+     * Assert that the provided value is not null.
+     * @param value The value to check.
+     */
+    assertNotNull<T>(value: T): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not null.
+     * @param value The value to check.
+     */
+    static assertNotNull<T>(test: Test, value: T): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     */
+    assertNotUndefinedAndNotNull<T>(value: T): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     */
+    static assertNotUndefinedAndNotNull<T>(test: Test, value: T): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided values point to the same object.
+     * @param left The first value.
+     * @param right The second value.
+     */
+    abstract assertSame<T>(left: T, right: T): void;
+    /**
+     * Assert that the provided values don't point to the same object.
+     * @param left The first value.
+     * @param right The second value.
+     */
+    abstract assertNotSame<T>(left: T, right: T): void;
+    /**
+     * Assert that the provided values are equal.
+     * @param left The first value.
+     * @param right The second value.
+     * @param message A message that will be shown when the values are not equal.
+     */
+    abstract assertEqual<T>(left: T, right: T, message?: string): void;
+    /**
+     * Assert that the provided values are not equal.
+     * @param left The first value.
+     * @param right The second value.
+     */
+    abstract assertNotEqual<T>(left: T, right: T): void;
+    /**
+     * Assert that the provided value is false.
+     * @param value The value to check.
+     */
+    assertFalse(value: boolean): asserts value is false;
+    /**
+     * Assert that the provided value is false.
+     * @param value The value to check.
+     */
+    static assertFalse(test: Test, value: boolean): asserts value is false;
+    /**
+     * Assert that the provided value is true.
+     * @param value The value to check.
+     */
+    assertTrue(value: boolean): asserts value is true;
+    /**
+     * Assert that the provided value is true.
+     * @param value The value to check.
+     */
+    static assertTrue(test: Test, value: boolean): asserts value is true;
+    /**
+     * Assert that the provided action throws the provided {@link Error} when it is run.
+     * @param action The action to run.
+     * @param expectedError The optional expected {@link Error} to compare against the thrown
+     * {@link Error}. If the expected {@link Error} is not provided, then any {@link Error} will
+     * satisfy this assertion.
+     */
+    abstract assertThrows(action: SyncResult<unknown> | (() => void), expectedError?: Error): void;
+    /**
+     * Assert that the provided action throws the provided {@link Error} when it is run.
+     * @param action The action to run.
+     * @param expectedError The expected {@link Error}.
+     */
+    abstract assertThrowsAsync(action: PromiseLike<unknown> | (() => PromiseLike<unknown>), expectedError: Error): PromiseAsyncResult<void>;
+    /**
+     * Assert that the provided value is an instance of the provided {@link Type}.
+     * @param value The value to check.
+     * @param type The {@link Type} to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T): asserts value is T;
+    /**
+     * Assert that the provided value is an instance of the provided {@link Type}.
+     * @param value The value to check.
+     * @param type The {@link Type} to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertInstanceOf<T>(test: Test, value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T): asserts value is T;
+}
+
+/**
+ * A {@link Test} type that uses the standard "assert" module to make assertions.
+ */
+declare class AssertTest implements Test {
+    private readonly name;
+    protected constructor(name: string);
+    /**
+     * Create a new {@link AssertTest} object.
+     */
+    static create(name: string): AssertTest;
+    fail(message: string): never;
+    assertUndefined(value: unknown): asserts value is undefined;
+    assertNotUndefined<T>(value: T): asserts value is NonNullable<T>;
+    assertNull(value: unknown): asserts value is null;
+    assertNotNull<T>(value: T): asserts value is NonNullable<T>;
+    assertNotUndefinedAndNotNull<T>(value: T): asserts value is NonNullable<T>;
+    assertSame<T>(left: T, right: T): void;
+    assertNotSame<T>(left: T, right: T): void;
+    assertEqual<T>(left: T, right: T, message?: string): void;
+    assertNotEqual<T>(left: T, right: T): void;
+    assertFalse(value: boolean): void;
+    assertTrue(value: boolean): void;
+    assertThrows(action: SyncResult<unknown> | (() => void), expectedError?: Error): void;
+    assertThrowsAsync(action: Promise<unknown> | (() => Promise<unknown>), expectedError: Error): PromiseAsyncResult<void>;
+    assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T): asserts value is T;
+}
+
+/**
+ * A type that is used to mark that a test group or a test should be skipped.
+ */
+declare abstract class TestSkip {
+    protected constructor();
+    /**
+     * Create a new {@link TestSkip} with the provided properties.
+     * @param shouldSkip Whether the tests associated with the new {@link TestSkip}
+     * should be skipped.
+     * @param message The message that explains why the tests associated with this {@link TestSkip}
+     * should be skipped.
+     */
+    static create(shouldSkip?: boolean, message?: string): TestSkip;
+    /**
+     * Get whether the tests associated with this {@link TestSkip} should be skipped.
+     */
+    abstract getShouldSkip(): boolean;
+    /**
+     * Get the message that explains why the tests associated with this {@link TestSkip}
+     * should be skipped.
+     */
+    abstract getMessage(): string;
+}
+
+/**
+ * A type that can be used to run tests.
+ */
+declare abstract class TestRunner {
+    /**
+     * Get a {@link string} that concatenates the {@link string} representation of each
+     * of the provided values into an "and-list".
+     * @param values The values to concatenate.
+     */
+    andList(values: unknown[] | Iterable<unknown>): string;
+    /**
+     * Get a {@link string} that concatenates the {@link string} representation of each
+     * of the provided values into an "and-list".
+     * @param values The values to concatenate.
+     */
+    static andList(runner: TestRunner, values: unknown[] | Iterable<unknown>): string;
+    /**
+     * Get the {@link string} representation of the provided value.
+     * @param value The value to get the {@link string} representation of.
+     */
+    toString(value: unknown): string;
+    /**
+     * Get the {@link string} representation of the provided value.
+     * @param value The value to get the {@link string} representation of.
+     */
+    static toString(_runner: TestRunner, value: unknown): string;
+    skip(message?: string): TestSkip;
+    /**
+     * Create a {@link TestSkip} object that will prevent tests from being run.
+     * @param shouldSkip Whether these tests should be skipped.
+     * @param message The message that explains why the tests are being skipped.
+     */
+    skip(shouldSkip: boolean, message?: string): TestSkip;
+    /**
+     * Create a {@link TestSkip} object that will prevent tests from being run.
+     * @param shouldSkip Whether these tests should be skipped.
+     * @param message The message that explains why the tests are being skipped.
+     */
+    static skip(_runner: TestRunner, shouldSkip?: boolean, message?: string): TestSkip;
+    static runTestAction(runner: TestRunner, name: string, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided file.
+     * @param fileName The name of the file that is being tested.
+     * @param testAction The action that will run the tests.
+     */
+    testFile(fileName: string, testAction: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided file.
+     * @param fileName The name of the file that is being tested.
+     * @param skip A value that indicates whether these tests should be skipped.
+     * @param testAction The action that will run the tests.
+     */
+    testFile(fileName: string, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided file.
+     * @param runner The {@link TestRunner} that will run the tests.
+     * @param fileName The name of the file that is being tested.
+     * @param testAction The action that will run the tests.
+     */
+    static testFile(runner: TestRunner, fileName: string, skipOrTestAction: TestSkip | ((() => void) | ((test: Test) => void)) | undefined, testAction?: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided type.
+     * @param type The {@link Type} or name of the type that is being tested.
+     * @param testAction The action that will run the tests.
+     */
+    testType(typeNameOrType: string | Type<unknown>, testAction: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided type.
+     * @param type The {@link Type} or name of the type that is being tested.
+     * @param skip A value that indicates whether these tests should be skipped.
+     * @param testAction The action that will run the tests.
+     */
+    testType(typeNameOrType: string | Type<unknown>, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided type.
+     * @param runner The {@link TestRunner} that will run the tests.
+     * @param type The {@link Type} or name of the type that is being tested.
+     * @param testAction The action that will run the tests.
+     */
+    static testType(runner: TestRunner, typeNameOrType: string | Type<unknown>, skipOrTestAction: TestSkip | undefined | ((() => void) | ((test: Test) => void)), testAction: ((() => void) | ((test: Test) => void)) | undefined): void;
+    /**
+     * Create a test group that will test the provided function.
+     * @param functionSignature The signature of the function that is being tested.
+     * @param testAction The action that will run the tests.
+     */
+    testFunction(functionSignature: string, testAction: (() => void) | ((test: Test) => void)): void;
+    testFunction(functionSignature: string, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
+    /**
+     * Create a test group that will test the provided function.
+     * @param runner The {@link TestRunner} that will run the tests.
+     * @param functionSignature The signature of the function that is being tested.
+     * @param testAction The action that will run the tests.
+     */
+    static testFunction(runner: TestRunner, functionSignature: string, skipOrTestAction: TestSkip | undefined | ((() => void) | ((test: Test) => void)), testAction: ((() => void) | ((test: Test) => void)) | undefined): void;
+    /**
+     * Create and run a test group with the provided name.
+     * @param testGroupName The name of the test group to run.
+     * @param testAction The action that runs the test group.
+     */
+    abstract testGroup(testGroupName: string, testAction: () => void): void;
+    /**
+     * Create and run a test group with the provided name.
+     * @param testGroupName The name of the test group to run.
+     * @param testAction The action that runs the test group.
+     */
+    abstract testGroup(testGroupName: string, skip: TestSkip | undefined, testAction: () => void): void;
+    /**
+     * Create and run a test with the provided name.
+     * @param testName The name of the test to run.
+     * @param testAction The action that runs the test.
+     */
+    abstract test(testName: string, testAction: (test: Test) => void): void;
+    /**
+     * Create and run a test with the provided name.
+     * @param testName The name of the test to run.
+     * @param testAction The action that runs the test.
+     */
+    abstract test(testName: string, skip: TestSkip | undefined, testAction: (test: Test) => void): void;
+}
+
+declare function test(runner: TestRunner): void;
+
+/**
+ * A type that is used to mark that a test group or a test should be skipped.
+ */
+declare class BasicTestSkip implements TestSkip {
+    private readonly shouldSkip;
+    private readonly message;
+    private constructor();
+    /**
+     * Create a new {@link TestSkip} with the provided properties.
+     * @param shouldSkip Whether the tests associated with the new {@link TestSkip}
+     * should be skipped.
+     * @param message The message that explains why the tests associated with this {@link TestSkip}
+     * should be skipped.
+     */
+    static create(shouldSkip?: boolean, message?: string): BasicTestSkip;
+    getShouldSkip(): boolean;
+    getMessage(): string;
+}
+
+declare class FailedTest {
+    private readonly fullTestNameParts;
+    private readonly error;
+    private constructor();
+    static create(fullTestNameParts: JavascriptIterable<string>, error: unknown): FailedTest;
+    getFullTestNameParts(): JavascriptIterable<string>;
+    getFullTestName(): string;
+    getError(): unknown;
+    getErrorMessage(): string;
+}
+
+declare class SkippedTest {
+    private readonly skip;
+    private readonly fullTestNameParts;
+    private constructor();
+    static create(skip: TestSkip, fullTestNameParts: JavascriptIterable<string>): SkippedTest;
+    getSkipMessage(): string;
+    getFullTestNameParts(): JavascriptIterable<string>;
+    getFullTestName(): string;
+}
+
+declare class TestAction {
+    private readonly parent;
+    private readonly name;
+    private readonly skip;
+    private readonly action;
+    private constructor();
+    static create(parent: TestAction | undefined, name: string, skip: TestSkip | undefined, action: () => (void | Promise<void>)): TestAction;
+    getParent(): TestAction | undefined;
+    getName(): string;
+    getFullNameParts(): JavascriptIterable<string>;
+    getFullName(): string;
+    getSkip(): TestSkip | undefined;
+    shouldSkip(): boolean;
+    getAction(): () => (void | Promise<void>);
+    runAsync(): void | Promise<void>;
+}
+
+type ConsoleTestFunction = (runner: ConsoleTestRunner) => (void | Promise<void>);
+type ConsoleTestFunctionContainer = {
+    test: ConsoleTestFunction;
+};
+declare class ConsoleTestRunner extends TestRunner {
+    private writeStream;
+    private readonly pendingActions;
+    private pendingActionsInsertIndex;
+    private currentTestAction;
+    private currentTest;
+    private passedTestCount;
+    private readonly skippedTests;
+    private readonly testFailures;
+    constructor();
+    static create(): ConsoleTestRunner;
+    static run(testFunction: ConsoleTestFunction | ConsoleTestFunctionContainer): Promise<void>;
+    static run(testFunctions: JavascriptIterable<ConsoleTestFunction | ConsoleTestFunctionContainer>): Promise<void>;
+    setWriteStream(writeStream: CharacterWriteStream): this;
+    /**
+     * Get the number of {@link TestAction}s that have yet to be executed.
+     */
+    getPendingTestActionsCount(): number;
+    /**
+     * Get the index in the pending-{@link TestAction} stack that new {@link TestAction}s will be
+     * inserted at.
+     */
+    getPendingTestActionsInsertIndex(): number;
+    /**
+     * Get the number of tests that have been skipped.
+     */
+    getSkippedTestCount(): number;
+    getSkippedTests(): Iterable<SkippedTest>;
+    /**
+     * Get the number of tests that have passed.
+     */
+    getPassedTestCount(): number;
+    getFailedTestCount(): number;
+    getFailedTests(): Iterable<FailedTest>;
+    /**
+     * Get the {@link TestAction} that is currently executing or undefined if no {@link TestAction}
+     * is executing.
+     */
+    getCurrentTestAction(): TestAction | undefined;
+    getCurrentTest(): Test | undefined;
+    private assertNoCurrentTest;
+    beforeTest(fullTestNameParts: JavascriptIterable<string>): PromiseAsyncResult<void>;
+    afterPassedTest(): PromiseAsyncResult<void>;
+    afterSkippedTest(fullTestNameParts: JavascriptIterable<string>, skip: TestSkip | undefined): PromiseAsyncResult<void>;
+    afterFailedTest(fullTestNameParts: JavascriptIterable<string>, error: unknown): PromiseAsyncResult<void>;
+    testGroup(testGroupName: string, testAction: () => (void | Promise<void>)): void;
+    testGroup(testGroupName: string, skip: TestSkip | undefined, testAction: () => (void | Promise<void>)): void;
+    test(testName: string, testAction: (test: Test) => (void | Promise<void>)): void;
+    test(testName: string, skip: TestSkip | undefined, testAction: (test: Test) => (void | Promise<void>)): void;
+    runAsync(): Promise<void>;
+    printSummary(): PromiseAsyncResult<void>;
+}
+
+export { AssertTest, BasicTestSkip, type ConsoleTestFunction, type ConsoleTestFunctionContainer, ConsoleTestRunner, FailedTest, SkippedTest, Test, TestAction, TestRunner, TestSkip, test };

package/outputs/testIndex.js

@@ -0,0 +1,26 @@
+import {
+  AssertTest,
+  BasicTestSkip,
+  ConsoleTestRunner,
+  FailedTest,
+  SkippedTest,
+  Test,
+  TestAction,
+  TestRunner,
+  TestSkip,
+  test
+} from "./chunk-CHBOMCYM.js";
+import "./chunk-5Z677JON.js";
+export {
+  AssertTest,
+  BasicTestSkip,
+  ConsoleTestRunner,
+  FailedTest,
+  SkippedTest,
+  Test,
+  TestAction,
+  TestRunner,
+  TestSkip,
+  test
+};
+//# sourceMappingURL=testIndex.js.map

package/outputs/testIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}