1 | export declare const enum Operator {
|
2 | EQUAL = "equal",
|
3 | NOT_EQUAL = "notEqual",
|
4 | IS = "is",
|
5 | OK = "ok",
|
6 | NOT_OK = "notOk",
|
7 | IS_NOT = "isNot",
|
8 | FAIL = "fail",
|
9 | THROWS = "throws",
|
10 | DOES_NOT_THROW = "doesNotThrow"
|
11 | }
|
12 | export interface Result {
|
13 | pass: boolean;
|
14 | description: string;
|
15 | id?: number;
|
16 | skip?: boolean;
|
17 | }
|
18 | export interface TestResult extends Result {
|
19 | executionTime: number;
|
20 | }
|
21 | export interface AssertionResult extends Result {
|
22 | operator: Operator;
|
23 | expected: any;
|
24 | actual: any;
|
25 | at?: string;
|
26 | }
|
27 | export interface SpecFunction {
|
28 | (t: Assert): any;
|
29 | }
|
30 | export interface ComparatorAssertionFunction {
|
31 | <T>(actual: T, expected: T, description?: string): AssertionResult;
|
32 | }
|
33 | export interface BooleanAssertionFunction {
|
34 | <T>(actual: T, description?: string): AssertionResult;
|
35 | }
|
36 | export interface ErrorAssertionFunction {
|
37 | (fn: Function, expected?: string | RegExp | Function, description?: string): AssertionResult;
|
38 | }
|
39 | export interface MessageAssertionFunction {
|
40 | (message?: string): AssertionResult;
|
41 | }
|
42 | export interface TestFunction {
|
43 | (description: string, spec: SpecFunction, options?: object): Promise<TestResult>;
|
44 | }
|
45 | export interface Assert {
|
46 | equal: ComparatorAssertionFunction;
|
47 | equals: ComparatorAssertionFunction;
|
48 | eq: ComparatorAssertionFunction;
|
49 | deepEqual: ComparatorAssertionFunction;
|
50 | notEqual: ComparatorAssertionFunction;
|
51 | notEquals: ComparatorAssertionFunction;
|
52 | notEq: ComparatorAssertionFunction;
|
53 | notDeepEqual: ComparatorAssertionFunction;
|
54 | is: ComparatorAssertionFunction;
|
55 | same: ComparatorAssertionFunction;
|
56 | isNot: ComparatorAssertionFunction;
|
57 | notSame: ComparatorAssertionFunction;
|
58 | ok: BooleanAssertionFunction;
|
59 | truthy: BooleanAssertionFunction;
|
60 | notOk: BooleanAssertionFunction;
|
61 | falsy: BooleanAssertionFunction;
|
62 | fail: MessageAssertionFunction;
|
63 | throws: ErrorAssertionFunction;
|
64 | doesNotThrow: ErrorAssertionFunction;
|
65 | test: TestFunction;
|
66 | skip: TestFunction;
|
67 | only: TestFunction;
|
68 | }
|
69 | export declare type AssertionFunction = ComparatorAssertionFunction | BooleanAssertionFunction | ErrorAssertionFunction | MessageAssertionFunction;
|
70 | export interface Counter {
|
71 | successCount: number;
|
72 | failureCount: number;
|
73 | skipCount: number;
|
74 | count: number;
|
75 | }
|
76 | export interface Test extends AsyncIterable<Message<any>>, TestResult, Counter {
|
77 | readonly routine: Promise<any>;
|
78 | readonly length: number;
|
79 | readonly error?: any;
|
80 | }
|
81 | export interface TestCounter extends Counter {
|
82 | update(assertion: Test | AssertionResult): void;
|
83 | }
|
84 | export interface TestHarnessConfiguration {
|
85 | runOnly?: boolean;
|
86 | indent?: boolean;
|
87 | }
|
88 | export interface TestHarness extends Assert, AsyncIterable<Message<any>>, Counter {
|
89 | report: (reporter?: Reporter) => Promise<void>;
|
90 | pass: boolean;
|
91 | }
|
92 | export interface RootTest extends TestFunction {
|
93 | indent: () => void;
|
94 | skip: TestFunction;
|
95 | }
|
96 | export declare const enum MessageType {
|
97 | TEST_START = "TEST_START",
|
98 | ASSERTION = "ASSERTION",
|
99 | TEST_END = "TEST_END",
|
100 | BAIL_OUT = "BAIL_OUT"
|
101 | }
|
102 | export interface Message<T> {
|
103 | offset: number;
|
104 | type: MessageType;
|
105 | data: T;
|
106 | }
|
107 | export interface Reporter {
|
108 | (stream: AsyncIterable<Message<any>>): Promise<void>;
|
109 | }
|
110 | export declare type StartTestMessage = Message<{
|
111 | description: string;
|
112 | }>;
|
113 | export declare type AssertionMessage = Message<Test | AssertionResult>;
|
114 | export declare type TestEndMessage = Message<Test>;
|
115 | export declare type BailoutMessage = Message<Error>;
|