/
set.ts
119 lines (102 loc) · 3.27 KB
/
set.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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
import isEqual = require('lodash.isequal');
import hasItems from '../utils/has-items';
import ofType from '../utils/of-type';
import {Predicate, PredicateOptions} from './predicate';
export class SetPredicate<T = any> extends Predicate<Set<T>> {
/**
@hidden
*/
constructor(options?: PredicateOptions) {
super('Set', options);
}
/**
Test a Set to have a specific size.
@param size - The size of the Set.
*/
size(size: number) {
return this.addValidator({
message: (set, label) => `Expected ${label} to have size \`${size}\`, got \`${set.size}\``,
validator: set => set.size === size
});
}
/**
Test a Set to have a minimum size.
@param size - The minimum size of the Set.
*/
minSize(size: number) {
return this.addValidator({
message: (set, label) => `Expected ${label} to have a minimum size of \`${size}\`, got \`${set.size}\``,
validator: set => set.size >= size,
negatedMessage: (set, label) => `Expected ${label} to have a maximum size of \`${size - 1}\`, got \`${set.size}\``
});
}
/**
Test a Set to have a maximum size.
@param size - The maximum size of the Set.
*/
maxSize(size: number) {
return this.addValidator({
message: (set, label) => `Expected ${label} to have a maximum size of \`${size}\`, got \`${set.size}\``,
validator: set => set.size <= size,
negatedMessage: (set, label) => `Expected ${label} to have a minimum size of \`${size + 1}\`, got \`${set.size}\``
});
}
/**
Test a Set to include all the provided items. The items are tested by identity, not structure.
@param items - The items that should be a item in the Set.
*/
has(...items: readonly T[]) {
return this.addValidator({
message: (_, label, missingItems) => `Expected ${label} to have items \`${JSON.stringify(missingItems)}\``,
validator: set => hasItems(set, items)
});
}
/**
Test a Set to include any of the provided items. The items are tested by identity, not structure.
@param items - The items that could be a item in the Set.
*/
hasAny(...items: readonly T[]) {
return this.addValidator({
message: (_, label) => `Expected ${label} to have any item of \`${JSON.stringify(items)}\``,
validator: set => items.some(item => set.has(item))
});
}
/**
Test all the items in the Set to match the provided predicate.
@param predicate - The predicate that should be applied against every item in the Set.
*/
ofType(predicate: Predicate<T>) {
return this.addValidator({
message: (_, label, error) => `(${label}) ${error}`,
validator: set => ofType(set, predicate)
});
}
/**
Test a Set to be empty.
*/
get empty() {
return this.addValidator({
message: (set, label) => `Expected ${label} to be empty, got \`${JSON.stringify([...set])}\``,
validator: set => set.size === 0
});
}
/**
Test a Set to be not empty.
*/
get nonEmpty() {
return this.addValidator({
message: (_, label) => `Expected ${label} to not be empty`,
validator: set => set.size > 0
});
}
/**
Test a Set to be deeply equal to the provided Set.
@param expected - Expected Set to match.
*/
deepEqual(expected: Set<T>) {
return this.addValidator({
message: (set, label) => `Expected ${label} to be deeply equal to \`${JSON.stringify([...expected])}\`, got \`${JSON.stringify([...set])}\``,
validator: set => isEqual(set, expected)
});
}
}