558 lines
15 KiB
JavaScript
558 lines
15 KiB
JavaScript
/// <reference path="./eltro.d.ts"/>
|
|
import * as readline from 'readline'
|
|
import { runWithCallbackSafe } from './callback.mjs'
|
|
import { printError } from './cli.mjs'
|
|
|
|
function Group(e, name) {
|
|
this.e = e
|
|
this.name = name
|
|
this.hasExclusive = false
|
|
this.parent = null
|
|
this.groups = []
|
|
this.tests = []
|
|
this.customTimeout = null
|
|
this.skipTest = false
|
|
this.isExclusive = false
|
|
this.before = null
|
|
this.after = null
|
|
this.beforeEach = null
|
|
this.afterEach = null
|
|
}
|
|
|
|
Group.prototype.timeout = function(time) {
|
|
this.customTimeout = time
|
|
}
|
|
|
|
Group.prototype.skip = function() {
|
|
this.skipTest = true
|
|
}
|
|
|
|
Group.prototype.__hasonly = function(markHas) {
|
|
if (this.skipTest) return
|
|
|
|
// Set hasExclusive with either mark or existing value
|
|
// Some groups might have .only() but that doesn't mean
|
|
// the children have .only() buut they should still be run
|
|
this.hasExclusive = this.hasExclusive || markHas
|
|
|
|
// Travel upwards to the root mark all the groups along the way
|
|
let g = this.parent
|
|
while (g) {
|
|
// If the parent has skipped marked, we definitely don't wanna
|
|
// mark that we have tests with exclusivity on.
|
|
if (g.skipTest) return
|
|
|
|
g.hasExclusive = true
|
|
g = g.parent
|
|
}
|
|
|
|
this.e.hasExclusive = true
|
|
}
|
|
|
|
Group.prototype.only = function() {
|
|
this.isExclusive = true
|
|
this.__hasonly(false)
|
|
}
|
|
|
|
function Test(e, group, name, func) {
|
|
this.e = e
|
|
this.group = group
|
|
this.skipTest = false
|
|
this.isExclusive = false
|
|
this.customTimeout = null
|
|
this.isBasic = false
|
|
this.name = name
|
|
this.func = func
|
|
this.error = null
|
|
this.startTime = null
|
|
this.totalTime = 0
|
|
}
|
|
|
|
Test.prototype.calculateTime = function() {
|
|
let end = process.hrtime(this.startTime)
|
|
this.totalTime = (end[0] * 1000 + Math.round(end[1] / 1000000))
|
|
}
|
|
|
|
Test.prototype.timeout = function(time) {
|
|
this.customTimeout = time
|
|
}
|
|
|
|
Test.prototype.skip = function() {
|
|
this.skipTest = true
|
|
}
|
|
|
|
Test.prototype.only = function() {
|
|
if (!this.e.ignoreOnly) {
|
|
this.isExclusive = true
|
|
this.group.__hasonly(true)
|
|
}
|
|
}
|
|
|
|
Test.prototype.clone = function(prefix = '') {
|
|
var t = new Test(this.e, this.group, prefix + this.name, this.func)
|
|
let properties = ['skipTest', 'isExclusive', 'customTimeout', 'isBasic', 'error']
|
|
for (let key of properties) {
|
|
t[key] = this[key]
|
|
}
|
|
return t
|
|
}
|
|
|
|
let stack = []
|
|
function captureUnknownErrors(e) {
|
|
stack.push(e)
|
|
}
|
|
function cancelCaptureUnknown(e) {
|
|
stack.splice(stack.indexOf(e), 1)
|
|
}
|
|
|
|
process.on('uncaughtException', function(err) {
|
|
for (let i = stack.length - 1; i >= 0; i--) {
|
|
if (stack[i].captureOutsideExceptions) {
|
|
stack[i].captureOutsideExceptions(err)
|
|
return
|
|
}
|
|
}
|
|
console.error('-- UNCAUGHT EXCPEPTION OUTSIDE OF TEST RUNNER --')
|
|
console.error(err)
|
|
})
|
|
|
|
function Eltro() {
|
|
this.__timeout = 2000
|
|
this.hasExclusive = false
|
|
this.reporter = 'list'
|
|
this.Eltro = Eltro
|
|
this.fileGroupMap = new Map()
|
|
this.groups = []
|
|
this.activeGroup = null
|
|
this.failedTests = []
|
|
this.hasTests = false
|
|
this.starting = null
|
|
this.ignoreOnly = false
|
|
this.logger = null
|
|
this.filename = ''
|
|
this.prefix = ''
|
|
this.temporary = {
|
|
timeout: 0,
|
|
skip: false,
|
|
only: false
|
|
}
|
|
this.describeTemporary = {
|
|
timeout: 0,
|
|
skip: false,
|
|
only: false
|
|
}
|
|
this.captureOutsideExceptions = null
|
|
}
|
|
|
|
Eltro.prototype.begin = function() {
|
|
if (this.starting) {
|
|
console.warn('WARNING: Multiple calls to Eltro.begin were done.')
|
|
console.warn(this.starting)
|
|
console.warn(new Error('Second call'))
|
|
return
|
|
}
|
|
this.hasTests = false
|
|
this.starting = new Error('First call')
|
|
this.filename = ''
|
|
this.prefix = ''
|
|
this.fileGroupMap.clear()
|
|
}
|
|
|
|
Eltro.prototype.__runTest = async function(stats, test, prefix = 'Test', child = null) {
|
|
if (this.reporter === 'list') {
|
|
process.stdout.write(' \x1b[90m? ' + test.name + '\x1b[0m')
|
|
}
|
|
|
|
let markRealTest = child || test
|
|
|
|
if (!test.skipTest) {
|
|
let err = await new Promise((resolve, reject) => {
|
|
if (test.error) {
|
|
return reject(test.error)
|
|
}
|
|
if (!test.func) {
|
|
return reject(new Error(`Test ${test.name} was missing function`))
|
|
}
|
|
this.captureOutsideExceptions = reject
|
|
// Flag to check if we finished
|
|
let finished = false
|
|
let timeout = test.customTimeout || this.__timeout
|
|
|
|
// Timeout timer in case test times out
|
|
let timer = setTimeout(function() {
|
|
if (finished === true) return
|
|
|
|
test.calculateTime()
|
|
reject(new Error('timeout of ' + timeout + 'ms exceeded. Ensure the done() callback is being called in this test.'))
|
|
}, timeout)
|
|
|
|
// start the test runner
|
|
try {
|
|
// Does it accept a callback
|
|
let checkIsCallback = (test.func.toString()).match(/^(function)? *\([^\)]+\)/)
|
|
let promise
|
|
|
|
test.startTime = process.hrtime()
|
|
// If the test requires callback, wrap it in a promise where callback
|
|
// either resolves or rejects that promise
|
|
if (checkIsCallback) {
|
|
promise = runWithCallbackSafe(test)
|
|
} else {
|
|
// Function doesn't require a callback, run it directly
|
|
promise = test.func()
|
|
}
|
|
|
|
// Check if the function we ran returned a promise
|
|
if (promise && promise.then && typeof(promise.then === 'function')) {
|
|
// If the promise from the function succeeded, resolve our promise.
|
|
// Otherwise reject it
|
|
promise.then(function() {
|
|
// check if our test had already finished and if so, do nothing
|
|
if (finished === true) return
|
|
|
|
test.calculateTime()
|
|
finished = true
|
|
clearTimeout(timer)
|
|
resolve()
|
|
}, function(err) {
|
|
// check if our test had already finished and if so, do nothing
|
|
if (finished === true) return
|
|
|
|
test.calculateTime()
|
|
finished = true
|
|
clearTimeout(timer)
|
|
reject(err)
|
|
})
|
|
} else {
|
|
// check if our test had already finished and if so, do nothing
|
|
if (finished === true) return
|
|
|
|
test.calculateTime()
|
|
// Possible this was a synchronous test, pass immediately
|
|
finished = true
|
|
clearTimeout(timer)
|
|
resolve()
|
|
}
|
|
} catch (err) {
|
|
// check if our test had already finished and if so, do nothing
|
|
if (finished === true) return
|
|
|
|
test.calculateTime()
|
|
// An error occured while running function. Possible exception
|
|
// during a synchronous test or something else.
|
|
finished = true
|
|
clearTimeout(timer)
|
|
reject(err)
|
|
}
|
|
})
|
|
.then(function() {
|
|
if (prefix === 'Test') {
|
|
stats.passed++
|
|
}
|
|
return null
|
|
}, (err) => {
|
|
let saveError = err
|
|
if (!saveError) {
|
|
saveError = new Error(prefix + ' promise rejected with empty message')
|
|
} else if (typeof(saveError) !== 'object' || saveError.message == null || saveError.stack == null) {
|
|
try {
|
|
saveError = new Error(prefix + ' promise rejected with ' + JSON.stringify(saveError))
|
|
} catch (parseError) {
|
|
saveError = new Error(prefix + ' promise rejected with ' + saveError + ' (Error stringifying: ' + parseError.message + ')')
|
|
}
|
|
saveError.originalError = err
|
|
}
|
|
return saveError
|
|
}
|
|
)
|
|
|
|
if (err) {
|
|
markRealTest.error = err
|
|
this.failedTests.push(markRealTest.clone(child ? prefix : ''))
|
|
|
|
stats.failed++
|
|
}
|
|
} else {
|
|
stats.skipped++
|
|
}
|
|
|
|
this.captureOutsideExceptions = null
|
|
|
|
if (this.reporter === 'list') {
|
|
readline.clearLine(process.stdout, 0)
|
|
readline.cursorTo(process.stdout, 0, null)
|
|
if (markRealTest.skipTest) {
|
|
process.stdout.write(' \x1b[94m- ' + markRealTest.name + '\x1b[0m\n')
|
|
} else if (!markRealTest.error) {
|
|
if (!test.name.startsWith('~')) {
|
|
process.stdout.write(' \x1b[32m√\x1b[90m ' + markRealTest.name + ' (' + markRealTest.totalTime + 'ms)\x1b[0m\n')
|
|
}
|
|
} else if (prefix === 'Test') {
|
|
process.stdout.write(' \x1b[31m' + this.failedTests.length + ') ' + markRealTest.name + ' (' + markRealTest.totalTime + 'ms)\x1b[0m\n')
|
|
}
|
|
} else if (this.reporter === 'dot') {
|
|
if (markRealTest.skipTest) {
|
|
process.stdout.write('\x1b[94m.\x1b[0m')
|
|
} else if (!markRealTest.error) {
|
|
process.stdout.write('\x1b[32m.\x1b[0m')
|
|
} else if (prefix === 'Test') {
|
|
process.stdout.write('\x1b[31m.\x1b[0m')
|
|
}
|
|
}
|
|
}
|
|
|
|
Eltro.prototype.__runGroup = async function(g, stats) {
|
|
if (g.tests.length) {
|
|
if (this.reporter === 'list') {
|
|
console.log(' ' + g.name)
|
|
}
|
|
}
|
|
if (g.before) {
|
|
for (let i = 0; i < g.before.length; i++) {
|
|
await this.__runTest(stats, g.before[i], 'Before')
|
|
if (g.before[i].error) return
|
|
}
|
|
}
|
|
for (let x = 0; x < g.tests.length; x++) {
|
|
if (!g.tests[x].skipTest && g.tests[x].isExclusive === g.hasExclusive) {
|
|
if (g.beforeEach) {
|
|
for (let i = 0; i < g.beforeEach.length && !g.tests[x].error; i++) {
|
|
await this.__runTest(stats, g.beforeEach[i], 'Before each: ', g.tests[x])
|
|
}
|
|
if (!g.tests[x].error) {
|
|
await this.__runTest(stats, g.tests[x])
|
|
}
|
|
} else {
|
|
await this.__runTest(stats, g.tests[x])
|
|
}
|
|
if (g.afterEach) {
|
|
let oldError = g.tests[x].error
|
|
g.tests[x].error = null
|
|
for (let i = 0; i < g.afterEach.length && !g.tests[x].error; i++) {
|
|
await this.__runTest(stats, g.afterEach[i], 'After each: ', g.tests[x])
|
|
}
|
|
if (oldError) {
|
|
g.tests[x].error = oldError
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (let x = 0; x < g.groups.length; x++) {
|
|
if (!g.groups[x].skipTest && g.hasExclusive === (g.groups[x].hasExclusive || g.groups[x].isExclusive)) {
|
|
await this.__runGroup(g.groups[x], stats)
|
|
}
|
|
}
|
|
if (g.after) {
|
|
for (let i = 0; i < g.after.length && !g.after.error; i++) {
|
|
await this.__runTest(stats, g.after[i], 'After')
|
|
}
|
|
}
|
|
}
|
|
|
|
Eltro.prototype.run = async function() {
|
|
if (this.reporter && this.reporter !== 'test') {
|
|
console.log('')
|
|
console.log('')
|
|
}
|
|
|
|
captureUnknownErrors(this)
|
|
|
|
let stats = {
|
|
passed: 0,
|
|
failed: 0,
|
|
skipped: 0,
|
|
}
|
|
|
|
let start = process.hrtime()
|
|
for (let i = 0; i < this.groups.length; i++) {
|
|
if (!this.groups[i].skipTest && this.hasExclusive === (this.groups[i].hasExclusive || this.groups[i].isExclusive)) {
|
|
await this.__runGroup(this.groups[i], stats)
|
|
}
|
|
}
|
|
let end = process.hrtime(start)
|
|
|
|
cancelCaptureUnknown(this)
|
|
|
|
if (this.reporter === 'test') {
|
|
if (this.logger && this.logger.log) {
|
|
for (let x = 0; x < this.failedTests.length; x++) {
|
|
let test = this.failedTests[x];
|
|
this.logger.log(test.name, test.error)
|
|
}
|
|
}
|
|
} else if (this.reporter) {
|
|
console.log('')
|
|
console.log('')
|
|
if (stats.passed) {
|
|
console.log(' \x1b[32m' + stats.passed + ' passing \x1b[90m(' + (end[0] * 1000 + Math.round(end[1] / 1000000)) + 'ms)\x1b[0m')
|
|
}
|
|
if (stats.failed) {
|
|
console.log(' \x1b[31m' + stats.failed + ' failing\x1b[0m')
|
|
}
|
|
if (stats.skipped) {
|
|
console.log(' \x1b[94m' + stats.skipped + ' pending\x1b[0m')
|
|
}
|
|
console.log('')
|
|
|
|
if (this.failedTests.length) {
|
|
for (let x = 0; x < this.failedTests.length; x++) {
|
|
let test = this.failedTests[x];
|
|
console.log(' ' + (x + 1) + ') ' + test.name + ':')
|
|
printError(test.error)
|
|
}
|
|
}
|
|
}
|
|
return stats
|
|
}
|
|
|
|
Eltro.prototype.setFilename = function(filename) {
|
|
if (!this.fileGroupMap.has(filename)) {
|
|
let g = new Group(this, filename + ':')
|
|
this.groups.push(g)
|
|
this.fileGroupMap.set(filename, g)
|
|
}
|
|
this.activeGroup = this.fileGroupMap.get(filename)
|
|
}
|
|
|
|
Eltro.prototype.resetFilename = function() {
|
|
this.activeGroup = null
|
|
}
|
|
|
|
let beforesandafters = [
|
|
['before', '~Before', false],
|
|
['after', '~After', false],
|
|
['beforeEach', '~Before each', true],
|
|
['afterEach', '~After each', true],
|
|
]
|
|
|
|
beforesandafters.forEach(function(item) {
|
|
let beforeAfter = item[0]
|
|
let fullName = item[1]
|
|
let bringToChildren = item[2]
|
|
|
|
Eltro.prototype[beforeAfter] = function(func) {
|
|
if (!this.activeGroup) {
|
|
throw new Error('Tests outside groups are not allowed.')
|
|
}
|
|
|
|
let test = func
|
|
|
|
if (!(test instanceof Test)) {
|
|
test = new Test(this, this.activeGroup, fullName + ': ' + this.activeGroup.name, func)
|
|
}
|
|
|
|
if (this.temporary.timeout || this.activeGroup.customTimeout) {
|
|
test.timeout(this.temporary.timeout || this.activeGroup.customTimeout)
|
|
this.temporary.timeout = 0
|
|
}
|
|
|
|
this.activeGroup[beforeAfter] = this.activeGroup[beforeAfter] || []
|
|
this.activeGroup[beforeAfter].push(test)
|
|
|
|
if (bringToChildren) {
|
|
for (let group of this.activeGroup.groups) {
|
|
group[beforeAfter].push(test)
|
|
}
|
|
}
|
|
|
|
return test
|
|
}
|
|
})
|
|
|
|
let bringToChildren = ['beforeEach', 'afterEach']
|
|
|
|
Eltro.prototype.describe = function(name, func) {
|
|
let before = this.activeGroup
|
|
|
|
let prefix = before ? before.name + ' ' : ''
|
|
|
|
this.activeGroup = new Group(this, prefix + name)
|
|
|
|
if (before) {
|
|
before.groups.push(this.activeGroup)
|
|
this.activeGroup.parent = before
|
|
this.activeGroup.customTimeout = before.customTimeout
|
|
} else {
|
|
this.groups.push(this.activeGroup)
|
|
}
|
|
|
|
if (this.temporary.timeout) {
|
|
this.activeGroup.timeout(this.temporary.timeout)
|
|
this.temporary.timeout = 0
|
|
}
|
|
if (this.temporary.skip) {
|
|
this.activeGroup.skip()
|
|
this.temporary.skip = false
|
|
}
|
|
if (this.temporary.only) {
|
|
this.activeGroup.only()
|
|
this.temporary.only = false
|
|
}
|
|
|
|
if (before) {
|
|
for (let beforeAfter of bringToChildren) {
|
|
if (!before[beforeAfter]) continue
|
|
|
|
for (let test of before[beforeAfter]) {
|
|
this[beforeAfter](test)
|
|
}
|
|
}
|
|
}
|
|
|
|
func()
|
|
|
|
this.activeGroup = before
|
|
}
|
|
|
|
Eltro.prototype.timeout = function(time) {
|
|
this.temporary.timeout = time
|
|
return this
|
|
}
|
|
|
|
Eltro.prototype.skip = function() {
|
|
this.temporary.skip = true
|
|
return this
|
|
}
|
|
|
|
Eltro.prototype.only = function() {
|
|
if (!this.ignoreOnly) {
|
|
this.temporary.only = true
|
|
}
|
|
return this
|
|
}
|
|
|
|
Eltro.prototype.test = function(name, func) {
|
|
if (!this.activeGroup) {
|
|
throw new Error('Tests outside groups are not allowed.')
|
|
}
|
|
|
|
let test = new Test(
|
|
this,
|
|
this.activeGroup,
|
|
[this.activeGroup.name.trim(), (name || '').trim()].filter(x => x).join(' '),
|
|
func
|
|
)
|
|
this.activeGroup.tests.push(test)
|
|
|
|
if (name == null) {
|
|
test.error = new Error(`An empty test or missing name under ${this.activeGroup.name.trim()} was found`)
|
|
}
|
|
|
|
if (this.temporary.only && !this.temporary.skip) {
|
|
test.only()
|
|
this.temporary.only = false
|
|
} else if (this.temporary.only) {
|
|
this.temporary.only = false
|
|
}
|
|
if (this.temporary.skip) {
|
|
test.skip()
|
|
this.temporary.skip = false
|
|
}
|
|
if (this.temporary.timeout || this.activeGroup.customTimeout) {
|
|
test.timeout(this.temporary.timeout || this.activeGroup.customTimeout)
|
|
this.temporary.timeout = 0
|
|
}
|
|
return test
|
|
}
|
|
|
|
export default new Eltro()
|