sandbox.replaceSetter = function replaceSetter(object, property, replacement) {
var descriptor = getPropertyDescriptor(object, property);
if (typeof descriptor === "undefined") {
throw new TypeError("Cannot replace non-existent own property " + valueToString(property));
}
if (typeof replacement !== "function") {
throw new TypeError("Expected replacement argument to be a function");
}
if (typeof descriptor.set !== "function") {
throw new Error("`object.property` is not a setter");
}
verifyNotReplaced(object, property);
// store a function for restoring the replaced property
push(fakeRestorers, getFakeRestorer(object, property));
// eslint-disable-next-line accessor-pairs
Object.defineProperty(object, property, {
set: replacement,
configurable: isPropertyConfigurable(object, property)
});
return replacement;
};
sandbox.stub = function stub(object, property) {
if (isEsModule(object)) {
throw new TypeError("ES Modules cannot be stubbed");
}
if (isNonExistentOwnProperty(object, property)) {
throw new TypeError("Cannot stub non-existent own property " + valueToString(property));
}
var stubbed = sinonStub.apply(null, arguments);
var isStubbingEntireObject = typeof property === "undefined" && typeof object === "object";
if (isStubbingEntireObject) {
var ownMethods = collectOwnMethods(stubbed);
forEach(ownMethods, function(method) {
push(collection, method);
});
usePromiseLibrary(promiseLib, ownMethods);
} else {
push(collection, stubbed);
usePromiseLibrary(promiseLib, stubbed);
}
return stubbed;
};
function match(expectation, message) {
var m = Object.create(matcher);
var type = typeOf(expectation);
if (message !== undefined && typeof message !== "string") {
throw new TypeError("Message should be a string");
}
if (arguments.length > 2) {
throw new TypeError(
"Expected 1 or 2 arguments, received " + arguments.length
);
}
if (type in TYPE_MAP) {
TYPE_MAP[type](m, expectation, message);
} else {
m.test = function(actual) {
return deepEqual(actual, expectation);
};
}
if (!m.message) {
m.message = "match(" + valueToString(expectation) + ")";
}
return m;
}
sandbox.replace = function replace(object, property, replacement) {
var descriptor = getPropertyDescriptor(object, property);
if (typeof descriptor === "undefined") {
throw new TypeError("Cannot replace non-existent own property " + valueToString(property));
}
if (typeof replacement === "undefined") {
throw new TypeError("Expected replacement argument to be defined");
}
if (typeof descriptor.get === "function") {
throw new Error("Use sandbox.replaceGetter for replacing getters");
}
if (typeof descriptor.set === "function") {
throw new Error("Use sandbox.replaceSetter for replacing setters");
}
if (typeof object[property] !== typeof replacement) {
throw new TypeError("Cannot replace " + typeof object[property] + " with " + typeof replacement);
}
verifyNotReplaced(object, property);
// store a function for restoring the replaced property
push(fakeRestorers, getFakeRestorer(object, property));
object[property] = replacement;
return replacement;
};
match.in = function(arrayOfExpectations) {
if (!Array.isArray(arrayOfExpectations)) {
throw new TypeError("array expected");
}
return match(function(actual) {
return some(arrayOfExpectations, function(expectation) {
return expectation === actual;
});
}, "in(" + valueToString(arrayOfExpectations) + ")");
};
function checkWrappedMethod(wrappedMethod) {
var error;
if (!isFunction(wrappedMethod)) {
error = new TypeError(
"Attempted to wrap " + typeof wrappedMethod + " property " + valueToString(property) + " as function"
);
} else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
error = new TypeError("Attempted to wrap " + valueToString(property) + " which is already wrapped");
} else if (wrappedMethod.calledBefore) {
var verb = wrappedMethod.returns ? "stubbed" : "spied on";
error = new TypeError("Attempted to wrap " + valueToString(property) + " which is already " + verb);
}
if (error) {
if (wrappedMethod && wrappedMethod.stackTraceError) {
error.stack += "\n--------------\n" + wrappedMethod.stackTraceError.stack;
}
throw error;
}
}
match.hasNested = function(property, value) {
assertType(property, "string", "property");
var onlyProperty = arguments.length === 1;
var message = 'hasNested("' + property + '"';
if (!onlyProperty) {
message += ", " + valueToString(value);
}
message += ")";
return match(function(actual) {
if (actual === undefined || actual === null || get(actual, property) === undefined) {
return false;
}
return onlyProperty || deepEqual(value, get(actual, property));
}, message);
};
return function(property, value) {
assertType(property, "string", "property");
var onlyProperty = arguments.length === 1;
var message = messagePrefix + '("' + property + '"';
if (!onlyProperty) {
message += ", " + valueToString(value);
}
message += ")";
return match(function(actual) {
if (actual === undefined || actual === null || !propertyTest(actual, property)) {
return false;
}
return onlyProperty || deepEqual(value, actual[property]);
}, message);
};
function match(expectation, message) {
var m = Object.create(matcher);
var type = typeOf(expectation);
if (type in TYPE_MAP) {
TYPE_MAP[type](m, expectation, message);
} else {
m.test = function(actual) {
return deepEqual(expectation, actual);
};
}
if (!m.message) {
m.message = "match(" + valueToString(expectation) + ")";
}
return m;
}
function getCallbackError(behavior, func, args) {
if (behavior.callArgAt < 0) {
var msg;
if (behavior.callArgProp) {
msg =
functionName(behavior.stub) +
" expected to yield to '" +
valueToString(behavior.callArgProp) +
"', but no object with such a property was passed.";
} else {
msg = functionName(behavior.stub) + " expected to yield, but no callback was passed.";
}
if (args.length > 0) {
msg += " Received [" + join(args, ", ") + "]";
}
return msg;
}
return "argument at index " + behavior.callArgAt + " is not a function: " + func;
}
/**
* @name samsam.match
* @param Object object
* @param Object matcher
*
* Compare arbitrary value ``object`` with matcher.
*/
function match(object, matcher) {
if (matcher && typeof matcher.test === "function") {
return matcher.test(object);
}
if (typeof matcher === "function") {
return matcher(object) === true;
}
if (typeof matcher === "string") {
matcher = matcher.toLowerCase();
var notNull = typeof object === "string" || !!object;
return (
notNull &&
valueToString(object)
.toLowerCase()
.indexOf(matcher) >= 0
);
}
if (typeof matcher === "number") {
return matcher === object;
}
if (typeof matcher === "boolean") {
return matcher === object;
}
if (typeof matcher === "undefined") {
return typeof object === "undefined";
}
if (matcher === null) {
return object === null;
}
if (object === null) {
return false;
}
if (isSet(object)) {
return isSubset(matcher, object, match);
}
if (getClass(object) === "Array" && getClass(matcher) === "Array") {
return arrayContains(object, matcher, match);
}
if (isDate(matcher)) {
return isDate(object) && object.getTime() === matcher.getTime();
}
if (matcher && typeof matcher === "object") {
if (matcher === object) {
return true;
}
if (typeof object !== "object") {
return false;
}
var prop;
// eslint-disable-next-line guard-for-in
for (prop in matcher) {
var value = object[prop];
if (
typeof value === "undefined" &&
typeof object.getAttribute === "function"
) {
value = object.getAttribute(prop);
}
if (
matcher[prop] === null ||
typeof matcher[prop] === "undefined"
) {
if (value !== matcher[prop]) {
return false;
}
} else if (
typeof value === "undefined" ||
!deepEqual(value, matcher[prop])
) {
return false;
}
}
return true;
}
throw new Error(
"Matcher was not a string, a number, a " +
"function, a boolean or an object"
);
}
array = map(Object.keys(expectation), function(key) {
return key + ": " + valueToString(expectation[key]);
});
match.same = function(expectation) {
return match(function(actual) {
return expectation === actual;
}, "same(" + valueToString(expectation) + ")");
};
function stringify(item) {
return typeof item === "string"
? "'" + item + "'"
: valueToString(item);
}
delegateToCalls("yieldToOn", false, "yieldToOn", true, function(property) {
throw new Error(
this.toString() + " cannot yield to '" + valueToString(property) + "' since it was not yet invoked."
);
});