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

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.'
);
});
});