-
Notifications
You must be signed in to change notification settings - Fork 0
/
check.js
122 lines (114 loc) · 3.31 KB
/
check.js
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
120
121
122
'use strict'
var should = require('should'),
ObjectID = require('mongodb').ObjectID,
types = [String, Number, Boolean, Object, Array, Date, RegExp, ObjectID]
/**
* @param {*} actual
* @param {*} expected
* @param {boolean} strict
* @param {boolean} forceJSON call toJSON if available
* @param {string[]} [ignoredKeys=[]] only used if strict is true and only useful in the root level
* @param {string} [path] used internally
* @throws if invalid. The exception has a 'path' field with the path name that caused the error
*/
module.exports = function (actual, expected, strict, forceJSON, ignoredKeys, path) {
var key, subpath
try {
// Call toJSON() if present
if (forceJSON) {
if (actual !== null &&
actual !== undefined &&
typeof actual.toJSON === 'function') {
actual = actual.toJSON()
}
if (expected !== null &&
expected !== undefined &&
typeof expected.toJSON === 'function') {
expected = expected.toJSON()
}
}
if (types.indexOf(expected) !== -1) {
// Simple type check
should(actual).be.instanceof(expected)
} else if (Array.isArray(expected)) {
// Check every array element
should(actual).be.an.Array()
if (strict) {
should(actual).have.length(expected.length)
} else {
should(actual).have.property('length').above(expected.length - 1)
}
checkArray(actual, expected, expected.isUnordered, strict, forceJSON, ignoredKeys, path)
} else if (expected &&
typeof expected === 'object' &&
(expected.constructor === Object || Object.getPrototypeOf(expected) === null)) {
// Hash map
should(actual).be.an.Object()
for (key in expected) {
if (typeof expected[key] === 'function' && types.indexOf(expected[key]) === -1) {
// Skip functions, like toJSON
continue
}
should(actual).have.property(key)
subpath = path ? path + '.' + key : key
module.exports(actual[key], expected[key], strict, forceJSON, [], subpath)
}
if (strict) {
ignoredKeys = ignoredKeys || []
for (key in actual) {
if (ignoredKeys.indexOf(key) === -1) {
should(expected).have.property(key)
}
}
}
} else {
// Simple value check
should(actual).match(expected)
}
} catch (e) {
if (!e.path) {
e.path = path
}
throw e
}
}
/**
* @param {Array} actual
* @param {Array} expected
* @param {boolean} isUnordered
* @param {boolean} strict
* @param {boolean} forceJSON
* @param {Array<string>} ignoredKeys
* @param {string} path
* @throws if invalid. The exception has a 'path' field with the path name that caused the error
*/
function checkArray(actual, expected, isUnordered, strict, forceJSON, ignoredKeys, path) {
if (!isUnordered) {
// Simple case: compare expected[i] with actual[i]
expected.forEach(function (each, i) {
module.exports(actual[i], each, strict, forceJSON, [], path ? path + '.' + i : i)
})
return
}
var visited = actual.map(function () {
return false
})
expected.forEach(function (eachExpected) {
var j
for (j = 0; j < actual.length; j++) {
if (visited[j]) {
continue
}
try {
module.exports(actual[j], eachExpected, strict, forceJSON, [], path ? path + '.' + j : j)
visited[j] = true
break
} catch (e) {
// Ignore these errors, we'll check next elements
}
}
if (j === actual.length) {
throw new Error('Unordered array mismatch')
}
})
}