modules/TestUtils.js
import isRegExp from 'is-regex'
import whyNotStrictlyEqual from 'is-equal/why'
import objectKeys from 'object-keys'
/**
* Returns the reason why the given arguments are not *conceptually*
* equal, if any; the empty string otherwise.
*/
export const whyNotEqual = (a, b) =>
(a == b ? '' : whyNotStrictlyEqual(a, b)) // eslint-disable-line eqeqeq
/**
* Returns true if the given arguments are *conceptually* equal.
*/
export const isEqual = (a, b) =>
whyNotEqual(a, b) === ''
/**
* Returns true if the given object is a function.
*/
export const isFunction = (object) =>
typeof object === 'function'
/**
* Returns true if the given object is an array.
*/
export const isArray = (object) =>
Array.isArray(object)
/**
* Returns true if the given object is an object.
*/
export const isObject = (object) =>
object && !isArray(object) && typeof object === 'object'
/**
* Returns true if the given object is an instanceof value
* or its typeof is the given value.
*/
export const isA = (object, value) => {
if (isFunction(value))
return object instanceof value
if (value === 'array')
return Array.isArray(object)
return typeof object === value
}
/**
* Returns true if the given function throws the given value
* when invoked. The value may be:
*
* - undefined, to merely assert there was a throw
* - a constructor function, for comparing using instanceof
* - a regular expression, to compare with the error message
* - a string, to find in the error message
*/
export const functionThrows = (fn, context, args, value) => {
try {
fn.apply(context, args)
} catch (error) {
if (value == null)
return true
if (isFunction(value) && error instanceof value)
return true
const message = error.message || error
if (typeof message === 'string') {
if (isRegExp(value) && value.test(error.message))
return true
if (typeof value === 'string' && message.indexOf(value) !== -1)
return true
}
}
return false
}
/**
* Returns true if the given array contains the value, false
* otherwise. The compareValues function must return false to
* indicate a non-match.
*/
export const arrayContains = (array, value, compareValues) =>
array.some(item => compareValues(item, value) !== false)
const ownEnumerableKeys = (object) => {
if (typeof Reflect === 'object' && typeof Reflect.ownKeys === 'function') {
return Reflect.ownKeys(object)
.filter(key => Object.getOwnPropertyDescriptor(object, key).enumerable)
}
if (typeof Object.getOwnPropertySymbols === 'function') {
return Object.getOwnPropertySymbols(object)
.filter(key => Object.getOwnPropertyDescriptor(object, key).enumerable)
.concat(objectKeys(object))
}
return objectKeys(object)
}
/**
* Returns true if the given object contains the value, false
* otherwise. The compareValues function must return false to
* indicate a non-match.
*/
export const objectContains = (object, value, compareValues) =>
ownEnumerableKeys(value).every(k => {
if (isObject(object[k]) && isObject(value[k]))
return objectContains(object[k], value[k], compareValues)
return compareValues(object[k], value[k])
})
/**
* Returns true if the given string contains the value, false otherwise.
*/
export const stringContains = (string, value) =>
string.indexOf(value) !== -1