@pipobscure/demitasse/index.d.ts

Miniscule BDD Testing Framework

declare class Cancelable<T> extends Promise<T> {
    cancel(): void;
}
export interface asserter {
    (): Promise<void> | void;
}
export interface describer {
    (): void;
}
export declare class AssertionError extends Error {
    code?: string;
    actual?: any;
    expected?: any;
}
export interface Walker {
    enter(item: TestSuite): void;
    case(item: TestCase): void;
    exit(item: TestSuite): void;
}
export interface Reporter extends Walker {
    bailed: boolean;
    report(item: TestCase, status: 'ok' | 'not ok' | 'skipped', error?: AssertionError): void;
}
export declare class TAPReporter implements Reporter {
    constructor();
    private stack;
    private summary;
    bailed: boolean;
    private indent;
    case(item: TestCase): void;
    report(item: TestCase, status: 'ok' | 'not ok' | 'skipped', error?: AssertionError): void;
    enter(item: TestSuite): void;
    exit(item: TestSuite): void;
}
declare class TestCase {
    constructor(label: string, runner: asserter);
    label: string;
    private readonly run;
    skipped: boolean;
    timeout: number;
    execute(context: Reporter): Promise<boolean>;
    propagateSkip(skipped: boolean): void;
    print(indent?: string): void;
}
declare class TestSuite extends TestCase {
    constructor(label: string);
    private _before;
    private _beforeEach;
    private _test;
    private _afterEach;
    private _after;
    private _only;
    before(item: TestCase): void;
    beforeEach(item: TestCase): void;
    test(item: TestCase): void;
    afterEach(item: TestCase): void;
    after(item: TestCase): void;
    only(item: TestCase): void;
    propagateSkip(skipped: boolean): void;
    executeList(context: Reporter, list: TestCase[]): Promise<boolean>;
    execute(context: Reporter): Promise<boolean>;
    print(indent?: string): void;
    [Symbol.iterator](): IterableIterator<TestCase>;
}
export interface ConfigOptions {
    autorun?: boolean;
    output?: (args: any[]) => void;
    logout?: (args: any[]) => void;
    reporter?: () => Reporter;
    timeout?: number;
    print?: boolean;
    summary?: boolean;
    sleep?: (ms: number) => Cancelable<void>;
}
export declare function configure(options?: ConfigOptions): void;
export declare function describe(label: string, runner: describer): {
    skip: () => any;
    todo: () => any;
    only: () => any;
};
export declare namespace describe {
    var skip: (label: string, runner: describer) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
    };
    var todo: (label: string, runner: describer) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
    };
    var only: (label: string, runner: describer) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
    };
}
export declare function before(runner: asserter): void;
export declare function beforeEach(runner: asserter): void;
export declare function it(label: string, runner: asserter): {
    skip: () => any;
    todo: () => any;
    only: () => any;
    timeout: (ms: number) => any;
};
export declare namespace it {
    var skip: (label: string, runner: asserter) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
        timeout: (ms: number) => any;
    };
    var todo: (label: string, runner: asserter) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
        timeout: (ms: number) => any;
    };
    var only: (label: string, runner: asserter) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
        timeout: (ms: number) => any;
    };
    var timeout: (label: string, ms: number, runner: asserter) => {
        skip: () => any;
        todo: () => any;
        only: () => any;
        timeout: (ms: number) => any;
    };
}
export declare const timeout: (label: string, ms: number, runner: asserter) => {
    skip: () => any;
    todo: () => any;
    only: () => any;
    timeout: (ms: number) => any;
};
export declare function afterEach(runner: asserter): void;
export declare function after(runner: asserter): void;
export declare function main(): Promise<boolean>;
export declare function skeleton(walker: Walker, items?: TestCase[]): void;
export {};