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

Run Prettier on all files

Browse Source
This commit is contained in:
Steve Gravrock
2020-09-29 18:05:38 -07:00
parent 7d5ca27b9d
commit d27bb8fa96
108 changed files with 4399 additions and 2926 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
package.json
View File

@@ -13,9 +13,9 @@
"bdd"
],
"scripts": {
"posttest": "eslint \"src/**/*.js\" \"spec/**/*.js\" && prettier --check src/**/*.js spec/**/*.js",
"posttest": "eslint \"src/**/*.js\" \"spec/**/*.js\" && prettier --check \"src/**/*.js\" \"spec/**/*.js\"",
"test": "grunt --stack execSpecsInNode",
"cleanup": "prettier --write src/**/*.js spec/**/*.js",
"cleanup": "prettier --write \"src/**/*.js\" \"spec/**/*.js\"",
"build": "grunt buildDistribution",
"serve": "node spec/support/localJasmineBrowser.js",
"serve:performance": "node spec/support/localJasmineBrowser.js jasmine-browser-performance.json",

23
spec/.eslintrc.js
View File

@@ -1,23 +1,20 @@
module.exports = {
"ignorePatterns": [
"support/ci.js",
"support/jasmine-browser.js"
],
ignorePatterns: ['support/ci.js', 'support/jasmine-browser.js'],
rules: {
// Relax rules for now to allow for the quirks of the test suite
// TODO: We should probably remove these & fix the resulting errors
"quotes": "off",
"semi": "off",
"key-spacing": "off",
"space-before-blocks": "off",
"no-unused-vars": "off",
"no-trailing-spaces": "off",
"block-spacing": "off",
quotes: 'off',
semi: 'off',
'key-spacing': 'off',
'space-before-blocks': 'off',
'no-unused-vars': 'off',
'no-trailing-spaces': 'off',
'block-spacing': 'off',
// Since linting is done at the end of the process and doesn't stop us
// from running tests, it makes sense to fail if debugger statements
// or console references are present.
"no-debugger": "error",
"no-console": "error",
'no-debugger': 'error',
'no-console': 'error'
}
};

32
spec/core/asymmetric_equality/AnySpec.js
View File

@@ -1,35 +1,35 @@
describe("Any", function() {
it("matches a string", function() {
describe('Any', function() {
it('matches a string', function() {
var any = new jasmineUnderTest.Any(String);
expect(any.asymmetricMatch("foo")).toBe(true);
expect(any.asymmetricMatch('foo')).toBe(true);
});
it("matches a number", function() {
it('matches a number', function() {
var any = new jasmineUnderTest.Any(Number);
expect(any.asymmetricMatch(1)).toBe(true);
});
it("matches a function", function() {
it('matches a function', function() {
var any = new jasmineUnderTest.Any(Function);
expect(any.asymmetricMatch(function(){})).toBe(true);
expect(any.asymmetricMatch(function() {})).toBe(true);
});
it("matches an Object", function() {
it('matches an Object', function() {
var any = new jasmineUnderTest.Any(Object);
expect(any.asymmetricMatch({})).toBe(true);
});
it("matches a Boolean", function() {
it('matches a Boolean', function() {
var any = new jasmineUnderTest.Any(Boolean);
expect(any.asymmetricMatch(true)).toBe(true);
});
it("matches a Map", function() {
it('matches a Map', function() {
jasmine.getEnv().requireFunctioningMaps();
var any = new jasmineUnderTest.Any(Map);
@@ -37,7 +37,7 @@ describe("Any", function() {
expect(any.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Set", function() {
it('matches a Set', function() {
jasmine.getEnv().requireFunctioningSets();
var any = new jasmineUnderTest.Any(Set);
@@ -45,7 +45,7 @@ describe("Any", function() {
expect(any.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a TypedArray", function() {
it('matches a TypedArray', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var any = new jasmineUnderTest.Any(Uint32Array); // eslint-disable-line compat/compat
@@ -53,7 +53,7 @@ describe("Any", function() {
expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Symbol", function() {
it('matches a Symbol', function() {
jasmine.getEnv().requireFunctioningSymbols();
var any = new jasmineUnderTest.Any(Symbol); // eslint-disable-line compat/compat
@@ -61,14 +61,14 @@ describe("Any", function() {
expect(any.asymmetricMatch(Symbol())).toBe(true); // eslint-disable-line compat/compat
});
it("matches another constructed object", function() {
it('matches another constructed object', function() {
var Thing = function() {},
any = new jasmineUnderTest.Any(Thing);
expect(any.asymmetricMatch(new Thing())).toBe(true);
});
it("does not treat null as an Object", function() {
it('does not treat null as an Object', function() {
var any = new jasmineUnderTest.Any(Object);
expect(any.asymmetricMatch(null)).toBe(false);
@@ -81,8 +81,8 @@ describe("Any", function() {
expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
});
describe("when called without an argument", function() {
it("tells the user to pass a constructor or use jasmine.anything()", function() {
describe('when called without an argument', function() {
it('tells the user to pass a constructor or use jasmine.anything()', function() {
expect(function() {
new jasmineUnderTest.Any();
}).toThrowError(TypeError, /constructor.*anything/);

22
spec/core/asymmetric_equality/AnythingSpec.js
View File

@@ -1,29 +1,29 @@
describe("Anything", function() {
it("matches a string", function() {
describe('Anything', function() {
it('matches a string', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch('foo')).toBe(true);
});
it("matches a number", function() {
it('matches a number', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch(42)).toBe(true);
});
it("matches an object", function() {
it('matches an object', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch({ foo: 'bar' })).toBe(true);
});
it("matches an array", function() {
it('matches an array', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch([1,2,3])).toBe(true);
expect(anything.asymmetricMatch([1, 2, 3])).toBe(true);
});
it("matches a Map", function() {
it('matches a Map', function() {
jasmine.getEnv().requireFunctioningMaps();
var anything = new jasmineUnderTest.Anything();
@@ -31,7 +31,7 @@ describe("Anything", function() {
expect(anything.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Set", function() {
it('matches a Set', function() {
jasmine.getEnv().requireFunctioningSets();
var anything = new jasmineUnderTest.Anything();
@@ -39,7 +39,7 @@ describe("Anything", function() {
expect(anything.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a TypedArray", function() {
it('matches a TypedArray', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var anything = new jasmineUnderTest.Anything();
@@ -47,7 +47,7 @@ describe("Anything", function() {
expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Symbol", function() {
it('matches a Symbol', function() {
jasmine.getEnv().requireFunctioningSymbols();
var anything = new jasmineUnderTest.Anything();
@@ -71,6 +71,6 @@ describe("Anything", function() {
it("jasmineToString's itself", function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.jasmineToString()).toEqual("<jasmine.anything>");
expect(anything.jasmineToString()).toEqual('<jasmine.anything>');
});
});

54
spec/core/asymmetric_equality/ArrayContainingSpec.js
View File

@@ -1,47 +1,47 @@
describe("ArrayContaining", function() {
it("matches any actual to an empty array", function() {
describe('ArrayContaining', function() {
it('matches any actual to an empty array', function() {
var containing = new jasmineUnderTest.ArrayContaining([]);
expect(containing.asymmetricMatch("foo")).toBe(true);
expect(containing.asymmetricMatch('foo')).toBe(true);
});
it("does not work when not passed an array", function() {
var containing = new jasmineUnderTest.ArrayContaining("foo");
it('does not work when not passed an array', function() {
var containing = new jasmineUnderTest.ArrayContaining('foo');
expect(function() {
containing.asymmetricMatch([]);
}).toThrowError(/not 'foo'/);
});
it("matches when the item is in the actual", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('matches when the item is in the actual', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch(["foo"], matchersUtil)).toBe(true);
expect(containing.asymmetricMatch(['foo'], matchersUtil)).toBe(true);
});
it("matches when additional items are in the actual", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('matches when additional items are in the actual', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch(["foo", "bar"], matchersUtil)).toBe(true);
expect(containing.asymmetricMatch(['foo', 'bar'], matchersUtil)).toBe(true);
});
it("does not match when the item is not in the actual", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('does not match when the item is not in the actual', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch(["bar"], matchersUtil)).toBe(false);
expect(containing.asymmetricMatch(['bar'], matchersUtil)).toBe(false);
});
it("does not match when the actual is not an array", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('does not match when the actual is not an array', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch("foo", matchersUtil)).toBe(false);
expect(containing.asymmetricMatch('foo', matchersUtil)).toBe(false);
});
it("jasmineToStrings itself", function() {
it('jasmineToStrings itself', function() {
var sample = [],
matcher = new jasmineUnderTest.ArrayContaining(sample),
pp = jasmine.createSpy('pp').and.returnValue('sample');
@@ -52,17 +52,23 @@ describe("ArrayContaining", function() {
expect(pp).toHaveBeenCalledWith(sample);
});
it("uses custom equality testers", function() {
it('uses custom equality testers', function() {
var tester = function(a, b) {
// All "foo*" strings match each other.
if (typeof a == "string" && typeof b == "string" &&
a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
if (
typeof a == 'string' &&
typeof b == 'string' &&
a.substr(0, 3) == 'foo' &&
b.substr(0, 3) == 'foo'
) {
return true;
}
};
var containing = new jasmineUnderTest.ArrayContaining(["fooVal"]);
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var containing = new jasmineUnderTest.ArrayContaining(['fooVal']);
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch(["fooBar"], matchersUtil)).toBe(true);
expect(containing.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
});
});

36
spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js
View File

@@ -1,35 +1,37 @@
describe("ArrayWithExactContents", function() {
it("matches an array with the same items in a different order", function() {
describe('ArrayWithExactContents', function() {
it('matches an array with the same items in a different order', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(matcher.asymmetricMatch([2, 'a', /a/], matchersUtil)).toBe(true);
});
it("does not work when not passed an array", function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents("foo");
it('does not work when not passed an array', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents('foo');
expect(function() {
matcher.asymmetricMatch([]);
}).toThrowError(/not 'foo'/);
});
it("does not match when an item is missing", function() {
it('does not match when an item is missing', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(false);
expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(
false
);
});
it("does not match when there is an extra item", function() {
it('does not match when there is an extra item', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents(['a']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
});
it("jasmineToStrings itself", function() {
it('jasmineToStrings itself', function() {
var sample = [],
matcher = new jasmineUnderTest.ArrayWithExactContents(sample),
pp = jasmine.createSpy('pp').and.returnValue('sample');
@@ -40,17 +42,23 @@ describe("ArrayWithExactContents", function() {
expect(pp).toHaveBeenCalledWith(sample);
});
it("uses custom equality testers", function() {
it('uses custom equality testers', function() {
var tester = function(a, b) {
// All "foo*" strings match each other.
if (typeof a == "string" && typeof b == "string" &&
a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
if (
typeof a == 'string' &&
typeof b == 'string' &&
a.substr(0, 3) == 'foo' &&
b.substr(0, 3) == 'foo'
) {
return true;
}
};
var matcher = new jasmineUnderTest.ArrayWithExactContents(["fooVal"]);
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var matcher = new jasmineUnderTest.ArrayWithExactContents(['fooVal']);
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(matcher.asymmetricMatch(["fooBar"], matchersUtil)).toBe(true);
expect(matcher.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
});
});

20
spec/core/asymmetric_equality/EmptySpec.js
View File

@@ -1,27 +1,27 @@
describe("Empty", function () {
it("matches an empty object", function () {
describe('Empty', function() {
it('matches an empty object', function() {
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch({})).toBe(true);
expect(empty.asymmetricMatch({undefined: false})).toBe(false);
expect(empty.asymmetricMatch({ undefined: false })).toBe(false);
});
it("matches an empty array", function () {
it('matches an empty array', function() {
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch([])).toBe(true);
expect(empty.asymmetricMatch([1, 12, 3])).toBe(false);
});
it("matches an empty string", function () {
it('matches an empty string', function() {
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch("")).toBe(true);
expect(empty.asymmetricMatch('')).toBe(true);
expect(empty.asymmetricMatch('')).toBe(true);
expect(empty.asymmetricMatch('12312')).toBe(false);
});
it("matches an empty map", function () {
it('matches an empty map', function() {
jasmine.getEnv().requireFunctioningMaps();
var empty = new jasmineUnderTest.Empty();
var fullMap = new Map(); // eslint-disable-line compat/compat
@@ -31,7 +31,7 @@ describe("Empty", function () {
expect(empty.asymmetricMatch(fullMap)).toBe(false);
});
it("matches an empty set", function () {
it('matches an empty set', function() {
jasmine.getEnv().requireFunctioningSets();
var empty = new jasmineUnderTest.Empty();
var fullSet = new Set(); // eslint-disable-line compat/compat
@@ -41,11 +41,11 @@ describe("Empty", function () {
expect(empty.asymmetricMatch(fullSet)).toBe(false);
});
it("matches an empty typed array", function() {
it('matches an empty typed array', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch(new Int16Array())).toBe(true); // eslint-disable-line compat/compat
expect(empty.asymmetricMatch(new Int16Array([1,2]))).toBe(false); // eslint-disable-line compat/compat
expect(empty.asymmetricMatch(new Int16Array([1, 2]))).toBe(false); // eslint-disable-line compat/compat
});
});

56
spec/core/asymmetric_equality/FalsySpec.js
View File

@@ -1,38 +1,38 @@
describe("Falsy", function() {
it("is true for an empty string", function() {
var falsy = new jasmineUnderTest.Falsy();
describe('Falsy', function() {
it('is true for an empty string', function() {
var falsy = new jasmineUnderTest.Falsy();
expect(falsy.asymmetricMatch("")).toBe(true);
expect(falsy.asymmetricMatch('')).toBe(true);
expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
});
expect(falsy.asymmetricMatch('')).toBe(true);
expect(falsy.asymmetricMatch('')).toBe(true);
expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
});
it("is false for a number that is 0", function() {
var falsy = new jasmineUnderTest.Falsy(Number);
it('is false for a number that is 0', function() {
var falsy = new jasmineUnderTest.Falsy(Number);
expect(falsy.asymmetricMatch(1)).toBe(false);
expect(falsy.asymmetricMatch(0)).toBe(true);
expect(falsy.asymmetricMatch(-23)).toBe(false);
expect(falsy.asymmetricMatch(-3.1)).toBe(false);
});
expect(falsy.asymmetricMatch(1)).toBe(false);
expect(falsy.asymmetricMatch(0)).toBe(true);
expect(falsy.asymmetricMatch(-23)).toBe(false);
expect(falsy.asymmetricMatch(-3.1)).toBe(false);
});
it("is true for a null or undefined", function() {
var falsy = new jasmineUnderTest.Falsy(Function);
it('is true for a null or undefined', function() {
var falsy = new jasmineUnderTest.Falsy(Function);
expect(falsy.asymmetricMatch(null)).toBe(true);
expect(falsy.asymmetricMatch(undefined )).toBe(true);
});
expect(falsy.asymmetricMatch(null)).toBe(true);
expect(falsy.asymmetricMatch(undefined)).toBe(true);
});
it("is true for NaN", function() {
var falsy = new jasmineUnderTest.Falsy(Object);
it('is true for NaN', function() {
var falsy = new jasmineUnderTest.Falsy(Object);
expect(falsy.asymmetricMatch(NaN)).toBe(true);
});
expect(falsy.asymmetricMatch(NaN)).toBe(true);
});
it("is true for a false Boolean", function() {
var falsy = new jasmineUnderTest.Falsy(Boolean);
it('is true for a false Boolean', function() {
var falsy = new jasmineUnderTest.Falsy(Boolean);
expect(falsy.asymmetricMatch(false)).toBe(true);
expect(falsy.asymmetricMatch(true)).toBe(false);
});
expect(falsy.asymmetricMatch(false)).toBe(true);
expect(falsy.asymmetricMatch(true)).toBe(false);
});
});

114
spec/core/asymmetric_equality/MapContainingSpec.js
View File

@@ -1,6 +1,7 @@
/* eslint-disable compat/compat */
describe('MapContaining', function() {
function MapI(iterable) { // for IE11
function MapI(iterable) {
// for IE11
var map = new Map();
iterable.forEach(function(kv) {
map.set(kv[0], kv[1]);
@@ -12,7 +13,6 @@ describe('MapContaining', function() {
jasmine.getEnv().requireFunctioningMaps();
});
it('matches any actual map to an empty map', function() {
var actualMap = new MapI([['foo', 'bar']]);
var containing = new jasmineUnderTest.MapContaining(new Map());
@@ -23,14 +23,11 @@ describe('MapContaining', function() {
it('matches when all the key/value pairs in sample have matches in actual', function() {
var actualMap = new MapI([
['foo', [1, 2, 3]],
[{'foo': 'bar'}, 'baz'],
['other', 'any'],
[{ foo: 'bar' }, 'baz'],
['other', 'any']
]);
var containingMap = new MapI([
[{'foo': 'bar'}, 'baz'],
['foo', [1, 2, 3]],
]);
var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -40,13 +37,10 @@ describe('MapContaining', function() {
it('does not match when a key is not in actual', function() {
var actualMap = new MapI([
['foo', [1, 2, 3]],
[{'foo': 'not a bar'}, 'baz'],
[{ foo: 'not a bar' }, 'baz']
]);
var containingMap = new MapI([
[{'foo': 'bar'}, 'baz'],
['foo', [1, 2, 3]],
]);
var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -54,15 +48,9 @@ describe('MapContaining', function() {
});
it('does not match when a value is not in actual', function() {
var actualMap = new MapI([
['foo', [1, 2, 3]],
[{'foo': 'bar'}, 'baz'],
]);
var actualMap = new MapI([['foo', [1, 2, 3]], [{ foo: 'bar' }, 'baz']]);
var containingMap = new MapI([
[{'foo': 'bar'}, 'baz'],
['foo', [1, 2]],
]);
var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2]]]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -73,18 +61,12 @@ describe('MapContaining', function() {
var actualMap = new MapI([
['foo1', 'not a bar'],
['foo2', 'bar'],
['baz', [1, 2, 3, 4]],
['baz', [1, 2, 3, 4]]
]);
var containingMap = new MapI([
[
jasmineUnderTest.stringMatching(/^foo\d/),
'bar'
],
[
'baz',
jasmineUnderTest.arrayContaining([2, 3])
],
[jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
['baz', jasmineUnderTest.arrayContaining([2, 3])]
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -93,20 +75,11 @@ describe('MapContaining', function() {
});
it('does not match when a key in sample has no asymmetric matches in actual', function() {
var actualMap = new MapI([
['a-foo1', 'bar'],
['baz', [1, 2, 3, 4]],
]);
var actualMap = new MapI([['a-foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
var containingMap = new MapI([
[
jasmineUnderTest.stringMatching(/^foo\d/),
'bar'
],
[
'baz',
jasmineUnderTest.arrayContaining([2, 3])
],
[jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
['baz', jasmineUnderTest.arrayContaining([2, 3])]
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -115,20 +88,11 @@ describe('MapContaining', function() {
});
it('does not match when a value in sample has no asymmetric matches in actual', function() {
var actualMap = new MapI([
['foo1', 'bar'],
['baz', [1, 2, 3, 4]],
]);
var actualMap = new MapI([['foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
var containingMap = new MapI([
[
jasmineUnderTest.stringMatching(/^foo\d/),
'bar'
],
[
'baz',
jasmineUnderTest.arrayContaining([4, 5])
],
[jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
['baz', jasmineUnderTest.arrayContaining([4, 5])]
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -140,18 +104,12 @@ describe('MapContaining', function() {
var actualMap = new MapI([
['foo', new MapI([['foo1', 1], ['foo2', 2]])],
[new MapI([[1, 'bar1'], [2, 'bar2']]), 'bar'],
['other', 'any'],
['other', 'any']
]);
var containingMap = new MapI([
[
'foo',
new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))
],
[
new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])),
'bar'
],
['foo', new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))],
[new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])), 'bar']
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -162,25 +120,41 @@ describe('MapContaining', function() {
it('uses custom equality testers', function() {
function tester(a, b) {
// treat all negative numbers as equal
return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
return typeof a == 'number' && typeof b == 'number'
? a < 0 && b < 0
: a === b;
}
var actualMap = new MapI([['foo', -1]]);
var containing = new jasmineUnderTest.MapContaining(new MapI([['foo', -2]]));
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var containing = new jasmineUnderTest.MapContaining(
new MapI([['foo', -2]])
);
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
});
it('does not match when actual is not a map', function() {
var containingMap = new MapI([['foo', 'bar']]);
expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')).toBe(false);
expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)).toBe(false);
expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({'foo': 'bar'})).toBe(false);
expect(
new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')
).toBe(false);
expect(
new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)
).toBe(false);
expect(
new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({
foo: 'bar'
})
).toBe(false);
});
it('throws an error when sample is not a map', function() {
expect(function() {
new jasmineUnderTest.MapContaining({'foo': 'bar'}).asymmetricMatch(new Map());
new jasmineUnderTest.MapContaining({ foo: 'bar' }).asymmetricMatch(
new Map()
);
}).toThrowError(/You must provide a map/);
});

20
spec/core/asymmetric_equality/NotEmptySpec.js
View File

@@ -1,27 +1,27 @@
describe("NotEmpty", function () {
it("matches a non empty object", function () {
describe('NotEmpty', function() {
it('matches a non empty object', function() {
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch({undefined: false})).toBe(true);
expect(notEmpty.asymmetricMatch({ undefined: false })).toBe(true);
expect(notEmpty.asymmetricMatch({})).toBe(false);
});
it("matches a non empty array", function () {
it('matches a non empty array', function() {
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch([1, 12, 3])).toBe(true);
expect(notEmpty.asymmetricMatch([])).toBe(false);
});
it("matches a non empty string", function () {
it('matches a non empty string', function() {
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch('12312')).toBe(true);
expect(notEmpty.asymmetricMatch("")).toBe(false);
expect(notEmpty.asymmetricMatch('')).toBe(false);
expect(notEmpty.asymmetricMatch('')).toBe(false);
});
it("matches a non empty map", function () {
it('matches a non empty map', function() {
jasmine.getEnv().requireFunctioningMaps();
var notEmpty = new jasmineUnderTest.NotEmpty();
var fullMap = new Map(); // eslint-disable-line compat/compat
@@ -32,7 +32,7 @@ describe("NotEmpty", function () {
expect(notEmpty.asymmetricMatch(emptyMap)).toBe(false);
});
it("matches a non empty set", function () {
it('matches a non empty set', function() {
jasmine.getEnv().requireFunctioningSets();
var notEmpty = new jasmineUnderTest.NotEmpty();
var filledSet = new Set(); // eslint-disable-line compat/compat
@@ -43,11 +43,11 @@ describe("NotEmpty", function () {
expect(notEmpty.asymmetricMatch(emptySet)).toBe(false);
});
it("matches a non empty typed array", function() {
it('matches a non empty typed array', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch(new Int16Array([1,2,3]))).toBe(true); // eslint-disable-line compat/compat
expect(notEmpty.asymmetricMatch(new Int16Array([1, 2, 3]))).toBe(true); // eslint-disable-line compat/compat
expect(notEmpty.asymmetricMatch(new Int16Array())).toBe(false); // eslint-disable-line compat/compat
});
});

143
spec/core/asymmetric_equality/ObjectContainingSpec.js
View File

@@ -1,47 +1,55 @@
describe("ObjectContaining", function() {
it("matches any object actual to an empty object", function() {
describe('ObjectContaining', function() {
it('matches any object actual to an empty object', function() {
var containing = new jasmineUnderTest.ObjectContaining({});
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({foo: 1}, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ foo: 1 }, matchersUtil)).toBe(true);
});
it("does not match when the actual is not an object", function() {
it('does not match when the actual is not an object', function() {
var containing = new jasmineUnderTest.ObjectContaining({});
[1, true, undefined, "a string"].forEach(function(actual) {
[1, true, undefined, 'a string'].forEach(function(actual) {
expect(containing.asymmetricMatch(actual)).toBe(false);
});
});
it("does not match an empty object actual", function() {
var containing = new jasmineUnderTest.ObjectContaining("foo");
it('does not match an empty object actual', function() {
var containing = new jasmineUnderTest.ObjectContaining('foo');
expect(function() {
containing.asymmetricMatch({})
}).toThrowError(/not 'foo'/)
containing.asymmetricMatch({});
}).toThrowError(/not 'foo'/);
});
it("matches when the key/value pair is present in the actual", function() {
var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
it('matches when the key/value pair is present in the actual', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"}, matchersUtil)).toBe(true);
expect(
containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
).toBe(true);
});
it("does not match when the key/value pair is not present in the actual", function() {
var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
it('does not match when the key/value pair is not present in the actual', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({bar: "barVal", quux: "quuxVal"}, matchersUtil)).toBe(false);
expect(
containing.asymmetricMatch(
{ bar: 'barVal', quux: 'quuxVal' },
matchersUtil
)
).toBe(false);
});
it("does not match when the key is present but the value is different in the actual", function() {
var containing = new jasmineUnderTest.ObjectContaining({foo: "other"});
it('does not match when the key is present but the value is different in the actual', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'other' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"}, matchersUtil)).toBe(false);
expect(
containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
).toBe(false);
});
it("jasmineToString's itself", function() {
@@ -53,46 +61,55 @@ describe("ObjectContaining", function() {
'<jasmine.objectContaining(sample)>'
);
expect(pp).toHaveBeenCalledWith(sample);
});
it("matches recursively", function() {
var containing = new jasmineUnderTest.ObjectContaining({one: new jasmineUnderTest.ObjectContaining({two: {}})});
it('matches recursively', function() {
var containing = new jasmineUnderTest.ObjectContaining({
one: new jasmineUnderTest.ObjectContaining({ two: {} })
});
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({one: {two: {}}}, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ one: { two: {} } }, matchersUtil)).toBe(
true
);
});
it("matches when key is present with undefined value", function() {
it('matches when key is present with undefined value', function() {
var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(
true
);
});
it("does not match when key with undefined value is not present", function() {
it('does not match when key with undefined value is not present', function() {
var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({}, matchersUtil)).toBe(false);
});
it("matches defined properties", function(){
var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
it('matches defined properties', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
var definedPropertyObject = {};
Object.defineProperty(definedPropertyObject, "foo", {
get: function() { return "fooVal" }
Object.defineProperty(definedPropertyObject, 'foo', {
get: function() {
return 'fooVal';
}
});
expect(containing.asymmetricMatch(definedPropertyObject, matchersUtil)).toBe(true);
expect(
containing.asymmetricMatch(definedPropertyObject, matchersUtil)
).toBe(true);
});
it("matches prototype properties", function(){
var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
it('matches prototype properties', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
var prototypeObject = {foo: "fooVal"};
var prototypeObject = { foo: 'fooVal' };
var obj;
if (Object.create) {
@@ -107,23 +124,31 @@ describe("ObjectContaining", function() {
expect(containing.asymmetricMatch(obj, matchersUtil)).toBe(true);
});
it("uses custom equality testers", function() {
it('uses custom equality testers', function() {
var tester = function(a, b) {
// All "foo*" strings match each other.
if (typeof a == "string" && typeof b == "string" &&
a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
if (
typeof a == 'string' &&
typeof b == 'string' &&
a.substr(0, 3) == 'foo' &&
b.substr(0, 3) == 'foo'
) {
return true;
}
};
var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch({foo: "fooBar"}, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ foo: 'fooBar' }, matchersUtil)).toBe(
true
);
});
describe("valuesForDiff_", function() {
describe("when other is not an object", function() {
it("sets self to jasmineToString()", function () {
describe('valuesForDiff_', function() {
describe('when other is not an object', function() {
it('sets self to jasmineToString()', function() {
var containing = new jasmineUnderTest.ObjectContaining({}),
pp = jasmineUnderTest.makePrettyPrinter(),
result = containing.valuesForDiff_('a', pp);
@@ -135,27 +160,31 @@ describe("ObjectContaining", function() {
});
});
describe("when other is an object", function() {
it("includes keys that are present in both other and sample", function() {
var sample = {a: 1, b: 2},
other = {a: 3, b: 4},
describe('when other is an object', function() {
it('includes keys that are present in both other and sample', function() {
var sample = { a: 1, b: 2 },
other = { a: 3, b: 4 },
containing = new jasmineUnderTest.ObjectContaining(sample),
result = containing.valuesForDiff_(other);
expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
expect(result.self).not.toBeInstanceOf(
jasmineUnderTest.ObjectContaining
);
expect(result).toEqual({
self: sample,
other: other
});
});
it("includes keys that are present only in sample", function() {
var sample = {a: 1, b: 2},
other = {a: 3},
it('includes keys that are present only in sample', function() {
var sample = { a: 1, b: 2 },
other = { a: 3 },
containing = new jasmineUnderTest.ObjectContaining(sample),
result = containing.valuesForDiff_(other);
expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
expect(result.self).not.toBeInstanceOf(
jasmineUnderTest.ObjectContaining
);
expect(containing.valuesForDiff_(other)).toEqual({
self: sample,
other: {
@@ -165,13 +194,15 @@ describe("ObjectContaining", function() {
});
});
it("omits keys that are present only in other", function() {
var sample = {a: 1, b: 2},
other = {a: 3, b: 4, c: 5},
it('omits keys that are present only in other', function() {
var sample = { a: 1, b: 2 },
other = { a: 3, b: 4, c: 5 },
containing = new jasmineUnderTest.ObjectContaining(sample),
result = containing.valuesForDiff_(other);
expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
expect(result.self).not.toBeInstanceOf(
jasmineUnderTest.ObjectContaining
);
expect(result).toEqual({
self: sample,
other: {

63
spec/core/asymmetric_equality/SetContainingSpec.js
View File

@@ -1,6 +1,7 @@
/* eslint-disable compat/compat */
describe('SetContaining', function() {
function SetI(iterable) { // for IE11
function SetI(iterable) {
// for IE11
var set = new Set();
iterable.forEach(function(v) {
set.add(v);
@@ -12,7 +13,6 @@ describe('SetContaining', function() {
jasmine.getEnv().requireFunctioningSets();
});
it('matches any actual set to an empty set', function() {
var actualSet = new SetI(['foo', 'bar']);
var containing = new jasmineUnderTest.SetContaining(new Set());
@@ -21,13 +21,9 @@ describe('SetContaining', function() {
});
it('matches when all the values in sample have matches in actual', function() {
var actualSet = new SetI([
{'foo': 'bar'}, 'baz', [1, 2, 3]
]);
var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
var containingSet = new SetI([
[1, 2, 3], {'foo': 'bar'}
]);
var containingSet = new SetI([[1, 2, 3], { foo: 'bar' }]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -35,13 +31,9 @@ describe('SetContaining', function() {
});
it('does not match when a value is not in actual', function() {
var actualSet = new SetI([
{'foo': 'bar'}, 'baz', [1, 2, 3]
]);
var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
var containingSet = new SetI([
[1, 2], {'foo': 'bar'}
]);
var containingSet = new SetI([[1, 2], { foo: 'bar' }]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -49,13 +41,11 @@ describe('SetContaining', function() {
});
it('matches when all the values in sample have asymmetric matches in actual', function() {
var actualSet = new SetI([
[1, 2, 3, 4], 'other', 'foo1'
]);
var actualSet = new SetI([[1, 2, 3, 4], 'other', 'foo1']);
var containingSet = new SetI([
jasmineUnderTest.stringMatching(/^foo\d/),
jasmineUnderTest.arrayContaining([2, 3]),
jasmineUnderTest.arrayContaining([2, 3])
]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -64,13 +54,11 @@ describe('SetContaining', function() {
});
it('does not match when a value in sample has no asymmetric matches in actual', function() {
var actualSet = new SetI([
'a-foo1', [1, 2, 3, 4], 'other'
]);
var actualSet = new SetI(['a-foo1', [1, 2, 3, 4], 'other']);
var containingSet = new SetI([
jasmine.stringMatching(/^foo\d/),
jasmine.arrayContaining([2, 3]),
jasmine.arrayContaining([2, 3])
]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -79,12 +67,11 @@ describe('SetContaining', function() {
});
it('matches recursively', function() {
var actualSet = new SetI([
'foo', new SetI([1, 'bar', 2]), 'other'
]);
var actualSet = new SetI(['foo', new SetI([1, 'bar', 2]), 'other']);
var containingSet = new SetI([
new jasmineUnderTest.SetContaining(new SetI(['bar'])), 'foo'
new jasmineUnderTest.SetContaining(new SetI(['bar'])),
'foo'
]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -95,25 +82,37 @@ describe('SetContaining', function() {
it('uses custom equality testers', function() {
function tester(a, b) {
// treat all negative numbers as equal
return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
return typeof a == 'number' && typeof b == 'number'
? a < 0 && b < 0
: a === b;
}
var actualSet = new SetI(['foo', -1]);
var containing = new jasmineUnderTest.SetContaining(new SetI([-2, 'foo']));
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
});
it('does not match when actual is not a set', function() {
var containingSet = new SetI(['foo']);
expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')).toBe(false);
expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)).toBe(false);
expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])).toBe(false);
expect(
new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')
).toBe(false);
expect(
new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)
).toBe(false);
expect(
new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])
).toBe(false);
});
it('throws an error when sample is not a set', function() {
expect(function() {
new jasmineUnderTest.SetContaining({'foo': 'bar'}).asymmetricMatch(new Set());
new jasmineUnderTest.SetContaining({ foo: 'bar' }).asymmetricMatch(
new Set()
);
}).toThrowError(/You must provide a set/);
});

12
spec/core/asymmetric_equality/StringMatchingSpec.js
View File

@@ -1,19 +1,19 @@
describe("StringMatching", function() {
it("matches a string against a provided regexp", function() {
describe('StringMatching', function() {
it('matches a string against a provided regexp', function() {
var matcher = new jasmineUnderTest.StringMatching(/foo/);
expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
expect(matcher.asymmetricMatch('barbaz')).toBe(false);
});
it("matches a string against provided string", function() {
it('matches a string against provided string', function() {
var matcher = new jasmineUnderTest.StringMatching('foo');
expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
expect(matcher.asymmetricMatch('barbaz')).toBe(false);
});
it("raises an Error when the expected is not a String or RegExp", function() {
it('raises an Error when the expected is not a String or RegExp', function() {
expect(function() {
new jasmineUnderTest.StringMatching({});
}).toThrowError(/not a String or a RegExp/);
@@ -22,6 +22,8 @@ describe("StringMatching", function() {
it("jasmineToString's itself", function() {
var matching = new jasmineUnderTest.StringMatching(/^foo/);
expect(matching.jasmineToString()).toEqual("<jasmine.stringMatching(/^foo/)>");
expect(matching.jasmineToString()).toEqual(
'<jasmine.stringMatching(/^foo/)>'
);
});
});

28
spec/core/asymmetric_equality/TruthySpec.js
View File

@@ -1,12 +1,12 @@
describe("Truthy", function () {
it("is true for a non empty string", function () {
describe('Truthy', function() {
it('is true for a non empty string', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch("foo")).toBe(true);
expect(truthy.asymmetricMatch("")).toBe(false);
expect(truthy.asymmetricMatch('foo')).toBe(true);
expect(truthy.asymmetricMatch('')).toBe(false);
});
it("is true for a number that is not 0", function () {
it('is true for a number that is not 0', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(1)).toBe(true);
@@ -15,49 +15,47 @@ describe("Truthy", function () {
expect(truthy.asymmetricMatch(-3.1)).toBe(true);
});
it("is true for a function", function () {
it('is true for a function', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(function () {
})).toBe(true);
expect(truthy.asymmetricMatch(function() {})).toBe(true);
});
it("is true for an Object", function () {
it('is true for an Object', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch({})).toBe(true);
});
it("is true for a truthful Boolean", function () {
it('is true for a truthful Boolean', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(true)).toBe(true);
expect(truthy.asymmetricMatch(false)).toBe(false);
});
it("is true for an empty object", function () {
it('is true for an empty object', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch({})).toBe(true);
});
it("is true for an empty array", function () {
it('is true for an empty array', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch([])).toBe(true);
});
it("is true for a date", function () {
it('is true for a date', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(new Date())).toBe(true);
});
it("is true for a infiniti", function () {
it('is true for a infiniti', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(Infinity)).toBe(true);
expect(truthy.asymmetricMatch(-Infinity)).toBe(true);
});
});

153
spec/core/integration/AsymmetricEqualityTestersSpec.js
View File

@@ -1,12 +1,12 @@
describe('Asymmetric equality testers (Integration)', function () {
describe('Asymmetric equality testers (Integration)', function() {
function verifyPasses(expectations, setup) {
it('passes', function (done) {
it('passes', function(done) {
var env = new jasmineUnderTest.Env();
env.it('a spec', function () {
env.it('a spec', function() {
expectations(env);
});
var specExpectations = function (result) {
var specExpectations = function(result) {
expect(result.status).toEqual('passed');
expect(result.passedExpectations.length)
.withContext('Number of passed expectations')
@@ -14,115 +14,122 @@ describe('Asymmetric equality testers (Integration)', function () {
expect(result.failedExpectations.length)
.withContext('Number of failed expectations')
.toEqual(0);
expect(result.failedExpectations[0] && result.failedExpectations[0].message)
expect(
result.failedExpectations[0] && result.failedExpectations[0].message
)
.withContext('Failure message')
.toBeUndefined();
};
env.addReporter({specDone: specExpectations});
env.addReporter({ specDone: specExpectations });
env.execute(null, done);
});
}
function verifyFails(expectations) {
it('fails', function (done) {
it('fails', function(done) {
var env = new jasmineUnderTest.Env();
env.it('a spec', function () {
env.it('a spec', function() {
expectations(env);
});
var specExpectations = function (result) {
var specExpectations = function(result) {
expect(result.status).toEqual('failed');
expect(result.failedExpectations.length)
.withContext('Number of failed expectations')
.toEqual(1);
expect(result.failedExpectations[0].message)
.withContext('Failed with a thrown error rather than a matcher failure')
.withContext(
'Failed with a thrown error rather than a matcher failure'
)
.not.toMatch(/^Error: /);
expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
expect(result.failedExpectations[0].matcherName)
.withContext('Matcher name')
.not.toEqual('');
};
env.addReporter({specDone: specExpectations});
env.addReporter({ specDone: specExpectations });
env.execute(null, done);
});
}
describe('any', function () {
verifyPasses(function (env) {
describe('any', function() {
verifyPasses(function(env) {
env.expect(5).toEqual(jasmineUnderTest.any(Number));
});
verifyFails(function (env) {
env.expect("five").toEqual(jasmineUnderTest.any(Number));
verifyFails(function(env) {
env.expect('five').toEqual(jasmineUnderTest.any(Number));
});
});
describe('anything', function () {
verifyPasses(function (env) {
describe('anything', function() {
verifyPasses(function(env) {
env.expect('').toEqual(jasmineUnderTest.anything());
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect(null).toEqual(jasmineUnderTest.anything());
});
});
describe('arrayContaining', function () {
verifyPasses(function (env) {
env.addCustomEqualityTester(function (a, b) {
describe('arrayContaining', function() {
verifyPasses(function(env) {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
env.expect([1, 2, 3]).toEqual(jasmineUnderTest.arrayContaining(["2"]));
env.expect([1, 2, 3]).toEqual(jasmineUnderTest.arrayContaining(['2']));
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect(null).toEqual(jasmineUnderTest.arrayContaining([2]));
});
});
describe('arrayWithExactContents', function () {
verifyPasses(function (env) {
env.addCustomEqualityTester(function (a, b) {
describe('arrayWithExactContents', function() {
verifyPasses(function(env) {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
env.expect([1, 2]).toEqual(jasmineUnderTest.arrayWithExactContents(["2", "1"]));
env
.expect([1, 2])
.toEqual(jasmineUnderTest.arrayWithExactContents(['2', '1']));
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect([]).toEqual(jasmineUnderTest.arrayWithExactContents([2]));
});
});
describe('empty', function () {
verifyPasses(function (env) {
describe('empty', function() {
verifyPasses(function(env) {
env.expect([]).toEqual(jasmineUnderTest.empty());
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect([1]).toEqual(jasmineUnderTest.empty());
});
});
describe('falsy', function () {
verifyPasses(function (env) {
describe('falsy', function() {
verifyPasses(function(env) {
env.expect(false).toEqual(jasmineUnderTest.falsy());
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect(true).toEqual(jasmineUnderTest.falsy());
});
});
describe('mapContaining', function () {
describe('mapContaining', function() {
if (jasmine.getEnv().hasFunctioningMaps()) {
verifyPasses(function (env) {
verifyPasses(function(env) {
var actual = new Map();
actual.set('a', "2");
actual.set('a', '2');
var expected = new Map();
expected.set('a', 2);
env.addCustomEqualityTester(function (a, b) {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
@@ -130,54 +137,62 @@ describe('Asymmetric equality testers (Integration)', function () {
});
} else {
it('passes', function() {
jasmine.getEnv().pending('Browser has incomplete or missing support for Maps');
jasmine
.getEnv()
.pending('Browser has incomplete or missing support for Maps');
});
}
if (jasmine.getEnv().hasFunctioningMaps()) {
verifyFails(function (env) {
env.expect('something').toEqual(jasmineUnderTest.mapContaining(new Map()));
verifyFails(function(env) {
env
.expect('something')
.toEqual(jasmineUnderTest.mapContaining(new Map()));
});
} else {
it('fails', function() {
jasmine.getEnv().pending('Browser has incomplete or missing support for Maps');
jasmine
.getEnv()
.pending('Browser has incomplete or missing support for Maps');
});
}
});
describe('notEmpty', function () {
verifyPasses(function (env) {
describe('notEmpty', function() {
verifyPasses(function(env) {
env.expect([1]).toEqual(jasmineUnderTest.notEmpty());
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect([]).toEqual(jasmineUnderTest.notEmpty());
});
});
describe('objectContaining', function () {
verifyPasses(function (env) {
env.addCustomEqualityTester(function (a, b) {
describe('objectContaining', function() {
verifyPasses(function(env) {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
env.expect({a: 1, b: 2}).toEqual(jasmineUnderTest.objectContaining({a: "1"}));
env
.expect({ a: 1, b: 2 })
.toEqual(jasmineUnderTest.objectContaining({ a: '1' }));
});
verifyFails(function (env) {
env.expect({}).toEqual(jasmineUnderTest.objectContaining({a: "1"}));
verifyFails(function(env) {
env.expect({}).toEqual(jasmineUnderTest.objectContaining({ a: '1' }));
});
});
describe('setContaining', function () {
describe('setContaining', function() {
if (jasmine.getEnv().hasFunctioningSets()) {
verifyPasses(function (env) {
verifyPasses(function(env) {
var actual = new Set();
actual.add("1");
actual.add('1');
var expected = new Set();
actual.add(1);
env.addCustomEqualityTester(function (a, b) {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
@@ -185,37 +200,43 @@ describe('Asymmetric equality testers (Integration)', function () {
});
} else {
it('pases', function() {
jasmine.getEnv().pending('Browser has incomplete or missing support for Sets');
jasmine
.getEnv()
.pending('Browser has incomplete or missing support for Sets');
});
}
if (jasmine.getEnv().hasFunctioningSets()) {
verifyFails(function (env) {
env.expect('something').toEqual(jasmineUnderTest.setContaining(new Set()));
verifyFails(function(env) {
env
.expect('something')
.toEqual(jasmineUnderTest.setContaining(new Set()));
});
} else {
it('fails', function() {
jasmine.getEnv().pending('Browser has incomplete or missing support for Sets');
jasmine
.getEnv()
.pending('Browser has incomplete or missing support for Sets');
});
}
});
describe('stringMatching', function () {
verifyPasses(function (env) {
describe('stringMatching', function() {
verifyPasses(function(env) {
env.expect('foo').toEqual(jasmineUnderTest.stringMatching(/o/));
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect('bar').toEqual(jasmineUnderTest.stringMatching(/o/));
});
});
describe('truthy', function () {
verifyPasses(function (env) {
describe('truthy', function() {
verifyPasses(function(env) {
env.expect(true).toEqual(jasmineUnderTest.truthy());
});
verifyFails(function (env) {
verifyFails(function(env) {
env.expect(false).toEqual(jasmineUnderTest.truthy());
});
});

60
spec/core/integration/CustomAsyncMatchersSpec.js
View File

@@ -4,7 +4,7 @@ describe('Custom Async Matchers (Integration)', function() {
beforeEach(function() {
env = new jasmineUnderTest.Env();
env.configure({random: false});
env.configure({ random: false });
});
afterEach(function() {
@@ -17,7 +17,11 @@ describe('Custom Async Matchers (Integration)', function() {
env.it('spec using custom async matcher', function() {
env.addAsyncMatchers({
toBeReal: function() {
return { compare: function() { return Promise.resolve({ pass: true }); } };
return {
compare: function() {
return Promise.resolve({ pass: true });
}
};
}
});
@@ -39,8 +43,12 @@ describe('Custom Async Matchers (Integration)', function() {
env.addAsyncMatchers({
toBeReal: function() {
return {
compare: function() { return Promise.resolve({ pass: true }); },
negativeCompare: function() { return Promise.resolve({ pass: true }); }
compare: function() {
return Promise.resolve({ pass: true });
},
negativeCompare: function() {
return Promise.resolve({ pass: true });
}
};
}
});
@@ -74,7 +82,9 @@ describe('Custom Async Matchers (Integration)', function() {
});
var specExpectations = function(result) {
expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
expect(result.failedExpectations[0].message).toEqual(
"Expected 'a' to be real."
);
};
env.addReporter({ specDone: specExpectations });
@@ -82,22 +92,24 @@ describe('Custom Async Matchers (Integration)', function() {
});
// TODO: remove this in the next major release.
it("passes the jasmine utility and current equality testers to the matcher factory", function(done) {
it('passes the jasmine utility and current equality testers to the matcher factory', function(done) {
jasmine.getEnv().requirePromises();
var matcherFactory = function () {
var matcherFactory = function() {
return {
compare: function () {
return Promise.resolve({pass: true});
compare: function() {
return Promise.resolve({ pass: true });
}
};
},
matcherFactorySpy = jasmine.createSpy("matcherFactorySpy").and.callFake(matcherFactory),
customEqualityFn = function () {
matcherFactorySpy = jasmine
.createSpy('matcherFactorySpy')
.and.callFake(matcherFactory),
customEqualityFn = function() {
return true;
};
env.it("spec with expectation", function() {
env.it('spec with expectation', function() {
env.addCustomEqualityTester(customEqualityFn);
env.addAsyncMatchers({
toBeReal: matcherFactorySpy
@@ -117,31 +129,35 @@ describe('Custom Async Matchers (Integration)', function() {
env.execute(null, done);
});
it("provides custom equality testers to the matcher factory via matchersUtil", function(done) {
it('provides custom equality testers to the matcher factory via matchersUtil', function(done) {
jasmine.getEnv().requirePromises();
var matcherFactory = function (matchersUtil) {
var matcherFactory = function(matchersUtil) {
return {
compare: function (actual, expected) {
return Promise.resolve({pass: matchersUtil.equals(actual[0], expected)});
compare: function(actual, expected) {
return Promise.resolve({
pass: matchersUtil.equals(actual[0], expected)
});
}
};
},
customEqualityFn = jasmine.createSpy("customEqualityFn").and.callFake(function (a, b) {
return a.toString() === b;
});
customEqualityFn = jasmine
.createSpy('customEqualityFn')
.and.callFake(function(a, b) {
return a.toString() === b;
});
env.it("spec with expectation", function() {
env.it('spec with expectation', function() {
env.addCustomEqualityTester(customEqualityFn);
env.addAsyncMatchers({
toBeArrayWithFirstElement: matcherFactory
});
return env.expectAsync([1, 2]).toBeArrayWithFirstElement("1");
return env.expectAsync([1, 2]).toBeArrayWithFirstElement('1');
});
var specExpectations = function(result) {
expect(customEqualityFn).toHaveBeenCalledWith(1, "1");
expect(customEqualityFn).toHaveBeenCalledWith(1, '1');
expect(result.failedExpectations).toEqual([]);
};

182
spec/core/integration/CustomMatchersSpec.js
View File

@@ -1,52 +1,65 @@
describe("Custom Matchers (Integration)", function () {
describe('Custom Matchers (Integration)', function() {
var env;
var fakeTimer;
beforeEach(function () {
beforeEach(function() {
env = new jasmineUnderTest.Env();
env.configure({random: false});
env.configure({ random: false });
});
afterEach(function() {
env.cleanup_();
});
it("allows adding more matchers local to a spec", function (done) {
env.it('spec defining a custom matcher', function () {
it('allows adding more matchers local to a spec', function(done) {
env.it('spec defining a custom matcher', function() {
env.addMatchers({
matcherForSpec: function () {
matcherForSpec: function() {
return {
compare: function (actual, expected) {
return {pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected};
compare: function(actual, expected) {
return {
pass: false,
message:
'matcherForSpec: actual: ' +
actual +
'; expected: ' +
expected
};
}
}
};
}
});
env.expect("zzz").matcherForSpec("yyy");
env.expect('zzz').matcherForSpec('yyy');
});
env.it("spec without custom matcher defined", function() {
expect(env.expect("zzz").matcherForSpec).toBeUndefined();
env.it('spec without custom matcher defined', function() {
expect(env.expect('zzz').matcherForSpec).toBeUndefined();
});
var specDoneSpy = jasmine.createSpy("specDoneSpy");
var specDoneSpy = jasmine.createSpy('specDoneSpy');
var expectations = function() {
var firstSpecResult = specDoneSpy.calls.first().args[0];
expect(firstSpecResult.status).toEqual("failed");
expect(firstSpecResult.failedExpectations[0].message).toEqual("matcherForSpec: actual: zzz; expected: yyy");
expect(firstSpecResult.status).toEqual('failed');
expect(firstSpecResult.failedExpectations[0].message).toEqual(
'matcherForSpec: actual: zzz; expected: yyy'
);
done();
};
env.addReporter({ specDone:specDoneSpy });
env.addReporter({ specDone: specDoneSpy });
env.execute(null, expectations);
});
it("passes the spec if the custom matcher passes", function(done) {
env.it("spec using custom matcher", function() {
it('passes the spec if the custom matcher passes', function(done) {
env.it('spec using custom matcher', function() {
env.addMatchers({
toBeReal: function() {
return { compare: function() { return { pass: true }; } };
return {
compare: function() {
return { pass: true };
}
};
}
});
@@ -61,20 +74,30 @@ describe("Custom Matchers (Integration)", function () {
env.execute(null, done);
});
it("passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers", function(done) {
env.it("spec using custom equality matcher", function() {
it('passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers', function(done) {
env.it('spec using custom equality matcher', function() {
var customEqualityFn = function(a, b) {
// All "foo*" strings match each other.
if (typeof a == "string" && typeof b == "string" &&
a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
if (
typeof a == 'string' &&
typeof b == 'string' &&
a.substr(0, 3) == 'foo' &&
b.substr(0, 3) == 'foo'
) {
return true;
}
};
env.addCustomEqualityTester(customEqualityFn);
env.expect({foo: 'fooValue'}).toEqual(jasmineUnderTest.objectContaining({foo: 'fooBar'}));
env.expect(['fooValue', 'things']).toEqual(jasmineUnderTest.arrayContaining(['fooBar']));
env.expect(['fooValue']).toEqual(jasmineUnderTest.arrayWithExactContents(['fooBar']));
env
.expect({ foo: 'fooValue' })
.toEqual(jasmineUnderTest.objectContaining({ foo: 'fooBar' }));
env
.expect(['fooValue', 'things'])
.toEqual(jasmineUnderTest.arrayContaining(['fooBar']));
env
.expect(['fooValue'])
.toEqual(jasmineUnderTest.arrayWithExactContents(['fooBar']));
});
var specExpectations = function(result) {
@@ -85,26 +108,30 @@ describe("Custom Matchers (Integration)", function () {
env.execute(null, done);
});
it("supports asymmetric equality testers that take a list of custom equality testers", function(done) {
it('supports asymmetric equality testers that take a list of custom equality testers', function(done) {
// TODO: remove this in the next major release.
spyOn(jasmineUnderTest, 'getEnv').and.returnValue(env);
env.it("spec using custom asymmetric equality tester", function() {
env.it('spec using custom asymmetric equality tester', function() {
var customEqualityFn = function(a, b) {
if (a === 2 && b === "two") {
if (a === 2 && b === 'two') {
return true;
}
};
var arrayWithFirstElement = function(sample) {
return {
asymmetricMatch: function (actual, customEqualityTesters) {
return jasmineUnderTest.matchersUtil.equals(sample, actual[0], customEqualityTesters);
asymmetricMatch: function(actual, customEqualityTesters) {
return jasmineUnderTest.matchersUtil.equals(
sample,
actual[0],
customEqualityTesters
);
}
};
};
env.addCustomEqualityTester(customEqualityFn);
env.expect(["two"]).toEqual(arrayWithFirstElement(2));
env.expect(['two']).toEqual(arrayWithFirstElement(2));
});
var specExpectations = function(result) {
@@ -115,8 +142,8 @@ describe("Custom Matchers (Integration)", function () {
env.execute(null, done);
});
it("displays an appropriate failure message if a custom equality matcher fails", function(done) {
env.it("spec using custom equality matcher", function() {
it('displays an appropriate failure message if a custom equality matcher fails', function(done) {
env.it('spec using custom equality matcher', function() {
var customEqualityFn = function(a, b) {
// "foo" is not equal to anything
if (a === 'foo' || b === 'foo') {
@@ -125,7 +152,7 @@ describe("Custom Matchers (Integration)", function () {
};
env.addCustomEqualityTester(customEqualityFn);
env.expect({foo: 'foo'}).toEqual({foo: 'foo'});
env.expect({ foo: 'foo' }).toEqual({ foo: 'foo' });
});
var specExpectations = function(result) {
@@ -139,13 +166,17 @@ describe("Custom Matchers (Integration)", function () {
env.execute(null, done);
});
it("uses the negative compare function for a negative comparison, if provided", function(done) {
env.it("spec with custom negative comparison matcher", function() {
it('uses the negative compare function for a negative comparison, if provided', function(done) {
env.it('spec with custom negative comparison matcher', function() {
env.addMatchers({
toBeReal: function() {
return {
compare: function() { return { pass: true }; },
negativeCompare: function() { return { pass: true }; }
compare: function() {
return { pass: true };
},
negativeCompare: function() {
return { pass: true };
}
};
}
});
@@ -161,7 +192,7 @@ describe("Custom Matchers (Integration)", function () {
env.execute(null, done);
});
it("generates messages with the same rules as built in matchers absent a custom message", function(done) {
it('generates messages with the same rules as built in matchers absent a custom message', function(done) {
env.it('spec with an expectation', function() {
env.addMatchers({
toBeReal: function() {
@@ -169,25 +200,29 @@ describe("Custom Matchers (Integration)", function () {
compare: function() {
return { pass: false };
}
}
};
}
});
env.expect("a").toBeReal();
env.expect('a').toBeReal();
});
var specExpectations = function(result) {
expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
expect(result.failedExpectations[0].message).toEqual(
"Expected 'a' to be real."
);
};
env.addReporter({ specDone: specExpectations });
env.execute(null, done);
});
it("passes the expected and actual arguments to the comparison function", function(done) {
var argumentSpy = jasmine.createSpy("argument spy").and.returnValue({ pass: true });
it('passes the expected and actual arguments to the comparison function', function(done) {
var argumentSpy = jasmine
.createSpy('argument spy')
.and.returnValue({ pass: true });
env.it('spec with an expectation', function () {
env.it('spec with an expectation', function() {
env.addMatchers({
toBeReal: function() {
return { compare: argumentSpy };
@@ -195,14 +230,14 @@ describe("Custom Matchers (Integration)", function () {
});
env.expect(true).toBeReal();
env.expect(true).toBeReal("arg");
env.expect(true).toBeReal("arg1", "arg2");
env.expect(true).toBeReal('arg');
env.expect(true).toBeReal('arg1', 'arg2');
});
var specExpectations = function() {
expect(argumentSpy).toHaveBeenCalledWith(true);
expect(argumentSpy).toHaveBeenCalledWith(true, "arg");
expect(argumentSpy).toHaveBeenCalledWith(true, "arg1", "arg2");
expect(argumentSpy).toHaveBeenCalledWith(true, 'arg');
expect(argumentSpy).toHaveBeenCalledWith(true, 'arg1', 'arg2');
};
env.addReporter({ specDone: specExpectations });
@@ -210,13 +245,22 @@ describe("Custom Matchers (Integration)", function () {
});
// TODO: remove this in the next major release.
it("passes the jasmine utility and current equality testers to the matcher factory", function(done) {
var matcherFactory = function() { return { compare: function() { return {pass: true}; }}; },
matcherFactorySpy = jasmine.createSpy("matcherFactorySpy").and.callFake(matcherFactory),
customEqualityFn = function() { return true; };
it('passes the jasmine utility and current equality testers to the matcher factory', function(done) {
var matcherFactory = function() {
return {
compare: function() {
return { pass: true };
}
};
},
matcherFactorySpy = jasmine
.createSpy('matcherFactorySpy')
.and.callFake(matcherFactory),
customEqualityFn = function() {
return true;
};
env.it("spec with expectation", function() {
env.it('spec with expectation', function() {
env.addCustomEqualityTester(customEqualityFn);
env.addMatchers({
toBeReal: matcherFactorySpy
@@ -236,33 +280,35 @@ describe("Custom Matchers (Integration)", function () {
env.execute(null, done);
});
it("provides custom equality testers to the matcher factory via matchersUtil", function (done) {
var matcherFactory = function (matchersUtil) {
it('provides custom equality testers to the matcher factory via matchersUtil', function(done) {
var matcherFactory = function(matchersUtil) {
return {
compare: function (actual, expected) {
return {pass: matchersUtil.equals(actual[0], expected)};
compare: function(actual, expected) {
return { pass: matchersUtil.equals(actual[0], expected) };
}
};
},
customEqualityFn = jasmine.createSpy("customEqualityFn").and.callFake(function (a, b) {
return a.toString() === b;
});
customEqualityFn = jasmine
.createSpy('customEqualityFn')
.and.callFake(function(a, b) {
return a.toString() === b;
});
env.it("spec with expectation", function () {
env.it('spec with expectation', function() {
env.addCustomEqualityTester(customEqualityFn);
env.addMatchers({
toBeArrayWithFirstElement: matcherFactory
});
env.expect([1, 2]).toBeArrayWithFirstElement("1");
env.expect([1, 2]).toBeArrayWithFirstElement('1');
});
var specExpectations = function (result) {
expect(customEqualityFn).toHaveBeenCalledWith(1, "1");
var specExpectations = function(result) {
expect(customEqualityFn).toHaveBeenCalledWith(1, '1');
expect(result.failedExpectations).toEqual([]);
};
env.addReporter({specDone: specExpectations});
env.addReporter({ specDone: specExpectations });
env.execute(null, done);
});
});

42
spec/core/integration/CustomObjectFormatterSpec.js
View File

@@ -1,14 +1,16 @@
describe("Custom object formatters", function() {
describe('Custom object formatters', function() {
var env;
beforeEach(function() {
env = new jasmineUnderTest.Env();
env.configure({random: false});
env.configure({ random: false });
});
it("scopes custom object formatters to a spec", function(done) {
it('scopes custom object formatters to a spec', function(done) {
env.it('a spec with custom pretty-printer', function() {
env.addCustomObjectFormatter(function(obj) { return 'custom(' + obj + ')'; });
env.addCustomObjectFormatter(function(obj) {
return 'custom(' + obj + ')';
});
env.expect(42).toBeUndefined();
});
@@ -21,23 +23,29 @@ describe("Custom object formatters", function() {
specResults.push(result);
};
var expectations = function() {
expect(specResults[0].failedExpectations[0].message).toEqual("Expected custom(42) to be undefined.");
expect(specResults[1].failedExpectations[0].message).toEqual("Expected 42 to be undefined.");
expect(specResults[0].failedExpectations[0].message).toEqual(
'Expected custom(42) to be undefined.'
);
expect(specResults[1].failedExpectations[0].message).toEqual(
'Expected 42 to be undefined.'
);
done();
};
env.addReporter({ specDone:specDone });
env.addReporter({ specDone: specDone });
env.execute(null, expectations);
});
it("scopes custom object formatters to a suite", function(done) {
it('scopes custom object formatters to a suite', function(done) {
env.it('a spec without custom pretty-printer', function() {
env.expect(42).toBeUndefined();
});
env.describe('with custom pretty-printer', function() {
env.beforeEach(function() {
env.addCustomObjectFormatter(function(obj) { return 'custom(' + obj + ')'; });
env.addCustomObjectFormatter(function(obj) {
return 'custom(' + obj + ')';
});
});
env.it('a spec', function() {
@@ -50,18 +58,24 @@ describe("Custom object formatters", function() {
specResults.push(result);
};
var expectations = function() {
expect(specResults[0].failedExpectations[0].message).toEqual("Expected 42 to be undefined.");
expect(specResults[1].failedExpectations[0].message).toEqual("Expected custom(42) to be undefined.");
expect(specResults[0].failedExpectations[0].message).toEqual(
'Expected 42 to be undefined.'
);
expect(specResults[1].failedExpectations[0].message).toEqual(
'Expected custom(42) to be undefined.'
);
done();
};
env.addReporter({ specDone:specDone });
env.addReporter({ specDone: specDone });
env.execute(null, expectations);
});
it("throws an exception if you try to add a custom object formatter outside a runable", function() {
it('throws an exception if you try to add a custom object formatter outside a runable', function() {
expect(function() {
env.addCustomObjectFormatter(function() {});
}).toThrowError('Custom object formatters must be added in a before function or a spec')
}).toThrowError(
'Custom object formatters must be added in a before function or a spec'
);
});
});

27
spec/core/integration/CustomSpyStrategiesSpec.js
View File

@@ -3,7 +3,7 @@ describe('Custom Spy Strategies (Integration)', function() {
beforeEach(function() {
env = new jasmineUnderTest.Env();
env.configure({random: false});
env.configure({ random: false });
});
afterEach(function() {
@@ -11,10 +11,8 @@ describe('Custom Spy Strategies (Integration)', function() {
});
it('allows adding more strategies local to a suite', function(done) {
var plan = jasmine.createSpy('custom strategy plan')
.and.returnValue(42);
var strategy = jasmine.createSpy('custom strategy')
.and.returnValue(plan);
var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
var jasmineDone = jasmine.createSpy('jasmineDone');
env.describe('suite defining a custom spy strategy', function() {
@@ -45,10 +43,8 @@ describe('Custom Spy Strategies (Integration)', function() {
});
it('allows adding more strategies local to a spec', function(done) {
var plan = jasmine.createSpy('custom strategy plan')
.and.returnValue(42);
var strategy = jasmine.createSpy('custom strategy')
.and.returnValue(plan);
var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
var jasmineDone = jasmine.createSpy('jasmineDone');
env.it('spec defining a custom spy strategy', function() {
@@ -74,17 +70,17 @@ describe('Custom Spy Strategies (Integration)', function() {
});
it('allows using custom strategies on a per-argument basis', function(done) {
var plan = jasmine.createSpy('custom strategy plan')
.and.returnValue(42);
var strategy = jasmine.createSpy('custom strategy')
.and.returnValue(plan);
var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
var jasmineDone = jasmine.createSpy('jasmineDone');
env.it('spec defining a custom spy strategy', function() {
env.addSpyStrategy('frobnicate', strategy);
var spy = env.createSpy('something')
var spy = env
.createSpy('something')
.and.returnValue('no args return')
.withArgs(1, 2, 3).and.frobnicate(17);
.withArgs(1, 2, 3)
.and.frobnicate(17);
expect(spy()).toEqual('no args return');
expect(plan).not.toHaveBeenCalled();
@@ -114,7 +110,6 @@ describe('Custom Spy Strategies (Integration)', function() {
specDone = jasmine.createSpy('specDone'),
jasmineDone = jasmine.createSpy('jasmineDone');
env.beforeEach(function() {
env.addSpyStrategy('frobnicate', strategy1);
env.addSpyStrategy('jiggle', strategy2);

14
spec/core/integration/DefaultSpyStrategySpec.js
View File

@@ -3,7 +3,7 @@ describe('Default Spy Strategy (Integration)', function() {
beforeEach(function() {
env = new jasmineUnderTest.Env();
env.configure({random: false});
env.configure({ random: false });
});
afterEach(function() {
@@ -13,7 +13,7 @@ describe('Default Spy Strategy (Integration)', function() {
it('allows defining a default spy strategy', function(done) {
env.describe('suite with default strategy', function() {
env.beforeEach(function() {
env.setDefaultSpyStrategy(function (and) {
env.setDefaultSpyStrategy(function(and) {
and.returnValue(42);
});
});
@@ -40,12 +40,16 @@ describe('Default Spy Strategy (Integration)', function() {
env.execute(null, expectations);
});
it('uses the default spy strategy defined when the spy is created', function (done) {
it('uses the default spy strategy defined when the spy is created', function(done) {
env.it('spec', function() {
var a = env.createSpy('a');
env.setDefaultSpyStrategy(function (and) { and.returnValue(42); });
env.setDefaultSpyStrategy(function(and) {
and.returnValue(42);
});
var b = env.createSpy('b');
env.setDefaultSpyStrategy(function (and) { and.stub(); });
env.setDefaultSpyStrategy(function(and) {
and.stub();
});
var c = env.createSpy('c');
env.setDefaultSpyStrategy();
var d = env.createSpy('d');

1812
spec/core/integration/EnvSpec.js
View File

File diff suppressed because it is too large Load Diff

171
spec/core/integration/MatchersSpec.js
View File

@@ -23,7 +23,9 @@ describe('Matchers (Integration)', function() {
expect(result.failedExpectations.length)
.withContext('Number of failed expectations')
.toEqual(0);
expect(result.failedExpectations[0] && result.failedExpectations[0].message)
expect(
result.failedExpectations[0] && result.failedExpectations[0].message
)
.withContext('Failure message')
.toBeUndefined();
};
@@ -45,12 +47,17 @@ describe('Matchers (Integration)', function() {
.withContext('Number of failed expectations')
.toEqual(1);
expect(result.failedExpectations[0].message)
.withContext('Failed with a thrown error rather than a matcher failure')
.withContext(
'Failed with a thrown error rather than a matcher failure'
)
.not.toMatch(/^Error: /);
expect(result.failedExpectations[0].message)
.withContext('Failed with a thrown type error rather than a matcher failure')
.withContext(
'Failed with a thrown type error rather than a matcher failure'
)
.not.toMatch(/^TypeError: /);
expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
expect(result.failedExpectations[0].matcherName)
.withContext('Matcher name')
.not.toEqual('');
};
@@ -61,18 +68,19 @@ describe('Matchers (Integration)', function() {
function verifyFailsWithCustomObjectFormatters(config) {
it('uses custom object formatters', function(done) {
env.it('a spec', function () {
env.it('a spec', function() {
env.addCustomObjectFormatter(config.formatter);
config.expectations(env);
});
var specExpectations = function (result) {
var specExpectations = function(result) {
expect(result.status).toEqual('failed');
expect(result.failedExpectations.length)
.withContext('Number of failed expectations')
.toEqual(1);
expect(result.failedExpectations[0].message)
.toEqual(config.expectedMessage);
expect(result.failedExpectations[0].message).toEqual(
config.expectedMessage
);
};
env.addReporter({ specDone: specExpectations });
@@ -96,7 +104,9 @@ describe('Matchers (Integration)', function() {
expect(result.failedExpectations.length)
.withContext('Number of failed expectations')
.toEqual(0);
expect(result.failedExpectations[0] && result.failedExpectations[0].message)
expect(
result.failedExpectations[0] && result.failedExpectations[0].message
)
.withContext('Failure message')
.toBeUndefined();
};
@@ -120,9 +130,12 @@ describe('Matchers (Integration)', function() {
.withContext('Number of failed expectations')
.toEqual(1);
expect(result.failedExpectations[0].message)
.withContext('Failed with a thrown error rather than a matcher failure')
.withContext(
'Failed with a thrown error rather than a matcher failure'
)
.not.toMatch(/^Error: /);
expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
expect(result.failedExpectations[0].matcherName)
.withContext('Matcher name')
.not.toEqual('');
};
@@ -135,18 +148,19 @@ describe('Matchers (Integration)', function() {
it('uses custom object formatters', function(done) {
var env = new jasmineUnderTest.Env();
jasmine.getEnv().requirePromises();
env.it('a spec', function () {
env.it('a spec', function() {
env.addCustomObjectFormatter(config.formatter);
return config.expectations(env);
});
var specExpectations = function (result) {
var specExpectations = function(result) {
expect(result.status).toEqual('failed');
expect(result.failedExpectations.length)
.withContext('Number of failed expectations')
.toEqual(1);
expect(result.failedExpectations[0].message)
.toEqual(config.expectedMessage);
expect(result.failedExpectations[0].message).toEqual(
config.expectedMessage
);
};
env.addReporter({ specDone: specExpectations });
@@ -154,7 +168,6 @@ describe('Matchers (Integration)', function() {
});
}
describe('nothing', function() {
verifyPasses(function(env) {
env.expect().nothing();
@@ -330,16 +343,18 @@ describe('Matchers (Integration)', function() {
env.expect(1).toBePositiveInfinity();
},
expectedMessage: 'Expected |1| to be Infinity.'
})
});
});
describe('toBeResolved', function() {
verifyPassesAsync(function(env) {
return env.expectAsync(Promise.resolve()).toBeResolved(); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve()).toBeResolved();
});
verifyFailsAsync(function(env) {
return env.expectAsync(Promise.reject()).toBeResolved(); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.reject()).toBeResolved();
});
});
@@ -348,11 +363,13 @@ describe('Matchers (Integration)', function() {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
return env.expectAsync(Promise.resolve('5')).toBeResolvedTo(5); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve('5')).toBeResolvedTo(5);
});
verifyFailsAsync(function(env) {
return env.expectAsync(Promise.resolve('foo')).toBeResolvedTo('bar'); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve('foo')).toBeResolvedTo('bar');
});
verifyFailsWithCustomObjectFormattersAsync({
@@ -360,20 +377,24 @@ describe('Matchers (Integration)', function() {
return '|' + val + '|';
},
expectations: function(env) {
return env.expectAsync(Promise.resolve('x')).toBeResolvedTo('y'); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve('x')).toBeResolvedTo('y');
},
expectedMessage: 'Expected a promise to be resolved to |y| ' +
expectedMessage:
'Expected a promise to be resolved to |y| ' +
'but it was resolved to |x|.'
});
});
describe('toBeRejected', function() {
verifyPassesAsync(function(env) {
return env.expectAsync(Promise.reject('nope')).toBeRejected(); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.reject('nope')).toBeRejected();
});
verifyFailsAsync(function(env) {
return env.expectAsync(Promise.resolve()).toBeRejected(); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve()).toBeRejected();
});
});
@@ -382,11 +403,13 @@ describe('Matchers (Integration)', function() {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
return env.expectAsync(Promise.reject('5')).toBeRejectedWith(5); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.reject('5')).toBeRejectedWith(5);
});
verifyFailsAsync(function(env) {
return env.expectAsync(Promise.resolve()).toBeRejectedWith('nope'); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve()).toBeRejectedWith('nope');
});
verifyFailsWithCustomObjectFormattersAsync({
@@ -394,20 +417,28 @@ describe('Matchers (Integration)', function() {
return '|' + val + '|';
},
expectations: function(env) {
return env.expectAsync(Promise.reject('x')).toBeRejectedWith('y'); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.reject('x')).toBeRejectedWith('y');
},
expectedMessage: 'Expected a promise to be rejected with |y| ' +
expectedMessage:
'Expected a promise to be rejected with |y| ' +
'but it was rejected with |x|.'
});
});
describe('toBeRejectedWithError', function() {
verifyPassesAsync(function(env) {
return env.expectAsync(Promise.reject(new Error())).toBeRejectedWithError(Error); // eslint-disable-line compat/compat
return (
env
// eslint-disable-next-line compat/compat
.expectAsync(Promise.reject(new Error()))
.toBeRejectedWithError(Error)
);
});
verifyFailsAsync(function(env) {
return env.expectAsync(Promise.resolve()).toBeRejectedWithError(Error); // eslint-disable-line compat/compat
// eslint-disable-next-line compat/compat
return env.expectAsync(Promise.resolve()).toBeRejectedWithError(Error);
});
verifyFailsWithCustomObjectFormattersAsync({
@@ -415,9 +446,15 @@ describe('Matchers (Integration)', function() {
return '|' + val + '|';
},
expectations: function(env) {
return env.expectAsync(Promise.reject('foo')).toBeRejectedWithError('foo'); // eslint-disable-line compat/compat
return (
env
// eslint-disable-next-line compat/compat
.expectAsync(Promise.reject('foo'))
.toBeRejectedWithError('foo')
);
},
expectedMessage: 'Expected a promise to be rejected with Error: |foo| ' +
expectedMessage:
'Expected a promise to be rejected with Error: |foo| ' +
'but it was rejected with |foo|.'
});
});
@@ -486,7 +523,7 @@ describe('Matchers (Integration)', function() {
}
},
expectations: function(env) {
env.expect([{foo: 4}]).toEqual([{foo: 5}]);
env.expect([{ foo: 4 }]).toEqual([{ foo: 5 }]);
},
expectedMessage: 'Expected $[0].foo = four to equal five.'
});
@@ -494,11 +531,11 @@ describe('Matchers (Integration)', function() {
describe('toHaveSize', function() {
verifyPasses(function(env) {
env.expect(['a','b']).toHaveSize(2);
env.expect(['a', 'b']).toHaveSize(2);
});
verifyFails(function(env) {
env.expect(['a','b']).toHaveSize(1);
env.expect(['a', 'b']).toHaveSize(1);
});
});
@@ -517,14 +554,16 @@ describe('Matchers (Integration)', function() {
describe('toHaveBeenCalledBefore', function() {
verifyPasses(function(env) {
var a = env.createSpy('a'), b = env.createSpy('b');
var a = env.createSpy('a'),
b = env.createSpy('b');
a();
b();
env.expect(a).toHaveBeenCalledBefore(b);
});
verifyFails(function(env) {
var a = env.createSpy('a'), b = env.createSpy('b');
var a = env.createSpy('a'),
b = env.createSpy('b');
b();
a();
env.expect(a).toHaveBeenCalledBefore(b);
@@ -567,7 +606,8 @@ describe('Matchers (Integration)', function() {
var spy = env.createSpy('foo');
env.expect(spy).toHaveBeenCalledWith('x');
},
expectedMessage: 'Expected spy foo to have been called with:\n' +
expectedMessage:
'Expected spy foo to have been called with:\n' +
' |x|\n' +
'but it was never called.'
});
@@ -622,7 +662,11 @@ describe('Matchers (Integration)', function() {
env.addCustomEqualityTester(function(a, b) {
return a.toString() === b.toString();
});
env.expect(function() { throw '5'; }).toThrow(5);
env
.expect(function() {
throw '5';
})
.toThrow(5);
});
verifyFails(function(env) {
@@ -635,9 +679,11 @@ describe('Matchers (Integration)', function() {
},
expectations: function(env) {
var spy = env.createSpy('foo');
env.expect(function() {
throw 'x'
}).not.toThrow();
env
.expect(function() {
throw 'x';
})
.not.toThrow();
},
expectedMessage: 'Expected function not to throw, but it threw |x|.'
});
@@ -645,11 +691,15 @@ describe('Matchers (Integration)', function() {
describe('toThrowError', function() {
verifyPasses(function(env) {
env.expect(function() { throw new Error(); }).toThrowError();
env
.expect(function() {
throw new Error();
})
.toThrowError();
});
verifyFails(function(env) {
env.expect(function() { }).toThrowError();
env.expect(function() {}).toThrowError();
});
verifyFailsWithCustomObjectFormatters({
@@ -658,9 +708,11 @@ describe('Matchers (Integration)', function() {
},
expectations: function(env) {
var spy = env.createSpy('foo');
env.expect(function() {
throw 'x'
}).toThrowError();
env
.expect(function() {
throw 'x';
})
.toThrowError();
},
expectedMessage: 'Expected function to throw an Error, but it threw |x|.'
});
@@ -672,11 +724,15 @@ describe('Matchers (Integration)', function() {
}
verifyPasses(function(env) {
env.expect(throws).toThrowMatching(function() { return true; });
env.expect(throws).toThrowMatching(function() {
return true;
});
});
verifyFails(function(env) {
env.expect(throws).toThrowMatching(function() { return false; });
env.expect(throws).toThrowMatching(function() {
return false;
});
});
verifyFailsWithCustomObjectFormatters({
@@ -685,13 +741,16 @@ describe('Matchers (Integration)', function() {
},
expectations: function(env) {
var spy = env.createSpy('foo');
env.expect(function() {
throw new Error('nope')
}).toThrowMatching(function() {
return false;
});
env
.expect(function() {
throw new Error('nope');
})
.toThrowMatching(function() {
return false;
});
},
expectedMessage: 'Expected function to throw an exception matching ' +
expectedMessage:
'Expected function to throw an exception matching ' +
'a predicate, but it threw Error with message |nope|.'
});
});

430
spec/core/integration/SpecRunningSpec.js
View File

@@ -1,10 +1,10 @@
describe("spec running", function () {
describe('spec running', function() {
var env;
beforeEach(function() {
jasmine.getEnv().registerIntegrationMatchers();
env = new jasmineUnderTest.Env();
env.configure({random: false});
env.configure({ random: false });
});
afterEach(function() {
@@ -14,18 +14,13 @@ describe("spec running", function () {
it('should assign spec ids sequentially', function() {
var it0, it1, it2, it3, it4;
env.describe('test suite', function() {
it0 = env.it('spec 0', function() {
});
it1 = env.it('spec 1', function() {
});
it2 = env.xit('spec 2', function() {
});
it3 = env.it('spec 3', function() {
});
it0 = env.it('spec 0', function() {});
it1 = env.it('spec 1', function() {});
it2 = env.xit('spec 2', function() {});
it3 = env.it('spec 3', function() {});
});
env.describe('test suite 2', function() {
it4 = env.it('spec 4', function() {
});
it4 = env.it('spec 4', function() {});
});
expect(it0.id).toEqual('spec0');
@@ -35,29 +30,28 @@ describe("spec running", function () {
expect(it4.id).toEqual('spec4');
});
it('nested suites', function (done) {
it('nested suites', function(done) {
var foo = 0;
var bar = 0;
var baz = 0;
var quux = 0;
var nested = env.describe('suite', function () {
env.describe('nested', function () {
env.it('should run nested suites', function () {
var nested = env.describe('suite', function() {
env.describe('nested', function() {
env.it('should run nested suites', function() {
foo++;
});
env.it('should run nested suites', function () {
env.it('should run nested suites', function() {
bar++;
});
});
env.describe('nested 2', function () {
env.it('should run suites following nested suites', function () {
env.describe('nested 2', function() {
env.it('should run suites following nested suites', function() {
baz++;
});
});
env.it('should run tests following nested suites', function () {
env.it('should run tests following nested suites', function() {
quux++;
});
});
@@ -76,14 +70,14 @@ describe("spec running", function () {
});
});
it("should permit nested describes", function(done) {
it('should permit nested describes', function(done) {
var actions = [];
env.beforeEach(function () {
env.beforeEach(function() {
actions.push('topSuite beforeEach');
});
env.afterEach(function () {
env.afterEach(function() {
actions.push('topSuite afterEach');
});
@@ -135,40 +129,40 @@ describe("spec running", function () {
env.execute(null, function() {
var expected = [
"topSuite beforeEach",
"outer beforeEach",
"outer it 1",
"outer afterEach",
"topSuite afterEach",
'topSuite beforeEach',
'outer beforeEach',
'outer it 1',
'outer afterEach',
'topSuite afterEach',
"topSuite beforeEach",
"outer beforeEach",
"inner 1 beforeEach",
"inner 1 it",
"inner 1 afterEach",
"outer afterEach",
"topSuite afterEach",
'topSuite beforeEach',
'outer beforeEach',
'inner 1 beforeEach',
'inner 1 it',
'inner 1 afterEach',
'outer afterEach',
'topSuite afterEach',
"topSuite beforeEach",
"outer beforeEach",
"outer it 2",
"outer afterEach",
"topSuite afterEach",
'topSuite beforeEach',
'outer beforeEach',
'outer it 2',
'outer afterEach',
'topSuite afterEach',
"topSuite beforeEach",
"outer beforeEach",
"inner 2 beforeEach",
"inner 2 it",
"inner 2 afterEach",
"outer afterEach",
"topSuite afterEach"
'topSuite beforeEach',
'outer beforeEach',
'inner 2 beforeEach',
'inner 2 it',
'inner 2 afterEach',
'outer afterEach',
'topSuite afterEach'
];
expect(actions).toEqual(expected);
done();
});
});
it("should run multiple befores and afters ordered so functions declared later are treated as more specific", function(done) {
it('should run multiple befores and afters ordered so functions declared later are treated as more specific', function(done) {
var actions = [];
env.beforeAll(function() {
@@ -187,19 +181,19 @@ describe("spec running", function () {
actions.push('runner afterAll2');
});
env.beforeEach(function () {
env.beforeEach(function() {
actions.push('runner beforeEach1');
});
env.afterEach(function () {
env.afterEach(function() {
actions.push('runner afterEach1');
});
env.beforeEach(function () {
env.beforeEach(function() {
actions.push('runner beforeEach2');
});
env.afterEach(function () {
env.afterEach(function() {
actions.push('runner afterEach2');
});
@@ -227,19 +221,19 @@ describe("spec running", function () {
env.execute(null, function() {
var expected = [
"runner beforeAll1",
"runner beforeAll2",
"runner beforeEach1",
"runner beforeEach2",
"beforeEach1",
"beforeEach2",
"outer it 1",
"afterEach2",
"afterEach1",
"runner afterEach2",
"runner afterEach1",
"runner afterAll2",
"runner afterAll1"
'runner beforeAll1',
'runner beforeAll2',
'runner beforeEach1',
'runner beforeEach2',
'beforeEach1',
'beforeEach2',
'outer it 1',
'afterEach2',
'afterEach1',
'runner afterEach2',
'runner afterEach1',
'runner afterAll2',
'runner afterAll1'
];
expect(actions).toEqual(expected);
done();
@@ -257,11 +251,11 @@ describe("spec running", function () {
actions.push('runner afterAll');
});
env.beforeEach(function () {
env.beforeEach(function() {
actions.push('runner beforeEach');
});
env.afterEach(function () {
env.afterEach(function() {
actions.push('runner afterEach');
});
@@ -289,15 +283,15 @@ describe("spec running", function () {
env.execute(null, function() {
var expected = [
"runner beforeAll",
"inner beforeAll",
"runner beforeEach",
"inner beforeEach",
"it",
"inner afterEach",
"runner afterEach",
"inner afterAll",
"runner afterAll"
'runner beforeAll',
'inner beforeAll',
'runner beforeEach',
'inner beforeEach',
'it',
'inner afterEach',
'runner afterEach',
'inner afterAll',
'runner afterAll'
];
expect(actions).toEqual(expected);
done();
@@ -317,11 +311,11 @@ describe("spec running", function () {
actions.push('runner afterAll');
});
env.beforeEach(function () {
env.beforeEach(function() {
actions.push('runner beforeEach');
});
env.afterEach(function () {
env.afterEach(function() {
actions.push('runner afterEach');
});
@@ -353,38 +347,38 @@ describe("spec running", function () {
env.execute([spec2.id, spec.id], function() {
var expected = [
"runner beforeAll",
"inner beforeAll",
"runner beforeEach",
"inner beforeEach",
"it2",
"inner afterEach",
"runner afterEach",
'runner beforeAll',
'inner beforeAll',
'runner beforeEach',
'inner beforeEach',
'it2',
'inner afterEach',
'runner afterEach',
"runner beforeEach",
"inner beforeEach",
"it",
"inner afterEach",
"runner afterEach",
"inner afterAll",
"runner afterAll"
'runner beforeEach',
'inner beforeEach',
'it',
'inner afterEach',
'runner afterEach',
'inner afterAll',
'runner afterAll'
];
expect(actions).toEqual(expected);
done();
});
});
it('only runs *Alls once in a focused suite', function(done){
it('only runs *Alls once in a focused suite', function(done) {
var actions = [];
env.fdescribe('Suite', function() {
env.beforeAll(function(){
env.beforeAll(function() {
actions.push('beforeAll');
});
env.it('should run beforeAll once', function() {
actions.push('spec');
});
env.afterAll(function(){
env.afterAll(function() {
actions.push('afterAll');
});
});
@@ -398,20 +392,28 @@ describe("spec running", function () {
describe('focused runnables', function() {
it('runs the relevant alls and eachs for each runnable', function(done) {
var actions = [];
env.beforeAll(function() {actions.push('beforeAll')});
env.afterAll(function() {actions.push('afterAll')});
env.beforeEach(function() {actions.push('beforeEach')});
env.afterEach(function() {actions.push('afterEach')});
env.beforeAll(function() {
actions.push('beforeAll');
});
env.afterAll(function() {
actions.push('afterAll');
});
env.beforeEach(function() {
actions.push('beforeEach');
});
env.afterEach(function() {
actions.push('afterEach');
});
env.fdescribe('a focused suite', function() {
env.it('is run', function() {
actions.push('spec in fdescribe')
actions.push('spec in fdescribe');
});
});
env.describe('an unfocused suite', function() {
env.fit('has a focused spec', function() {
actions.push('focused spec')
actions.push('focused spec');
});
});
@@ -432,15 +434,15 @@ describe("spec running", function () {
});
});
it('focused specs in focused suites cause non-focused siblings to not run', function(done){
it('focused specs in focused suites cause non-focused siblings to not run', function(done) {
var actions = [];
env.fdescribe('focused suite', function() {
env.it('unfocused spec', function() {
actions.push('unfocused spec')
actions.push('unfocused spec');
});
env.fit('focused spec', function() {
actions.push('focused spec')
actions.push('focused spec');
});
});
@@ -451,12 +453,12 @@ describe("spec running", function () {
});
});
it('focused suites in focused suites cause non-focused siblings to not run', function(done){
it('focused suites in focused suites cause non-focused siblings to not run', function(done) {
var actions = [];
env.fdescribe('focused suite', function() {
env.it('unfocused spec', function() {
actions.push('unfocused spec')
actions.push('unfocused spec');
});
env.fdescribe('inner focused suite', function() {
env.it('inner spec', function() {
@@ -477,7 +479,7 @@ describe("spec running", function () {
env.fdescribe('focused suite', function() {
env.it('unfocused spec', function() {
actions.push('unfocused spec')
actions.push('unfocused spec');
});
env.describe('inner focused suite', function() {
env.fit('focused spec', function() {
@@ -495,12 +497,12 @@ describe("spec running", function () {
});
it("shouldn't run disabled suites", function(done) {
var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
suite = env.describe('A Suite', function() {
env.xdescribe('with a disabled suite', function(){
env.it('spec inside a disabled suite', specInADisabledSuite);
var specInADisabledSuite = jasmine.createSpy('specInADisabledSuite'),
suite = env.describe('A Suite', function() {
env.xdescribe('with a disabled suite', function() {
env.it('spec inside a disabled suite', specInADisabledSuite);
});
});
});
env.execute(null, function() {
expect(specInADisabledSuite).not.toHaveBeenCalled();
@@ -509,16 +511,16 @@ describe("spec running", function () {
});
it("shouldn't run before/after functions in disabled suites", function(done) {
var shouldNotRun = jasmine.createSpy("shouldNotRun"),
suite = env.xdescribe('A disabled Suite', function() {
// None of the before/after functions should run.
env.beforeAll(shouldNotRun);
env.beforeEach(shouldNotRun);
env.afterEach(shouldNotRun);
env.afterAll(shouldNotRun);
var shouldNotRun = jasmine.createSpy('shouldNotRun'),
suite = env.xdescribe('A disabled Suite', function() {
// None of the before/after functions should run.
env.beforeAll(shouldNotRun);
env.beforeEach(shouldNotRun);
env.afterEach(shouldNotRun);
env.afterAll(shouldNotRun);
env.it('spec inside a disabled suite', shouldNotRun);
});
env.it('spec inside a disabled suite', shouldNotRun);
});
env.execute(null, function() {
expect(shouldNotRun).not.toHaveBeenCalled();
@@ -526,9 +528,9 @@ describe("spec running", function () {
});
});
it("should allow top level suites to be disabled", function(done) {
var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
otherSpec = jasmine.createSpy("otherSpec");
it('should allow top level suites to be disabled', function(done) {
var specInADisabledSuite = jasmine.createSpy('specInADisabledSuite'),
otherSpec = jasmine.createSpy('otherSpec');
env.xdescribe('A disabled suite', function() {
env.it('spec inside a disabled suite', specInADisabledSuite);
@@ -544,19 +546,19 @@ describe("spec running", function () {
});
});
it("should set all pending specs to pending when a suite is run", function(done) {
it('should set all pending specs to pending when a suite is run', function(done) {
var pendingSpec,
suite = env.describe('default current suite', function() {
pendingSpec = env.it("I am a pending spec");
pendingSpec = env.it('I am a pending spec');
});
env.execute(null, function() {
expect(pendingSpec.status()).toBe("pending");
expect(pendingSpec.status()).toBe('pending');
done();
});
});
it("should recover gracefully when there are errors in describe functions", function(done) {
it('should recover gracefully when there are errors in describe functions', function(done) {
var specs = [],
reporter = jasmine.createSpyObj(['specDone', 'suiteDone']);
@@ -565,83 +567,95 @@ describe("spec running", function () {
});
expect(function() {
env.describe("outer1", function() {
env.describe("inner1", function() {
env.it("should thingy", function() {
env.describe('outer1', function() {
env.describe('inner1', function() {
env.it('should thingy', function() {
this.expect(true).toEqual(true);
});
throw new Error("inner error");
throw new Error('inner error');
});
env.describe("inner2", function() {
env.it("should other thingy", function() {
env.describe('inner2', function() {
env.it('should other thingy', function() {
this.expect(true).toEqual(true);
});
});
throw new Error("outer error");
throw new Error('outer error');
});
}).not.toThrow();
env.describe("outer2", function() {
env.it("should xxx", function() {
env.describe('outer2', function() {
env.it('should xxx', function() {
this.expect(true).toEqual(true);
});
});
env.addReporter(reporter);
env.execute(null, function() {
expect(specs).toEqual(['outer1 inner1 should thingy', 'outer1 inner2 should other thingy', 'outer2 should xxx']);
expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1 inner1', [/inner error/]);
expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1', [/outer error/]);
expect(specs).toEqual([
'outer1 inner1 should thingy',
'outer1 inner2 should other thingy',
'outer2 should xxx'
]);
expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable(
'outer1 inner1',
[/inner error/]
);
expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1', [
/outer error/
]);
done();
});
});
it("re-enters suites that have no *Alls", function(done) {
it('re-enters suites that have no *Alls', function(done) {
var actions = [],
spec1, spec2, spec3;
spec1,
spec2,
spec3;
env.describe("top", function() {
spec1 = env.it("spec1", function() {
actions.push("spec1");
env.describe('top', function() {
spec1 = env.it('spec1', function() {
actions.push('spec1');
});
spec2 = env.it("spec2", function() {
actions.push("spec2");
spec2 = env.it('spec2', function() {
actions.push('spec2');
});
});
spec3 = env.it("spec3", function() {
actions.push("spec3");
spec3 = env.it('spec3', function() {
actions.push('spec3');
});
env.execute([spec2.id, spec3.id, spec1.id], function() {
expect(actions).toEqual(["spec2", "spec3", "spec1"]);
expect(actions).toEqual(['spec2', 'spec3', 'spec1']);
done();
});
});
it("refuses to re-enter suites with a beforeAll", function() {
it('refuses to re-enter suites with a beforeAll', function() {
var actions = [],
spec1, spec2, spec3;
spec1,
spec2,
spec3;
env.describe("top", function() {
env.describe('top', function() {
env.beforeAll(function() {});
spec1 = env.it("spec1", function() {
actions.push("spec1");
spec1 = env.it('spec1', function() {
actions.push('spec1');
});
spec2 = env.it("spec2", function() {
actions.push("spec2");
spec2 = env.it('spec2', function() {
actions.push('spec2');
});
});
spec3 = env.it("spec3", function() {
actions.push("spec3");
spec3 = env.it('spec3', function() {
actions.push('spec3');
});
expect(function() {
@@ -650,24 +664,26 @@ describe("spec running", function () {
expect(actions).toEqual([]);
});
it("refuses to re-enter suites with a afterAll", function() {
it('refuses to re-enter suites with a afterAll', function() {
var actions = [],
spec1, spec2, spec3;
spec1,
spec2,
spec3;
env.describe("top", function() {
env.describe('top', function() {
env.afterAll(function() {});
spec1 = env.it("spec1", function() {
actions.push("spec1");
spec1 = env.it('spec1', function() {
actions.push('spec1');
});
spec2 = env.it("spec2", function() {
actions.push("spec2");
spec2 = env.it('spec2', function() {
actions.push('spec2');
});
});
spec3 = env.it("spec3", function() {
actions.push("spec3");
spec3 = env.it('spec3', function() {
actions.push('spec3');
});
expect(function() {
@@ -676,15 +692,15 @@ describe("spec running", function () {
expect(actions).toEqual([]);
});
it("should run the tests in a consistent order when a seed is supplied", function(done) {
it('should run the tests in a consistent order when a seed is supplied', function(done) {
var actions = [];
env.configure({random: true, seed: '123456'});
env.configure({ random: true, seed: '123456' });
env.beforeEach(function () {
env.beforeEach(function() {
actions.push('topSuite beforeEach');
});
env.afterEach(function () {
env.afterEach(function() {
actions.push('topSuite afterEach');
});
@@ -769,14 +785,14 @@ describe("spec running", function () {
});
});
describe("When throwOnExpectationFailure is set", function() {
it("skips to cleanup functions after an error", function(done) {
describe('When throwOnExpectationFailure is set', function() {
it('skips to cleanup functions after an error', function(done) {
var actions = [];
env.describe('Something', function() {
env.beforeEach(function() {
actions.push('outer beforeEach');
throw new Error("error");
throw new Error('error');
});
env.afterEach(function() {
@@ -792,13 +808,13 @@ describe("spec running", function () {
actions.push('inner afterEach');
});
env.it('does it' , function() {
env.it('does it', function() {
actions.push('inner it');
});
});
});
env.configure({oneFailurePerSpec: true});
env.configure({ oneFailurePerSpec: true });
env.execute(null, function() {
expect(actions).toEqual([
@@ -810,7 +826,7 @@ describe("spec running", function () {
});
});
it("skips to cleanup functions after done.fail is called", function(done) {
it('skips to cleanup functions after done.fail is called', function(done) {
var actions = [];
env.describe('Something', function() {
@@ -824,23 +840,20 @@ describe("spec running", function () {
actions.push('afterEach');
});
env.it('does it' , function() {
env.it('does it', function() {
actions.push('it');
});
});
env.configure({oneFailurePerSpec: true});
env.configure({ oneFailurePerSpec: true });
env.execute(null, function() {
expect(actions).toEqual([
'beforeEach',
'afterEach'
]);
expect(actions).toEqual(['beforeEach', 'afterEach']);
done();
});
});
it("skips to cleanup functions when an async function times out", function(done) {
it('skips to cleanup functions when an async function times out', function(done) {
var actions = [];
env.describe('Something', function() {
@@ -852,23 +865,20 @@ describe("spec running", function () {
actions.push('afterEach');
});
env.it('does it' , function() {
env.it('does it', function() {
actions.push('it');
});
});
env.configure({oneFailurePerSpec: true});
env.configure({ oneFailurePerSpec: true });
env.execute(null, function() {
expect(actions).toEqual([
'beforeEach',
'afterEach'
]);
expect(actions).toEqual(['beforeEach', 'afterEach']);
done();
});
});
it("skips to cleanup functions after an error with deprecations", function(done) {
it('skips to cleanup functions after an error with deprecations', function(done) {
var actions = [];
spyOn(env, 'deprecated');
@@ -876,7 +886,7 @@ describe("spec running", function () {
env.describe('Something', function() {
env.beforeEach(function() {
actions.push('outer beforeEach');
throw new Error("error");
throw new Error('error');
});
env.afterEach(function() {
@@ -892,7 +902,7 @@ describe("spec running", function () {
actions.push('inner afterEach');
});
env.it('does it' , function() {
env.it('does it', function() {
actions.push('inner it');
});
});
@@ -911,7 +921,7 @@ describe("spec running", function () {
});
});
it("skips to cleanup functions after done.fail is called with deprecations", function(done) {
it('skips to cleanup functions after done.fail is called with deprecations', function(done) {
var actions = [];
spyOn(env, 'deprecated');
@@ -927,7 +937,7 @@ describe("spec running", function () {
actions.push('afterEach');
});
env.it('does it' , function() {
env.it('does it', function() {
actions.push('it');
});
});
@@ -935,16 +945,13 @@ describe("spec running", function () {
env.throwOnExpectationFailure(true);
env.execute(null, function() {
expect(actions).toEqual([
'beforeEach',
'afterEach'
]);
expect(actions).toEqual(['beforeEach', 'afterEach']);
expect(env.deprecated).toHaveBeenCalled();
done();
});
});
it("skips to cleanup functions when an async function times out with deprecations", function(done) {
it('skips to cleanup functions when an async function times out with deprecations', function(done) {
var actions = [];
spyOn(env, 'deprecated');
@@ -958,7 +965,7 @@ describe("spec running", function () {
actions.push('afterEach');
});
env.it('does it' , function() {
env.it('does it', function() {
actions.push('it');
});
});
@@ -966,18 +973,15 @@ describe("spec running", function () {
env.throwOnExpectationFailure(true);
env.execute(null, function() {
expect(actions).toEqual([
'beforeEach',
'afterEach'
]);
expect(actions).toEqual(['beforeEach', 'afterEach']);
expect(env.deprecated).toHaveBeenCalled();
done();
});
});
});
describe("when stopOnSpecFailure is on", function() {
it("does not run further specs when one fails", function(done) {
describe('when stopOnSpecFailure is on', function() {
it('does not run further specs when one fails', function(done) {
var actions = [];
env.describe('wrapper', function() {
@@ -993,7 +997,7 @@ describe("spec running", function () {
});
});
env.configure({random: false, failFast: true});
env.configure({ random: false, failFast: true });
env.execute(null, function() {
expect(actions).toEqual(['fails']);
@@ -1001,7 +1005,7 @@ describe("spec running", function () {
});
});
it("does not run further specs when one fails when configured with deprecated option", function(done) {
it('does not run further specs when one fails when configured with deprecated option', function(done) {
var actions = [];
spyOn(env, 'deprecated');
@@ -1019,7 +1023,7 @@ describe("spec running", function () {
});
});
env.configure({random: false});
env.configure({ random: false });
env.stopOnSpecFailure(true);
env.execute(null, function() {

161
spec/core/matchers/DiffBuilderSpec.js
View File

@@ -1,132 +1,159 @@
describe("DiffBuilder", function () {
it("records the actual and expected objects", function () {
describe('DiffBuilder', function() {
it('records the actual and expected objects', function() {
var diffBuilder = jasmineUnderTest.DiffBuilder();
diffBuilder.setRoots({x: 'actual'}, {x: 'expected'});
diffBuilder.setRoots({ x: 'actual' }, { x: 'expected' });
diffBuilder.recordMismatch();
expect(diffBuilder.getMessage()).toEqual("Expected Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
expect(diffBuilder.getMessage()).toEqual(
"Expected Object({ x: 'actual' }) to equal Object({ x: 'expected' })."
);
});
it("prints the path at which the difference was found", function () {
it('prints the path at which the difference was found', function() {
var diffBuilder = jasmineUnderTest.DiffBuilder();
diffBuilder.setRoots({foo: {x: 'actual'}}, {foo: {x: 'expected'}});
diffBuilder.setRoots({ foo: { x: 'actual' } }, { foo: { x: 'expected' } });
diffBuilder.withPath('foo', function () {
diffBuilder.withPath('foo', function() {
diffBuilder.recordMismatch();
});
expect(diffBuilder.getMessage()).toEqual("Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
expect(diffBuilder.getMessage()).toEqual(
"Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' })."
);
});
it("prints multiple messages, separated by newlines", function () {
it('prints multiple messages, separated by newlines', function() {
var diffBuilder = jasmineUnderTest.DiffBuilder();
diffBuilder.setRoots({foo: 1, bar: 3}, {foo: 2, bar: 4});
diffBuilder.setRoots({ foo: 1, bar: 3 }, { foo: 2, bar: 4 });
diffBuilder.withPath('foo', function () {
diffBuilder.withPath('foo', function() {
diffBuilder.recordMismatch();
});
diffBuilder.withPath('bar', function () {
diffBuilder.withPath('bar', function() {
diffBuilder.recordMismatch();
});
var message =
"Expected $.foo = 1 to equal 2.\n" +
"Expected $.bar = 3 to equal 4.";
'Expected $.foo = 1 to equal 2.\n' + 'Expected $.bar = 3 to equal 4.';
expect(diffBuilder.getMessage()).toEqual(message);
});
it("allows customization of the message", function () {
it('allows customization of the message', function() {
var diffBuilder = jasmineUnderTest.DiffBuilder();
diffBuilder.setRoots({x: 'bar'}, {x: 'foo'});
diffBuilder.setRoots({ x: 'bar' }, { x: 'foo' });
function darthVaderFormatter(actual, expected, path) {
return "I find your lack of " + expected + " disturbing. (was " + actual + ", at " + path + ")"
return (
'I find your lack of ' +
expected +
' disturbing. (was ' +
actual +
', at ' +
path +
')'
);
}
diffBuilder.withPath('x', function () {
diffBuilder.withPath('x', function() {
diffBuilder.recordMismatch(darthVaderFormatter);
});
expect(diffBuilder.getMessage()).toEqual("I find your lack of foo disturbing. (was bar, at $.x)");
expect(diffBuilder.getMessage()).toEqual(
'I find your lack of foo disturbing. (was bar, at $.x)'
);
});
it("uses the injected pretty-printer", function () {
var prettyPrinter = function (val) {
it('uses the injected pretty-printer', function() {
var prettyPrinter = function(val) {
return '|' + val + '|';
},
diffBuilder = jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
prettyPrinter.customFormat_ = function () {
};
diffBuilder = jasmineUnderTest.DiffBuilder({
prettyPrinter: prettyPrinter
});
prettyPrinter.customFormat_ = function() {};
diffBuilder.setRoots({foo: 'actual'}, {foo: 'expected'});
diffBuilder.withPath('foo', function () {
diffBuilder.setRoots({ foo: 'actual' }, { foo: 'expected' });
diffBuilder.withPath('foo', function() {
diffBuilder.recordMismatch();
});
expect(diffBuilder.getMessage()).toEqual("Expected $.foo = |actual| to equal |expected|.");
expect(diffBuilder.getMessage()).toEqual(
'Expected $.foo = |actual| to equal |expected|.'
);
});
it("passes the injected pretty-printer to the diff formatter", function () {
it('passes the injected pretty-printer to the diff formatter', function() {
var diffFormatter = jasmine.createSpy('diffFormatter'),
prettyPrinter = function () {
},
diffBuilder = jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
prettyPrinter.customFormat_ = function () {
};
prettyPrinter = function() {},
diffBuilder = jasmineUnderTest.DiffBuilder({
prettyPrinter: prettyPrinter
});
prettyPrinter.customFormat_ = function() {};
diffBuilder.setRoots({x: 'bar'}, {x: 'foo'});
diffBuilder.withPath('x', function () {
diffBuilder.setRoots({ x: 'bar' }, { x: 'foo' });
diffBuilder.withPath('x', function() {
diffBuilder.recordMismatch(diffFormatter);
});
diffBuilder.getMessage();
expect(diffFormatter).toHaveBeenCalledWith('bar', 'foo', jasmine.anything(), prettyPrinter);
expect(diffFormatter).toHaveBeenCalledWith(
'bar',
'foo',
jasmine.anything(),
prettyPrinter
);
});
it("uses custom object formatters on leaf nodes", function() {
it('uses custom object formatters on leaf nodes', function() {
var formatter = function(x) {
if (typeof x === 'number') {
return '[number:' + x + ']';
}
};
prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
var diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
var diffBuilder = new jasmineUnderTest.DiffBuilder({
prettyPrinter: prettyPrinter
});
diffBuilder.setRoots(5, 4);
diffBuilder.recordMismatch();
expect(diffBuilder.getMessage()).toEqual('Expected [number:5] to equal [number:4].');
expect(diffBuilder.getMessage()).toEqual(
'Expected [number:5] to equal [number:4].'
);
});
it("uses custom object formatters on non leaf nodes", function () {
var formatter = function (x) {
it('uses custom object formatters on non leaf nodes', function() {
var formatter = function(x) {
if (x.hasOwnProperty('a')) {
return '[thing with a=' + x.a + ', b=' + JSON.stringify(x.b) + ']';
}
};
prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
var diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
var expectedMsg = 'Expected $[0].foo = [thing with a=1, b={"x":42}] to equal [thing with a=1, b={"x":43}].\n' +
var diffBuilder = new jasmineUnderTest.DiffBuilder({
prettyPrinter: prettyPrinter
});
var expectedMsg =
'Expected $[0].foo = [thing with a=1, b={"x":42}] to equal [thing with a=1, b={"x":43}].\n' +
"Expected $[0].bar = 'yes' to equal 'no'.";
diffBuilder.setRoots(
[{foo: {a: 1, b: {x: 42}}, bar: 'yes'}],
[{foo: {a: 1, b: {x: 43}}, bar: 'no'}]
[{ foo: { a: 1, b: { x: 42 } }, bar: 'yes' }],
[{ foo: { a: 1, b: { x: 43 } }, bar: 'no' }]
);
diffBuilder.withPath(0, function () {
diffBuilder.withPath('foo', function () {
diffBuilder.withPath('b', function () {
diffBuilder.withPath('x', function () {
diffBuilder.withPath(0, function() {
diffBuilder.withPath('foo', function() {
diffBuilder.withPath('b', function() {
diffBuilder.withPath('x', function() {
diffBuilder.recordMismatch();
});
});
});
diffBuilder.withPath('bar', function () {
diffBuilder.withPath('bar', function() {
diffBuilder.recordMismatch();
});
});
@@ -136,14 +163,16 @@ describe("DiffBuilder", function () {
it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ at the root', function() {
var prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter}),
expectedMsg = 'Expected $.foo = 1 to equal 2.\n' +
"Expected $.baz = undefined to equal 3.";
diffBuilder = new jasmineUnderTest.DiffBuilder({
prettyPrinter: prettyPrinter
}),
expectedMsg =
'Expected $.foo = 1 to equal 2.\n' +
'Expected $.baz = undefined to equal 3.';
diffBuilder.setRoots(
{foo: 1, bar: 2},
jasmine.objectContaining({foo: 2, baz: 3})
{ foo: 1, bar: 2 },
jasmine.objectContaining({ foo: 2, baz: 3 })
);
diffBuilder.withPath('foo', function() {
@@ -158,21 +187,23 @@ describe("DiffBuilder", function () {
it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ below the root', function() {
var prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter}),
expectedMsg = 'Expected $.x.foo = 1 to equal 2.\n' +
"Expected $.x.baz = undefined to equal 3.";
diffBuilder = new jasmineUnderTest.DiffBuilder({
prettyPrinter: prettyPrinter
}),
expectedMsg =
'Expected $.x.foo = 1 to equal 2.\n' +
'Expected $.x.baz = undefined to equal 3.';
diffBuilder.setRoots(
{x: {foo: 1, bar: 2}},
{x: jasmine.objectContaining({foo: 2, baz: 3})}
{ x: { foo: 1, bar: 2 } },
{ x: jasmine.objectContaining({ foo: 2, baz: 3 }) }
);
diffBuilder.withPath('x', function() {
diffBuilder.withPath('foo', function () {
diffBuilder.withPath('foo', function() {
diffBuilder.recordMismatch();
});
diffBuilder.withPath('baz', function () {
diffBuilder.withPath('baz', function() {
diffBuilder.recordMismatch();
});
});

52
spec/core/matchers/MismatchTreeSpec.js
View File

@@ -1,15 +1,15 @@
describe('MismatchTree', function () {
describe('#add', function () {
describe('When the path is empty', function () {
it('flags the root node as mismatched', function () {
describe('MismatchTree', function() {
describe('#add', function() {
describe('When the path is empty', function() {
it('flags the root node as mismatched', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath([]));
expect(tree.isMismatch).toBe(true);
});
});
describe('When the path is not empty', function () {
it('flags the node as mismatched', function () {
describe('When the path is not empty', function() {
it('flags the node as mismatched', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
@@ -17,7 +17,7 @@ describe('MismatchTree', function () {
expect(tree.child('a').child('b').isMismatch).toBe(true);
});
it('does not flag ancestors as mismatched', function () {
it('does not flag ancestors as mismatched', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
@@ -27,7 +27,7 @@ describe('MismatchTree', function () {
});
});
it('stores the formatter on only the target node', function () {
it('stores the formatter on only the target node', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
@@ -37,7 +37,7 @@ describe('MismatchTree', function () {
expect(tree.child('a').child('b').formatter).toBe(formatter);
});
it('stores the path to the node', function () {
it('stores the path to the node', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
@@ -46,8 +46,8 @@ describe('MismatchTree', function () {
});
});
describe('#traverse', function () {
it('calls the callback for all nodes that are or contain mismatches', function () {
describe('#traverse', function() {
it('calls the callback for all nodes that are or contain mismatches', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
tree.add(new jasmineUnderTest.ObjectPath(['c']));
@@ -56,20 +56,28 @@ describe('MismatchTree', function () {
tree.traverse(visit);
expect(visit).toHaveBeenCalledWith(
new jasmineUnderTest.ObjectPath([]), false, undefined
new jasmineUnderTest.ObjectPath([]),
false,
undefined
);
expect(visit).toHaveBeenCalledWith(
new jasmineUnderTest.ObjectPath(['a']), false, undefined
new jasmineUnderTest.ObjectPath(['a']),
false,
undefined
);
expect(visit).toHaveBeenCalledWith(
new jasmineUnderTest.ObjectPath(['a', 'b']), true, formatter
new jasmineUnderTest.ObjectPath(['a', 'b']),
true,
formatter
);
expect(visit).toHaveBeenCalledWith(
new jasmineUnderTest.ObjectPath(['c']), true, undefined
new jasmineUnderTest.ObjectPath(['c']),
true,
undefined
);
});
it('does not call the callback if there are no mismatches', function () {
it('does not call the callback if there are no mismatches', function() {
var tree = new jasmineUnderTest.MismatchTree();
var visit = jasmine.createSpy('visit');
@@ -78,12 +86,12 @@ describe('MismatchTree', function () {
expect(visit).not.toHaveBeenCalled();
});
it('visits parents before children', function () {
it('visits parents before children', function() {
var tree = new jasmineUnderTest.MismatchTree();
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
var visited = [];
tree.traverse(function (path) {
tree.traverse(function(path) {
visited.push(path);
return true;
});
@@ -101,7 +109,7 @@ describe('MismatchTree', function () {
tree.add(new jasmineUnderTest.ObjectPath([1]));
var visited = [];
tree.traverse(function (path) {
tree.traverse(function(path) {
visited.push(path);
return true;
});
@@ -118,7 +126,7 @@ describe('MismatchTree', function () {
tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
var visited = [];
tree.traverse(function (path) {
tree.traverse(function(path) {
visited.push(path);
return path.depth() === 0;
});
@@ -130,7 +138,5 @@ describe('MismatchTree', function () {
});
});
function formatter() {
}
function formatter() {}
});

5
spec/core/matchers/NullDiffBuilderSpec.js
View File

@@ -1,8 +1,7 @@
describe('NullDiffBuilder', function () {
it('responds to withPath() by calling the passed function', function () {
describe('NullDiffBuilder', function() {
it('responds to withPath() by calling the passed function', function() {
var spy = jasmine.createSpy('callback');
jasmineUnderTest.NullDiffBuilder().withPath('does not matter', spy);
expect(spy).toHaveBeenCalled();
});
});

14
spec/core/matchers/async/toBePendingSpec.js
View File

@@ -8,7 +8,7 @@ describe('toBePending', function() {
actual = new Promise(function() {});
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: true}));
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
@@ -20,7 +20,7 @@ describe('toBePending', function() {
actual = Promise.resolve();
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: false}));
expect(result).toEqual(jasmine.objectContaining({ pass: false }));
});
});
@@ -32,21 +32,19 @@ describe('toBePending', function() {
actual = Promise.reject(new Error('promise was rejected'));
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: false}));
expect(result).toEqual(jasmine.objectContaining({ pass: false }));
});
});
it('fails if actual is not a promise', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil(),
matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
actual = 'not a promise';
matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
actual = 'not a promise';
function f() {
return matcher.compare(actual);
}
expect(f).toThrowError(
'Expected toBePending to be called on a promise.'
);
expect(f).toThrowError('Expected toBePending to be called on a promise.');
});
});

8
spec/core/matchers/async/toBeRejectedSpec.js
View File

@@ -8,7 +8,7 @@ describe('toBeRejected', function() {
actual = Promise.reject('AsyncExpectationSpec rejection');
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: true}));
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
@@ -20,7 +20,7 @@ describe('toBeRejected', function() {
actual = Promise.resolve();
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: false}));
expect(result).toEqual(jasmine.objectContaining({ pass: false }));
});
});
@@ -33,8 +33,6 @@ describe('toBeRejected', function() {
return matcher.compare(actual);
}
expect(f).toThrowError(
'Expected toBeRejected to be called on a promise.'
);
expect(f).toThrowError('Expected toBeRejected to be called on a promise.');
});
});

261
spec/core/matchers/async/toBeRejectedWithErrorSpec.js
View File

@@ -1,174 +1,253 @@
/* eslint-disable compat/compat */
describe('#toBeRejectedWithError', function () {
it('passes when Error type matches', function () {
describe('#toBeRejectedWithError', function() {
it('passes when Error type matches', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new TypeError('foo'));
return matcher.compare(actual, TypeError).then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with TypeError, but it was.'
}));
return matcher.compare(actual, TypeError).then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
'Expected a promise not to be rejected with TypeError, but it was.'
})
);
});
});
it('passes when Error type and message matches', function () {
it('passes when Error type and message matches', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new TypeError('foo'));
return matcher.compare(actual, TypeError, 'foo').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with TypeError: \'foo\', but it was.'
}));
return matcher.compare(actual, TypeError, 'foo').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
"Expected a promise not to be rejected with TypeError: 'foo', but it was."
})
);
});
});
it('passes when Error matches and is exactly Error', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error());
return matcher.compare(actual, Error).then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with Error, but it was.'
}));
return matcher.compare(actual, Error).then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
'Expected a promise not to be rejected with Error, but it was.'
})
);
});
});
it('passes when Error message matches a string', function () {
it('passes when Error message matches a string', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error('foo'));
return matcher.compare(actual, 'foo').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with Error: \'foo\', but it was.'
}));
return matcher.compare(actual, 'foo').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
"Expected a promise not to be rejected with Error: 'foo', but it was."
})
);
});
});
it('passes when Error message matches a RegExp', function () {
it('passes when Error message matches a RegExp', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error('foo'));
return matcher.compare(actual, /foo/).then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with Error: /foo/, but it was.'
}));
return matcher.compare(actual, /foo/).then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
'Expected a promise not to be rejected with Error: /foo/, but it was.'
})
);
});
});
it('passes when Error message is empty', function () {
it('passes when Error message is empty', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error());
return matcher.compare(actual, '').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with Error: \'\', but it was.'
}));
return matcher.compare(actual, '').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
"Expected a promise not to be rejected with Error: '', but it was."
})
);
});
});
it('passes when no arguments', function () {
it('passes when no arguments', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error());
return matcher.compare(actual, void 0).then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with Error, but it was.'
}));
return matcher.compare(actual, void 0).then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message:
'Expected a promise not to be rejected with Error, but it was.'
})
);
});
});
it('fails when resolved', function () {
it('fails when resolved', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.resolve(new Error('foo'));
return matcher.compare(actual, 'foo').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: 'Expected a promise to be rejected but it was resolved.'
}));
return matcher.compare(actual, 'foo').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message: 'Expected a promise to be rejected but it was resolved.'
})
);
});
});
it('fails when rejected with non Error type', function () {
it('fails when rejected with non Error type', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject('foo');
return matcher.compare(actual, 'foo').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: 'Expected a promise to be rejected with Error: \'foo\' but it was rejected with \'foo\'.'
}));
return matcher.compare(actual, 'foo').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message:
"Expected a promise to be rejected with Error: 'foo' but it was rejected with 'foo'."
})
);
});
});
it('fails when Error type mismatches', function () {
it('fails when Error type mismatches', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error('foo'));
return matcher.compare(actual, TypeError, 'foo').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: 'Expected a promise to be rejected with TypeError: \'foo\' but it was rejected with type Error.'
}));
return matcher.compare(actual, TypeError, 'foo').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message:
"Expected a promise to be rejected with TypeError: 'foo' but it was rejected with type Error."
})
);
});
});
it('fails when Error message mismatches', function () {
it('fails when Error message mismatches', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = Promise.reject(new Error('foo'));
return matcher.compare(actual, 'bar').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: 'Expected a promise to be rejected with Error: \'bar\' but it was rejected with Error: foo.'
}));
return matcher.compare(actual, 'bar').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message:
"Expected a promise to be rejected with Error: 'bar' but it was rejected with Error: foo."
})
);
});
});
it('fails if actual is not a promise', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
matchersUtil
),
actual = 'not a promise';
function f() {

67
spec/core/matchers/async/toBeRejectedWithSpec.js
View File

@@ -1,74 +1,91 @@
/* eslint-disable compat/compat */
describe('#toBeRejectedWith', function () {
it('should return true if the promise is rejected with the expected value', function () {
describe('#toBeRejectedWith', function() {
it('should return true if the promise is rejected with the expected value', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil(),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
actual = Promise.reject({error: 'PEBCAK'});
actual = Promise.reject({ error: 'PEBCAK' });
return matcher.compare(actual, {error: 'PEBCAK'}).then(function (result) {
return matcher.compare(actual, { error: 'PEBCAK' }).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
it('should fail if the promise resolves', function () {
it('should fail if the promise resolves', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil(),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
actual = Promise.resolve();
return matcher.compare(actual, '').then(function (result) {
return matcher.compare(actual, '').then(function(result) {
expect(result).toEqual(jasmine.objectContaining({ pass: false }));
});
});
it('should fail if the promise is rejected with a different value', function () {
it('should fail if the promise is rejected with a different value', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
actual = Promise.reject('A Bad Apple');
return matcher.compare(actual, 'Some Cool Thing').then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'.",
}));
return matcher.compare(actual, 'Some Cool Thing').then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message:
"Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'."
})
);
});
});
it('should build its error correctly when negated', function () {
it('should build its error correctly when negated', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
actual = Promise.reject(true);
return matcher.compare(actual, true).then(function (result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with true.'
}));
return matcher.compare(actual, true).then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be rejected with true.'
})
);
});
});
it('should support custom equality testers', function () {
it('should support custom equality testers', function() {
jasmine.getEnv().requirePromises();
var customEqualityTesters = [function() { return true; }],
matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
var customEqualityTesters = [
function() {
return true;
}
],
matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: customEqualityTesters
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
actual = Promise.reject('actual');
return matcher.compare(actual, 'expected').then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: true}));
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
it('fails if actual is not a promise', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
actual = 'not a promise';

8
spec/core/matchers/async/toBeResolvedSpec.js
View File

@@ -8,7 +8,7 @@ describe('toBeResolved', function() {
actual = Promise.resolve();
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: true}));
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
@@ -20,7 +20,7 @@ describe('toBeResolved', function() {
actual = Promise.reject('AsyncExpectationSpec rejection');
return matcher.compare(actual).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: false}));
expect(result).toEqual(jasmine.objectContaining({ pass: false }));
});
});
@@ -33,8 +33,6 @@ describe('toBeResolved', function() {
return matcher.compare(actual);
}
expect(f).toThrowError(
'Expected toBeResolved to be called on a promise.'
);
expect(f).toThrowError('Expected toBeResolved to be called on a promise.');
});
});

66
spec/core/matchers/async/toBeResolvedToSpec.js
View File

@@ -5,62 +5,80 @@ describe('#toBeResolvedTo', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil(),
matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
actual = Promise.resolve({foo: 42});
actual = Promise.resolve({ foo: 42 });
return matcher.compare(actual, {foo: 42}).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: true}));
return matcher.compare(actual, { foo: 42 }).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
it('fails if the promise is rejected', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
actual = Promise.reject('AsyncExpectationSpec error');
return matcher.compare(actual, '').then(function(result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: "Expected a promise to be resolved to '' but it was rejected.",
}));
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message:
"Expected a promise to be resolved to '' but it was rejected."
})
);
});
});
it('fails if the promise is resolved to a different value', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
actual = Promise.resolve({foo: 17});
actual = Promise.resolve({ foo: 17 });
return matcher.compare(actual, {foo: 42}).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({
pass: false,
message: 'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).',
}));
return matcher.compare(actual, { foo: 42 }).then(function(result) {
expect(result).toEqual(
jasmine.objectContaining({
pass: false,
message:
'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).'
})
);
});
});
it('builds its message correctly when negated', function() {
jasmine.getEnv().requirePromises();
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
actual = Promise.resolve(true);
return matcher.compare(actual, true).then(function(result) {
expect(result).toEqual(jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be resolved to true.'
}));
expect(result).toEqual(
jasmine.objectContaining({
pass: true,
message: 'Expected a promise not to be resolved to true.'
})
);
});
});
it('supports custom equality testers', function() {
jasmine.getEnv().requirePromises();
var customEqualityTesters = [function() { return true; }],
var customEqualityTesters = [
function() {
return true;
}
],
matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: customEqualityTesters,
pp: jasmineUnderTest.makePrettyPrinter()
@@ -69,12 +87,14 @@ describe('#toBeResolvedTo', function() {
actual = Promise.resolve('actual');
return matcher.compare(actual, 'expected').then(function(result) {
expect(result).toEqual(jasmine.objectContaining({pass: true}));
expect(result).toEqual(jasmine.objectContaining({ pass: true }));
});
});
it('fails if actual is not a promise', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
actual = 'not a promise';

635
spec/core/matchers/matchersUtilSpec.js
View File

File diff suppressed because it is too large Load Diff

30
spec/core/matchers/toBeCloseToSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeCloseTo", function() {
it("passes when within two decimal places by default", function() {
describe('toBeCloseTo', function() {
it('passes when within two decimal places by default', function() {
var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
result;
@@ -13,7 +13,7 @@ describe("toBeCloseTo", function() {
expect(result.pass).toBe(true);
});
it("fails when not within two decimal places by default", function() {
it('fails when not within two decimal places by default', function() {
var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
result;
@@ -24,7 +24,7 @@ describe("toBeCloseTo", function() {
expect(result.pass).toBe(false);
});
it("accepts an optional precision argument", function() {
it('accepts an optional precision argument', function() {
var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
result;
@@ -47,23 +47,29 @@ describe("toBeCloseTo", function() {
expect(result.pass).toBe(true);
});
it("fails when one of the arguments is null", function() {
it('fails when one of the arguments is null', function() {
var matcher = jasmineUnderTest.matchers.toBeCloseTo();
expect(function() {
matcher.compare(null, null);
}).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(null).');
}).toThrowError(
'Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(null).'
);
expect(function() {
matcher.compare(0, null);
}).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(0).toBeCloseTo(null).');
}).toThrowError(
'Cannot use toBeCloseTo with null. Arguments evaluated to: expect(0).toBeCloseTo(null).'
);
expect(function() {
matcher.compare(null, 0);
}).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).');
}).toThrowError(
'Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).'
);
});
it("rounds expected values", function() {
it('rounds expected values', function() {
var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
result;
@@ -91,15 +97,15 @@ describe("toBeCloseTo", function() {
expect(result.pass).toBe(true);
});
it("handles edge cases with rounding", function () {
it('handles edge cases with rounding', function() {
var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
result;
// these cases resulted in false negatives in version of V8
// these cases resulted in false negatives in version of V8
// included in Node.js 12 and Chrome 74 (and Edge Chromium)
result = matcher.compare(4.030904708957288, 4.0309, 5);
expect(result.pass).toBe(true);
result = matcher.compare(4.82665525779431,4.82666, 5);
result = matcher.compare(4.82665525779431, 4.82666, 5);
expect(result.pass).toBe(true);
result = matcher.compare(-2.82665525779431, -2.82666, 5);
expect(result.pass).toBe(true);

9
spec/core/matchers/toBeDefinedSpec.js
View File

@@ -1,18 +1,17 @@
describe("toBeDefined", function() {
it("matches for defined values", function() {
describe('toBeDefined', function() {
it('matches for defined values', function() {
var matcher = jasmineUnderTest.matchers.toBeDefined(),
result;
result = matcher.compare('foo');
expect(result.pass).toBe(true);
});
it("fails when matching undefined values", function() {
it('fails when matching undefined values', function() {
var matcher = jasmineUnderTest.matchers.toBeDefined(),
result;
result = matcher.compare(void 0);
expect(result.pass).toBe(false);
})
});
});

8
spec/core/matchers/toBeFalseSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeFalse", function() {
it("passes for false", function() {
describe('toBeFalse', function() {
it('passes for false', function() {
var matcher = jasmineUnderTest.matchers.toBeFalse(),
result;
@@ -7,7 +7,7 @@ describe("toBeFalse", function() {
expect(result.pass).toBe(true);
});
it("fails for non-false", function() {
it('fails for non-false', function() {
var matcher = jasmineUnderTest.matchers.toBeFalse(),
result;
@@ -15,7 +15,7 @@ describe("toBeFalse", function() {
expect(result.pass).toBe(false);
});
it("fails for falsy", function() {
it('fails for falsy', function() {
var matcher = jasmineUnderTest.matchers.toBeFalse(),
result;

4
spec/core/matchers/toBeFalsySpec.js
View File

@@ -1,4 +1,4 @@
describe("toBeFalsy", function() {
describe('toBeFalsy', function() {
it("passes for 'falsy' values", function() {
var matcher = jasmineUnderTest.matchers.toBeFalsy(),
result;
@@ -29,7 +29,7 @@ describe("toBeFalsy", function() {
result = matcher.compare(1);
expect(result.pass).toBe(false);
result = matcher.compare("foo");
result = matcher.compare('foo');
expect(result.pass).toBe(false);
result = matcher.compare({});

8
spec/core/matchers/toBeGreaterThanOrEqualSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeGreaterThanOrEqual", function() {
it("passes when actual >= expected", function() {
describe('toBeGreaterThanOrEqual', function() {
it('passes when actual >= expected', function() {
var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
result;
@@ -16,7 +16,7 @@ describe("toBeGreaterThanOrEqual", function() {
expect(result.pass).toBe(true);
});
it("fails when actual < expected", function() {
it('fails when actual < expected', function() {
var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
result;
@@ -25,5 +25,5 @@ describe("toBeGreaterThanOrEqual", function() {
result = matcher.compare(1, 1.0000001);
expect(result.pass).toBe(false);
})
});
});

6
spec/core/matchers/toBeGreaterThanSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeGreaterThan", function() {
it("passes when actual > expected", function() {
describe('toBeGreaterThan', function() {
it('passes when actual > expected', function() {
var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
result;
@@ -7,7 +7,7 @@ describe("toBeGreaterThan", function() {
expect(result.pass).toBe(true);
});
it("fails when actual <= expected", function() {
it('fails when actual <= expected', function() {
var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
result;

27
spec/core/matchers/toBeInstanceOfSpec.js
View File

@@ -92,13 +92,14 @@ describe('toBeInstanceOf', function() {
describe('when expecting Function', function() {
it('passes for a function', function() {
var fn = function() { };
var fn = function() {};
var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
var result = matcher.compare(fn, Function);
expect(result).toEqual({
pass: true,
message: 'Expected instance of Function not to be an instance of Function'
message:
'Expected instance of Function not to be an instance of Function'
});
});
@@ -111,13 +112,14 @@ describe('toBeInstanceOf', function() {
var result = matcher.compare(fn, Function);
expect(result).toEqual({
pass: true,
message: 'Expected instance of AsyncFunction not to be an instance of Function'
message:
'Expected instance of AsyncFunction not to be an instance of Function'
});
});
});
describe('when expecting Object', function() {
function Animal() { }
function Animal() {}
it('passes for any object', function() {
var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
@@ -164,14 +166,15 @@ describe('toBeInstanceOf', function() {
var result = matcher.compare(object, Object);
expect(result).toEqual({
pass: true,
message: 'Expected instance of null({ }) not to be an instance of Object'
message:
'Expected instance of null({ }) not to be an instance of Object'
});
});
});
describe('when expecting a user-defined class', function() {
// Base class
function Animal() { }
function Animal() {}
// Subclasses, defined using syntax that is as old as possible
function Dog() {
@@ -218,8 +221,10 @@ describe('toBeInstanceOf', function() {
var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
expect(function() {
matcher.compare({}, 'Error');
}).toThrowError('<toBeInstanceOf> : Expected value is not a constructor function\n' +
'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)');
}).toThrowError(
'<toBeInstanceOf> : Expected value is not a constructor function\n' +
'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)'
);
});
it('raises an error if missing an expected value', function() {
@@ -228,7 +233,9 @@ describe('toBeInstanceOf', function() {
});
expect(function() {
matcher.compare({}, undefined);
}).toThrowError('<toBeInstanceOf> : Expected value is not a constructor function\n' +
'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)');
}).toThrowError(
'<toBeInstanceOf> : Expected value is not a constructor function\n' +
'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)'
);
});
});

8
spec/core/matchers/toBeLessThanOrEqualSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeLessThanOrEqual", function() {
it("passes when actual <= expected", function() {
describe('toBeLessThanOrEqual', function() {
it('passes when actual <= expected', function() {
var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
result;
@@ -11,12 +11,12 @@ describe("toBeLessThanOrEqual", function() {
result = matcher.compare(1, 1.0000001);
expect(result.pass).toBe(true);
result = matcher.compare(1.0, 1.0);
expect(result.pass).toBe(true);
});
it("fails when actual < expected", function() {
it('fails when actual < expected', function() {
var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
result;

6
spec/core/matchers/toBeLessThanSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeLessThan", function() {
it("passes when actual < expected", function() {
describe('toBeLessThan', function() {
it('passes when actual < expected', function() {
var matcher = jasmineUnderTest.matchers.toBeLessThan(),
result;
@@ -7,7 +7,7 @@ describe("toBeLessThan", function() {
expect(result.pass).toBe(true);
});
it("fails when actual <= expected", function() {
it('fails when actual <= expected', function() {
var matcher = jasmineUnderTest.matchers.toBeLessThan(),
result;

12
spec/core/matchers/toBeNaNSpec.js
View File

@@ -1,14 +1,14 @@
describe("toBeNaN", function() {
it("passes for NaN with a custom .not fail", function() {
describe('toBeNaN', function() {
it('passes for NaN with a custom .not fail', function() {
var matcher = jasmineUnderTest.matchers.toBeNaN(),
result;
result = matcher.compare(Number.NaN);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected actual not to be NaN.");
expect(result.message).toEqual('Expected actual not to be NaN.');
});
it("fails for anything not a NaN", function() {
it('fails for anything not a NaN', function() {
var matcher = jasmineUnderTest.matchers.toBeNaN(),
result;
@@ -28,12 +28,12 @@ describe("toBeNaN", function() {
expect(result.pass).toBe(false);
});
it("has a custom message on failure", function() {
it('has a custom message on failure', function() {
var matcher = jasmineUnderTest.matchers.toBeNaN({
pp: jasmineUnderTest.makePrettyPrinter()
}),
result = matcher.compare(0);
expect(result.message()).toEqual("Expected 0 to be NaN.");
expect(result.message()).toEqual('Expected 0 to be NaN.');
});
});

11
spec/core/matchers/toBeNegativeInfinitySpec.js
View File

@@ -1,4 +1,4 @@
describe("toBeNegativeInfinity", function() {
describe('toBeNegativeInfinity', function() {
it("fails for anything that isn't -Infinity", function() {
var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
result;
@@ -13,21 +13,20 @@ describe("toBeNegativeInfinity", function() {
expect(result.pass).toBe(false);
});
it("has a custom message on failure", function() {
it('has a custom message on failure', function() {
var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity({
pp: jasmineUnderTest.makePrettyPrinter()
}),
result = matcher.compare(0);
expect(result.message()).toEqual("Expected 0 to be -Infinity.")
expect(result.message()).toEqual('Expected 0 to be -Infinity.');
});
it("succeeds for -Infinity", function() {
it('succeeds for -Infinity', function() {
var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
result = matcher.compare(Number.NEGATIVE_INFINITY);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected actual not to be -Infinity.")
expect(result.message).toEqual('Expected actual not to be -Infinity.');
});
});

6
spec/core/matchers/toBeNullSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeNull", function() {
it("passes for null", function() {
describe('toBeNull', function() {
it('passes for null', function() {
var matcher = jasmineUnderTest.matchers.toBeNull(),
result;
@@ -7,7 +7,7 @@ describe("toBeNull", function() {
expect(result.pass).toBe(true);
});
it("fails for non-null", function() {
it('fails for non-null', function() {
var matcher = jasmineUnderTest.matchers.toBeNull(),
result;

11
spec/core/matchers/toBePositiveInfinitySpec.js
View File

@@ -1,4 +1,4 @@
describe("toBePositiveInfinity", function() {
describe('toBePositiveInfinity', function() {
it("fails for anything that isn't Infinity", function() {
var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
result;
@@ -13,21 +13,20 @@ describe("toBePositiveInfinity", function() {
expect(result.pass).toBe(false);
});
it("has a custom message on failure", function() {
it('has a custom message on failure', function() {
var matcher = jasmineUnderTest.matchers.toBePositiveInfinity({
pp: jasmineUnderTest.makePrettyPrinter()
}),
result = matcher.compare(0);
expect(result.message()).toEqual("Expected 0 to be Infinity.")
expect(result.message()).toEqual('Expected 0 to be Infinity.');
});
it("succeeds for Infinity", function() {
it('succeeds for Infinity', function() {
var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
result = matcher.compare(Number.POSITIVE_INFINITY);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected actual not to be Infinity.")
expect(result.message).toEqual('Expected actual not to be Infinity.');
});
});

64
spec/core/matchers/toBeSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBe", function() {
it("passes with no message when actual === expected", function() {
describe('toBe', function() {
it('passes with no message when actual === expected', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil(),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result;
@@ -8,29 +8,37 @@ describe("toBe", function() {
expect(result.pass).toBe(true);
});
it("passes with a custom message when expected is an array", function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
it('passes with a custom message when expected is an array', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result,
array = [1];
result = matcher.compare(array, array);
expect(result.pass).toBe(true);
expect(result.message).toBe("Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
expect(result.message).toBe(
'Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
);
});
it("passes with a custom message when expected is an object", function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
it('passes with a custom message when expected is an object', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result,
obj = {foo: "bar"};
obj = { foo: 'bar' };
result = matcher.compare(obj, obj);
expect(result.pass).toBe(true);
expect(result.message).toBe("Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
expect(result.message).toBe(
"Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe()."
);
});
it("fails with no message when actual !== expected", function() {
it('fails with no message when actual !== expected', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil(),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result;
@@ -40,35 +48,47 @@ describe("toBe", function() {
expect(result.message).toBeUndefined();
});
it("fails with a custom message when expected is an array", function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
it('fails with a custom message when expected is an array', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result;
result = matcher.compare([1], [1]);
expect(result.pass).toBe(false);
expect(result.message).toBe("Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
expect(result.message).toBe(
'Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
);
});
it("fails with a custom message when expected is an object", function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
it('fails with a custom message when expected is an object', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result;
result = matcher.compare({foo: "bar"}, {foo: "bar"});
result = matcher.compare({ foo: 'bar' }, { foo: 'bar' });
expect(result.pass).toBe(false);
expect(result.message).toBe("Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
expect(result.message).toBe(
"Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe()."
);
});
it("works with custom object formatters when expected is an object", function() {
var formatter = function(x) { return '<' + x.foo + '>'; },
it('works with custom object formatters when expected is an object', function() {
var formatter = function(x) {
return '<' + x.foo + '>';
},
prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]),
matchersUtil = new jasmineUnderTest.MatchersUtil({pp: prettyPrinter}),
matchersUtil = new jasmineUnderTest.MatchersUtil({ pp: prettyPrinter }),
matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
result;
result = matcher.compare({foo: "bar"}, {foo: "bar"});
result = matcher.compare({ foo: 'bar' }, { foo: 'bar' });
expect(result.pass).toBe(false);
expect(result.message).toBe("Expected <bar> to be <bar>. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
expect(result.message).toBe(
'Expected <bar> to be <bar>. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
);
});
});

6
spec/core/matchers/toBeTrueSpec.js
View File

@@ -1,5 +1,5 @@
describe("toBeTrue", function() {
it("passes for true", function() {
describe('toBeTrue', function() {
it('passes for true', function() {
var matcher = jasmineUnderTest.matchers.toBeTrue(),
result;
@@ -7,7 +7,7 @@ describe("toBeTrue", function() {
expect(result.pass).toBe(true);
});
it("fails for non-true", function() {
it('fails for non-true', function() {
var matcher = jasmineUnderTest.matchers.toBeTrue(),
result;

4
spec/core/matchers/toBeTruthySpec.js
View File

@@ -1,4 +1,4 @@
describe("toBeTruthy", function() {
describe('toBeTruthy', function() {
it("passes for 'truthy' values", function() {
var matcher = jasmineUnderTest.matchers.toBeTruthy(),
result;
@@ -9,7 +9,7 @@ describe("toBeTruthy", function() {
result = matcher.compare(1);
expect(result.pass).toBe(true);
result = matcher.compare("foo");
result = matcher.compare('foo');
expect(result.pass).toBe(true);
result = matcher.compare({});

9
spec/core/matchers/toBeUndefinedSpec.js
View File

@@ -1,18 +1,17 @@
describe("toBeUndefined", function() {
it("passes for undefined values", function() {
describe('toBeUndefined', function() {
it('passes for undefined values', function() {
var matcher = jasmineUnderTest.matchers.toBeUndefined(),
result;
result = matcher.compare(void 0);
expect(result.pass).toBe(true);
});
it("fails when matching defined values", function() {
it('fails when matching defined values', function() {
var matcher = jasmineUnderTest.matchers.toBeUndefined(),
result;
result = matcher.compare('foo');
expect(result.pass).toBe(false);
})
});
});

16
spec/core/matchers/toContainSpec.js
View File

@@ -1,21 +1,23 @@
describe("toContain", function() {
it("delegates to jasmineUnderTest.matchersUtil.contains", function() {
describe('toContain', function() {
it('delegates to jasmineUnderTest.matchersUtil.contains', function() {
var matchersUtil = {
contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
},
matcher = jasmineUnderTest.matchers.toContain(matchersUtil),
result;
result = matcher.compare("ABC", "B");
expect(matchersUtil.contains).toHaveBeenCalledWith("ABC", "B");
result = matcher.compare('ABC', 'B');
expect(matchersUtil.contains).toHaveBeenCalledWith('ABC', 'B');
expect(result.pass).toBe(true);
});
it("works with custom equality testers", function() {
var tester = function (a, b) {
it('works with custom equality testers', function() {
var tester = function(a, b) {
return a.toString() === b.toString();
},
matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]}),
matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
}),
matcher = jasmineUnderTest.matchers.toContain(matchersUtil),
result;

678
spec/core/matchers/toEqualSpec.js
View File

File diff suppressed because it is too large Load Diff

62
spec/core/matchers/toHaveBeenCalledBeforeSpec.js
View File

@@ -1,29 +1,29 @@
describe("toHaveBeenCalledBefore", function() {
it("throws an exception when the actual is not a spy", function() {
describe('toHaveBeenCalledBefore', function() {
it('throws an exception when the actual is not a spy', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {},
spy = new jasmineUnderTest.Env().createSpy('a spy');
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {},
spy = new jasmineUnderTest.Env().createSpy('a spy');
expect(function () {
expect(function() {
matcher.compare(fn, spy);
}).toThrowError(Error, /Expected a spy, but got Function./);
});
it("throws an exception when the expected is not a spy", function() {
it('throws an exception when the expected is not a spy', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore({
pp: jasmineUnderTest.makePrettyPrinter()
}),
spy = new jasmineUnderTest.Env().createSpy('a spy'),
fn = function() {};
pp: jasmineUnderTest.makePrettyPrinter()
}),
spy = new jasmineUnderTest.Env().createSpy('a spy'),
fn = function() {};
expect(function () {
expect(function() {
matcher.compare(spy, fn);
}).toThrowError(Error, /Expected a spy, but got Function./);
});
it("fails when the actual was not called", function () {
it('fails when the actual was not called', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
firstSpy = new jasmineUnderTest.Spy('first spy'),
secondSpy = new jasmineUnderTest.Spy('second spy');
@@ -32,10 +32,12 @@ describe("toHaveBeenCalledBefore", function() {
result = matcher.compare(firstSpy, secondSpy);
expect(result.pass).toBe(false);
expect(result.message).toMatch(/Expected spy first spy to have been called./);
expect(result.message).toMatch(
/Expected spy first spy to have been called./
);
});
it("fails when the expected was not called", function () {
it('fails when the expected was not called', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
firstSpy = new jasmineUnderTest.Spy('first spy'),
secondSpy = new jasmineUnderTest.Spy('second spy');
@@ -44,10 +46,12 @@ describe("toHaveBeenCalledBefore", function() {
result = matcher.compare(firstSpy, secondSpy);
expect(result.pass).toBe(false);
expect(result.message).toMatch(/Expected spy second spy to have been called./);
expect(result.message).toMatch(
/Expected spy second spy to have been called./
);
});
it("fails when the actual is called after the expected", function () {
it('fails when the actual is called after the expected', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
firstSpy = new jasmineUnderTest.Spy('first spy'),
secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -58,10 +62,12 @@ describe("toHaveBeenCalledBefore", function() {
result = matcher.compare(firstSpy, secondSpy);
expect(result.pass).toBe(false);
expect(result.message).toEqual('Expected spy first spy to have been called before spy second spy');
expect(result.message).toEqual(
'Expected spy first spy to have been called before spy second spy'
);
});
it("fails when the actual is called before and after the expected", function () {
it('fails when the actual is called before and after the expected', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
firstSpy = new jasmineUnderTest.Spy('first spy'),
secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -73,10 +79,12 @@ describe("toHaveBeenCalledBefore", function() {
result = matcher.compare(firstSpy, secondSpy);
expect(result.pass).toBe(false);
expect(result.message).toEqual('Expected latest call to spy first spy to have been called before first call to spy second spy (no interleaved calls)');
expect(result.message).toEqual(
'Expected latest call to spy first spy to have been called before first call to spy second spy (no interleaved calls)'
);
});
it("fails when the expected is called before and after the actual", function () {
it('fails when the expected is called before and after the actual', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
firstSpy = new jasmineUnderTest.Spy('first spy'),
secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -88,10 +96,12 @@ describe("toHaveBeenCalledBefore", function() {
result = matcher.compare(firstSpy, secondSpy);
expect(result.pass).toBe(false);
expect(result.message).toEqual('Expected first call to spy second spy to have been called after latest call to spy first spy (no interleaved calls)');
expect(result.message).toEqual(
'Expected first call to spy second spy to have been called after latest call to spy first spy (no interleaved calls)'
);
});
it("passes when the actual is called before the expected", function () {
it('passes when the actual is called before the expected', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
firstSpy = new jasmineUnderTest.Spy('first spy'),
secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -102,6 +112,8 @@ describe("toHaveBeenCalledBefore", function() {
result = matcher.compare(firstSpy, secondSpy);
expect(result.pass).toBe(true);
expect(result.message).toEqual('Expected spy first spy to not have been called before spy second spy, but it was');
expect(result.message).toEqual(
'Expected spy first spy to not have been called before spy second spy, but it was'
);
});
});

57
spec/core/matchers/toHaveBeenCalledOnceWithSpec.js
View File

@@ -1,6 +1,5 @@
describe("toHaveBeenCalledOnceWith", function () {
it("passes when the actual was called only once and with matching parameters", function () {
describe('toHaveBeenCalledOnceWith', function() {
it('passes when the actual was called only once and with matching parameters', function() {
var pp = jasmineUnderTest.makePrettyPrinter(),
util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -11,13 +10,23 @@ describe("toHaveBeenCalledOnceWith", function () {
result = matcher.compare(calledSpy, 'a', 'b');
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected spy called-spy to have been called 0 times, multiple times, or once, but with arguments different from:\n [ 'a', 'b' ]\nBut the actual call was:\n [ 'a', 'b' ].\n\n");
expect(result.message).toEqual(
"Expected spy called-spy to have been called 0 times, multiple times, or once, but with arguments different from:\n [ 'a', 'b' ]\nBut the actual call was:\n [ 'a', 'b' ].\n\n"
);
});
it("supports custom equality testers", function () {
var customEqualityTesters = [function() { return true; }],
matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(matchersUtil),
it('supports custom equality testers', function() {
var customEqualityTesters = [
function() {
return true;
}
],
matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: customEqualityTesters
}),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(
matchersUtil
),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
@@ -27,7 +36,7 @@ describe("toHaveBeenCalledOnceWith", function () {
expect(result.pass).toBe(true);
});
it("fails when the actual was never called", function () {
it('fails when the actual was never called', function() {
var pp = jasmineUnderTest.makePrettyPrinter(),
util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -37,10 +46,12 @@ describe("toHaveBeenCalledOnceWith", function () {
result = matcher.compare(calledSpy, 'a', 'b');
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut it was never called.\n\n");
expect(result.message).toEqual(
"Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut it was never called.\n\n"
);
});
it("fails when the actual was called once with different parameters", function () {
it('fails when the actual was called once with different parameters', function() {
var pp = jasmineUnderTest.makePrettyPrinter(),
util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -51,10 +62,12 @@ describe("toHaveBeenCalledOnceWith", function () {
result = matcher.compare(calledSpy, 'a', 'b');
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut the actual call was:\n [ 'a', 'c' ].\nExpected $[1] = 'c' to equal 'b'.\n\n");
expect(result.message).toEqual(
"Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut the actual call was:\n [ 'a', 'c' ].\nExpected $[1] = 'c' to equal 'b'.\n\n"
);
});
it("fails when the actual was called multiple times with expected parameters", function () {
it('fails when the actual was called multiple times with expected parameters', function() {
var pp = jasmineUnderTest.makePrettyPrinter(),
util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -66,10 +79,12 @@ describe("toHaveBeenCalledOnceWith", function () {
result = matcher.compare(calledSpy, 'a', 'b');
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut the actual calls were:\n [ 'a', 'b' ],\n [ 'a', 'b' ].\n\n");
expect(result.message).toEqual(
"Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut the actual calls were:\n [ 'a', 'b' ],\n [ 'a', 'b' ].\n\n"
);
});
it("fails when the actual was called multiple times (one of them - with expected parameters)", function () {
it('fails when the actual was called multiple times (one of them - with expected parameters)', function() {
var pp = jasmineUnderTest.makePrettyPrinter(),
util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -81,15 +96,19 @@ describe("toHaveBeenCalledOnceWith", function () {
result = matcher.compare(calledSpy, 'a', 'b');
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut the actual calls were:\n [ 'a', 'b' ],\n [ 'a', 'c' ].\n\n");
expect(result.message).toEqual(
"Expected spy called-spy to have been called only once, and with given args:\n [ 'a', 'b' ]\nBut the actual calls were:\n [ 'a', 'b' ],\n [ 'a', 'c' ].\n\n"
);
});
it("throws an exception when the actual is not a spy", function () {
it('throws an exception when the actual is not a spy', function() {
var pp = jasmineUnderTest.makePrettyPrinter(),
util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
fn = function () { };
fn = function() {};
expect(function () { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
expect(function() {
matcher.compare(fn);
}).toThrowError(/Expected a spy, but got Function./);
});
});

29
spec/core/matchers/toHaveBeenCalledSpec.js
View File

@@ -1,5 +1,5 @@
describe("toHaveBeenCalled", function() {
it("passes when the actual was called, with a custom .not fail message", function() {
describe('toHaveBeenCalled', function() {
it('passes when the actual was called, with a custom .not fail message', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
@@ -8,10 +8,12 @@ describe("toHaveBeenCalled", function() {
result = matcher.compare(calledSpy);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected spy called-spy not to have been called.");
expect(result.message).toEqual(
'Expected spy called-spy not to have been called.'
);
});
it("fails when the actual was not called", function() {
it('fails when the actual was not called', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
result;
@@ -20,30 +22,35 @@ describe("toHaveBeenCalled", function() {
expect(result.pass).toBe(false);
});
it("throws an exception when the actual is not a spy", function() {
it('throws an exception when the actual is not a spy', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalled({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {};
expect(function() { matcher.compare(fn) }).toThrowError(Error, /Expected a spy, but got Function./);
expect(function() {
matcher.compare(fn);
}).toThrowError(Error, /Expected a spy, but got Function./);
});
it("throws an exception when invoked with any arguments", function() {
it('throws an exception when invoked with any arguments', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
spy = new jasmineUnderTest.Spy('sample spy');
expect(function() { matcher.compare(spy, 'foo') }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
expect(function() {
matcher.compare(spy, 'foo');
}).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
});
it("has a custom message on failure", function() {
it('has a custom message on failure', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
spy = new jasmineUnderTest.Spy('sample-spy'),
result;
result = matcher.compare(spy);
expect(result.message).toEqual("Expected spy sample-spy to have been called.");
expect(result.message).toEqual(
'Expected spy sample-spy to have been called.'
);
});
});

45
spec/core/matchers/toHaveBeenCalledTimesSpec.js
View File

@@ -1,12 +1,12 @@
describe("toHaveBeenCalledTimes", function() {
it("passes when the actual 0 matches the expected 0 ", function () {
describe('toHaveBeenCalledTimes', function() {
it('passes when the actual 0 matches the expected 0 ', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
result = matcher.compare(calledSpy, 0);
expect(result.pass).toBeTruthy();
});
it("passes when the actual matches the expected", function() {
it('passes when the actual matches the expected', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
@@ -16,18 +16,20 @@ describe("toHaveBeenCalledTimes", function() {
expect(result.pass).toBe(true);
});
it("fails when expected numbers is not supplied", function(){
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
it('fails when expected numbers is not supplied', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
spy = new jasmineUnderTest.Spy('spy'),
result;
spy();
expect(function() {
matcher.compare(spy);
}).toThrowError(/The expected times failed is a required argument and must be a number./);
expect(function() {
matcher.compare(spy);
}).toThrowError(
/The expected times failed is a required argument and must be a number./
);
});
it("fails when the actual was called less than the expected", function() {
it('fails when the actual was called less than the expected', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
result;
@@ -36,7 +38,7 @@ describe("toHaveBeenCalledTimes", function() {
expect(result.pass).toBe(false);
});
it("fails when the actual was called more than expected", function() {
it('fails when the actual was called more than expected', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
result;
@@ -48,7 +50,7 @@ describe("toHaveBeenCalledTimes", function() {
expect(result.pass).toBe(false);
});
it("throws an exception when the actual is not a spy", function() {
it('throws an exception when the actual is not a spy', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes({
pp: jasmineUnderTest.makePrettyPrinter()
}),
@@ -59,7 +61,7 @@ describe("toHaveBeenCalledTimes", function() {
}).toThrowError(/Expected a spy, but got Function./);
});
it("has a custom message on failure that tells it was called only once", function() {
it('has a custom message on failure that tells it was called only once', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
spy = new jasmineUnderTest.Spy('sample-spy'),
result;
@@ -69,10 +71,14 @@ describe("toHaveBeenCalledTimes", function() {
spy();
result = matcher.compare(spy, 1);
expect(result.message).toEqual('Expected spy sample-spy to have been called once. It was called ' + 4 + ' times.');
expect(result.message).toEqual(
'Expected spy sample-spy to have been called once. It was called ' +
4 +
' times.'
);
});
it("has a custom message on failure that tells how many times it was called", function() {
it('has a custom message on failure that tells how many times it was called', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
spy = new jasmineUnderTest.Spy('sample-spy'),
result;
@@ -82,7 +88,10 @@ describe("toHaveBeenCalledTimes", function() {
spy();
result = matcher.compare(spy, 2);
expect(result.message).toEqual('Expected spy sample-spy to have been called 2 times. It was called ' + 4 + ' times.');
expect(result.message).toEqual(
'Expected spy sample-spy to have been called 2 times. It was called ' +
4 +
' times.'
);
});
});

105
spec/core/matchers/toHaveBeenCalledWithSpec.js
View File

@@ -1,24 +1,31 @@
describe("toHaveBeenCalledWith", function() {
it("passes when the actual was called with matching parameters", function() {
describe('toHaveBeenCalledWith', function() {
it('passes when the actual was called with matching parameters', function() {
var matchersUtil = {
contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
calledSpy('a', 'b');
result = matcher.compare(calledSpy, 'a', 'b');
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected spy called-spy not to have been called with:\n [ 'a', 'b' ]\nbut it was.");
expect(result.message()).toEqual(
"Expected spy called-spy not to have been called with:\n [ 'a', 'b' ]\nbut it was."
);
});
it("supports custom equality testers", function() {
var customEqualityTesters = [function() { return true; }],
matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
it('supports custom equality testers', function() {
var customEqualityTesters = [
function() {
return true;
}
],
matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: customEqualityTesters
}),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
calledSpy = new jasmineUnderTest.Spy('called-spy'),
result;
@@ -28,25 +35,31 @@ describe("toHaveBeenCalledWith", function() {
expect(result.pass).toBe(true);
});
it("fails when the actual was not called", function() {
it('fails when the actual was not called', function() {
var matchersUtil = {
contains: jasmine.createSpy('delegated-contains').and.returnValue(false),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
result;
contains: jasmine
.createSpy('delegated-contains')
.and.returnValue(false),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
result;
result = matcher.compare(uncalledSpy);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected spy uncalled spy to have been called with:\n [ ]\nbut it was never called.");
expect(result.message()).toEqual(
'Expected spy uncalled spy to have been called with:\n [ ]\nbut it was never called.'
);
});
it("fails when the actual was called with different parameters", function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
calledSpy = new jasmineUnderTest.Spy('called spy'),
result;
it('fails when the actual was called with different parameters', function() {
var matchersUtil = new jasmineUnderTest.MatchersUtil({
pp: jasmineUnderTest.makePrettyPrinter()
}),
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
calledSpy = new jasmineUnderTest.Spy('called spy'),
result;
calledSpy('a');
calledSpy('c', 'd');
@@ -55,30 +68,32 @@ describe("toHaveBeenCalledWith", function() {
expect(result.pass).toBe(false);
expect(result.message()).toEqual(
"Expected spy called spy to have been called with:\n" +
" [ 'a', 'b' ]\n" +
"but actual calls were:\n" +
" [ 'a' ],\n" +
" [ 'c', 'd' ],\n" +
" [ 'a', 'b', 'c' ].\n\n" +
"Call 0:\n" +
" Expected $.length = 1 to equal 2.\n" +
" Expected $[1] = undefined to equal 'b'.\n" +
"Call 1:\n" +
" Expected $[0] = 'c' to equal 'a'.\n" +
" Expected $[1] = 'd' to equal 'b'.\n" +
"Call 2:\n" +
" Expected $.length = 3 to equal 2.\n" +
" Unexpected $[2] = 'c' in array.");
'Expected spy called spy to have been called with:\n' +
" [ 'a', 'b' ]\n" +
'but actual calls were:\n' +
" [ 'a' ],\n" +
" [ 'c', 'd' ],\n" +
" [ 'a', 'b', 'c' ].\n\n" +
'Call 0:\n' +
' Expected $.length = 1 to equal 2.\n' +
" Expected $[1] = undefined to equal 'b'.\n" +
'Call 1:\n' +
" Expected $[0] = 'c' to equal 'a'.\n" +
" Expected $[1] = 'd' to equal 'b'.\n" +
'Call 2:\n' +
' Expected $.length = 3 to equal 2.\n' +
" Unexpected $[2] = 'c' in array."
);
});
it("throws an exception when the actual is not a spy", function() {
it('throws an exception when the actual is not a spy', function() {
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function () {
};
fn = function() {};
expect(function() { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
expect(function() {
matcher.compare(fn);
}).toThrowError(/Expected a spy, but got Function./);
});
});

9
spec/core/matchers/toHaveClassSpec.js
View File

@@ -5,7 +5,10 @@ describe('toHaveClass', function() {
it('fails for a DOM element that lacks the expected class', function() {
var matcher = jasmineUnderTest.matchers.toHaveClass(),
result = matcher.compare(this.domHelpers.createElementWithClassName(''), 'foo');
result = matcher.compare(
this.domHelpers.createElementWithClassName(''),
'foo'
);
expect(result.pass).toBe(false);
});
@@ -41,11 +44,11 @@ describe('toHaveClass', function() {
var textNode = this.domHelpers.document.createTextNode('');
expect(function() {
matcher.compare(textNode, 'foo')
matcher.compare(textNode, 'foo');
}).toThrowError('HTMLNode is not a DOM element');
expect(function() {
matcher.compare({classList: ''}, 'foo');
matcher.compare({ classList: '' }, 'foo');
}).toThrowError("Object({ classList: '' }) is not a DOM element");
});
});

16
spec/core/matchers/toHaveSizeSpec.js
View File

@@ -18,28 +18,28 @@ describe('toHaveSize', function() {
it('passes for an object with the proper number of keys', function() {
var matcher = jasmineUnderTest.matchers.toHaveSize(),
result = matcher.compare({a: 1, b: 2}, 2);
result = matcher.compare({ a: 1, b: 2 }, 2);
expect(result.pass).toBe(true);
});
it('fails for an object with a different number of keys', function() {
var matcher = jasmineUnderTest.matchers.toHaveSize(),
result = matcher.compare({a: 1, b: 2}, 1);
result = matcher.compare({ a: 1, b: 2 }, 1);
expect(result.pass).toBe(false);
});
it('passes for an object with an explicit `length` property that matches', function() {
var matcher = jasmineUnderTest.matchers.toHaveSize(),
result = matcher.compare({a: 1, b: 2, length: 5}, 5);
result = matcher.compare({ a: 1, b: 2, length: 5 }, 5);
expect(result.pass).toBe(true);
});
it('fails for an object with an explicit `length` property that does not match', function() {
var matcher = jasmineUnderTest.matchers.toHaveSize(),
result = matcher.compare({a: 1, b: 2, length: 5}, 1);
result = matcher.compare({ a: 1, b: 2, length: 5 }, 1);
expect(result.pass).toBe(false);
});
@@ -62,8 +62,8 @@ describe('toHaveSize', function() {
jasmine.getEnv().requireFunctioningMaps();
var map = new Map();
map.set('a',1);
map.set('b',2);
map.set('a', 1);
map.set('b', 2);
var matcher = jasmineUnderTest.matchers.toHaveSize(),
result = matcher.compare(map, 2);
@@ -75,8 +75,8 @@ describe('toHaveSize', function() {
jasmine.getEnv().requireFunctioningMaps();
var map = new Map();
map.set('a',1);
map.set('b',2);
map.set('a', 1);
map.set('b', 2);
var matcher = jasmineUnderTest.matchers.toHaveSize(),
result = matcher.compare(map, 1);

14
spec/core/matchers/toMatchSpec.js
View File

@@ -1,6 +1,5 @@
describe("toMatch", function() {
it("passes when RegExps are equivalent", function() {
describe('toMatch', function() {
it('passes when RegExps are equivalent', function() {
var matcher = jasmineUnderTest.matchers.toMatch(),
result;
@@ -8,7 +7,7 @@ describe("toMatch", function() {
expect(result.pass).toBe(true);
});
it("fails when RegExps are not equivalent", function() {
it('fails when RegExps are not equivalent', function() {
var matcher = jasmineUnderTest.matchers.toMatch(),
result;
@@ -16,7 +15,7 @@ describe("toMatch", function() {
expect(result.pass).toBe(false);
});
it("passes when the actual matches the expected string as a pattern", function() {
it('passes when the actual matches the expected string as a pattern', function() {
var matcher = jasmineUnderTest.matchers.toMatch(),
result;
@@ -24,7 +23,7 @@ describe("toMatch", function() {
expect(result.pass).toBe(true);
});
it("fails when the actual matches the expected string as a pattern", function() {
it('fails when the actual matches the expected string as a pattern', function() {
var matcher = jasmineUnderTest.matchers.toMatch(),
result;
@@ -32,7 +31,7 @@ describe("toMatch", function() {
expect(result.pass).toBe(false);
});
it("throws an Error when the expected is not a String or RegExp", function() {
it('throws an Error when the expected is not a String or RegExp', function() {
var matcher = jasmineUnderTest.matchers.toMatch();
expect(function() {
@@ -40,4 +39,3 @@ describe("toMatch", function() {
}).toThrowError(/Expected is not a String or a RegExp/);
});
});

169
spec/core/matchers/toThrowErrorSpec.js
View File

@@ -1,5 +1,5 @@
describe("toThrowError", function() {
it("throws an error when the actual is not a function", function() {
describe('toThrowError', function() {
it('throws an error when the actual is not a function', function() {
var matcher = jasmineUnderTest.matchers.toThrowError();
expect(function() {
@@ -7,10 +7,10 @@ describe("toThrowError", function() {
}).toThrowError(/Actual is not a Function/);
});
it("throws an error when the expected is not an Error, string, or RegExp", function() {
it('throws an error when the expected is not an Error, string, or RegExp', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
throw new Error("foo");
throw new Error('foo');
};
expect(function() {
@@ -18,21 +18,21 @@ describe("toThrowError", function() {
}).toThrowError(/Expected is not an Error, string, or RegExp./);
});
it("throws an error when the expected error type is not an Error", function() {
it('throws an error when the expected error type is not an Error', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
throw new Error("foo");
throw new Error('foo');
};
expect(function() {
matcher.compare(fn, void 0, "foo");
matcher.compare(fn, void 0, 'foo');
}).toThrowError(/Expected error type is not an Error./);
});
it("throws an error when the expected error message is not a string or RegExp", function() {
it('throws an error when the expected error message is not a string or RegExp', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
throw new Error("foo");
throw new Error('foo');
};
expect(function() {
@@ -40,7 +40,7 @@ describe("toThrowError", function() {
}).toThrowError(/Expected error message is not a string or RegExp./);
});
it("fails if actual does not throw at all", function() {
it('fails if actual does not throw at all', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
return true;
@@ -50,10 +50,10 @@ describe("toThrowError", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected function to throw an Error.");
expect(result.message).toEqual('Expected function to throw an Error.');
});
it("fails if thrown is not an instanceof Error", function() {
it('fails if thrown is not an instanceof Error', function() {
var matcher = jasmineUnderTest.matchers.toThrowError({
pp: jasmineUnderTest.makePrettyPrinter()
}),
@@ -64,12 +64,14 @@ describe("toThrowError", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw an Error, but it threw 4.");
expect(result.message()).toEqual(
'Expected function to throw an Error, but it threw 4.'
);
});
describe("when error is from another frame", function() {
describe('when error is from another frame', function() {
function isNotRunningInBrowser() {
return typeof document === 'undefined'
return typeof document === 'undefined';
}
var iframe = null;
@@ -80,31 +82,36 @@ describe("toThrowError", function() {
}
});
it("passes if thrown is an instanceof Error regardless of global that contains its constructor", function() {
it('passes if thrown is an instanceof Error regardless of global that contains its constructor', function() {
if (isNotRunningInBrowser()) {
return;
}
var matcher = jasmineUnderTest.matchers.toThrowError();
iframe = document.body.appendChild(document.createElement("iframe"));
iframe.src = "about:blank";
iframe = document.body.appendChild(document.createElement('iframe'));
iframe.src = 'about:blank';
var iframeDocument = iframe.contentWindow.document;
if (iframeDocument.body) {
iframeDocument.body.appendChild(iframeDocument.createElement("script"))
.textContent = "function method() { throw new Error('foo'); }";
iframeDocument.body.appendChild(
iframeDocument.createElement('script')
).textContent = "function method() { throw new Error('foo'); }";
} else {
// IE 10 and older
iframeDocument.write("<html><head><script>function method() { throw new Error('foo'); }</script></head></html>");
iframeDocument.write(
"<html><head><script>function method() { throw new Error('foo'); }</script></head></html>"
);
}
var result = matcher.compare(iframe.contentWindow.method);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected function not to throw an Error, but it threw Error.");
expect(result.message).toEqual(
'Expected function not to throw an Error, but it threw Error.'
);
});
});
it("fails with the correct message if thrown is a falsy value", function() {
it('fails with the correct message if thrown is a falsy value', function() {
var matcher = jasmineUnderTest.matchers.toThrowError({
pp: jasmineUnderTest.makePrettyPrinter()
}),
@@ -115,10 +122,12 @@ describe("toThrowError", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw an Error, but it threw undefined.");
expect(result.message()).toEqual(
'Expected function to throw an Error, but it threw undefined.'
);
});
it("passes if thrown is a type of Error, but there is no expected error", function() {
it('passes if thrown is a type of Error, but there is no expected error', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
throw new TypeError();
@@ -128,70 +137,80 @@ describe("toThrowError", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected function not to throw an Error, but it threw TypeError.");
expect(result.message).toEqual(
'Expected function not to throw an Error, but it threw TypeError.'
);
});
it("passes if thrown is an Error and the expected is the same message", function() {
it('passes if thrown is an Error and the expected is the same message', function() {
var matcher = jasmineUnderTest.matchers.toThrowError({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {
throw new Error("foo");
throw new Error('foo');
},
result;
result = matcher.compare(fn, "foo");
result = matcher.compare(fn, 'foo');
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw an exception with message 'foo'.");
expect(result.message()).toEqual(
"Expected function not to throw an exception with message 'foo'."
);
});
it("fails if thrown is an Error and the expected is not the same message", function() {
it('fails if thrown is an Error and the expected is not the same message', function() {
var matcher = jasmineUnderTest.matchers.toThrowError({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {
throw new Error("foo");
throw new Error('foo');
},
result;
result = matcher.compare(fn, "bar");
result = matcher.compare(fn, 'bar');
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'.");
expect(result.message()).toEqual(
"Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'."
);
});
it("passes if thrown is an Error and the expected is a RegExp that matches the message", function() {
it('passes if thrown is an Error and the expected is a RegExp that matches the message', function() {
var matcher = jasmineUnderTest.matchers.toThrowError({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {
throw new Error("a long message");
throw new Error('a long message');
},
result;
result = matcher.compare(fn, /long/);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw an exception with a message matching /long/.");
expect(result.message()).toEqual(
'Expected function not to throw an exception with a message matching /long/.'
);
});
it("fails if thrown is an Error and the expected is a RegExp that does not match the message", function() {
it('fails if thrown is an Error and the expected is a RegExp that does not match the message', function() {
var matcher = jasmineUnderTest.matchers.toThrowError({
pp: jasmineUnderTest.makePrettyPrinter()
}),
fn = function() {
throw new Error("a long message");
throw new Error('a long message');
},
result;
result = matcher.compare(fn, /foo/);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'.");
expect(result.message()).toEqual(
"Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'."
);
});
it("passes if thrown is an Error and the expected the same Error", function() {
it('passes if thrown is an Error and the expected the same Error', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
throw new Error();
@@ -201,12 +220,14 @@ describe("toThrowError", function() {
result = matcher.compare(fn, Error);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw Error.");
expect(result.message()).toEqual('Expected function not to throw Error.');
});
it("passes if thrown is a custom error that takes arguments and the expected is the same error", function() {
it('passes if thrown is a custom error that takes arguments and the expected is the same error', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
CustomError = function CustomError(arg) { arg.x },
CustomError = function CustomError(arg) {
arg.x;
},
fn = function() {
throw new CustomError({ x: 1 });
},
@@ -217,10 +238,12 @@ describe("toThrowError", function() {
result = matcher.compare(fn, CustomError);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw CustomError.");
expect(result.message()).toEqual(
'Expected function not to throw CustomError.'
);
});
it("fails if thrown is an Error and the expected is a different Error", function() {
it('fails if thrown is an Error and the expected is a different Error', function() {
var matcher = jasmineUnderTest.matchers.toThrowError(),
fn = function() {
throw new Error();
@@ -230,94 +253,108 @@ describe("toThrowError", function() {
result = matcher.compare(fn, TypeError);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw TypeError, but it threw Error.");
expect(result.message()).toEqual(
'Expected function to throw TypeError, but it threw Error.'
);
});
it("passes if thrown is a type of Error and it is equal to the expected Error and message", function() {
it('passes if thrown is a type of Error and it is equal to the expected Error and message', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
fn = function() {
throw new TypeError("foo");
throw new TypeError('foo');
},
result;
result = matcher.compare(fn, TypeError, "foo");
result = matcher.compare(fn, TypeError, 'foo');
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw TypeError with message 'foo'.");
expect(result.message()).toEqual(
"Expected function not to throw TypeError with message 'foo'."
);
});
it("passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message", function() {
it('passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
CustomError = function CustomError(arg) { this.message = arg.message; },
CustomError = function CustomError(arg) {
this.message = arg.message;
},
fn = function() {
throw new CustomError({message: "foo"});
throw new CustomError({ message: 'foo' });
},
result;
CustomError.prototype = new Error();
result = matcher.compare(fn, CustomError, "foo");
result = matcher.compare(fn, CustomError, 'foo');
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw CustomError with message 'foo'.");
expect(result.message()).toEqual(
"Expected function not to throw CustomError with message 'foo'."
);
});
it("fails if thrown is a type of Error and the expected is a different Error", function() {
it('fails if thrown is a type of Error and the expected is a different Error', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
fn = function() {
throw new TypeError("foo");
throw new TypeError('foo');
},
result;
result = matcher.compare(fn, TypeError, "bar");
result = matcher.compare(fn, TypeError, 'bar');
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'.");
expect(result.message()).toEqual(
"Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'."
);
});
it("passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message", function() {
it('passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
fn = function() {
throw new TypeError("foo");
throw new TypeError('foo');
},
result;
result = matcher.compare(fn, TypeError, /foo/);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw TypeError with a message matching /foo/.");
expect(result.message()).toEqual(
'Expected function not to throw TypeError with a message matching /foo/.'
);
});
it("fails if thrown is a type of Error and the expected is a different Error", function() {
it('fails if thrown is a type of Error and the expected is a different Error', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
pp: jasmineUnderTest.makePrettyPrinter()
},
matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
fn = function() {
throw new TypeError("foo");
throw new TypeError('foo');
},
result;
result = matcher.compare(fn, TypeError, /bar/);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'.");
expect(result.message()).toEqual(
"Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'."
);
});
});

54
spec/core/matchers/toThrowMatchingSpec.js
View File

@@ -1,16 +1,18 @@
describe("toThrowMatching", function() {
it("throws an error when the actual is not a function", function() {
describe('toThrowMatching', function() {
it('throws an error when the actual is not a function', function() {
var matcher = jasmineUnderTest.matchers.toThrowMatching();
expect(function() {
matcher.compare({}, function() { return true; });
matcher.compare({}, function() {
return true;
});
}).toThrowError(/Actual is not a Function/);
});
it("throws an error when the expected is not a function", function() {
it('throws an error when the expected is not a function', function() {
var matcher = jasmineUnderTest.matchers.toThrowMatching(),
fn = function() {
throw new Error("foo");
throw new Error('foo');
};
expect(function() {
@@ -18,20 +20,22 @@ describe("toThrowMatching", function() {
}).toThrowError(/Predicate is not a Function/);
});
it("fails if actual does not throw at all", function() {
it('fails if actual does not throw at all', function() {
var matcher = jasmineUnderTest.matchers.toThrowMatching(),
fn = function() {
return true;
},
result;
result = matcher.compare(fn, function() { return true; });
result = matcher.compare(fn, function() {
return true;
});
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected function to throw an exception.");
expect(result.message).toEqual('Expected function to throw an exception.');
});
it("fails with the correct message if thrown is a falsy value", function() {
it('fails with the correct message if thrown is a falsy value', function() {
var matcher = jasmineUnderTest.matchers.toThrowMatching({
pp: jasmineUnderTest.makePrettyPrinter()
}),
@@ -40,38 +44,50 @@ describe("toThrowMatching", function() {
},
result;
result = matcher.compare(fn, function() { return false; });
result = matcher.compare(fn, function() {
return false;
});
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw undefined.");
expect(result.message()).toEqual(
'Expected function to throw an exception matching a predicate, but it threw undefined.'
);
});
it("passes if the argument is a function that returns true when called with the error", function() {
it('passes if the argument is a function that returns true when called with the error', function() {
var matcher = jasmineUnderTest.matchers.toThrowMatching(),
predicate = function(e) { return e.message === "nope" },
predicate = function(e) {
return e.message === 'nope';
},
fn = function() {
throw new TypeError("nope");
throw new TypeError('nope');
},
result;
result = matcher.compare(fn, predicate);
expect(result.pass).toBe(true);
expect(result.message).toEqual("Expected function not to throw an exception matching a predicate.");
expect(result.message).toEqual(
'Expected function not to throw an exception matching a predicate.'
);
});
it("fails if the argument is a function that returns false when called with the error", function() {
it('fails if the argument is a function that returns false when called with the error', function() {
var matcher = jasmineUnderTest.matchers.toThrowMatching({
pp: jasmineUnderTest.makePrettyPrinter()
}),
predicate = function(e) { return e.message === "oh no" },
predicate = function(e) {
return e.message === 'oh no';
},
fn = function() {
throw new TypeError("nope");
throw new TypeError('nope');
},
result;
result = matcher.compare(fn, predicate);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'.");
expect(result.message()).toEqual(
"Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'."
);
});
});

39
spec/core/matchers/toThrowSpec.js
View File

@@ -1,6 +1,5 @@
describe("toThrow", function() {
it("throws an error when the actual is not a function", function() {
describe('toThrow', function() {
it('throws an error when the actual is not a function', function() {
var matcher = jasmineUnderTest.matchers.toThrow();
expect(function() {
@@ -9,7 +8,7 @@ describe("toThrow", function() {
}).toThrowError(/Actual is not a Function/);
});
it("fails if actual does not throw", function() {
it('fails if actual does not throw', function() {
var matcher = jasmineUnderTest.matchers.toThrow(),
fn = function() {
return true;
@@ -19,10 +18,10 @@ describe("toThrow", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(false);
expect(result.message).toEqual("Expected function to throw an exception.");
expect(result.message).toEqual('Expected function to throw an exception.');
});
it("passes if it throws but there is no expected", function() {
it('passes if it throws but there is no expected', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
@@ -36,10 +35,12 @@ describe("toThrow", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw, but it threw 5.");
expect(result.message()).toEqual(
'Expected function not to throw, but it threw 5.'
);
});
it("passes even if what is thrown is falsy", function() {
it('passes even if what is thrown is falsy', function() {
var matcher = jasmineUnderTest.matchers.toThrow({
pp: jasmineUnderTest.makePrettyPrinter()
}),
@@ -50,10 +51,12 @@ describe("toThrow", function() {
result = matcher.compare(fn);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw, but it threw undefined.");
expect(result.message()).toEqual(
'Expected function not to throw, but it threw undefined.'
);
});
it("passes if what is thrown is equivalent to what is expected", function() {
it('passes if what is thrown is equivalent to what is expected', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
pp: jasmineUnderTest.makePrettyPrinter()
@@ -67,10 +70,10 @@ describe("toThrow", function() {
result = matcher.compare(fn, 5);
expect(result.pass).toBe(true);
expect(result.message()).toEqual("Expected function not to throw 5.");
expect(result.message()).toEqual('Expected function not to throw 5.');
});
it("fails if what is thrown is not equivalent to what is expected", function() {
it('fails if what is thrown is not equivalent to what is expected', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
pp: jasmineUnderTest.makePrettyPrinter()
@@ -81,13 +84,15 @@ describe("toThrow", function() {
},
result;
result = matcher.compare(fn, "foo");
result = matcher.compare(fn, 'foo');
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw 'foo', but it threw 5.");
expect(result.message()).toEqual(
"Expected function to throw 'foo', but it threw 5."
);
});
it("fails if what is thrown is not equivalent to undefined", function() {
it('fails if what is thrown is not equivalent to undefined', function() {
var matchersUtil = {
equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
pp: jasmineUnderTest.makePrettyPrinter()
@@ -101,6 +106,8 @@ describe("toThrow", function() {
result = matcher.compare(fn, void 0);
expect(result.pass).toBe(false);
expect(result.message()).toEqual("Expected function to throw undefined, but it threw 5.");
expect(result.message()).toEqual(
'Expected function to throw undefined, but it threw 5.'
);
});
});

3
src/core/asymmetric_equality/Any.js
View File

@@ -1,10 +1,9 @@
getJasmineRequireObj().Any = function(j$) {
function Any(expectedObject) {
if (typeof expectedObject === 'undefined') {
throw new TypeError(
'jasmine.any() expects to be passed a constructor function. ' +
'Please pass one or use jasmine.anything() to match any object.'
'Please pass one or use jasmine.anything() to match any object.'
);
}
this.expectedObject = expectedObject;

1
src/core/asymmetric_equality/Anything.js
View File

@@ -1,5 +1,4 @@
getJasmineRequireObj().Anything = function(j$) {
function Anything() {}
Anything.prototype.asymmetricMatch = function(other) {

10
src/core/asymmetric_equality/ArrayContaining.js
View File

@@ -5,7 +5,11 @@ getJasmineRequireObj().ArrayContaining = function(j$) {
ArrayContaining.prototype.asymmetricMatch = function(other, matchersUtil) {
if (!j$.isArray_(this.sample)) {
throw new Error('You must provide an array to arrayContaining, not ' + j$.pp(this.sample) + '.');
throw new Error(
'You must provide an array to arrayContaining, not ' +
j$.pp(this.sample) +
'.'
);
}
// If the actual parameter is not an array, we can fail immediately, since it couldn't
@@ -25,8 +29,8 @@ getJasmineRequireObj().ArrayContaining = function(j$) {
return true;
};
ArrayContaining.prototype.jasmineToString = function (pp) {
return '<jasmine.arrayContaining(' + pp(this.sample) +')>';
ArrayContaining.prototype.jasmineToString = function(pp) {
return '<jasmine.arrayContaining(' + pp(this.sample) + ')>';
};
return ArrayContaining;

12
src/core/asymmetric_equality/ArrayWithExactContents.js
View File

@@ -1,12 +1,18 @@
getJasmineRequireObj().ArrayWithExactContents = function(j$) {
function ArrayWithExactContents(sample) {
this.sample = sample;
}
ArrayWithExactContents.prototype.asymmetricMatch = function(other, matchersUtil) {
ArrayWithExactContents.prototype.asymmetricMatch = function(
other,
matchersUtil
) {
if (!j$.isArray_(this.sample)) {
throw new Error('You must provide an array to arrayWithExactContents, not ' + j$.pp(this.sample) + '.');
throw new Error(
'You must provide an array to arrayWithExactContents, not ' +
j$.pp(this.sample) +
'.'
);
}
if (this.sample.length !== other.length) {

7
src/core/asymmetric_equality/Empty.js
View File

@@ -1,8 +1,7 @@
getJasmineRequireObj().Empty = function (j$) {
getJasmineRequireObj().Empty = function(j$) {
function Empty() {}
Empty.prototype.asymmetricMatch = function (other) {
Empty.prototype.asymmetricMatch = function(other) {
if (j$.isString_(other) || j$.isArray_(other) || j$.isTypedArray_(other)) {
return other.length === 0;
}
@@ -17,7 +16,7 @@ getJasmineRequireObj().Empty = function (j$) {
return false;
};
Empty.prototype.jasmineToString = function () {
Empty.prototype.jasmineToString = function() {
return '<jasmine.empty>';
};

1
src/core/asymmetric_equality/Falsy.js
View File

@@ -1,5 +1,4 @@
getJasmineRequireObj().Falsy = function(j$) {
function Falsy() {}
Falsy.prototype.asymmetricMatch = function(other) {

8
src/core/asymmetric_equality/MapContaining.js
View File

@@ -1,7 +1,9 @@
getJasmineRequireObj().MapContaining = function(j$) {
function MapContaining(sample) {
if (!j$.isMap(sample)) {
throw new Error('You must provide a map to `mapContaining`, not ' + j$.pp(sample));
throw new Error(
'You must provide a map to `mapContaining`, not ' + j$.pp(sample)
);
}
this.sample = sample;
@@ -17,8 +19,8 @@ getJasmineRequireObj().MapContaining = function(j$) {
var hasMatch = false;
j$.util.forEachBreakable(other, function(oBreakLoop, oValue, oKey) {
if (
matchersUtil.equals(oKey, key)
&& matchersUtil.equals(oValue, value)
matchersUtil.equals(oKey, key) &&
matchersUtil.equals(oValue, value)
) {
hasMatch = true;
oBreakLoop();

7
src/core/asymmetric_equality/NotEmpty.js
View File

@@ -1,8 +1,7 @@
getJasmineRequireObj().NotEmpty = function (j$) {
getJasmineRequireObj().NotEmpty = function(j$) {
function NotEmpty() {}
NotEmpty.prototype.asymmetricMatch = function (other) {
NotEmpty.prototype.asymmetricMatch = function(other) {
if (j$.isString_(other) || j$.isArray_(other) || j$.isTypedArray_(other)) {
return other.length !== 0;
}
@@ -18,7 +17,7 @@ getJasmineRequireObj().NotEmpty = function (j$) {
return false;
};
NotEmpty.prototype.jasmineToString = function () {
NotEmpty.prototype.jasmineToString = function() {
return '<jasmine.notEmpty>';
};

23
src/core/asymmetric_equality/ObjectContaining.js
View File

@@ -1,5 +1,4 @@
getJasmineRequireObj().ObjectContaining = function(j$) {
function ObjectContaining(sample) {
this.sample = sample;
}
@@ -17,7 +16,7 @@ getJasmineRequireObj().ObjectContaining = function(j$) {
}
function hasProperty(obj, property) {
if (!obj || typeof(obj) !== 'object') {
if (!obj || typeof obj !== 'object') {
return false;
}
@@ -29,12 +28,22 @@ getJasmineRequireObj().ObjectContaining = function(j$) {
}
ObjectContaining.prototype.asymmetricMatch = function(other, matchersUtil) {
if (typeof(this.sample) !== 'object') { throw new Error('You must provide an object to objectContaining, not \''+this.sample+'\'.'); }
if (typeof(other) !== 'object') { return false; }
if (typeof this.sample !== 'object') {
throw new Error(
"You must provide an object to objectContaining, not '" +
this.sample +
"'."
);
}
if (typeof other !== 'object') {
return false;
}
for (var property in this.sample) {
if (!hasProperty(other, property) ||
!matchersUtil.equals(this.sample[property], other[property])) {
if (
!hasProperty(other, property) ||
!matchersUtil.equals(this.sample[property], other[property])
) {
return false;
}
}
@@ -51,7 +60,7 @@ getJasmineRequireObj().ObjectContaining = function(j$) {
}
var filteredOther = {};
Object.keys(this.sample).forEach(function (k) {
Object.keys(this.sample).forEach(function(k) {
// eq short-circuits comparison of objects that have different key sets,
// so include all keys even if undefined.
filteredOther[k] = other[k];

4
src/core/asymmetric_equality/SetContaining.js
View File

@@ -1,7 +1,9 @@
getJasmineRequireObj().SetContaining = function(j$) {
function SetContaining(sample) {
if (!j$.isSet(sample)) {
throw new Error('You must provide a set to `setContaining`, not ' + j$.pp(sample));
throw new Error(
'You must provide a set to `setContaining`, not ' + j$.pp(sample)
);
}
this.sample = sample;

1
src/core/asymmetric_equality/StringMatching.js
View File

@@ -1,5 +1,4 @@
getJasmineRequireObj().StringMatching = function(j$) {
function StringMatching(expected) {
if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
throw new Error('Expected is not a String or a RegExp');

1
src/core/asymmetric_equality/Truthy.js
View File

@@ -1,5 +1,4 @@
getJasmineRequireObj().Truthy = function(j$) {
function Truthy() {}
Truthy.prototype.asymmetricMatch = function(other) {

59
src/core/matchers/DiffBuilder.js
View File

@@ -1,4 +1,4 @@
getJasmineRequireObj().DiffBuilder = function (j$) {
getJasmineRequireObj().DiffBuilder = function(j$) {
return function DiffBuilder(config) {
var prettyPrinter = (config || {}).prettyPrinter || j$.makePrettyPrinter(),
mismatches = new j$.MismatchTree(),
@@ -7,21 +7,28 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
expectedRoot = undefined;
return {
setRoots: function (actual, expected) {
setRoots: function(actual, expected) {
actualRoot = actual;
expectedRoot = expected;
},
recordMismatch: function (formatter) {
recordMismatch: function(formatter) {
mismatches.add(path, formatter);
},
getMessage: function () {
getMessage: function() {
var messages = [];
mismatches.traverse(function (path, isLeaf, formatter) {
var actualCustom, expectedCustom, useCustom,
derefResult = dereferencePath(path, actualRoot, expectedRoot, prettyPrinter),
mismatches.traverse(function(path, isLeaf, formatter) {
var actualCustom,
expectedCustom,
useCustom,
derefResult = dereferencePath(
path,
actualRoot,
expectedRoot,
prettyPrinter
),
actual = derefResult.actual,
expected = derefResult.expected;
@@ -32,15 +39,22 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
actualCustom = prettyPrinter.customFormat_(actual);
expectedCustom = prettyPrinter.customFormat_(expected);
useCustom = !(j$.util.isUndefined(actualCustom) && j$.util.isUndefined(expectedCustom));
useCustom = !(
j$.util.isUndefined(actualCustom) &&
j$.util.isUndefined(expectedCustom)
);
if (useCustom) {
messages.push(wrapPrettyPrinted(actualCustom, expectedCustom, path));
messages.push(
wrapPrettyPrinted(actualCustom, expectedCustom, path)
);
return false; // don't recurse further
}
if (isLeaf) {
messages.push(defaultFormatter(actual, expected, path, prettyPrinter));
messages.push(
defaultFormatter(actual, expected, path, prettyPrinter)
);
}
return true;
@@ -49,7 +63,7 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
return messages.join('\n');
},
withPath: function (pathComponent, block) {
withPath: function(pathComponent, block) {
var oldPath = path;
path = path.add(pathComponent);
block();
@@ -58,22 +72,32 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
};
function defaultFormatter(actual, expected, path, prettyPrinter) {
return wrapPrettyPrinted(prettyPrinter(actual), prettyPrinter(expected), path);
return wrapPrettyPrinted(
prettyPrinter(actual),
prettyPrinter(expected),
path
);
}
function wrapPrettyPrinted(actual, expected, path) {
return 'Expected ' +
path + (path.depth() ? ' = ' : '') +
return (
'Expected ' +
path +
(path.depth() ? ' = ' : '') +
actual +
' to equal ' +
expected +
'.';
'.'
);
}
};
function dereferencePath(objectPath, actual, expected, pp) {
function handleAsymmetricExpected() {
if (j$.isAsymmetricEqualityTester_(expected) && j$.isFunction_(expected.valuesForDiff_)) {
if (
j$.isAsymmetricEqualityTester_(expected) &&
j$.isFunction_(expected.valuesForDiff_)
) {
var asymmetricResult = expected.valuesForDiff_(actual, pp);
expected = asymmetricResult.self;
actual = asymmetricResult.other;
@@ -89,7 +113,6 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
handleAsymmetricExpected();
}
return {actual: actual, expected: expected};
return { actual: actual, expected: expected };
}
};

11
src/core/matchers/MismatchTree.js
View File

@@ -1,5 +1,4 @@
getJasmineRequireObj().MismatchTree = function (j$) {
getJasmineRequireObj().MismatchTree = function(j$) {
/*
To be able to apply custom object formatters at all possible levels of an
object graph, DiffBuilder needs to be able to know not just where the
@@ -14,7 +13,7 @@ getJasmineRequireObj().MismatchTree = function (j$) {
this.isMismatch = false;
}
MismatchTree.prototype.add = function (path, formatter) {
MismatchTree.prototype.add = function(path, formatter) {
var key, child;
if (path.depth() === 0) {
@@ -34,8 +33,9 @@ getJasmineRequireObj().MismatchTree = function (j$) {
}
};
MismatchTree.prototype.traverse = function (visit) {
var i, hasChildren = this.children.length > 0;
MismatchTree.prototype.traverse = function(visit) {
var i,
hasChildren = this.children.length > 0;
if (this.isMismatch || hasChildren) {
if (visit(this.path, !hasChildren, this.formatter)) {
@@ -59,4 +59,3 @@ getJasmineRequireObj().MismatchTree = function (j$) {
return MismatchTree;
};

2
src/core/matchers/ObjectPath.js
View File

@@ -32,7 +32,7 @@ getJasmineRequireObj().ObjectPath = function(j$) {
return '.' + prop;
}
return '[\'' + prop + '\']';
return "['" + prop + "']";
}
function map(array, fn) {

8
src/core/matchers/async/toBePending.js
View File

@@ -17,8 +17,12 @@ getJasmineRequireObj().toBePending = function(j$) {
}
var want = {};
return Promise.race([actual, Promise.resolve(want)]).then(
function(got) { return {pass: want === got}; },
function() { return {pass: false}; }
function(got) {
return { pass: want === got };
},
function() {
return { pass: false };
}
);
}
};

8
src/core/matchers/async/toBeRejected.js
View File

@@ -17,8 +17,12 @@ getJasmineRequireObj().toBeRejected = function(j$) {
throw new Error('Expected toBeRejected to be called on a promise.');
}
return actual.then(
function() { return {pass: false}; },
function() { return {pass: true}; }
function() {
return { pass: false };
},
function() {
return { pass: true };
}
);
}
};

43
src/core/matchers/async/toBeRejectedWith.js
View File

@@ -15,35 +15,44 @@ getJasmineRequireObj().toBeRejectedWith = function(j$) {
return {
compare: function(actualPromise, expectedValue) {
if (!j$.isPromiseLike(actualPromise)) {
throw new Error('Expected toBeRejectedWith to be called on a promise.');
throw new Error(
'Expected toBeRejectedWith to be called on a promise.'
);
}
function prefix(passed) {
return 'Expected a promise ' +
return (
'Expected a promise ' +
(passed ? 'not ' : '') +
'to be rejected with ' + matchersUtil.pp(expectedValue);
'to be rejected with ' +
matchersUtil.pp(expectedValue)
);
}
return actualPromise.then(
function() {
return {
pass: false,
message: prefix(false) + ' but it was resolved.'
};
},
function(actualValue) {
if (matchersUtil.equals(actualValue, expectedValue)) {
return {
pass: true,
message: prefix(true) + '.'
};
} else {
return {
pass: false,
message: prefix(false) + ' but it was rejected with ' + matchersUtil.pp(actualValue) + '.'
message: prefix(false) + ' but it was resolved.'
};
},
function(actualValue) {
if (matchersUtil.equals(actualValue, expectedValue)) {
return {
pass: true,
message: prefix(true) + '.'
};
} else {
return {
pass: false,
message:
prefix(false) +
' but it was rejected with ' +
matchersUtil.pp(actualValue) +
'.'
};
}
}
}
);
}
};

45
src/core/matchers/async/toBeRejectedWithError.js
View File

@@ -18,7 +18,9 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
return {
compare: function(actualPromise, arg1, arg2) {
if (!j$.isPromiseLike(actualPromise)) {
throw new Error('Expected toBeRejectedWithError to be called on a promise.');
throw new Error(
'Expected toBeRejectedWithError to be called on a promise.'
);
}
var expected = getExpectedFromArgs(arg1, arg2, matchersUtil);
@@ -30,7 +32,9 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
message: 'Expected a promise to be rejected but it was resolved.'
};
},
function(actualValue) { return matchError(actualValue, expected, matchersUtil); }
function(actualValue) {
return matchError(actualValue, expected, matchersUtil);
}
);
}
};
@@ -42,16 +46,25 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
}
if (!(actual instanceof expected.error)) {
return fail(expected, 'rejected with type ' + j$.fnNameFor(actual.constructor));
return fail(
expected,
'rejected with type ' + j$.fnNameFor(actual.constructor)
);
}
var actualMessage = actual.message;
if (actualMessage === expected.message || typeof expected.message === 'undefined') {
if (
actualMessage === expected.message ||
typeof expected.message === 'undefined'
) {
return pass(expected);
}
if (expected.message instanceof RegExp && expected.message.test(actualMessage)) {
if (
expected.message instanceof RegExp &&
expected.message.test(actualMessage)
) {
return pass(expected);
}
@@ -61,18 +74,25 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
function pass(expected) {
return {
pass: true,
message: 'Expected a promise not to be rejected with ' + expected.printValue + ', but it was.'
message:
'Expected a promise not to be rejected with ' +
expected.printValue +
', but it was.'
};
}
function fail(expected, message) {
return {
pass: false,
message: 'Expected a promise to be rejected with ' + expected.printValue + ' but it was ' + message + '.'
message:
'Expected a promise to be rejected with ' +
expected.printValue +
' but it was ' +
message +
'.'
};
}
function getExpectedFromArgs(arg1, arg2, matchersUtil) {
var error, message;
@@ -87,11 +107,16 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
return {
error: error,
message: message,
printValue: j$.fnNameFor(error) + (typeof message === 'undefined' ? '' : ': ' + matchersUtil.pp(message))
printValue:
j$.fnNameFor(error) +
(typeof message === 'undefined' ? '' : ': ' + matchersUtil.pp(message))
};
}
function isErrorConstructor(value) {
return typeof value === 'function' && (value === Error || j$.isError_(value.prototype));
return (
typeof value === 'function' &&
(value === Error || j$.isError_(value.prototype))
);
}
};

8
src/core/matchers/async/toBeResolved.js
View File

@@ -18,8 +18,12 @@ getJasmineRequireObj().toBeResolved = function(j$) {
}
return actual.then(
function() { return {pass: true}; },
function() { return {pass: false}; }
function() {
return { pass: true };
},
function() {
return { pass: false };
}
);
}
};

13
src/core/matchers/async/toBeResolvedTo.js
View File

@@ -19,9 +19,12 @@ getJasmineRequireObj().toBeResolvedTo = function(j$) {
}
function prefix(passed) {
return 'Expected a promise ' +
return (
'Expected a promise ' +
(passed ? 'not ' : '') +
'to be resolved to ' + matchersUtil.pp(expectedValue);
'to be resolved to ' +
matchersUtil.pp(expectedValue)
);
}
return actualPromise.then(
@@ -34,7 +37,11 @@ getJasmineRequireObj().toBeResolvedTo = function(j$) {
} else {
return {
pass: false,
message: prefix(false) + ' but it was resolved to ' + matchersUtil.pp(actualValue) + '.'
message:
prefix(false) +
' but it was resolved to ' +
matchersUtil.pp(actualValue) +
'.'
};
}
},

240
src/core/matchers/matchersUtil.js
View File

@@ -21,7 +21,7 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
* @return {string} The pretty-printed value
*/
this.pp = options.pp || function() {};
};
}
/**
* Determines whether `haystack` contains `needle`, using the same comparison
@@ -39,9 +39,10 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
return haystack.has(needle);
}
if ((Object.prototype.toString.apply(haystack) === '[object Array]') ||
(!!haystack && !haystack.indexOf))
{
if (
Object.prototype.toString.apply(haystack) === '[object Array]' ||
(!!haystack && !haystack.indexOf)
) {
for (var i = 0; i < haystack.length; i++) {
if (this.equals(haystack[i], needle, customTesters)) {
return true;
@@ -60,9 +61,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
isNot = args[1],
actual = args[2],
expected = args.slice(3),
englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) {
return ' ' + s.toLowerCase();
});
var message = 'Expected ' +
var message =
'Expected ' +
self.pp(actual) +
(isNot ? ' not ' : ' ') +
englishyPredicate;
@@ -79,20 +83,41 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
return message + '.';
};
MatchersUtil.prototype.asymmetricDiff_ = function(a, b, aStack, bStack, customTesters, diffBuilder) {
MatchersUtil.prototype.asymmetricDiff_ = function(
a,
b,
aStack,
bStack,
customTesters,
diffBuilder
) {
if (j$.isFunction_(b.valuesForDiff_)) {
var values = b.valuesForDiff_(a, this.pp);
this.eq_(values.other, values.self, aStack, bStack, customTesters, diffBuilder);
this.eq_(
values.other,
values.self,
aStack,
bStack,
customTesters,
diffBuilder
);
} else {
diffBuilder.recordMismatch();
}
};
MatchersUtil.prototype.asymmetricMatch_ = function(a, b, aStack, bStack, customTesters, diffBuilder) {
MatchersUtil.prototype.asymmetricMatch_ = function(
a,
b,
aStack,
bStack,
customTesters,
diffBuilder
) {
var asymmetricA = j$.isAsymmetricEqualityTester_(a),
asymmetricB = j$.isAsymmetricEqualityTester_(b),
shim,
result;
asymmetricB = j$.isAsymmetricEqualityTester_(b),
shim,
result;
if (asymmetricA === asymmetricB) {
return undefined;
@@ -127,7 +152,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
* @param [customTesters] An array of custom equality testers
* @returns {boolean} True if the values are equal
*/
MatchersUtil.prototype.equals = function(a, b, customTestersOrDiffBuilder, diffBuilderOrNothing) {
MatchersUtil.prototype.equals = function(
a,
b,
customTestersOrDiffBuilder,
diffBuilderOrNothing
) {
var customTesters, diffBuilder;
if (isDiffBuilder(customTestersOrDiffBuilder)) {
@@ -146,10 +176,26 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
// Equality function lovingly adapted from isEqual in
// [Underscore](http://underscorejs.org)
MatchersUtil.prototype.eq_ = function(a, b, aStack, bStack, customTesters, diffBuilder) {
var result = true, self = this, i;
MatchersUtil.prototype.eq_ = function(
a,
b,
aStack,
bStack,
customTesters,
diffBuilder
) {
var result = true,
self = this,
i;
var asymmetricResult = this.asymmetricMatch_(a, b, aStack, bStack, customTesters, diffBuilder);
var asymmetricResult = this.asymmetricMatch_(
a,
b,
aStack,
bStack,
customTesters,
diffBuilder
);
if (!j$.util.isUndefined(asymmetricResult)) {
return asymmetricResult;
}
@@ -207,7 +253,8 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
case '[object Number]':
// `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
// other numeric values.
result = a != +a ? b != +b : (a === 0 && b === 0 ? 1 / a == 1 / b : a == +b);
result =
a != +a ? b != +b : a === 0 && b === 0 ? 1 / a == 1 / b : a == +b;
if (!result) {
diffBuilder.recordMismatch();
}
@@ -224,10 +271,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
return result;
// RegExps are compared by their source patterns and flags.
case '[object RegExp]':
return a.source == b.source &&
return (
a.source == b.source &&
a.global == b.global &&
a.multiline == b.multiline &&
a.ignoreCase == b.ignoreCase;
a.ignoreCase == b.ignoreCase
);
}
if (typeof a != 'object' || typeof b != 'object') {
diffBuilder.recordMismatch();
@@ -261,7 +310,9 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
while (length--) {
// Linear search. Performance is inversely proportional to the number of
// unique nested structures.
if (aStack[length] == a) { return bStack[length] == b; }
if (aStack[length] == a) {
return bStack[length] == b;
}
}
// Add the first object to the stack of traversed objects.
aStack.push(a);
@@ -283,10 +334,20 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
for (i = 0; i < aLength || i < bLength; i++) {
diffBuilder.withPath(i, function() {
if (i >= bLength) {
diffBuilder.recordMismatch(actualArrayIsLongerFormatter.bind(null, self.pp));
diffBuilder.recordMismatch(
actualArrayIsLongerFormatter.bind(null, self.pp)
);
result = false;
} else {
result = self.eq_(i < aLength ? a[i] : void 0, i < bLength ? b[i] : void 0, aStack, bStack, customTesters, diffBuilder) && result;
result =
self.eq_(
i < aLength ? a[i] : void 0,
i < bLength ? b[i] : void 0,
aStack,
bStack,
customTesters,
diffBuilder
) && result;
}
});
}
@@ -301,11 +362,11 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
var keysA = [];
var keysB = [];
a.forEach( function( valueA, keyA ) {
keysA.push( keyA );
a.forEach(function(valueA, keyA) {
keysA.push(keyA);
});
b.forEach( function( valueB, keyB ) {
keysB.push( keyB );
b.forEach(function(valueB, keyB) {
keysB.push(keyB);
});
// For both sets of keys, check they map to equal values in both maps.
@@ -326,13 +387,30 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
// Only use the cmpKey when one of the keys is asymmetric and the corresponding key matches,
// otherwise explicitly look up the mapKey in the other Map since we want keys with unique
// obj identity (that are otherwise equal) to not match.
if (j$.isAsymmetricEqualityTester_(mapKey) || j$.isAsymmetricEqualityTester_(cmpKey) &&
this.eq_(mapKey, cmpKey, aStack, bStack, customTesters, j$.NullDiffBuilder())) {
if (
j$.isAsymmetricEqualityTester_(mapKey) ||
(j$.isAsymmetricEqualityTester_(cmpKey) &&
this.eq_(
mapKey,
cmpKey,
aStack,
bStack,
customTesters,
j$.NullDiffBuilder()
))
) {
mapValueB = b.get(cmpKey);
} else {
mapValueB = b.get(mapKey);
}
result = this.eq_(mapValueA, mapValueB, aStack, bStack, customTesters, j$.NullDiffBuilder());
result = this.eq_(
mapValueA,
mapValueB,
aStack,
bStack,
customTesters,
j$.NullDiffBuilder()
);
}
}
@@ -347,12 +425,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
}
var valuesA = [];
a.forEach( function( valueA ) {
valuesA.push( valueA );
a.forEach(function(valueA) {
valuesA.push(valueA);
});
var valuesB = [];
b.forEach( function( valueB ) {
valuesB.push( valueB );
b.forEach(function(valueB) {
valuesB.push(valueB);
});
// For both sets, check they are all contained in the other set
@@ -376,7 +454,14 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
otherValue = otherValues[l];
prevStackSize = baseStack.length;
// compare by value equality
found = this.eq_(baseValue, otherValue, baseStack, otherStack, customTesters, j$.NullDiffBuilder());
found = this.eq_(
baseValue,
otherValue,
baseStack,
otherStack,
customTesters,
j$.NullDiffBuilder()
);
if (!found && prevStackSize !== baseStack.length) {
baseStack.splice(prevStackSize);
otherStack.splice(prevStackSize);
@@ -391,27 +476,35 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
return false;
}
} else {
// Objects with different constructors are not equivalent, but `Object`s
// or `Array`s from different frames are.
var aCtor = a.constructor, bCtor = b.constructor;
if (aCtor !== bCtor &&
isFunction(aCtor) && isFunction(bCtor) &&
a instanceof aCtor && b instanceof bCtor &&
!(aCtor instanceof aCtor && bCtor instanceof bCtor)) {
diffBuilder.recordMismatch(constructorsAreDifferentFormatter.bind(null, this.pp));
var aCtor = a.constructor,
bCtor = b.constructor;
if (
aCtor !== bCtor &&
isFunction(aCtor) &&
isFunction(bCtor) &&
a instanceof aCtor &&
b instanceof bCtor &&
!(aCtor instanceof aCtor && bCtor instanceof bCtor)
) {
diffBuilder.recordMismatch(
constructorsAreDifferentFormatter.bind(null, this.pp)
);
return false;
}
}
// Deep compare objects.
var aKeys = keys(a, className == '[object Array]'), key;
var aKeys = keys(a, className == '[object Array]'),
key;
size = aKeys.length;
// Ensure that both objects contain the same number of properties before comparing deep equality.
if (keys(b, className == '[object Array]').length !== size) {
diffBuilder.recordMismatch(objectKeysAreDifferentFormatter.bind(null, this.pp));
diffBuilder.recordMismatch(
objectKeysAreDifferentFormatter.bind(null, this.pp)
);
return false;
}
@@ -419,13 +512,17 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
key = aKeys[i];
// Deep compare each member
if (!j$.util.has(b, key)) {
diffBuilder.recordMismatch(objectKeysAreDifferentFormatter.bind(null, this.pp));
diffBuilder.recordMismatch(
objectKeysAreDifferentFormatter.bind(null, this.pp)
);
result = false;
continue;
}
diffBuilder.withPath(key, function() {
if(!self.eq_(a[key], b[key], aStack, bStack, customTesters, diffBuilder)) {
if (
!self.eq_(a[key], b[key], aStack, bStack, customTesters, diffBuilder)
) {
result = false;
}
});
@@ -443,23 +540,24 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
};
function keys(obj, isArray) {
var allKeys = Object.keys ? Object.keys(obj) :
(function(o) {
var allKeys = Object.keys
? Object.keys(obj)
: (function(o) {
var keys = [];
for (var key in o) {
if (j$.util.has(o, key)) {
keys.push(key);
}
if (j$.util.has(o, key)) {
keys.push(key);
}
}
return keys;
})(obj);
})(obj);
if (!isArray) {
return allKeys;
}
if (allKeys.length === 0) {
return allKeys;
return allKeys;
}
var extraKeys = [];
@@ -478,21 +576,25 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
function objectKeysAreDifferentFormatter(pp, actual, expected, path) {
var missingProperties = j$.util.objectDifference(expected, actual),
extraProperties = j$.util.objectDifference(actual, expected),
missingPropertiesMessage = formatKeyValuePairs(pp, missingProperties),
extraPropertiesMessage = formatKeyValuePairs(pp, extraProperties),
messages = [];
extraProperties = j$.util.objectDifference(actual, expected),
missingPropertiesMessage = formatKeyValuePairs(pp, missingProperties),
extraPropertiesMessage = formatKeyValuePairs(pp, extraProperties),
messages = [];
if (!path.depth()) {
path = 'object';
}
if (missingPropertiesMessage.length) {
messages.push('Expected ' + path + ' to have properties' + missingPropertiesMessage);
messages.push(
'Expected ' + path + ' to have properties' + missingPropertiesMessage
);
}
if (extraPropertiesMessage.length) {
messages.push('Expected ' + path + ' not to have properties' + extraPropertiesMessage);
messages.push(
'Expected ' + path + ' not to have properties' + extraPropertiesMessage
);
}
return messages.join('\n');
@@ -503,17 +605,25 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
path = 'object';
}
return 'Expected ' +
path + ' to be a kind of ' +
return (
'Expected ' +
path +
' to be a kind of ' +
j$.fnNameFor(expected.constructor) +
', but was ' + pp(actual) + '.';
', but was ' +
pp(actual) +
'.'
);
}
function actualArrayIsLongerFormatter(pp, actual, expected, path) {
return 'Unexpected ' +
path + (path.depth() ? ' = ' : '') +
return (
'Unexpected ' +
path +
(path.depth() ? ' = ' : '') +
pp(actual) +
' in array.';
' in array.'
);
}
function formatKeyValuePairs(pp, obj) {

11
src/core/matchers/toBe.js
View File

@@ -9,7 +9,8 @@ getJasmineRequireObj().toBe = function(j$) {
* expect(thing).toBe(realThing);
*/
function toBe(matchersUtil) {
var tip = ' Tip: To check for deep equality, use .toEqual() instead of .toBe().';
var tip =
' Tip: To check for deep equality, use .toEqual() instead of .toBe().';
return {
compare: function(actual, expected) {
@@ -18,7 +19,13 @@ getJasmineRequireObj().toBe = function(j$) {
};
if (typeof expected === 'object') {
result.message = matchersUtil.buildFailureMessage('toBe', result.pass, actual, expected) + tip;
result.message =
matchersUtil.buildFailureMessage(
'toBe',
result.pass,
actual,
expected
) + tip;
}
return result;

9
src/core/matchers/toBeCloseTo.js
View File

@@ -17,8 +17,13 @@ getJasmineRequireObj().toBeCloseTo = function() {
}
if (expected === null || actual === null) {
throw new Error('Cannot use toBeCloseTo with null. Arguments evaluated to: ' +
'expect(' + actual + ').toBeCloseTo(' + expected + ').'
throw new Error(
'Cannot use toBeCloseTo with null. Arguments evaluated to: ' +
'expect(' +
actual +
').toBeCloseTo(' +
expected +
').'
);
}

2
src/core/matchers/toBeDefined.js
View File

@@ -11,7 +11,7 @@ getJasmineRequireObj().toBeDefined = function() {
return {
compare: function(actual) {
return {
pass: (void 0 !== actual)
pass: void 0 !== actual
};
}
};

1
src/core/matchers/toBeGreaterThan.js
View File

@@ -20,4 +20,3 @@ getJasmineRequireObj().toBeGreaterThan = function() {
return toBeGreaterThan;
};

38
src/core/matchers/toBeInstanceOf.js
View File

@@ -1,5 +1,8 @@
getJasmineRequireObj().toBeInstanceOf = function(j$) {
var usageError = j$.formatErrorMsg('<toBeInstanceOf>', 'expect(value).toBeInstanceOf(<ConstructorFunction>)');
var usageError = j$.formatErrorMsg(
'<toBeInstanceOf>',
'expect(value).toBeInstanceOf(<ConstructorFunction>)'
);
/**
* {@link expect} the actual to be an instance of the expected class
@@ -15,27 +18,42 @@ getJasmineRequireObj().toBeInstanceOf = function(j$) {
function toBeInstanceOf(matchersUtil) {
return {
compare: function(actual, expected) {
var actualType = actual && actual.constructor ? j$.fnNameFor(actual.constructor) : matchersUtil.pp(actual),
expectedType = expected ? j$.fnNameFor(expected) : matchersUtil.pp(expected),
expectedMatcher,
pass;
var actualType =
actual && actual.constructor
? j$.fnNameFor(actual.constructor)
: matchersUtil.pp(actual),
expectedType = expected
? j$.fnNameFor(expected)
: matchersUtil.pp(expected),
expectedMatcher,
pass;
try {
expectedMatcher = new j$.Any(expected);
pass = expectedMatcher.asymmetricMatch(actual);
expectedMatcher = new j$.Any(expected);
pass = expectedMatcher.asymmetricMatch(actual);
} catch (error) {
throw new Error(usageError('Expected value is not a constructor function'));
throw new Error(
usageError('Expected value is not a constructor function')
);
}
if (pass) {
return {
pass: true,
message: 'Expected instance of ' + actualType + ' not to be an instance of ' + expectedType
message:
'Expected instance of ' +
actualType +
' not to be an instance of ' +
expectedType
};
} else {
return {
pass: false,
message: 'Expected instance of ' + actualType + ' to be an instance of ' + expectedType
message:
'Expected instance of ' +
actualType +
' to be an instance of ' +
expectedType
};
}
}

1
src/core/matchers/toBeLessThan.js
View File

@@ -10,7 +10,6 @@ getJasmineRequireObj().toBeLessThan = function() {
*/
function toBeLessThan() {
return {
compare: function(actual, expected) {
return {
pass: actual < expected

1
src/core/matchers/toBeLessThanOrEqual.js
View File

@@ -10,7 +10,6 @@ getJasmineRequireObj().toBeLessThanOrEqual = function() {
*/
function toBeLessThanOrEqual() {
return {
compare: function(actual, expected) {
return {
pass: actual <= expected

6
src/core/matchers/toBeNaN.js
View File

@@ -11,13 +11,15 @@ getJasmineRequireObj().toBeNaN = function(j$) {
return {
compare: function(actual) {
var result = {
pass: (actual !== actual)
pass: actual !== actual
};
if (result.pass) {
result.message = 'Expected actual not to be NaN.';
} else {
result.message = function() { return 'Expected ' + matchersUtil.pp(actual) + ' to be NaN.'; };
result.message = function() {
return 'Expected ' + matchersUtil.pp(actual) + ' to be NaN.';
};
}
return result;

6
src/core/matchers/toBeNegativeInfinity.js
View File

@@ -11,13 +11,15 @@ getJasmineRequireObj().toBeNegativeInfinity = function(j$) {
return {
compare: function(actual) {
var result = {
pass: (actual === Number.NEGATIVE_INFINITY)
pass: actual === Number.NEGATIVE_INFINITY
};
if (result.pass) {
result.message = 'Expected actual not to be -Infinity.';
} else {
result.message = function() { return 'Expected ' + matchersUtil.pp(actual) + ' to be -Infinity.'; };
result.message = function() {
return 'Expected ' + matchersUtil.pp(actual) + ' to be -Infinity.';
};
}
return result;

6
src/core/matchers/toBePositiveInfinity.js
View File

@@ -11,13 +11,15 @@ getJasmineRequireObj().toBePositiveInfinity = function(j$) {
return {
compare: function(actual) {
var result = {
pass: (actual === Number.POSITIVE_INFINITY)
pass: actual === Number.POSITIVE_INFINITY
};
if (result.pass) {
result.message = 'Expected actual not to be Infinity.';
} else {
result.message = function() { return 'Expected ' + matchersUtil.pp(actual) + ' to be Infinity.'; };
result.message = function() {
return 'Expected ' + matchersUtil.pp(actual) + ' to be Infinity.';
};
}
return result;

1
src/core/matchers/toContain.js
View File

@@ -12,7 +12,6 @@ getJasmineRequireObj().toContain = function() {
function toContain(matchersUtil) {
return {
compare: function(actual, expected) {
return {
pass: matchersUtil.contains(actual, expected)
};

2
src/core/matchers/toEqual.js
View File

@@ -14,7 +14,7 @@ getJasmineRequireObj().toEqual = function(j$) {
var result = {
pass: false
},
diffBuilder = j$.DiffBuilder({prettyPrinter: matchersUtil.pp});
diffBuilder = j$.DiffBuilder({ prettyPrinter: matchersUtil.pp });
result.pass = matchersUtil.equals(actual, expected, diffBuilder);

22
src/core/matchers/toHaveBeenCalled.js
View File

@@ -1,6 +1,8 @@
getJasmineRequireObj().toHaveBeenCalled = function(j$) {
var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalled>', 'expect(<spyObj>).toHaveBeenCalled()');
var getErrorMsg = j$.formatErrorMsg(
'<toHaveBeenCalled>',
'expect(<spyObj>).toHaveBeenCalled()'
);
/**
* {@link expect} the actual (a {@link Spy}) to have been called.
@@ -17,18 +19,24 @@ getJasmineRequireObj().toHaveBeenCalled = function(j$) {
var result = {};
if (!j$.isSpy(actual)) {
throw new Error(getErrorMsg('Expected a spy, but got ' + matchersUtil.pp(actual) + '.'));
throw new Error(
getErrorMsg(
'Expected a spy, but got ' + matchersUtil.pp(actual) + '.'
)
);
}
if (arguments.length > 1) {
throw new Error(getErrorMsg('Does not take arguments, use toHaveBeenCalledWith'));
throw new Error(
getErrorMsg('Does not take arguments, use toHaveBeenCalledWith')
);
}
result.pass = actual.calls.any();
result.message = result.pass ?
'Expected spy ' + actual.and.identity + ' not to have been called.' :
'Expected spy ' + actual.and.identity + ' to have been called.';
result.message = result.pass
? 'Expected spy ' + actual.and.identity + ' not to have been called.'
: 'Expected spy ' + actual.and.identity + ' to have been called.';
return result;
}

53
src/core/matchers/toHaveBeenCalledBefore.js
View File

@@ -1,6 +1,8 @@
getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledBefore>', 'expect(<spyObj>).toHaveBeenCalledBefore(<spyObj>)');
var getErrorMsg = j$.formatErrorMsg(
'<toHaveBeenCalledBefore>',
'expect(<spyObj>).toHaveBeenCalledBefore(<spyObj>)'
);
/**
* {@link expect} the actual value (a {@link Spy}) to have been called before another {@link Spy}.
@@ -15,20 +17,30 @@ getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
return {
compare: function(firstSpy, latterSpy) {
if (!j$.isSpy(firstSpy)) {
throw new Error(getErrorMsg('Expected a spy, but got ' + matchersUtil.pp(firstSpy) + '.'));
throw new Error(
getErrorMsg(
'Expected a spy, but got ' + matchersUtil.pp(firstSpy) + '.'
)
);
}
if (!j$.isSpy(latterSpy)) {
throw new Error(getErrorMsg('Expected a spy, but got ' + matchersUtil.pp(latterSpy) + '.'));
throw new Error(
getErrorMsg(
'Expected a spy, but got ' + matchersUtil.pp(latterSpy) + '.'
)
);
}
var result = { pass: false };
if (!firstSpy.calls.count()) {
result.message = 'Expected spy ' + firstSpy.and.identity + ' to have been called.';
result.message =
'Expected spy ' + firstSpy.and.identity + ' to have been called.';
return result;
}
if (!latterSpy.calls.count()) {
result.message = 'Expected spy ' + latterSpy.and.identity + ' to have been called.';
result.message =
'Expected spy ' + latterSpy.and.identity + ' to have been called.';
return result;
}
@@ -38,17 +50,36 @@ getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
result.pass = latest1stSpyCall < first2ndSpyCall;
if (result.pass) {
result.message = 'Expected spy ' + firstSpy.and.identity + ' to not have been called before spy ' + latterSpy.and.identity + ', but it was';
result.message =
'Expected spy ' +
firstSpy.and.identity +
' to not have been called before spy ' +
latterSpy.and.identity +
', but it was';
} else {
var first1stSpyCall = firstSpy.calls.first().invocationOrder;
var latest2ndSpyCall = latterSpy.calls.mostRecent().invocationOrder;
if(first1stSpyCall < first2ndSpyCall) {
result.message = 'Expected latest call to spy ' + firstSpy.and.identity + ' to have been called before first call to spy ' + latterSpy.and.identity + ' (no interleaved calls)';
if (first1stSpyCall < first2ndSpyCall) {
result.message =
'Expected latest call to spy ' +
firstSpy.and.identity +
' to have been called before first call to spy ' +
latterSpy.and.identity +
' (no interleaved calls)';
} else if (latest2ndSpyCall > latest1stSpyCall) {
result.message = 'Expected first call to spy ' + latterSpy.and.identity + ' to have been called after latest call to spy ' + firstSpy.and.identity + ' (no interleaved calls)';
result.message =
'Expected first call to spy ' +
latterSpy.and.identity +
' to have been called after latest call to spy ' +
firstSpy.and.identity +
' (no interleaved calls)';
} else {
result.message = 'Expected spy ' + firstSpy.and.identity + ' to have been called before spy ' + latterSpy.and.identity;
result.message =
'Expected spy ' +
firstSpy.and.identity +
' to have been called before spy ' +
latterSpy.and.identity;
}
}

68
src/core/matchers/toHaveBeenCalledOnceWith.js
View File

@@ -1,6 +1,8 @@
getJasmineRequireObj().toHaveBeenCalledOnceWith = function (j$) {
var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledOnceWith>', 'expect(<spyObj>).toHaveBeenCalledOnceWith(...arguments)');
getJasmineRequireObj().toHaveBeenCalledOnceWith = function(j$) {
var getErrorMsg = j$.formatErrorMsg(
'<toHaveBeenCalledOnceWith>',
'expect(<spyObj>).toHaveBeenCalledOnceWith(...arguments)'
);
/**
* {@link expect} the actual (a {@link Spy}) to have been called exactly once, and exactly with the particular arguments.
@@ -13,31 +15,44 @@ getJasmineRequireObj().toHaveBeenCalledOnceWith = function (j$) {
*/
function toHaveBeenCalledOnceWith(util) {
return {
compare: function () {
compare: function() {
var args = Array.prototype.slice.call(arguments, 0),
actual = args[0],
expectedArgs = args.slice(1);
if (!j$.isSpy(actual)) {
throw new Error(getErrorMsg('Expected a spy, but got ' + util.pp(actual) + '.'));
throw new Error(
getErrorMsg('Expected a spy, but got ' + util.pp(actual) + '.')
);
}
var prettyPrintedCalls = actual.calls.allArgs().map(function (argsForCall) {
return ' ' + util.pp(argsForCall);
});
var prettyPrintedCalls = actual.calls
.allArgs()
.map(function(argsForCall) {
return ' ' + util.pp(argsForCall);
});
if (actual.calls.count() === 1 && util.contains(actual.calls.allArgs(), expectedArgs)) {
if (
actual.calls.count() === 1 &&
util.contains(actual.calls.allArgs(), expectedArgs)
) {
return {
pass: true,
message: 'Expected spy ' + actual.and.identity + ' to have been called 0 times, multiple times, or once, but with arguments different from:\n'
+ ' ' + util.pp(expectedArgs) + '\n'
+ 'But the actual call was:\n'
+ prettyPrintedCalls.join(',\n') + '.\n\n'
message:
'Expected spy ' +
actual.and.identity +
' to have been called 0 times, multiple times, or once, but with arguments different from:\n' +
' ' +
util.pp(expectedArgs) +
'\n' +
'But the actual call was:\n' +
prettyPrintedCalls.join(',\n') +
'.\n\n'
};
}
function getDiffs() {
return actual.calls.allArgs().map(function (argsForCall, callIx) {
return actual.calls.allArgs().map(function(argsForCall, callIx) {
var diffBuilder = new j$.DiffBuilder();
util.equals(argsForCall, expectedArgs, diffBuilder);
return diffBuilder.getMessage();
@@ -49,17 +64,32 @@ getJasmineRequireObj().toHaveBeenCalledOnceWith = function (j$) {
case 0:
return 'But it was never called.\n\n';
case 1:
return 'But the actual call was:\n' + prettyPrintedCalls.join(',\n') + '.\n' + getDiffs().join('\n') + '\n\n';
return (
'But the actual call was:\n' +
prettyPrintedCalls.join(',\n') +
'.\n' +
getDiffs().join('\n') +
'\n\n'
);
default:
return 'But the actual calls were:\n' + prettyPrintedCalls.join(',\n') + '.\n\n';
return (
'But the actual calls were:\n' +
prettyPrintedCalls.join(',\n') +
'.\n\n'
);
}
}
return {
pass: false,
message: 'Expected spy ' + actual.and.identity + ' to have been called only once, and with given args:\n'
+ ' ' + util.pp(expectedArgs) + '\n'
+ butString()
message:
'Expected spy ' +
actual.and.identity +
' to have been called only once, and with given args:\n' +
' ' +
util.pp(expectedArgs) +
'\n' +
butString()
};
}
};

Some files were not shown because too many files have changed in this diff Show More