@everyonesoftware/common 6.0.0 → 8.0.0

package/outputs/testIndex.d.cts

@@ -1,4 +1,4 @@
-import { S as SyncResult, P as PromiseAsyncResult, k as Type, I as Iterable, f as JavascriptIterable, C as CharacterWriteStream } from './characterWriteStream-DUlG_bx_.cjs';
+import { f as JavascriptIterable, S as SyncResult, P as PromiseAsyncResult, k as Type, I as Iterable, A as AsyncResult, C as CharacterWriteStream } from './characterWriteStream-ogvZec-U.cjs';
 
 /**
  * A type that can be used to make assertions during a test.
@@ -61,6 +61,12 @@ declare abstract class Test {
      * @param value The value to check.
      */
     static assertNotUndefinedAndNotNull<T>(test: Test, value: T): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided collection is not undefined, not null, and not empty.
+     * @param value The value to check.
+     */
+    assertNotEmpty(value: JavascriptIterable<unknown>): void;
+    static assertNotEmpty(test: Test, value: JavascriptIterable<unknown>): void;
     /**
      * Assert that the provided values point to the same object.
      * @param left The first value.
@@ -91,10 +97,6 @@ declare abstract class Test {
      * @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.
@@ -142,18 +144,18 @@ declare abstract class Test {
  * 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);
+    private constructor();
     /**
      * Create a new {@link AssertTest} object.
      */
-    static create(name: string): AssertTest;
+    static create(): 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>;
+    assertNotEmpty(value: JavascriptIterable<unknown>): void;
     assertSame<T>(left: T, right: T): void;
     assertNotSame<T>(left: T, right: T): void;
     assertEqual<T>(left: T, right: T, message?: string): void;
@@ -228,61 +230,44 @@ declare abstract class TestRunner {
      * @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;
+    abstract 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;
+    abstract testFile(fileName: string, skip: TestSkip | 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;
+    abstract 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;
+    abstract testType(typeNameOrType: string | Type<unknown>, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): 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;
+    abstract testFunction(functionSignature: string, 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;
+    abstract testFunction(functionSignature: string, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
     /**
      * Create and run a test group with the provided name.
      * @param testGroupName The name of the test group to run.
@@ -330,71 +315,167 @@ declare class BasicTestSkip implements TestSkip {
     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;
-}
-
+type TestActionType = "file" | "type" | "function" | "group" | "test";
 declare class TestAction {
     private readonly parent;
     private readonly name;
+    private readonly type;
     private readonly skip;
     private readonly action;
     private constructor();
-    static create(parent: TestAction | undefined, name: string, skip: TestSkip | undefined, action: () => (void | Promise<void>)): TestAction;
+    static create(parent: TestAction | undefined, name: string, type: TestActionType, skip: TestSkip | undefined, action: () => (void | Promise<void>)): TestAction;
     getParent(): TestAction | undefined;
     getName(): string;
     getFullNameParts(): JavascriptIterable<string>;
     getFullName(): string;
+    getType(): TestActionType;
     getSkip(): TestSkip | undefined;
     shouldSkip(): boolean;
     getAction(): () => (void | Promise<void>);
     runAsync(): void | Promise<void>;
 }
 
+/**
+ * Options that can be passed to {@link TestError.getErrorString()}.
+ */
+interface GetErrorStringOptions {
+    /**
+     * Whether all of the file paths in the stack trace should be shortened to be relative to the
+     * current directory.
+     */
+    readonly relativeFilePaths?: boolean;
+    /**
+     * Remove any stack frames from code that is not part of the current project.
+     */
+    readonly removeNonProjectPaths?: boolean;
+}
+declare abstract class TestError {
+    protected constructor();
+    /**
+     * Get the error that caused the test or test group to fail.
+     */
+    abstract getError(): unknown;
+    /**
+     * Get the string representation of the error.
+     */
+    abstract getErrorString(options?: GetErrorStringOptions): string;
+}
+
+declare class FailedTest {
+    private readonly testAction;
+    private readonly error;
+    private constructor();
+    static create(testAction: TestAction, error: TestError): FailedTest;
+    getTestAction(): TestAction;
+    getTestError(): TestError;
+}
+
+declare class SkippedTest {
+    private readonly skip;
+    private readonly testAction;
+    private constructor();
+    static create(skip: TestSkip, testAction: TestAction): SkippedTest;
+    getSkipMessage(): string;
+    getTestAction(): TestAction;
+}
+
+type ConsoleTestRunnerStyle = TestActionType | "passed" | "skipped" | "failed";
+declare abstract class ConsoleTestRunnerUI {
+    private writeStream?;
+    private readonly styles;
+    private getErrorStringOptions?;
+    protected constructor();
+    static flat(): FlatConsoleTestRunnerUI;
+    static tree(): TreeConsoleTestRunnerUI;
+    setWriteStream(writeStream: CharacterWriteStream): this;
+    setStyle(style: ConsoleTestRunnerStyle, styleFunction: (text: string) => string): this;
+    setStyles(styles: Partial<Record<ConsoleTestRunnerStyle, (text: string) => string>>): this;
+    private applyStyle;
+    protected addIndentation(): void;
+    protected removeIndentation(): void;
+    protected indent(action: () => number | void | PromiseLike<number | void>): AsyncResult<number>;
+    protected writeString(text: string): AsyncResult<number>;
+    protected writeLine(text?: string): AsyncResult<number>;
+    protected writeTestActionName(testAction: TestAction): AsyncResult<number>;
+    protected writeFullTestActionName(testAction: TestAction): AsyncResult<number>;
+    setGetErrorStringOptions(options: GetErrorStringOptions | undefined): this;
+    beforeTestGroup(testGroup: TestAction): AsyncResult<void>;
+    afterTestGroup(testGroup: TestAction): AsyncResult<void>;
+    beforeTest(testAction: TestAction): AsyncResult<void>;
+    afterPassedTest(testAction: TestAction): AsyncResult<void>;
+    afterSkippedTest(testAction: TestAction, skip: TestSkip): AsyncResult<void>;
+    afterFailedTest(currentTestAction: TestAction, error: TestError): AsyncResult<void>;
+    writeSummary(passedTestCount: number, skippedTests: Iterable<SkippedTest>, failedTests: Iterable<FailedTest>): AsyncResult<void>;
+}
+declare class FlatConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+    protected constructor();
+    static create(): FlatConsoleTestRunnerUI;
+    beforeTest(testAction: TestAction): AsyncResult<void>;
+}
+declare class TreeConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+    private testActions;
+    private testActionWrittenDepth;
+    protected constructor();
+    static create(): TreeConsoleTestRunnerUI;
+    beforeTestGroup(testGroup: TestAction): AsyncResult<void>;
+    afterTestGroup(testGroup: TestAction): AsyncResult<void>;
+    beforeTest(testAction: TestAction): AsyncResult<void>;
+}
+
+/**
+ * A type that can create new {@link Test} objects.
+ */
+declare abstract class TestCreator {
+    /**
+     * Create the default {@link TestCreator}.
+     */
+    static create(): TestCreator;
+    /**
+     * Create a new {@link Test} object.
+     */
+    abstract createTest(): Test;
+}
+
+declare abstract class TestErrorCreator {
+    static create(): TestErrorCreator;
+    abstract createTestError(error: unknown): TestError;
+}
+
 type ConsoleTestFunction = (runner: ConsoleTestRunner) => (void | Promise<void>);
 type ConsoleTestFunctionContainer = {
     test: ConsoleTestFunction;
 };
-declare class ConsoleTestRunner extends TestRunner {
+declare class ConsoleTestRunner implements TestRunner {
     private writeStream;
-    private readonly pendingActions;
-    private pendingActionsInsertIndex;
+    private readonly testActions;
+    private testActionInsertIndex;
     private currentTestAction;
     private currentTest;
     private passedTestCount;
     private readonly skippedTests;
     private readonly testFailures;
-    constructor();
-    static create(): ConsoleTestRunner;
+    private readonly testCreator;
+    private readonly testErrorCreator;
+    private readonly ui;
+    constructor(testCreator?: TestCreator, testErrorCreator?: TestErrorCreator, ui?: ConsoleTestRunnerUI);
+    static create(testCreator?: TestCreator, testErrorCreator?: TestErrorCreator, ui?: ConsoleTestRunnerUI): ConsoleTestRunner;
     static run(testFunction: ConsoleTestFunction | ConsoleTestFunctionContainer): Promise<void>;
     static run(testFunctions: JavascriptIterable<ConsoleTestFunction | ConsoleTestFunctionContainer>): Promise<void>;
     setWriteStream(writeStream: CharacterWriteStream): this;
+    setStyle(style: ConsoleTestRunnerStyle, styleFunction: (text: string) => string): this;
+    setStyles(styles: Partial<Record<ConsoleTestRunnerStyle, (text: string) => string>>): this;
+    setGetErrorStringOptions(options: GetErrorStringOptions): this;
     /**
      * Get the number of {@link TestAction}s that have yet to be executed.
      */
-    getPendingTestActionsCount(): number;
+    getTestActionCount(): number;
     /**
-     * Get the index in the pending-{@link TestAction} stack that new {@link TestAction}s will be
+     * Get the index in the {@link TestAction} list that new {@link TestAction}s will be
      * inserted at.
      */
-    getPendingTestActionsInsertIndex(): number;
+    getTestActionInsertIndex(): number;
+    private resetTestActionInsertIndex;
+    private insertTestAction;
     /**
      * Get the number of tests that have been skipped.
      */
@@ -413,16 +494,31 @@ declare class ConsoleTestRunner extends TestRunner {
     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>;
+    beforeTestGroup(testAction: TestAction): AsyncResult<void>;
+    afterTestGroup(testAction: TestAction): AsyncResult<void>;
+    beforeTest(testAction: TestAction): AsyncResult<void>;
+    afterPassedTest(testAction: TestAction): AsyncResult<void>;
+    afterSkippedTest(testAction: TestAction, skip: TestSkip): AsyncResult<void>;
+    afterFailedTest(testAction: TestAction, error: TestError): AsyncResult<void>;
+    andList(values: unknown[] | Iterable<unknown>): string;
+    toString(value: unknown): string;
+    skip(message?: string): TestSkip;
+    skip(shouldSkip: boolean, message?: string): TestSkip;
+    testFile(fileName: string, testAction: (() => void) | ((test: Test) => void)): void;
+    testFile(fileName: string, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
+    testType(typeNameOrType: string | Type<unknown>, testAction: (() => void) | ((test: Test) => void)): void;
+    testType(typeNameOrType: string | Type<unknown>, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): void;
+    testFunction(functionSignature: string, testAction: (() => void) | ((test: Test) => void)): void;
+    testFunction(functionSignature: string, skip: TestSkip | undefined, testAction: (() => void) | ((test: Test) => void)): 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;
+    private innerTestGroup;
+    private innerTest;
+    private testGroupOrTest;
     runAsync(): Promise<void>;
-    printSummary(): PromiseAsyncResult<void>;
+    printSummary(): AsyncResult<void>;
 }
 
-export { AssertTest, BasicTestSkip, type ConsoleTestFunction, type ConsoleTestFunctionContainer, ConsoleTestRunner, FailedTest, SkippedTest, Test, TestAction, TestRunner, TestSkip, test };
+export { AssertTest, BasicTestSkip, type ConsoleTestFunction, type ConsoleTestFunctionContainer, ConsoleTestRunner, FailedTest, SkippedTest, Test, TestAction, type TestActionType, TestRunner, TestSkip, test };