383 lines
12 KiB
JavaScript
383 lines
12 KiB
JavaScript
import assert from '../lib/assert.mjs'
|
|
import t from '../lib/eltro.mjs'
|
|
import { spy, stub } from '../index.mjs'
|
|
|
|
[spy, stub].forEach(function(tester, i) {
|
|
t.describe(`#${i === 0 ? 'spy' : 'stub'}()`, function() {
|
|
t.test('should support reset', function() {
|
|
let spyer = tester()
|
|
assert.strictEqual(spyer.callCount, 0)
|
|
assert.notOk(spyer.called)
|
|
assert.strictEqual(spyer.firstCall, null)
|
|
assert.strictEqual(spyer.secondCall, null)
|
|
assert.strictEqual(spyer.thirdCall, null)
|
|
assert.strictEqual(spyer.lastCall, null)
|
|
|
|
spyer(1)
|
|
spyer(2)
|
|
spyer(3)
|
|
spyer(4)
|
|
spyer(5)
|
|
|
|
assert.notStrictEqual(spyer.callCount, 0)
|
|
assert.ok(spyer.called)
|
|
assert.notStrictEqual(spyer.firstCall, null)
|
|
assert.notStrictEqual(spyer.secondCall, null)
|
|
assert.notStrictEqual(spyer.thirdCall, null)
|
|
assert.notStrictEqual(spyer.lastCall, null)
|
|
assert.strictEqual(spyer.lastCall[0], 5)
|
|
|
|
spyer.reset()
|
|
|
|
assert.strictEqual(spyer.callCount, 0)
|
|
assert.notOk(spyer.called)
|
|
assert.strictEqual(spyer.firstCall, null)
|
|
assert.strictEqual(spyer.secondCall, null)
|
|
assert.strictEqual(spyer.thirdCall, null)
|
|
assert.strictEqual(spyer.lastCall, null)
|
|
})
|
|
|
|
t.test('should keep track of call count', function() {
|
|
let spyer = tester()
|
|
assert.strictEqual(spyer.callCount, 0)
|
|
assert.notOk(spyer.called)
|
|
assert.strictEqual(spyer.firstCall, null)
|
|
assert.strictEqual(spyer.secondCall, null)
|
|
assert.strictEqual(spyer.thirdCall, null)
|
|
|
|
spyer()
|
|
assert.strictEqual(spyer.callCount, 1)
|
|
assert.ok(spyer.called)
|
|
assert.deepStrictEqual(spyer.firstCall, [])
|
|
assert.strictEqual(spyer.secondCall, null)
|
|
assert.strictEqual(spyer.thirdCall, null)
|
|
|
|
spyer()
|
|
assert.strictEqual(spyer.callCount, 2)
|
|
assert.ok(spyer.called)
|
|
assert.deepStrictEqual(spyer.firstCall, [])
|
|
assert.deepStrictEqual(spyer.secondCall, [])
|
|
assert.strictEqual(spyer.thirdCall, null)
|
|
|
|
spyer()
|
|
assert.strictEqual(spyer.callCount, 3)
|
|
assert.ok(spyer.called)
|
|
assert.deepStrictEqual(spyer.firstCall, [])
|
|
assert.deepStrictEqual(spyer.secondCall, [])
|
|
assert.deepStrictEqual(spyer.thirdCall, [])
|
|
|
|
spyer()
|
|
assert.strictEqual(spyer.callCount, 4)
|
|
})
|
|
|
|
t.test('should keep track of arguments used to call', function() {
|
|
const assertFirstArgs = 'asdf'
|
|
const assertSecondArgs = { a: 1 }
|
|
const assertThirdArgs = [{ b: 1 }, { c: 2 }]
|
|
let spyer = tester()
|
|
assert.notOk(spyer.called)
|
|
|
|
spyer(assertFirstArgs)
|
|
assert.strictEqual(spyer.lastCall[0], assertFirstArgs)
|
|
spyer(assertSecondArgs)
|
|
assert.strictEqual(spyer.lastCall[0], assertSecondArgs)
|
|
spyer(assertThirdArgs[0], assertThirdArgs[1])
|
|
assert.strictEqual(spyer.lastCall[0], assertThirdArgs[0])
|
|
assert.strictEqual(spyer.lastCall[1], assertThirdArgs[1])
|
|
assert.strictEqual(spyer.callCount, 3)
|
|
|
|
assert.strictEqual(spyer.getCall(0)[0], assertFirstArgs)
|
|
assert.strictEqual(spyer.getCall(1)[0], assertSecondArgs)
|
|
assert.strictEqual(spyer.getCall(2)[0], assertThirdArgs[0])
|
|
assert.strictEqual(spyer.getCall(2)[1], assertThirdArgs[1])
|
|
|
|
assert.strictEqual(spyer.firstCall[0], assertFirstArgs)
|
|
assert.strictEqual(spyer.secondCall[0], assertSecondArgs)
|
|
assert.strictEqual(spyer.thirdCall[0], assertThirdArgs[0])
|
|
assert.strictEqual(spyer.thirdCall[1], assertThirdArgs[1])
|
|
})
|
|
|
|
|
|
t.test('should support searching for a call', function() {
|
|
const assertFirstArgs = 'asdf'
|
|
const assertSecondArgs = { a: 1 }
|
|
const assertThirdArgs = [{ b: 1 }, { c: 2 }]
|
|
let spyer = tester()
|
|
assert.notOk(spyer.called)
|
|
|
|
spyer(assertFirstArgs)
|
|
spyer(assertSecondArgs)
|
|
spyer(assertThirdArgs[0], assertThirdArgs[1])
|
|
|
|
let call = spyer.findCall((args) => args[0] === assertSecondArgs)
|
|
assert.strictEqual(spyer.secondCall, call)
|
|
assert.strictEqual(call[0], assertSecondArgs)
|
|
|
|
call = spyer.findCall((args) => args[0].b === assertThirdArgs[0].b)
|
|
assert.strictEqual(spyer.thirdCall, call)
|
|
assert.strictEqual(call[0], assertThirdArgs[0])
|
|
assert.strictEqual(call[1], assertThirdArgs[1])
|
|
|
|
call = spyer.findCall((args) => typeof args[0] === 'string')
|
|
assert.strictEqual(spyer.firstCall, call)
|
|
assert.strictEqual(call[0], assertFirstArgs)
|
|
|
|
call = spyer.findCall(() => false)
|
|
assert.strictEqual(call, null)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('#stub()', function() {
|
|
t.test('should support returns', function() {
|
|
const assertInput = { a : 1 }
|
|
const assertReturns = { b: 3 }
|
|
let s = stub()
|
|
assert.strictEqual(s(), undefined)
|
|
s.returns(assertReturns)
|
|
assert.strictEqual(s(assertInput), assertReturns)
|
|
assert.ok(s.called)
|
|
assert.strictEqual(s.callCount, 2)
|
|
assert.strictEqual(s.secondCall[0], assertInput)
|
|
})
|
|
|
|
t.test('should support throws', function() {
|
|
const assertInput = { a : 1 }
|
|
const assertThrows = new Error('testety test')
|
|
let s = stub()
|
|
assert.strictEqual(s(), undefined)
|
|
s.throws(assertThrows)
|
|
assert.throws(function() {
|
|
s(assertInput)
|
|
}, assertThrows)
|
|
assert.ok(s.called)
|
|
assert.strictEqual(s.callCount, 2)
|
|
assert.strictEqual(s.secondCall[0], assertInput)
|
|
})
|
|
|
|
t.test('should support resolves', async function() {
|
|
const assertInput = { a : 1 }
|
|
const assertReturns = { b: 3 }
|
|
let s = stub()
|
|
assert.strictEqual(s(), undefined)
|
|
s.resolves(assertReturns)
|
|
let promiser = s(assertInput)
|
|
assert.ok(promiser.then)
|
|
assert.strictEqual(typeof(promiser.then), 'function')
|
|
let output = await promiser
|
|
assert.strictEqual(output, assertReturns)
|
|
})
|
|
|
|
t.test('should support rejects', async function() {
|
|
const assertInput = { a : 1 }
|
|
const assertReturns = { b: 3 }
|
|
let s = stub()
|
|
assert.strictEqual(s(), undefined)
|
|
s.rejects(assertReturns)
|
|
let promiser = s(assertInput)
|
|
assert.ok(promiser.then)
|
|
assert.strictEqual(typeof(promiser.then), 'function')
|
|
let output = await assert.isRejected(promiser)
|
|
assert.strictEqual(output, assertReturns)
|
|
})
|
|
|
|
t.test('should support custom function overwrite', async function() {
|
|
const assertInput = { a : 1 }
|
|
const assertReturns = { b: 3 }
|
|
let ourCallCount = 50
|
|
let s = stub(function(input) {
|
|
ourCallCount++
|
|
assert.strictEqual(input, assertInput)
|
|
return assertReturns
|
|
})
|
|
assert.strictEqual(s(assertInput), assertReturns)
|
|
assert.ok(s.called)
|
|
assert.strictEqual(s.callCount, 1)
|
|
assert.strictEqual(ourCallCount, 51)
|
|
assert.strictEqual(s.firstCall[0], assertInput)
|
|
|
|
assert.throws(function() {
|
|
s(null)
|
|
})
|
|
})
|
|
|
|
t.test('should support custom function overwrite after the fact', async function() {
|
|
const assertInput = { a : 1 }
|
|
const assertReturns = { b: 3 }
|
|
let ourCallCount = 0
|
|
let s = stub()
|
|
assert.strictEqual(s(null), undefined)
|
|
s.returnWith(function(input) {
|
|
ourCallCount++
|
|
assert.strictEqual(input, assertInput)
|
|
return assertReturns
|
|
})
|
|
assert.strictEqual(s(assertInput), assertReturns)
|
|
assert.ok(s.called)
|
|
assert.strictEqual(s.callCount, 2)
|
|
assert.strictEqual(ourCallCount, 1)
|
|
assert.strictEqual(s.secondCall[0], assertInput)
|
|
|
|
assert.throws(function() {
|
|
s(null)
|
|
})
|
|
})
|
|
|
|
t.test('should throw if parameter is something else than a function', function() {
|
|
assert.ok(stub(null))
|
|
assert.ok(stub(0))
|
|
assert.ok(stub(''))
|
|
assert.strictEqual(stub(null)(), undefined)
|
|
assert.strictEqual(stub(0)(), undefined)
|
|
assert.strictEqual(stub('')(), undefined)
|
|
assert.throws(function() { stub([]) })
|
|
assert.throws(function() { stub({}) })
|
|
assert.throws(function() { stub(123) })
|
|
assert.throws(function() { stub('asdf') })
|
|
})
|
|
|
|
t.test('should throw if returnWith is called with something else than a function', function() {
|
|
assert.throws(function() { stub().returnWith(0) })
|
|
assert.throws(function() { stub().returnWith('') })
|
|
assert.throws(function() { stub().returnWith(null) })
|
|
assert.throws(function() { stub().returnWith([]) })
|
|
assert.throws(function() { stub().returnWith({}) })
|
|
assert.throws(function() { stub().returnWith(123) })
|
|
assert.throws(function() { stub().returnWith('asdf') })
|
|
})
|
|
|
|
t.test('should support reset on returning', function() {
|
|
let s = stub()
|
|
assert.strictEqual(s.callCount, 0)
|
|
assert.notOk(s.called)
|
|
assert.strictEqual(s.firstCall, null)
|
|
assert.strictEqual(s.secondCall, null)
|
|
assert.strictEqual(s.thirdCall, null)
|
|
|
|
assert.strictEqual(s(), undefined)
|
|
|
|
s.returns('test')
|
|
|
|
assert.strictEqual(s(1), 'test')
|
|
assert.strictEqual(s(2), 'test')
|
|
assert.strictEqual(s(3), 'test')
|
|
assert.strictEqual(s(4), 'test')
|
|
assert.strictEqual(s(5), 'test')
|
|
assert.strictEqual(s.lastCall[0], 5)
|
|
|
|
assert.notStrictEqual(s.callCount, 0)
|
|
assert.ok(s.called)
|
|
assert.notStrictEqual(s.firstCall, null)
|
|
assert.notStrictEqual(s.secondCall, null)
|
|
assert.notStrictEqual(s.thirdCall, null)
|
|
|
|
s.reset()
|
|
|
|
assert.strictEqual(s.callCount, 0)
|
|
assert.notOk(s.called)
|
|
assert.strictEqual(s.firstCall, null)
|
|
assert.strictEqual(s.secondCall, null)
|
|
assert.strictEqual(s.thirdCall, null)
|
|
assert.strictEqual(s(), undefined)
|
|
|
|
s.returnWith(function() { return 'yes' })
|
|
assert.strictEqual(s(), 'yes')
|
|
s.reset()
|
|
assert.strictEqual(s(), undefined)
|
|
})
|
|
|
|
t.test('reset should default though to constructor returner', function() {
|
|
let s = stub(function() { return 'success' })
|
|
assert.strictEqual(s.callCount, 0)
|
|
assert.notOk(s.called)
|
|
assert.strictEqual(s.firstCall, null)
|
|
assert.strictEqual(s.secondCall, null)
|
|
assert.strictEqual(s.thirdCall, null)
|
|
|
|
assert.strictEqual(s(), 'success')
|
|
|
|
s.returns('test')
|
|
|
|
assert.strictEqual(s(1), 'test')
|
|
assert.strictEqual(s(2), 'test')
|
|
assert.strictEqual(s(3), 'test')
|
|
assert.strictEqual(s(4), 'test')
|
|
assert.strictEqual(s(5), 'test')
|
|
|
|
assert.notStrictEqual(s.callCount, 0)
|
|
assert.ok(s.called)
|
|
assert.notStrictEqual(s.firstCall, null)
|
|
assert.notStrictEqual(s.secondCall, null)
|
|
assert.notStrictEqual(s.thirdCall, null)
|
|
|
|
s.reset()
|
|
|
|
assert.strictEqual(s.callCount, 0)
|
|
assert.notOk(s.called)
|
|
assert.strictEqual(s.firstCall, null)
|
|
assert.strictEqual(s.secondCall, null)
|
|
assert.strictEqual(s.thirdCall, null)
|
|
assert.strictEqual(s(), 'success')
|
|
|
|
s.returnWith(function() { return 'yes' })
|
|
assert.strictEqual(s(), 'yes')
|
|
s.reset()
|
|
assert.strictEqual(s(), 'success')
|
|
})
|
|
|
|
t.test('should support chaining', function() {
|
|
let s = stub()
|
|
|
|
s.reset()
|
|
.returnWith(function() {})
|
|
.resolves(null)
|
|
.rejects(null)
|
|
.throws(null)
|
|
.returns(null)
|
|
.reset()
|
|
})
|
|
|
|
t.test('onCall should throw if not a number', function() {
|
|
let s = stub()
|
|
assert.throws(function() { s.onCall(undefined) })
|
|
assert.throws(function() { s.onCall([]) })
|
|
assert.throws(function() { s.onCall({}) })
|
|
assert.throws(function() { s.onCall('') })
|
|
assert.throws(function() { s.onCall('asdf') })
|
|
})
|
|
|
|
t.test('should support arbitrary call returns', function() {
|
|
let s = stub()
|
|
s.onCall(0).returns(1)
|
|
.onCall(1).returns(2)
|
|
|
|
assert.strictEqual(s(), 1)
|
|
assert.strictEqual(s(), 2)
|
|
|
|
s.reset()
|
|
assert.strictEqual(s(), undefined)
|
|
assert.strictEqual(s(), undefined)
|
|
})
|
|
|
|
t.test('should send propert arguments in defined calls', function() {
|
|
const assertInput = { a : 1 }
|
|
const assertReturns = { b: 3 }
|
|
let ourCallCount = 0
|
|
let s = stub()
|
|
s.onCall(3).returnWith(function(input) {
|
|
ourCallCount++
|
|
assert.strictEqual(input, assertInput)
|
|
return assertReturns
|
|
})
|
|
assert.strictEqual(s(null), undefined)
|
|
assert.strictEqual(s(null), undefined)
|
|
assert.strictEqual(s(null), undefined)
|
|
assert.strictEqual(s(assertInput), assertReturns)
|
|
assert.ok(s.called)
|
|
assert.strictEqual(s.callCount, 4)
|
|
assert.strictEqual(ourCallCount, 1)
|
|
assert.strictEqual(s.getCall(3)[0], assertInput)
|
|
assert.strictEqual(s(null), undefined)
|
|
})
|
|
})
|