/
expect.ts
72 lines (59 loc) · 2.14 KB
/
expect.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import { ArrayAssertion } from "./ArrayAssertion";
import { Assertion } from "./Assertion";
import { BooleanAssertion } from "./BooleanAssertion";
import { DateAssertion } from "./DateAssertion";
import { ErrorAssertion } from "./ErrorAssertion";
import { AnyFunction, FunctionAssertion } from "./FunctionAssertion";
import { NumberAssertion } from "./NumberAssertion";
import { ObjectAssertion } from "./ObjectAssertion";
import { PromiseAssertion } from "./PromiseAssertion";
import { StringAssertion } from "./StringAssertion";
import { config } from "./config/Config";
import { isAnyFunction, isStruct, isPromise } from "./helpers/guards";
import { Struct } from "./helpers/types";
export interface Expect {
(actual: boolean): BooleanAssertion;
(actual: number): NumberAssertion;
(actual: string): StringAssertion;
(actual: Date): DateAssertion;
<T>(actual: T[]): ArrayAssertion<T>;
<T>(actual: Promise<T>): PromiseAssertion<T>;
<T extends AnyFunction>(actual: T): FunctionAssertion<T>;
<T extends Error>(actual: T): ErrorAssertion<T>;
<T extends Struct>(actual: T): ObjectAssertion<T>;
<T>(actual: T): Assertion<T>;
}
function expectMatcher<T>(actual: T): ReturnType<Expect> {
const plugin = config.plugins().find(({ predicate }) => predicate(actual));
if (plugin?.insertAt === "top") {
return new plugin.Assertion(actual);
}
switch (typeof actual) {
case "boolean": return new BooleanAssertion(actual);
case "number": return new NumberAssertion(actual);
case "string": return new StringAssertion(actual);
}
if (actual instanceof Date) {
return new DateAssertion(actual);
}
if (Array.isArray(actual)) {
return new ArrayAssertion(actual);
}
if (isPromise<T>(actual)) {
return new PromiseAssertion(actual);
}
if (isAnyFunction(actual)) {
return new FunctionAssertion(actual);
}
if (actual instanceof Error) {
return new ErrorAssertion(actual);
}
if (plugin?.insertAt === "bottom") {
return new plugin.Assertion(actual);
}
if (isStruct(actual)) {
return new ObjectAssertion(actual);
}
return new Assertion(actual);
}
export const expect: Expect = expectMatcher as Expect;