mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-23 12:56:46 +08:00
1025 lines
30 KiB
TypeScript
1025 lines
30 KiB
TypeScript
/// <reference path="../mocha/mocha.d.ts"/>
|
|
/// <reference path="../node/node.d.ts"/>
|
|
/// <reference path="../bluebird/bluebird.d.ts"/>
|
|
|
|
/// <reference path="./simple-mock.d.ts"/>
|
|
|
|
'use strict'
|
|
|
|
import simple = require('simple-mock');
|
|
import assert = require('assert');
|
|
|
|
import Bluebird = require('bluebird');
|
|
|
|
// Following code is a TypeScript convertion of the test suite bundled with simple-mock.
|
|
// Original test in MIT license
|
|
|
|
describe('simple', function () {
|
|
describe('spy()', function () {
|
|
describe('for noop function', function () {
|
|
let spyFn: Simple.Spy<void>;
|
|
|
|
beforeEach(function () {
|
|
spyFn = simple.spy(function () {})
|
|
})
|
|
|
|
it('can be queried without having been called', function () {
|
|
assert.equal(spyFn.callCount, 0)
|
|
assert.deepEqual(spyFn.calls, [])
|
|
assert(spyFn.lastCall)
|
|
assert.deepEqual(spyFn.lastCall.args, [])
|
|
})
|
|
|
|
it('can be queried for arguments on a single call', function () {
|
|
let context = {
|
|
spyFn: spyFn
|
|
}
|
|
|
|
context.spyFn('with', 'args')
|
|
|
|
assert(spyFn.called)
|
|
assert.equal(spyFn.callCount, 1)
|
|
assert(spyFn.calls)
|
|
assert(spyFn.firstCall)
|
|
assert.equal(spyFn.firstCall, spyFn.lastCall)
|
|
assert.equal(spyFn.firstCall, spyFn.calls[0])
|
|
assert.deepEqual(spyFn.lastCall.args, ['with', 'args'])
|
|
assert.equal(spyFn.lastCall.context, context)
|
|
})
|
|
|
|
it('can be queried for arguments over multiple calls', function () {
|
|
let context = {
|
|
spyFn: spyFn
|
|
}
|
|
|
|
spyFn('with', 'args')
|
|
spyFn('and')
|
|
context.spyFn('more', 'args')
|
|
|
|
assert(spyFn.called)
|
|
assert.equal(spyFn.callCount, 3)
|
|
assert(spyFn.calls)
|
|
assert(spyFn.firstCall)
|
|
assert.equal(spyFn.firstCall, spyFn.calls[0])
|
|
assert.deepEqual(spyFn.firstCall.args, ['with', 'args'])
|
|
assert(spyFn.calls[1])
|
|
assert.deepEqual(spyFn.calls[1].args, ['and'])
|
|
assert(spyFn.lastCall)
|
|
assert.equal(spyFn.lastCall, spyFn.calls[2])
|
|
assert.deepEqual(spyFn.lastCall.args, ['more', 'args'])
|
|
assert.equal(spyFn.lastCall.context, context)
|
|
})
|
|
})
|
|
|
|
describe('for a throwing function', function () {
|
|
let originalFn: () => void;
|
|
let spyFn: Simple.Spy<void>;
|
|
beforeEach(function () {
|
|
let i = 0
|
|
|
|
originalFn = function () {
|
|
throw new Error(`${i++}`)
|
|
}
|
|
|
|
spyFn = simple.spy(originalFn)
|
|
})
|
|
|
|
it('can be queried without having been called', function () {
|
|
assert(!spyFn.called)
|
|
assert.equal(spyFn.callCount, 0)
|
|
assert.deepEqual(spyFn.calls, [])
|
|
assert(spyFn.lastCall)
|
|
assert.equal(spyFn.lastCall.threw, undefined)
|
|
})
|
|
|
|
it('can be queried for what it threw on a single call', function () {
|
|
let threw: Error;
|
|
try {
|
|
spyFn()
|
|
} catch (e) {
|
|
threw = e
|
|
}
|
|
|
|
assert(threw)
|
|
assert(spyFn.called)
|
|
assert.equal(spyFn.callCount, 1)
|
|
assert(spyFn.firstCall)
|
|
assert.equal(spyFn.firstCall.threw, threw)
|
|
})
|
|
|
|
it('can be queried for what it threw over multiple calls', function () {
|
|
let threw: Error[] = []
|
|
try {
|
|
spyFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
spyFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
spyFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
|
|
assert.equal(threw.length, 3)
|
|
assert(spyFn.called)
|
|
assert.equal(spyFn.callCount, 3)
|
|
assert(spyFn.firstCall)
|
|
assert.equal(spyFn.firstCall.threw, threw[0])
|
|
assert.equal(spyFn.calls[1].threw, threw[1])
|
|
assert.equal(spyFn.lastCall.threw, threw[2])
|
|
})
|
|
})
|
|
|
|
describe('for a returning function', function () {
|
|
let originalFn: () => number;
|
|
let spyFn: Simple.Spy<number>;
|
|
beforeEach(function () {
|
|
let i = 1
|
|
|
|
originalFn = () => {
|
|
return i++
|
|
}
|
|
|
|
spyFn = simple.spy(originalFn)
|
|
})
|
|
|
|
it('can be queried without having been called', function () {
|
|
assert(!spyFn.called)
|
|
assert.equal(spyFn.callCount, 0)
|
|
assert.deepEqual(spyFn.calls, [])
|
|
assert(spyFn.lastCall)
|
|
assert.equal(spyFn.lastCall.returned, undefined)
|
|
})
|
|
|
|
it('can be queried for what it threw on a single call', function () {
|
|
let returned: number
|
|
|
|
returned = spyFn()
|
|
|
|
assert(returned)
|
|
assert.equal(spyFn.callCount, 1)
|
|
assert(spyFn.firstCall)
|
|
assert.equal(spyFn.firstCall.returned, returned)
|
|
})
|
|
|
|
it('can be queried for what it threw over multiple calls', function () {
|
|
let returned: number[] = []
|
|
|
|
returned.push(spyFn())
|
|
returned.push(spyFn())
|
|
returned.push(spyFn())
|
|
|
|
assert.equal(returned.length, 3)
|
|
assert(spyFn.called)
|
|
assert.equal(spyFn.callCount, 3)
|
|
assert(spyFn.firstCall)
|
|
assert.equal(spyFn.firstCall.returned, returned[0])
|
|
assert.equal(spyFn.calls[1].returned, returned[1])
|
|
assert.equal(spyFn.lastCall.returned, returned[2])
|
|
})
|
|
})
|
|
|
|
describe('calls of multiple spies', function () {
|
|
it('can be compared to determine the order they were called in', function () {
|
|
let spy1 = simple.spy(function () {})
|
|
let spy2 = simple.spy(function () {})
|
|
let spy3 = simple.spy(function () {})
|
|
|
|
spy1()
|
|
spy3()
|
|
spy2()
|
|
spy1()
|
|
|
|
assert(spy1.lastCall.k > spy2.lastCall.k)
|
|
assert(spy1.lastCall.k > spy3.lastCall.k)
|
|
assert(spy2.lastCall.k > spy3.lastCall.k)
|
|
assert(spy3.lastCall.k > spy1.calls[0].k)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('stub()', function () {
|
|
describe('with no configuration', function () {
|
|
let stubFn: Simple.Stub<void>;
|
|
it('is also a spy', function () {
|
|
stubFn = simple.stub()
|
|
|
|
stubFn('etc')
|
|
assert(stubFn.called)
|
|
assert(stubFn.lastCall.args[0], 'etc')
|
|
})
|
|
})
|
|
|
|
describe('for a single callback configuration', function () {
|
|
let stubFn: Simple.Stub<void>;
|
|
describe('with default index', function () {
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().callbackWith(1, 2, 3)
|
|
})
|
|
|
|
it('can call back with arguments', function () {
|
|
stubFn('a', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(stubFn.lastCall.args[0], 'a')
|
|
assert.equal(arguments.length, 3)
|
|
assert.equal(arguments[0], 1)
|
|
assert.equal(arguments[1], 2)
|
|
assert.equal(arguments[2], 3)
|
|
})
|
|
})
|
|
|
|
it('can call back with arguments, over multiple calls', function () {
|
|
stubFn('a', function () {})
|
|
stubFn('b', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 2)
|
|
assert.equal(stubFn.lastCall.args[0], 'b')
|
|
assert.equal(arguments.length, 3)
|
|
assert.equal(arguments[0], 1)
|
|
assert.equal(arguments[1], 2)
|
|
assert.equal(arguments[2], 3)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('with specified index', function () {
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().callbackArgWith(1, 2, 3)
|
|
})
|
|
|
|
it('can call back with arguments', function () {
|
|
stubFn('a', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(stubFn.lastCall.args[0], 'a')
|
|
assert.equal(arguments.length, 2)
|
|
assert.equal(arguments[0], 2)
|
|
assert.equal(arguments[1], 3)
|
|
})
|
|
})
|
|
|
|
it('can call back with arguments, over multiple calls', function () {
|
|
stubFn('a', function () {})
|
|
stubFn('b', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 2)
|
|
assert.equal(stubFn.lastCall.args[0], 'b')
|
|
assert.equal(arguments.length, 2)
|
|
assert.equal(arguments[0], 2)
|
|
assert.equal(arguments[1], 3)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('with context specified', function () {
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().callback().inThisContext({ a: 'a' })
|
|
})
|
|
|
|
it('should do what...', function (done) {
|
|
stubFn(function () {
|
|
assert.equal(this.a, 'a')
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('for a multiple callback configurations', function () {
|
|
let stubFn: Simple.Stub<void>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().callbackWith(1).callbackWith(2).callbackWith(3)
|
|
})
|
|
|
|
it('can call back once with arguments', function () {
|
|
stubFn('a', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(stubFn.lastCall.args[0], 'a')
|
|
assert.equal(arguments[0], 1)
|
|
})
|
|
})
|
|
|
|
it('can call back with arguments, over multiple calls, looping per default', function () {
|
|
stubFn('a', function () {})
|
|
stubFn('b', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 2)
|
|
assert.equal(stubFn.lastCall.args[0], 'b')
|
|
assert.equal(arguments[0], 2)
|
|
})
|
|
stubFn('c', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 3)
|
|
assert.equal(stubFn.lastCall.args[0], 'c')
|
|
assert.equal(arguments[0], 3)
|
|
})
|
|
stubFn('d', function () {
|
|
assert.equal(stubFn.callCount, 4)
|
|
assert.equal(stubFn.lastCall.args[0], 'd')
|
|
assert.equal(arguments[0], 1)
|
|
})
|
|
})
|
|
|
|
it('can call back with arguments, over multiple calls, looping turned off', function () {
|
|
stubFn.loop = false
|
|
stubFn('a', function () {})
|
|
stubFn('b', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 2)
|
|
assert.equal(stubFn.lastCall.args[0], 'b')
|
|
assert.equal(arguments[0], 2)
|
|
})
|
|
stubFn('c', function () {
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 3)
|
|
assert.equal(stubFn.lastCall.args[0], 'c')
|
|
assert.equal(arguments[0], 3)
|
|
})
|
|
let neverCalled = true
|
|
stubFn('d', function () {
|
|
neverCalled = false
|
|
})
|
|
assert(neverCalled)
|
|
})
|
|
})
|
|
|
|
describe('for a single throwing configuration', function () {
|
|
let stubFn: Simple.Stub<void>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().throwWith(new Error('example'))
|
|
})
|
|
|
|
it('can throw', function () {
|
|
let threw: Error
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw = e
|
|
}
|
|
|
|
assert(threw)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(threw.message, 'example')
|
|
})
|
|
|
|
it('can throw over multiple calls, looping per default', function () {
|
|
let threw: Error[] = []
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
|
|
assert.equal(threw.length, 2)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 2)
|
|
assert.equal(threw[0], threw[1])
|
|
assert.equal(threw[0].message, 'example')
|
|
})
|
|
})
|
|
|
|
describe('for a multiple throwing configurations', function () {
|
|
let stubFn: Simple.Stub<void>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().throwWith(new Error('a')).throwWith(new Error('b'))
|
|
})
|
|
|
|
it('can throw', function () {
|
|
let threw: Error
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw = e
|
|
}
|
|
|
|
assert(threw)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(threw.message, 'a')
|
|
})
|
|
|
|
it('can throw over multiple calls, looping per default', function () {
|
|
let threw: Error[] = []
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
|
|
assert.equal(threw.length, 3)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 3)
|
|
assert.equal(threw[0].message, 'a')
|
|
assert.equal(threw[1].message, 'b')
|
|
assert.equal(threw[2].message, 'a')
|
|
})
|
|
|
|
it('can throw over multiple calls, looping turned off', function () {
|
|
stubFn.loop = false
|
|
|
|
let threw: Error[] = []
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
try {
|
|
stubFn()
|
|
} catch (e) {
|
|
threw.push(e)
|
|
}
|
|
|
|
assert.equal(threw.length, 2)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 3)
|
|
assert.equal(threw[0].message, 'a')
|
|
assert.equal(threw[1].message, 'b')
|
|
})
|
|
})
|
|
|
|
describe('for a single returning configuration', function () {
|
|
let stubFn: Simple.Stub<string>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub()
|
|
})
|
|
|
|
it('can return', function () {
|
|
stubFn.returnWith('example')
|
|
|
|
let returned: string
|
|
returned = stubFn()
|
|
|
|
assert(returned)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(returned, 'example')
|
|
})
|
|
|
|
it('can return an empty string', function () {
|
|
stubFn.returnWith('')
|
|
|
|
let returned: string
|
|
returned = stubFn()
|
|
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(returned, '')
|
|
})
|
|
|
|
it('can return over multiple calls, looping per default', function () {
|
|
stubFn.returnWith('example-a')
|
|
stubFn.returnWith('example-b')
|
|
|
|
let returned: string[] = []
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
|
|
assert.equal(returned.length, 4)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 4)
|
|
assert.equal(returned[0], returned[2])
|
|
assert.equal(returned[0], 'example-a')
|
|
assert.equal(returned[1], returned[3])
|
|
assert.equal(returned[1], 'example-b')
|
|
})
|
|
})
|
|
|
|
describe('for a multiple returning configurations', function () {
|
|
let stubFn: Simple.Stub<string>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().returnWith('a').returnWith('b')
|
|
})
|
|
|
|
it('can return', function () {
|
|
let returned: string
|
|
returned = stubFn()
|
|
|
|
assert(returned)
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(returned, 'a')
|
|
})
|
|
|
|
it('can return over multiple calls, looping per default', function () {
|
|
let returned: string[] = []
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
|
|
assert.equal(returned.length, 3)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 3)
|
|
assert.equal(returned[0], 'a')
|
|
assert.equal(returned[1], 'b')
|
|
assert.equal(returned[2], 'a')
|
|
})
|
|
|
|
it('can return over multiple calls, looping turned off', function () {
|
|
stubFn.loop = false
|
|
|
|
let returned: string[] = []
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
returned.push(stubFn())
|
|
|
|
assert.equal(returned.length, 3)
|
|
assert(stubFn.called)
|
|
assert.equal(stubFn.callCount, 3)
|
|
assert.equal(returned[0], 'a')
|
|
assert.equal(returned[1], 'b')
|
|
assert.equal(returned[2], undefined)
|
|
})
|
|
})
|
|
|
|
describe('for a specified function to call', function () {
|
|
it('should be called with arguments and return', function () {
|
|
let stubFn = simple.stub().callFn(function () {
|
|
return arguments
|
|
})
|
|
|
|
let returned = stubFn('z', 'x')
|
|
|
|
assert.equal(stubFn.callCount, 1)
|
|
assert.equal(returned[0], 'z')
|
|
assert.equal(returned[1], 'x')
|
|
})
|
|
|
|
it('should be able to throw', function () {
|
|
let stubFn = simple.stub().callFn(function () {
|
|
throw new Error('my message')
|
|
})
|
|
|
|
try {
|
|
stubFn()
|
|
} catch(e) {
|
|
assert(e instanceof Error)
|
|
assert.equal(e.message, 'my message')
|
|
}
|
|
})
|
|
|
|
it('should be called in context', function () {
|
|
let mockObj = {
|
|
stubFn: simple.stub().callFn(function () {
|
|
return this
|
|
})
|
|
}
|
|
|
|
let returned = mockObj.stubFn()
|
|
|
|
assert.equal(returned, mockObj)
|
|
})
|
|
|
|
it('can be called in specified context', function () {
|
|
let anotherMockObj = {}
|
|
|
|
let mockObj = {
|
|
stubFn: simple.stub().callFn(function () {
|
|
return this
|
|
}).inThisContext(anotherMockObj)
|
|
}
|
|
|
|
let returned = mockObj.stubFn()
|
|
|
|
assert.equal(returned, anotherMockObj)
|
|
})
|
|
})
|
|
|
|
describe('for custom/when-conforming promises', function () {
|
|
let fulfilledStub: Simple.Stub<boolean>
|
|
let rejectedStub: Simple.Stub<boolean>
|
|
|
|
beforeEach(function () {
|
|
fulfilledStub = simple.stub().returnWith(true)
|
|
rejectedStub = simple.stub().returnWith(true)
|
|
|
|
interface MockPromise<T> {
|
|
resolveValue: T,
|
|
rejectValue: T,
|
|
then(fulfilledFn: (value: any) => T, rejectedFn: (error: any) => T): void;
|
|
}
|
|
|
|
let mockPromise: MockPromise<boolean> = {
|
|
resolveValue: null as boolean,
|
|
rejectValue: null as boolean,
|
|
then: function (fulfilledFn: (value: any) => boolean, rejectedFn: (error: any) => boolean) {
|
|
let self = this
|
|
process.nextTick(function () {
|
|
if (self.resolveValue) return fulfilledFn(self.resolveValue)
|
|
if (self.rejectValue) return rejectedFn(self.rejectValue)
|
|
})
|
|
}
|
|
}
|
|
|
|
simple.mock(simple, 'Promise', {
|
|
when: function<T>(value: T) {
|
|
let promise: MockPromise<T> = Object.create(mockPromise)
|
|
promise.resolveValue = value
|
|
return promise
|
|
},
|
|
reject: function<T>(value: T) {
|
|
let promise: MockPromise<T> = Object.create(mockPromise)
|
|
promise.rejectValue = value
|
|
return promise
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('with a single resolving configuration', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().resolveWith('example')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 1)
|
|
assert.equal(fulfilledStub.lastCall.arg, 'example')
|
|
assert.equal(rejectedStub.callCount, 0)
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
|
|
describe('with a multiple resolving configurations', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().resolveWith('a').resolveWith('b')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 1)
|
|
assert.equal(fulfilledStub.lastCall.arg, 'a')
|
|
assert.equal(rejectedStub.callCount, 0)
|
|
done()
|
|
}, 0)
|
|
})
|
|
|
|
it('can return over multiple calls, looping per default', function (done) {
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 3)
|
|
assert.equal(fulfilledStub.calls[0].arg, 'a')
|
|
assert.equal(fulfilledStub.calls[1].arg, 'b')
|
|
assert.equal(fulfilledStub.calls[2].arg, 'a')
|
|
assert.equal(rejectedStub.callCount, 0)
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
|
|
describe('with a single rejecting configuration', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().rejectWith('example')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 0)
|
|
assert.equal(rejectedStub.callCount, 1)
|
|
assert.equal(rejectedStub.lastCall.arg, 'example')
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
|
|
describe('with a multiple rejecting configurations', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().rejectWith('a').rejectWith('b')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 0)
|
|
assert.equal(rejectedStub.callCount, 1)
|
|
assert.equal(rejectedStub.lastCall.arg, 'a')
|
|
done()
|
|
}, 0)
|
|
})
|
|
|
|
it('can return over multiple calls, looping per default', function (done) {
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 0)
|
|
assert.equal(rejectedStub.callCount, 3)
|
|
assert.equal(rejectedStub.calls[0].arg, 'a')
|
|
assert.equal(rejectedStub.calls[1].arg, 'b')
|
|
assert.equal(rejectedStub.calls[2].arg, 'a')
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('for native/conforming promises', function () {
|
|
let fulfilledStub: Simple.Stub<boolean>
|
|
let rejectedStub: Simple.Stub<boolean>
|
|
|
|
beforeEach(function () {
|
|
fulfilledStub = simple.stub().returnWith(true)
|
|
rejectedStub = simple.stub().returnWith(true)
|
|
})
|
|
|
|
describe('with a single resolving configuration', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().resolveWith('example')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 1)
|
|
assert.equal(fulfilledStub.lastCall.arg, 'example')
|
|
assert.equal(rejectedStub.callCount, 0)
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
|
|
describe('with a multiple resolving configurations', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().resolveWith('a').resolveWith('b')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 1)
|
|
assert.equal(fulfilledStub.lastCall.arg, 'a')
|
|
assert.equal(rejectedStub.callCount, 0)
|
|
done()
|
|
}, 0)
|
|
})
|
|
|
|
it('can return over multiple calls, looping per default', function (done) {
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 3)
|
|
assert.equal(fulfilledStub.calls[0].arg, 'a')
|
|
assert.equal(fulfilledStub.calls[1].arg, 'b')
|
|
assert.equal(fulfilledStub.calls[2].arg, 'a')
|
|
assert.equal(rejectedStub.callCount, 0)
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
|
|
describe('with a single rejecting configuration', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().rejectWith('example')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 0)
|
|
assert.equal(rejectedStub.callCount, 1)
|
|
assert.equal(rejectedStub.lastCall.arg, 'example')
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
|
|
describe('with a multiple rejecting configurations', function () {
|
|
let stubFn: Simple.Stub<PromiseLike<string>>;
|
|
beforeEach(function () {
|
|
stubFn = simple.stub().rejectWith('a').rejectWith('b')
|
|
})
|
|
|
|
it('can return a promise', function (done) {
|
|
let returned = stubFn()
|
|
|
|
assert(returned)
|
|
|
|
returned.then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 0)
|
|
assert.equal(rejectedStub.callCount, 1)
|
|
assert.equal(rejectedStub.lastCall.arg, 'a')
|
|
done()
|
|
}, 0)
|
|
})
|
|
|
|
it('can return over multiple calls, looping per default', function (done) {
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
stubFn().then(fulfilledStub, rejectedStub)
|
|
|
|
setTimeout(function () {
|
|
assert.equal(fulfilledStub.callCount, 0)
|
|
assert.equal(rejectedStub.callCount, 3)
|
|
assert.equal(rejectedStub.calls[0].arg, 'a')
|
|
assert.equal(rejectedStub.calls[1].arg, 'b')
|
|
assert.equal(rejectedStub.calls[2].arg, 'a')
|
|
done()
|
|
}, 0)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('mock()', function () {
|
|
describe('on a object with prototype', function () {
|
|
class ProtoKlass {
|
|
protoValue: string = 'x'
|
|
protoFn() {
|
|
return 'x'
|
|
}
|
|
}
|
|
|
|
let obj: any
|
|
|
|
before(function () {
|
|
})
|
|
|
|
beforeEach(function () {
|
|
obj = new ProtoKlass()
|
|
})
|
|
|
|
it('can mock instance values over its prototype\'s and restore', function () {
|
|
simple.mock(obj, 'protoValue', 'y')
|
|
assert.equal(obj.protoValue, 'y')
|
|
simple.restore()
|
|
assert.equal(obj.protoValue, 'x')
|
|
})
|
|
|
|
it('can mock with custom instance functions over its prototype\'s and restore', function () {
|
|
simple.mock(obj, 'protoFn', function () {
|
|
return 'y'
|
|
})
|
|
assert.equal(obj.protoFn(), 'y')
|
|
assert(obj.protoFn.called)
|
|
simple.restore()
|
|
assert.equal(obj.protoFn(), 'x')
|
|
})
|
|
|
|
it('can mock with stubbed functions over its prototype\'s and restore', function () {
|
|
simple.mock(obj, 'protoFn').returnWith('y')
|
|
assert.equal(obj.protoFn(), 'y')
|
|
assert(obj.protoFn.called)
|
|
simple.restore()
|
|
assert.equal(obj.protoFn(), 'x')
|
|
})
|
|
|
|
it('can mock with stubbed functions and prototype\'s original over its prototype\'s and restore', function () {
|
|
simple.mock(obj, 'protoFn').returnWith('y').callOriginal().returnWith('z')
|
|
assert.equal(obj.protoFn(), 'y')
|
|
assert.equal(obj.protoFn(), 'x')
|
|
assert.equal(obj.protoFn(), 'z')
|
|
assert.equal(obj.protoFn.callCount, 3)
|
|
simple.restore()
|
|
assert.equal(obj.protoFn(), 'x')
|
|
})
|
|
})
|
|
|
|
describe('on an anonymous object', function () {
|
|
let obj: any
|
|
beforeEach(function () {
|
|
obj = {
|
|
a: 'a',
|
|
b: 'b',
|
|
c: 'c',
|
|
fnD: function () {
|
|
return 'd'
|
|
}
|
|
}
|
|
})
|
|
|
|
it('can mock instance values and restore', function () {
|
|
let beforeKeys = Object.keys(obj)
|
|
simple.mock(obj, 'a', 'd')
|
|
simple.mock(obj, 'd', 'a')
|
|
assert.equal(obj.a, 'd')
|
|
assert.equal(obj.d, 'a')
|
|
simple.restore()
|
|
assert.equal(obj.a, 'a')
|
|
assert.equal(obj.d, undefined)
|
|
assert.deepEqual(Object.keys(obj), beforeKeys)
|
|
})
|
|
|
|
it('can mock with spy on pre-existing functions and restore', function () {
|
|
simple.mock(obj, 'fnD').returnWith('a')
|
|
assert.equal(obj.fnD(), 'a')
|
|
assert(obj.fnD.called)
|
|
simple.restore()
|
|
assert.equal(obj.fnD(), 'd')
|
|
})
|
|
|
|
it('can mock with newly stubbed functions and restore', function () {
|
|
simple.mock(obj, 'fnA').returnWith('a')
|
|
assert.equal(obj.fnA(), 'a')
|
|
assert(obj.fnA.called)
|
|
simple.restore()
|
|
assert.equal(obj.fnA, undefined)
|
|
})
|
|
})
|
|
|
|
describe('with one argument', function () {
|
|
it('returns a spy', function () {
|
|
let called = 0
|
|
|
|
let spy = simple.mock(function () {
|
|
called++
|
|
})
|
|
|
|
spy()
|
|
assert.equal(called, 1)
|
|
assert(spy.called)
|
|
})
|
|
})
|
|
|
|
describe('with no arguments', function () {
|
|
it('returns a stub', function () {
|
|
let stub = simple.mock().returnWith('x')
|
|
|
|
let x = stub()
|
|
assert(stub.called)
|
|
assert(x, 'x')
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
simple.Promise = Bluebird;
|