PHP WebShell
Текущая директория: /opt/BitGoJS/node_modules/should-sinon
Просмотр файла: should-sinon.js
(function (factory) {
if (typeof define === 'function' && define.amd) {
define(['should'], factory);
} else if (typeof exports === 'object') {
module.exports = factory(require('should'));
} else {
factory(should);
}
}(function (should) {
var Assertion = should.Assertion;
Assertion.add('sinonStub', function() {
this.params = { operator: 'to be sinon stub' };
this.is.not.null().and.not.undefined();
var method = this.obj;
if(method.proxy && method.proxy.isSinonProxy) {
method = method.proxy;
}
method.should.be.a.Function()
.and.have.property('getCall')
.which.is.a.Function();
});
function isStub(stub) {
if (!stub) {
return false;
}
if (method.proxy && method.proxy.isSinonProxy) {
verifyIsStub(method.proxy);
} else {
if (typeof method !== "function") {
assert.fail(method + " is not a function");
}
if (typeof method.getCall !== "function") {
assert.fail(method + " is not stubbed");
}
}
}
function timesInWords(count) {
switch (count) {
case 1:
return "once";
case 2:
return "twice";
case 3:
return "thrice";
default:
return (count || 0) + " times";
}
}
function isCall(call) {
return call && isSpy(call.proxy);
}
function isSpy(spy) {
return typeof spy === "function" &&
typeof spy.getCall === "function" &&
typeof spy.calledWithExactly === "function";
}
function proxySinonBooleanProperty(name, message) {
Assertion.add(name, function() {
var obj = this.obj;
if(!isSpy(obj) && !isCall(obj)) {
this.params = { obj: obj.toString(), operator: 'to be sinon spy or spy call' };
this.fail();
}
if(isCall(obj)) {
obj = obj.proxy;
}
this.params = { obj: obj.toString(), operator: obj.printf(message) };
should(obj[name]).be.true();
});
}
function proxySinonMethod(name, message) {
Assertion.add(name, function() {
var obj = this.obj;
if(!isSpy(obj) && !isCall(obj)) {
this.params = { obj: obj.toString(), operator: 'to be sinon spy or spy call' };
this.fail();
}
if(isCall(obj)) {
obj = obj.proxy;
}
var args = Array.prototype.slice.call(arguments);
args.unshift(message);
this.params = { obj: obj.toString(), operator: obj.printf.apply(obj, args) };
should(obj[name].apply(obj, arguments)).be.true();
});
}
/**
* Assert stub was called at least once
*
* @name called
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @example
*
* var callback = sinon.spy();
* callback();
* callback.should.be.called();
*/
proxySinonBooleanProperty('called', 'to have been called, but was called %c');
/**
* Assert stub was called at exactly once
*
* @name calledOnce
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @example
*
* var callback = sinon.spy();
* callback();
* callback.should.be.calledOnce();
*/
proxySinonBooleanProperty('calledOnce', 'to be called once but was called %c%C');
/**
* Assert stub was called at exactly twice
*
* @name calledTwice
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @example
*
* var callback = sinon.spy();
* callback();
* callback();
* callback.should.be.calledTwice();
*/
proxySinonBooleanProperty('calledTwice', 'to be called twice but was called %c%C');
/**
* Assert stub was called at exactly thrice
*
* @name calledThrice
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @example
*
* var callback = sinon.spy();
* callback();
* callback();
* callback();
* callback.should.be.calledThrice();
*/
proxySinonBooleanProperty('calledThrice', 'to be called thrice but was called %c%C');
/**
* Assert stub was called with given object as this
*
* @name calledOn
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {*} obj - object that was used as this
* @example
*
* var callback = sinon.spy();
* var obj = {};
* callback.call(obj);
* callback.should.be.calledOn(obj);
*/
proxySinonMethod('calledOn', 'to be called with %1 as this but was called with %t');
/**
* Assert stub was called with given object as this always. So if you call stub several times
* all should be with the same object
*
* @name alwaysCalledOn
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {*} obj - object that was used as this
* @example
*
* var callback = sinon.spy();
* var obj = {};
* callback.call(obj);
* callback.should.be.alwaysCalledOn(obj);
*/
proxySinonMethod('alwaysCalledOn', 'to always be called with %1 as this but was called with %t');
/**
* Asserts that stub was called with new
*
* @name calledWithNew
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @example
*
* var Class = sinon.spy();
*
* var c = new Class();
*
* Class.should.be.calledWithNew;
*/
proxySinonMethod('calledWithNew', 'to be called with new');
/**
* @name alwaysCalledWithNew
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @example
*
* var Class = sinon.spy();
*
* var c1 = new Class();
* var c2 = new Class();
*
* Class.should.be.alwaysCalledWithNew;
*/
proxySinonMethod('alwaysCalledWithNew', 'to always be called with new');
/**
* Asserts that stub was called with given arguments
*
* @name calledWith
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
* @example
*
* var callback = sinon.spy();
*
* callback(1, 2, 3);
*
* callback.should.be.calledWith(1, 2, 3);
*/
proxySinonMethod('calledWith', 'to be called with arguments %*%C');
/**
* @name alwaysCalledWith
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
* @example
*
* var callback = sinon.spy();
*
* callback(1, 2, 3);
*
* callback.should.be.alwaysCalledWith(1, 2, 3);
*/
proxySinonMethod('alwaysCalledWith', 'to always be called with arguments %*%C');
/**
* Returns true if the spy/stub was never called with the provided arguments.
*
* @name neverCalledWith
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
* @example
*
* var callback = sinon.spy();
*
* callback(1, 2, 3);
*
* callback.should.be.neverCalledWith(1, 2, 3);
*/
proxySinonMethod('neverCalledWith', 'to never be called with arguments %*%C');
/**
* Returns true if spy was called with matching arguments (and possibly others).
*
* @name calledWithMatch
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
*/
proxySinonMethod('calledWithMatch', 'to be called with match %*%C');
/**
* Returns true if spy was always called with matching arguments (and possibly others).
*
* @name alwaysCalledWithMatch
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
*/
proxySinonMethod('alwaysCalledWithMatch', 'to always be called with match %*%C');
/**
* Returns true if the spy/stub was never called with matching arguments.
*
* @name neverCalledWithMatch
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
*/
proxySinonMethod('neverCalledWithMatch', 'to never be called with match %*%C');
/**
* Returns true if call received provided arguments and no others.
*
* @name calledWithExactly
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
*/
proxySinonMethod('calledWithExactly', 'to be called with exact arguments %*%C');
/**
* Passes if the spy was always called with the provided arguments and no others.
*
* @name alwaysCalledWithExactly
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {...*} args - arguments that was used for calling
*/
proxySinonMethod('alwaysCalledWithExactly', 'to always be called with exact arguments %*%C');
/**
* Passes if the spy threw the given exception. The exception can be a
* string denoting its type, or an actual object. If no argument is
* provided, the assertion passes if the spy ever threw any exception.
*
* @name threw
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {string|Error} ex - exception to be thrown
*/
proxySinonMethod('threw', 'to throw exception%C');
/**
* Passes if the spy always threw the given exception. The exception can be a
* string denoting its type, or an actual object. If no argument is
* provided, the assertion passes if the spy ever threw any exception.
*
* @name alwaysThrew
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {string|Error} ex - exception to be thrown
*/
proxySinonMethod('alwaysThrew', 'to always throw exception%C');
/**
* Assert stub was called at exact number of times
*
* @name callCount
* @memberOf Assertion
* @category assertion stubs
* @module should-sinon
* @param {Number} count - number of calles
* @example
*
* var callback = sinon.spy();
* callback.should.have.callCount(0);
* callback();
* callback.should.have.callCount(1);
* callback();
* callback.should.have.callCount(2);
*/
Assertion.add('callCount', function(count) {
var obj = this.obj;
if(!isSpy(obj) && !isCall(obj)) {
this.params = { obj: obj.toString(), operator: 'to be sinon spy or spy call' };
this.fail();
}
if(isCall(obj)) {
obj = obj.proxy;
}
this.params = { operator: obj.printf('to be called ' + timesInWords(count) + ' but was called %c%C' )};
this.assert(obj.callCount === count);
});
}));
Выполнить команду
Для локальной разработки. Не используйте в интернете!