admin/jasmine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge common async/sync expectation stuff

Browse Source
This commit is contained in:
Gregg Van Hove
2018-10-24 16:17:30 -07:00
parent 1e47dcf2cc
commit 2d303a6e46
8 changed files with 441 additions and 522 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
src/core/AsyncExpectation.js
View File

@@ -1,134 +0,0 @@
getJasmineRequireObj().AsyncExpectation = function(j$) {
var promiseForMessage = {
jasmineToString: function() { return 'a promise'; }
};
/**
* Asynchronous matchers.
* @namespace async-matchers
*/
function AsyncExpectation(options) {
var global = options.global || j$.getGlobal();
this.util = options.util || { buildFailureMessage: function() {} };
this.customEqualityTesters = options.customEqualityTesters || [];
this.addExpectationResult = options.addExpectationResult || function(){};
this.actual = options.actual;
this.filters = new j$.ExpectationFilterChain();
if (!global.Promise) {
throw new Error('expectAsync is unavailable because the environment does not support promises.');
}
if (!j$.isPromiseLike(this.actual)) {
throw new Error('Expected expectAsync to be called with a promise.');
}
}
function wrapCompare(name, matcherFactory) {
return function() {
var self = this;
var args = Array.prototype.slice.call(arguments),
expected = args.slice(0);
args.unshift(this.actual);
// Capture the call stack here, before we go async, so that it will
// contain frames that are relevant to the user instead of just parts
// of Jasmine.
var errorForStack = j$.util.errorWithStack();
var matcherCompare = this.instantiateMatcher(matcherFactory);
return matcherCompare.apply(self, args).then(function(result) {
args[0] = promiseForMessage;
self.processResult(result, name, expected, args, errorForStack);
});
};
}
AsyncExpectation.prototype.processResult = function(result, name, expected, args, errorForStack) {
var message = this.buildMessage(result, name, args);
if (expected.length === 1) {
expected = expected[0];
}
this.addExpectationResult(
result.pass,
{
matcherName: name,
passed: result.pass,
message: message,
error: undefined,
errorForStack: errorForStack,
actual: this.actual,
expected: expected // TODO: this may need to be arrayified/sliced
}
);
};
AsyncExpectation.prototype.buildMessage = j$.Expectation.prototype.buildMessage;
AsyncExpectation.prototype.instantiateMatcher = j$.Expectation.prototype.instantiateMatcher;
AsyncExpectation.prototype.addFilter = j$.Expectation.prototype.addFilter;
AsyncExpectation.addCoreMatchers = function(matchers) {
var prototype = AsyncExpectation.prototype;
for (var matcherName in matchers) {
var matcher = matchers[matcherName];
prototype[matcherName] = wrapCompare(matcherName, matcher);
}
};
AsyncExpectation.factory = function(options) {
var expect = new AsyncExpectation(options);
expect.not = expect.addFilter(negatingFilter);
expect.withContext = function(message) {
var result = this.addFilter(new ContextAddingFilter(message));
result.not = result.addFilter(negatingFilter);
return result;
};
return expect;
};
var negatingFilter = {
selectComparisonFunc: function(matcher) {
function defaultNegativeCompare() {
return matcher.compare.apply(this, arguments).then(function(result) {
result.pass = !result.pass;
return result;
});
}
return defaultNegativeCompare;
},
buildFailureMessage: function(result, matcherName, args, util) {
if (result.message) {
if (j$.isFunction_(result.message)) {
return result.message();
} else {
return result.message;
}
}
args = args.slice();
args.unshift(true);
args.unshift(matcherName);
return util.buildFailureMessage.apply(null, args);
}
};
function ContextAddingFilter(message) {
this.message = message;
}
ContextAddingFilter.prototype.modifyFailureMessage = function(msg) {
return this.message + ': ' + msg;
};
return AsyncExpectation;
};

6
src/core/Env.js
View File

@@ -193,7 +193,7 @@ getJasmineRequireObj().Env = function(j$) {
};
j$.Expectation.addCoreMatchers(j$.matchers);
j$.AsyncExpectation.addCoreMatchers(j$.asyncMatchers);
j$.Expectation.addAsyncCoreMatchers(j$.asyncMatchers);
var nextSpecId = 0;
var getNextSpecId = function() {
@@ -206,7 +206,7 @@ getJasmineRequireObj().Env = function(j$) {
};
var expectationFactory = function(actual, spec) {
return j$.Expectation.Factory({
return j$.Expectation.factory({
util: j$.matchersUtil,
customEqualityTesters: runnableResources[spec.id].customEqualityTesters,
customMatchers: runnableResources[spec.id].customMatchers,
@@ -220,7 +220,7 @@ getJasmineRequireObj().Env = function(j$) {
};
var asyncExpectationFactory = function(actual, spec) {
return j$.AsyncExpectation.factory({
return j$.Expectation.asyncFactory({
util: j$.matchersUtil,
customEqualityTesters: runnableResources[spec.id].customEqualityTesters,
actual: actual,

205
src/core/Expectation.js
View File

@@ -1,139 +1,133 @@
getJasmineRequireObj().Expectation = function(j$) {
var promiseForMessage = {
jasmineToString: function() { return 'a promise'; }
};
/**
* Matchers that come with Jasmine out of the box.
* @namespace matchers
*/
function Expectation(options) {
this.util = options.util || { buildFailureMessage: function() {} };
this.customEqualityTesters = options.customEqualityTesters || [];
this.actual = options.actual;
this.addExpectationResult = options.addExpectationResult || function(){};
this.filters = new j$.ExpectationFilterChain();
this.expector = new j$.Expector(options);
var customMatchers = options.customMatchers || {};
for (var matcherName in customMatchers) {
this[matcherName] = wrapCompare(matcherName, customMatchers[matcherName]);
this[matcherName] = wrapSyncCompare(matcherName, customMatchers[matcherName]);
}
}
function wrapCompare(name, matcherFactory) {
Expectation.prototype.withContext = function withContext(message) {
return addFilter(this, new ContextAddingFilter(message));
};
Object.defineProperty(Expectation.prototype, 'not', {
get: function() {
return addFilter(this, syncNegatingFilter);
}
});
/**
* Asynchronous matchers.
* @namespace async-matchers
*/
function AsyncExpectation(options) {
var global = options.global || j$.getGlobal();
this.expector = new j$.Expector(options);
if (!global.Promise) {
throw new Error('expectAsync is unavailable because the environment does not support promises.');
}
if (!j$.isPromiseLike(this.expector.actual)) {
throw new Error('Expected expectAsync to be called with a promise.');
}
}
AsyncExpectation.prototype.withContext = function withContext(message) {
return addFilter(this, new ContextAddingFilter(message));
};
Object.defineProperty(AsyncExpectation.prototype, 'not', {
get: function() {
return addFilter(this, asyncNegatingFilter);
}
});
function wrapSyncCompare(name, matcherFactory) {
return function() {
var args = Array.prototype.slice.call(arguments, 0),
expected = args.slice(0);
args.unshift(this.actual);
var matcherCompare = this.instantiateMatcher(matcherFactory);
var result = matcherCompare.apply(null, args);
this.processResult(result, name, expected, args);
var result = this.expector.compare(name, matcherFactory, arguments);
this.expector.processResult(result);
};
}
Expectation.prototype.instantiateMatcher = function(matcherFactory) {
var matcher = matcherFactory(this.util, this.customEqualityTesters);
var comparisonFunc = this.filters.selectComparisonFunc(matcher);
return comparisonFunc || matcher.compare;
};
function wrapAsyncCompare(name, matcherFactory) {
return function() {
var self = this;
Expectation.prototype.processResult = function(result, name, expected, args) {
var message = this.buildMessage(result, name, args);
// Capture the call stack here, before we go async, so that it will contain
// frames that are relevant to the user instead of just parts of Jasmine.
var errorForStack = j$.util.errorWithStack();
if (expected.length === 1) {
expected = expected[0];
return this.expector.compare(name, matcherFactory, arguments).then(function(result) {
self.expector.processResult(result, errorForStack, promiseForMessage);
});
};
}
function addCoreMatchers(prototype, matchers, wrapper) {
for (var matcherName in matchers) {
var matcher = matchers[matcherName];
prototype[matcherName] = wrapper(matcherName, matcher);
}
}
this.addExpectationResult(
result.pass,
{
matcherName: name,
passed: result.pass,
message: message,
error: result.error,
actual: this.actual,
expected: expected // TODO: this may need to be arrayified/sliced
}
);
};
function addFilter(source, filter) {
var result = Object.create(source);
result.expector = source.expector.addFilter(filter);
return result;
}
Expectation.prototype.buildMessage = function(result, name, args) {
var util = this.util;
if (result.pass) {
return '';
}
var msg = this.filters.buildFailureMessage(result, name, args, util, defaultMessage);
return this.filters.modifyFailureMessage(msg || defaultMessage());
function defaultMessage() {
if (!result.message) {
args = args.slice();
args.unshift(false);
args.unshift(name);
return util.buildFailureMessage.apply(null, args);
} else if (j$.isFunction_(result.message)) {
function negatedFailureMessage(result, matcherName, args, util) {
if (result.message) {
if (j$.isFunction_(result.message)) {
return result.message();
} else {
return result.message;
}
}
};
Expectation.prototype.addFilter = function(filter) {
var result = Object.create(this);
result.filters = this.filters.addFilter(filter);
args = args.slice();
args.unshift(true);
args.unshift(matcherName);
return util.buildFailureMessage.apply(null, args);
}
function negate(result) {
result.pass = !result.pass;
return result;
};
}
Expectation.addCoreMatchers = function(matchers) {
var prototype = Expectation.prototype;
for (var matcherName in matchers) {
var matcher = matchers[matcherName];
prototype[matcherName] = wrapCompare(matcherName, matcher);
}
};
Expectation.Factory = function(options) {
var expect = new Expectation(options || {});
expect.not = expect.addFilter(negatingFilter);
expect.withContext = function(message) {
var result = this.addFilter(new ContextAddingFilter(message));
result.not = result.addFilter(negatingFilter);
return result;
};
return expect;
};
var negatingFilter = {
var syncNegatingFilter = {
selectComparisonFunc: function(matcher) {
function defaultNegativeCompare() {
var result = matcher.compare.apply(null, arguments);
result.pass = !result.pass;
return result;
return negate(matcher.compare.apply(null, arguments));
}
return matcher.negativeCompare || defaultNegativeCompare;
},
buildFailureMessage: function(result, matcherName, args, util) {
if (result.message) {
if (j$.isFunction_(result.message)) {
return result.message();
} else {
return result.message;
}
}
args = args.slice();
args.unshift(true);
args.unshift(matcherName);
return util.buildFailureMessage.apply(null, args);
}
buildFailureMessage: negatedFailureMessage
};
var asyncNegatingFilter = {
selectComparisonFunc: function(matcher) {
function defaultNegativeCompare() {
return matcher.compare.apply(this, arguments).then(negate);
}
return defaultNegativeCompare;
},
buildFailureMessage: negatedFailureMessage
};
function ContextAddingFilter(message) {
this.message = message;
@@ -143,5 +137,18 @@ getJasmineRequireObj().Expectation = function(j$) {
return this.message + ': ' + msg;
};
return Expectation;
return {
factory: function(options) {
return new Expectation(options || {});
},
addCoreMatchers: function(matchers) {
addCoreMatchers(Expectation.prototype, matchers, wrapSyncCompare);
},
asyncFactory: function(options) {
return new AsyncExpectation(options || {});
},
addAsyncCoreMatchers: function(matchers) {
addCoreMatchers(AsyncExpectation.prototype, matchers, wrapAsyncCompare);
}
};
};

80
src/core/Expector.js Normal file
View File

@@ -0,0 +1,80 @@
getJasmineRequireObj().Expector = function(j$) {
function Expector(options) {
this.util = options.util || { buildFailureMessage: function() {} };
this.customEqualityTesters = options.customEqualityTesters || [];
this.actual = options.actual;
this.addExpectationResult = options.addExpectationResult || function(){};
this.filters = new j$.ExpectationFilterChain();
}
Expector.prototype.instantiateMatcher = function(matcherName, matcherFactory, args) {
this.matcherName = matcherName;
this.args = Array.prototype.slice.call(args, 0);
this.expected = this.args.slice(0);
this.args.unshift(this.actual);
var matcher = matcherFactory(this.util, this.customEqualityTesters);
var comparisonFunc = this.filters.selectComparisonFunc(matcher);
return comparisonFunc || matcher.compare;
};
Expector.prototype.buildMessage = function(result) {
var self = this;
if (result.pass) {
return '';
}
var msg = this.filters.buildFailureMessage(result, this.matcherName, this.args, this.util, defaultMessage);
return this.filters.modifyFailureMessage(msg || defaultMessage());
function defaultMessage() {
if (!result.message) {
var args = self.args.slice();
args.unshift(false);
args.unshift(self.matcherName);
return self.util.buildFailureMessage.apply(null, args);
} else if (j$.isFunction_(result.message)) {
return result.message();
} else {
return result.message;
}
}
};
Expector.prototype.compare = function(matcherName, matcherFactory, args) {
var matcherCompare = this.instantiateMatcher(matcherName, matcherFactory, args);
return matcherCompare.apply(null, this.args);
};
Expector.prototype.addFilter = function(filter) {
var result = Object.create(this);
result.filters = this.filters.addFilter(filter);
return result;
};
Expector.prototype.processResult = function(result, errorForStack, actualOverride) {
this.args[0] = actualOverride || this.args[0];
var message = this.buildMessage(result);
if (this.expected.length === 1) {
this.expected = this.expected[0];
}
this.addExpectationResult(
result.pass,
{
matcherName: this.matcherName,
passed: result.pass,
message: message,
error: errorForStack ? undefined : result.error,
errorForStack: errorForStack || undefined,
actual: this.actual,
expected: this.expected // TODO: this may need to be arrayified/sliced
}
);
};
return Expector;
};

2
src/core/requireCore.js
View File

@@ -38,8 +38,8 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
j$.StackTrace = jRequire.StackTrace(j$);
j$.ExceptionFormatter = jRequire.ExceptionFormatter(j$);
j$.ExpectationFilterChain = jRequire.ExpectationFilterChain();
j$.Expector = jRequire.Expector(j$);
j$.Expectation = jRequire.Expectation(j$);
j$.AsyncExpectation = jRequire.AsyncExpectation(j$);
j$.buildExpectationResult = jRequire.buildExpectationResult();
j$.JsApiReporter = jRequire.JsApiReporter();
j$.matchersUtil = jRequire.matchersUtil(j$);