From 8cbcd054b62891994cec69a7ea3cf138d23dcbe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alex=20Ewerl=C3=B6f?= Date: Mon, 23 Nov 2015 19:32:49 +0100 Subject: [PATCH] added all tests from the original repo and passed all the tests --- .../jamiemason-jasmine-matchers-tests.ts | 1994 +++++++++++++++++ .../jamiemason-jasmine-matchers.d.ts | 148 +- 2 files changed, 2068 insertions(+), 74 deletions(-) create mode 100644 jasmine-matchers/jamiemason-jasmine-matchers-tests.ts diff --git a/jasmine-matchers/jamiemason-jasmine-matchers-tests.ts b/jasmine-matchers/jamiemason-jasmine-matchers-tests.ts new file mode 100644 index 000000000..ade9e8cb5 --- /dev/null +++ b/jasmine-matchers/jamiemason-jasmine-matchers-tests.ts @@ -0,0 +1,1994 @@ +/// +/// + +// Taken directly from the test directory of the original repo + +declare var describeWhenNotArray: (arr: string) => void; +declare var describeToBeArrayOfX: (arr: string, descriptor: {}) => void; +declare var describeToHaveArrayX: (arr: string, descriptor: () => void) => void; +declare var describeToHaveX: (arr: string, descriptor: () => void) => void; +declare var describeToHaveBooleanX: (arr: string, descriptor: () => void) => void; +declare var badReference: {someValue: any}; +var _undefined; + +describe('toBeAfter', function() { + describe('when invoked', function() { + describe('when value is a Date', function() { + describe('when date occurs after another', function() { + it('should confirm', function() { + expect(new Date('2013-01-01T01:00:00.000Z')).toBeAfter(new Date('2013-01-01T00:00:00.000Z')); + }); + }); + describe('when date does NOT occur after another', function() { + it('should deny', function() { + expect(new Date('2013-01-01T00:00:00.000Z')).not.toBeAfter(new Date('2013-01-01T01:00:00.000Z')); + }); + }); + }); + }); +}); + + +describe('toBeArray', function() { + describe('when invoked', function() { + describe('when subject is a true Array', function() { + it('should confirm', function() { + expect([]).toBeArray(); + expect(new Array()).toBeArray(); + }); + }); + describeWhenNotArray('toBeArray'); + }); +}); + + +describe('toBeArrayOfBooleans', function() { + describeToBeArrayOfX('toBeArrayOfBooleans', { + type: 'Boolean', + whenValid: function() { + expect([true]).toBeArrayOfBooleans(); + expect([new Boolean(true)]).toBeArrayOfBooleans(); + expect([new Boolean(false)]).toBeArrayOfBooleans(); + expect([false, true]).toBeArrayOfBooleans(); + }, + whenInvalid: function() { + expect([null]).not.toBeArrayOfBooleans(); + }, + whenMixed: function() { + expect([null, false]).not.toBeArrayOfBooleans(); + expect([null, true]).not.toBeArrayOfBooleans(); + } + }); +}); + + +describe('toBeArrayOfNumbers', function() { + describeToBeArrayOfX('toBeArrayOfNumbers', { + type: 'Number', + whenValid: function() { + expect([1]).toBeArrayOfNumbers(); + expect([new Number(1)]).toBeArrayOfNumbers(); + expect([new Number(0)]).toBeArrayOfNumbers(); + expect([0, 1]).toBeArrayOfNumbers(); + }, + whenInvalid: function() { + expect([null]).not.toBeArrayOfNumbers(); + }, + whenMixed: function() { + expect([null, 0]).not.toBeArrayOfNumbers(); + } + }); +}); + +describe('toBeArrayOfObjects', function() { + describeToBeArrayOfX('toBeArrayOfObjects', { + type: 'Object', + whenValid: function() { + expect([{}, {}]).toBeArrayOfObjects(); + }, + whenInvalid: function() { + expect([null]).not.toBeArrayOfObjects(); + expect(['Object']).not.toBeArrayOfObjects(); + expect(['[object Object]']).not.toBeArrayOfObjects(); + }, + whenMixed: function() { + expect([null, {}]).not.toBeArrayOfObjects(); + } + }); +}); + +describe('toBeArrayOfSize', function() { + describe('when invoked', function() { + describe('when subject is a true Array', function() { + describe('when subject has the expected number of members', function() { + it('should confirm', function() { + expect([]).toBeArrayOfSize(0); + expect([null]).toBeArrayOfSize(1); + expect([false, false]).toBeArrayOfSize(2); + expect([_undefined, _undefined]).toBeArrayOfSize(2); + }); + }); + describe('when subject has an unexpected number of members', function() { + it('should deny', function() { + expect([]).not.toBeArrayOfSize(1); + expect([null]).not.toBeArrayOfSize(0); + expect([true, true]).not.toBeArrayOfSize(1); + }); + }); + }); + describeWhenNotArray('toBeArrayOfSize'); + }); +}); + + +describe('toBeArrayOfStrings', function() { + describeToBeArrayOfX('toBeArrayOfStrings', { + type: 'String', + whenValid: function() { + expect(['truthy']).toBeArrayOfStrings(); + expect([new String('truthy')]).toBeArrayOfStrings(); + expect([new String('')]).toBeArrayOfStrings(); + expect(['', 'truthy']).toBeArrayOfStrings(); + }, + whenInvalid: function() { + expect([null]).not.toBeArrayOfStrings(); + }, + whenMixed: function() { + expect([null, '']).not.toBeArrayOfStrings(); + } + }); +}); + +describe('toBeBefore', function() { + describe('when invoked', function() { + describe('when value is a Date', function() { + describe('when date occurs before another', function() { + it('should confirm', function() { + expect(new Date('2013-01-01T00:00:00.000Z')).toBeBefore(new Date('2013-01-01T01:00:00.000Z')); + }); + }); + describe('when date does NOT occur before another', function() { + it('should deny', function() { + expect(new Date('2013-01-01T01:00:00.000Z')).not.toBeBefore(new Date('2013-01-01T00:00:00.000Z')); + }); + }); + }); + }); +}); + + +describe('toBeBoolean', function() { + describe('when invoked', function() { + describe('when subject not only truthy or falsy, but a boolean', function() { + it('should confirm', function() { + expect(true).toBeBoolean(); + expect(false).toBeBoolean(); + expect(new Boolean(true)).toBeBoolean(); + expect(new Boolean(false)).toBeBoolean(); + }); + }); + describe('when subject is truthy or falsy', function() { + it('should deny', function() { + expect(1).not.toBeBoolean(); + expect(0).not.toBeBoolean(); + }); + }); + }); +}); + +describe('toBeCalculable', function() { + describe('when invoked', function() { + describe('when subject CAN be coerced to be used in mathematical operations', function() { + it('should confirm', function() { + expect('1').toBeCalculable(); + expect('').toBeCalculable(); + expect(null).toBeCalculable(); + }); + }); + describe('when subject can NOT be coerced by JavaScript to be used in mathematical operations', function() { + it('should deny', function() { + expect({}).not.toBeCalculable(); + expect(NaN).not.toBeCalculable(); + }); + }); + }); +}); + +describe('toBeDate', function() { + describe('when invoked', function() { + describe('when value is an instance of Date', function() { + it('should confirm', function() { + expect(new Date()).toBeDate(); + }); + }); + describe('when value is NOT an instance of Date', function() { + it('should deny', function() { + expect(null).not.toBeDate(); + }); + }); + }); +}); + +describe('toBeEmptyArray', function() { + describe('when invoked', function() { + describe('when subject is a true Array', function() { + describe('when subject has members', function() { + it('should confirm', function() { + expect([]).toBeEmptyArray(); + }); + }); + describe('when subject has no members', function() { + it('should deny', function() { + expect([null]).not.toBeEmptyArray(); + expect(['']).not.toBeEmptyArray(); + expect([1]).not.toBeEmptyArray(); + expect([true]).not.toBeEmptyArray(); + expect([false]).not.toBeEmptyArray(); + }); + }); + }); + describeWhenNotArray('toBeEmptyArray'); + }); +}); + +describe('toBeEmptyObject', function() { + beforeEach(function() { + this.Foo = function() {}; + }); + describe('when invoked', function() { + describe('when subject IS an Object with no instance members', function() { + beforeEach(function() { + this.Foo.prototype = { + b: 2 + }; + }); + it('should confirm', function() { + expect(new this.Foo()).toBeEmptyObject(); + expect({}).toBeEmptyObject(); + }); + }); + describe('when subject is NOT an Object with no instance members', function() { + it('should deny', function() { + expect({ + a: 1 + }).not.toBeEmptyObject(); + expect(null).not.toBeNonEmptyObject(); + }); + }); + }); +}); + +describe('toBeEmptyString', function() { + describe('when invoked', function() { + describe('when subject IS a string with no characters', function() { + it('should confirm', function() { + expect('').toBeEmptyString(); + }); + }); + describe('when subject is NOT a string with no characters', function() { + it('should deny', function() { + expect(' ').not.toBeEmptyString(); + }); + }); + }); +}); + +describe('toBeEvenNumber', function() { + describe('when invoked', function() { + describe('when subject IS an even number', function() { + it('should confirm', function() { + expect(2).toBeEvenNumber(); + }); + }); + describe('when subject is NOT an even number', function() { + it('should deny', function() { + expect(1).not.toBeEvenNumber(); + expect(NaN).not.toBeEvenNumber(); + }); + }); + }); +}); + + +describe('toBeFalse', function() { + describe('when invoked', function() { + describe('when subject is not only falsy, but a boolean false', function() { + it('should confirm', function() { + expect(false).toBeFalse(); + expect(new Boolean(false)).toBeFalse(); + }); + }); + describe('when subject is falsy', function() { + it('should deny', function() { + expect(1).not.toBeFalse(); + }); + }); + }); +}); + +describe('toBeFunction', function() { + describe('when invoked', function() { + describe('when subject IS a function', function() { + it('should confirm', function() { + expect(function() {}).toBeFunction(); + }); + }); + describe('when subject is NOT a function', function() { + it('should deny', function() { + expect(/regexp/).not.toBeFunction(); + }); + }); + }); +}); + +describe('toBeHtmlString', function() { + describe('when invoked', function() { + describe('when subject IS a string of HTML markup', function() { + beforeEach(function() { + this.ngMultiLine = ''; + this.ngMultiLine += ''; + this.ngMultiLine += '\n'; + this.ngMultiLine += ' Watch with Google TV'; + this.ngMultiLine += '\n'; + this.ngMultiLine += ''; + this.ngMultiLine += '\n'; + }); + it('should confirm', function() { + expect('text').toBeHtmlString(); + expect('baz').toBeHtmlString(); + expect('
').toBeHtmlString(); + expect('
  • ').toBeHtmlString(); + expect(this.ngMultiLine).toBeHtmlString(); + }); + }); + describe('when subject is NOT a string of HTML markup', function() { + it('should deny', function() { + expect('div').not.toBeHtmlString(); + expect(null).not.toBeHtmlString(); + }); + }); + }); +}); + +describe('toBeIso8601', function() { + describe('when invoked', function() { + describe('when value is a Date String conforming to the ISO 8601 standard', function() { + describe('when specified date is valid', function() { + it('should confirm', function() { + expect('2013-07-08T07:29:15.863Z').toBeIso8601(); + expect('2013-07-08T07:29:15.863').toBeIso8601(); + expect('2013-07-08T07:29:15').toBeIso8601(); + expect('2013-07-08T07:29').toBeIso8601(); + expect('2013-07-08').toBeIso8601(); + }); + }); + describe('when specified date is NOT valid', function() { + it('should deny', function() { + expect('2013-99-12T00:00:00.000Z').not.toBeIso8601(); + expect('2013-12-99T00:00:00.000Z').not.toBeIso8601(); + expect('2013-01-01T99:00:00.000Z').not.toBeIso8601(); + expect('2013-01-01T99:99:00.000Z').not.toBeIso8601(); + expect('2013-01-01T00:00:99.000Z').not.toBeIso8601(); + }); + }); + }); + describe('when value is a String NOT conforming to the ISO 8601 standard', function() { + it('should deny', function() { + expect('2013-07-08T07:29:15.').not.toBeIso8601(); + expect('2013-07-08T07:29:').not.toBeIso8601(); + expect('2013-07-08T07:2').not.toBeIso8601(); + expect('2013-07-08T07:').not.toBeIso8601(); + expect('2013-07-08T07').not.toBeIso8601(); + expect('2013-07-08T').not.toBeIso8601(); + expect('2013-07-0').not.toBeIso8601(); + expect('2013-07-').not.toBeIso8601(); + expect('2013-07').not.toBeIso8601(); + expect('2013-0').not.toBeIso8601(); + expect('2013-').not.toBeIso8601(); + expect('2013').not.toBeIso8601(); + expect('201').not.toBeIso8601(); + expect('20').not.toBeIso8601(); + expect('2').not.toBeIso8601(); + expect('').not.toBeIso8601(); + }); + }); + }); +}); +var _undefined; + +describe('toBeJsonString', function() { + describe('when invoked', function() { + describe('when subject IS a string of parseable JSON', function() { + it('should confirm', function() { + expect('{}').toBeJsonString(); + expect('[]').toBeJsonString(); + expect('[1]').toBeJsonString(); + }); + }); + describe('when subject is NOT a string of parseable JSON', function() { + it('should deny', function() { + expect('[1,]').not.toBeJsonString(); + expect('<>').not.toBeJsonString(); + expect(null).not.toBeJsonString(); + expect('').not.toBeJsonString(); + expect(_undefined).not.toBeJsonString(); + }); + }); + }); +}); + +describe('toBeLongerThan', function() { + describe('when invoked', function() { + describe('when the subject and comparison ARE both strings', function() { + describe('when the subject IS longer than the comparision string', function() { + it('should confirm', function() { + expect('abc').toBeLongerThan('ab'); + expect('a').toBeLongerThan(''); + }); + }); + describe('when the subject is NOT longer than the comparision string', function() { + it('should deny', function() { + expect('ab').not.toBeLongerThan('abc'); + expect('').not.toBeLongerThan('a'); + }); + }); + }); + describe('when the subject and comparison are NOT both strings', function() { + it('should deny (we are asserting the relative lengths of two strings)', function() { + expect('truthy').not.toBeLongerThan(_undefined); + expect(_undefined).not.toBeLongerThan('truthy'); + expect('').not.toBeLongerThan(_undefined); + expect(_undefined).not.toBeLongerThan(''); + }); + }); + }); +}); + +describe('toBeNonEmptyArray', function() { + describe('when invoked', function() { + describe('when subject is a true Array', function() { + describe('when subject has members', function() { + it('should confirm', function() { + expect([null]).toBeNonEmptyArray(); + expect([_undefined]).toBeNonEmptyArray(); + expect(['']).toBeNonEmptyArray(); + }); + }); + describe('when subject has no members', function() { + it('should deny', function() { + expect([]).not.toBeNonEmptyArray(); + }); + }); + }); + describeWhenNotArray('toBeNonEmptyArray'); + }); +}); + +describe('toBeNonEmptyObject', function() { + beforeEach(function() { + this.Foo = function() {}; + }); + describe('when invoked', function() { + describe('when subject IS an Object with at least one instance member', function() { + it('should confirm', function() { + expect({ + a: 1 + }).toBeNonEmptyObject(); + }); + }); + describe('when subject is NOT an Object with at least one instance member', function() { + beforeEach(function() { + this.Foo.prototype = { + b: 2 + }; + }); + it('should deny', function() { + expect(new this.Foo()).not.toBeNonEmptyObject(); + expect({}).not.toBeNonEmptyObject(); + expect(null).not.toBeNonEmptyObject(); + }); + }); + }); +}); + +describe('toBeNonEmptyString', function() { + describe('when invoked', function() { + describe('when subject IS a string with at least one character', function() { + it('should confirm', function() { + expect(' ').toBeNonEmptyString(); + }); + }); + describe('when subject is NOT a string with at least one character', function() { + it('should deny', function() { + expect('').not.toBeNonEmptyString(); + expect(null).not.toBeNonEmptyString(); + }); + }); + }); +}); + +describe('toBeNumber', function() { + describe('when invoked', function() { + describe('when subject IS a number', function() { + it('should confirm', function() { + expect(1).toBeNumber(); + expect(1.11).toBeNumber(); + expect(1e3).toBeNumber(); + expect(0.11).toBeNumber(); + expect(-11).toBeNumber(); + }); + }); + describe('when subject is NOT a number', function() { + it('should deny', function() { + expect('1').not.toBeNumber(); + expect(NaN).not.toBeNumber(); + }); + }); + }); +}); + + +describe('toBeObject', function() { + beforeEach(function() { + this.Foo = function() {}; + }); + describe('when invoked', function() { + describe('when subject IS an Object', function() { + it('should confirm', function() { + expect(new Object()).toBeObject(); + expect(new this.Foo()).toBeObject(); + expect({}).toBeObject(); + }); + }); + describe('when subject is NOT an Object', function() { + it('should deny', function() { + expect(null).not.toBeObject(); + expect(123).not.toBeObject(); + expect('[object Object]').not.toBeObject(); + }); + }); + }); +}); + +describe('toBeOddNumber', function() { + describe('when invoked', function() { + describe('when subject IS an odd number', function() { + it('should confirm', function() { + expect(1).toBeOddNumber(); + }); + }); + describe('when subject is NOT an odd number', function() { + it('should deny', function() { + expect(2).not.toBeOddNumber(); + expect(NaN).not.toBeOddNumber(); + }); + }); + }); +}); +var _undefined; + +describe('toBeSameLengthAs', function() { + describe('when invoked', function() { + describe('when the subject and comparison ARE both strings', function() { + describe('when the subject IS the same length as the comparision string', function() { + it('should confirm', function() { + expect('ab').toBeSameLengthAs('ab'); + }); + }); + describe('when the subject is NOT the same length as the comparision string', function() { + it('should deny', function() { + expect('abc').not.toBeSameLengthAs('ab'); + expect('a').not.toBeSameLengthAs(''); + expect('').not.toBeSameLengthAs('a'); + }); + }); + }); + describe('when the subject and comparison are NOT both strings', function() { + it('should deny (we are asserting the relative lengths of two strings)', function() { + expect('truthy').not.toBeSameLengthAs(_undefined); + expect(_undefined).not.toBeSameLengthAs('truthy'); + expect('').not.toBeSameLengthAs(_undefined); + expect(_undefined).not.toBeSameLengthAs(''); + }); + }); + }); +}); +var _undefined; + +describe('toBeShorterThan', function() { + describe('when invoked', function() { + describe('when the subject and comparison ARE both strings', function() { + describe('when the subject IS shorter than the comparision string', function() { + it('should confirm', function() { + expect('ab').toBeShorterThan('abc'); + expect('').toBeShorterThan('a'); + }); + }); + describe('when the subject is NOT shorter than the comparision string', function() { + it('should deny', function() { + expect('abc').not.toBeShorterThan('ab'); + expect('a').not.toBeShorterThan(''); + }); + }); + }); + describe('when the subject and comparison are NOT both strings', function() { + it('should deny (we are asserting the relative lengths of two strings)', function() { + expect('truthy').not.toBeShorterThan(_undefined); + expect(_undefined).not.toBeShorterThan('truthy'); + expect('').not.toBeShorterThan(_undefined); + expect(_undefined).not.toBeShorterThan(''); + }); + }); + }); +}); + +describe('toBeString', function() { + describe('when invoked', function() { + describe('when subject IS a string of any length', function() { + it('should confirm', function() { + expect('').toBeString(); + expect(' ').toBeString(); + }); + }); + describe('when subject is NOT a string of any length', function() { + it('should deny', function() { + expect(null).not.toBeString(); + }); + }); + }); +}); + + +describe('toBeTrue', function() { + describe('when invoked', function() { + describe('when subject is not only truthy, but a boolean true', function() { + it('should confirm', function() { + expect(true).toBeTrue(); + expect(new Boolean(true)).toBeTrue(); + }); + }); + describe('when subject is truthy', function() { + it('should deny', function() { + expect(1).not.toBeTrue(); + }); + }); + }); +}); + +describe('toBeWhitespace', function() { + describe('when invoked', function() { + describe('when subject IS a string containing only tabs, spaces, returns etc', function() { + it('should confirm', function() { + expect(' ').toBeWhitespace(); + expect('').toBeWhitespace(); + }); + }); + describe('when subject is NOT a string containing only tabs, spaces, returns etc', function() { + it('should deny', function() { + expect('has-no-whitespace').not.toBeWhitespace(); + expect('has whitespace').not.toBeWhitespace(); + expect(null).not.toBeWhitespace(); + }); + }); + }); +}); + +describe('toBeWholeNumber', function() { + describe('when invoked', function() { + describe('when subject IS a number with no positive decimal places', function() { + it('should confirm', function() { + expect(1).toBeWholeNumber(); + expect(0).toBeWholeNumber(); + expect(0.0).toBeWholeNumber(); + }); + }); + describe('when subject is NOT a number with no positive decimal places', function() { + it('should deny', function() { + expect(NaN).not.toBeWholeNumber(); + expect(1.1).not.toBeWholeNumber(); + expect(0.1).not.toBeWholeNumber(); + }); + }); + }); +}); + +describe('toBeWithinRange', function() { + describe('when invoked', function() { + describe('when subject IS a number >= floor and <= ceiling', function() { + it('should confirm', function() { + expect(0).toBeWithinRange(0, 2); + expect(1).toBeWithinRange(0, 2); + expect(2).toBeWithinRange(0, 2); + }); + }); + describe('when subject is NOT a number >= floor and <= ceiling', function() { + it('should deny', function() { + expect(-3).not.toBeWithinRange(0, 2); + expect(-2).not.toBeWithinRange(0, 2); + expect(-1).not.toBeWithinRange(0, 2); + expect(3).not.toBeWithinRange(0, 2); + expect(NaN).not.toBeWithinRange(0, 2); + }); + }); + }); +}); +var _undefined; + +describe('toEndWith', function() { + describe('when invoked', function() { + describe('when subject is NOT an undefined or empty string', function() { + describe('when subject is a string whose trailing characters match the expected string', function() { + it('should confirm', function() { + expect('jamie').toEndWith('mie'); + }); + }); + describe('when subject is a string whose trailing characters DO NOT match the expected string', function() { + it('should deny', function() { + expect('jamie ').not.toEndWith('mie'); + expect('jamiE').not.toEndWith('mie'); + }); + }); + }); + describe('when subject IS an undefined or empty string', function() { + it('should deny', function() { + expect('').not.toEndWith(''); + expect(_undefined).not.toEndWith(''); + expect(_undefined).not.toEndWith('undefined'); + expect('undefined').not.toEndWith(_undefined); + }); + }); + }); +}); + +describe('toHaveArray', function() { + describeToHaveArrayX('toHaveArray', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveArray('memberName'); + expect({ + memberName: [1, 2, 3] + }).toHaveArray('memberName'); + }); + }); +}); + + +describe('toHaveArrayOfBooleans', function() { + describeToHaveArrayX('toHaveArrayOfBooleans', function() { + describe('when named Array is empty', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveArrayOfBooleans('memberName'); + }); + }); + describe('when named Array has items', function() { + describe('when all items are booleans', function() { + it('should confirm', function() { + expect({ + memberName: [true] + }).toHaveArrayOfBooleans('memberName'); + expect({ + memberName: [new Boolean(true)] + }).toHaveArrayOfBooleans('memberName'); + expect({ + memberName: [new Boolean(false)] + }).toHaveArrayOfBooleans('memberName'); + expect({ + memberName: [false, true] + }).toHaveArrayOfBooleans('memberName'); + }); + }); + describe('when any item is not a boolean', function() { + it('should deny', function() { + expect({ + memberName: [null] + }).not.toHaveArrayOfBooleans('memberName'); + expect({ + memberName: [null, false] + }).not.toHaveArrayOfBooleans('memberName'); + }); + }); + }); + }); +}); + + +describe('toHaveArrayOfNumbers', function() { + describeToHaveArrayX('toHaveArrayOfNumbers', function() { + describe('when named Array is empty', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveArrayOfNumbers('memberName'); + }); + }); + describe('when named Array has items', function() { + describe('when all items are numbers', function() { + it('should confirm', function() { + expect({ + memberName: [1] + }).toHaveArrayOfNumbers('memberName'); + expect({ + memberName: [new Number(1)] + }).toHaveArrayOfNumbers('memberName'); + expect({ + memberName: [new Number(0)] + }).toHaveArrayOfNumbers('memberName'); + expect({ + memberName: [0, 1] + }).toHaveArrayOfNumbers('memberName'); + }); + }); + describe('when any item is not a number', function() { + it('should deny', function() { + expect({ + memberName: [null] + }).not.toHaveArrayOfNumbers('memberName'); + expect({ + memberName: [null, 0] + }).not.toHaveArrayOfNumbers('memberName'); + }); + }); + }); + }); +}); + +describe('toHaveArrayOfObjects', function() { + describeToHaveArrayX('toHaveArrayOfObjects', function() { + describe('when named Array is empty', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveArrayOfObjects('memberName'); + }); + }); + describe('when named Array has items', function() { + describe('when all items are objects', function() { + it('should confirm', function() { + expect({ + memberName: [{}] + }).toHaveArrayOfObjects('memberName'); + expect({ + memberName: [{}, {}] + }).toHaveArrayOfObjects('memberName'); + }); + }); + describe('when any item is not an object', function() { + it('should deny', function() { + expect({ + memberName: [null] + }).not.toHaveArrayOfObjects('memberName'); + expect({ + memberName: [null, {}] + }).not.toHaveArrayOfObjects('memberName'); + }); + }); + }); + }); +}); + +describe('toHaveArrayOfSize', function() { + describeToHaveArrayX('toHaveArrayOfSize', function() { + describe('when number of expected items does not match', function() { + it('should deny', function() { + expect({ + memberName: '' + }).not.toHaveArrayOfSize('memberName'); + expect({ + memberName: ['bar'] + }).not.toHaveArrayOfSize('memberName', 0); + }); + }); + describe('when number of expected items does match', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveArrayOfSize('memberName', 0); + expect({ + memberName: ['bar'] + }).toHaveArrayOfSize('memberName', 1); + expect({ + memberName: ['bar', 'baz'] + }).toHaveArrayOfSize('memberName', 2); + }); + }); + }); +}); + + +describe('toHaveArrayOfStrings', function() { + describeToHaveArrayX('toHaveArrayOfStrings', function() { + describe('when named Array is empty', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveArrayOfStrings('memberName'); + }); + }); + describe('when named Array has items', function() { + describe('when all items are strings', function() { + it('should confirm', function() { + expect({ + memberName: ['truthy'] + }).toHaveArrayOfStrings('memberName'); + expect({ + memberName: [new String('truthy')] + }).toHaveArrayOfStrings('memberName'); + expect({ + memberName: [new String('')] + }).toHaveArrayOfStrings('memberName'); + expect({ + memberName: ['', 'truthy'] + }).toHaveArrayOfStrings('memberName'); + }); + }); + describe('when any item is not a string', function() { + it('should deny', function() { + expect({ + memberName: [null] + }).not.toHaveArrayOfStrings('memberName'); + expect({ + memberName: [null, ''] + }).not.toHaveArrayOfStrings('memberName'); + }); + }); + }); + }); +}); + + +describe('toHaveBoolean', function() { + describeToHaveBooleanX('toHaveBoolean', function() { + describe('when primitive', function() { + it('should confirm', function() { + expect({ + memberName: true + }).toHaveBoolean('memberName'); + expect({ + memberName: false + }).toHaveBoolean('memberName'); + }); + }); + describe('when Boolean object', function() { + it('should confirm', function() { + expect({ + memberName: new Boolean(true) + }).toHaveBoolean('memberName'); + expect({ + memberName: new Boolean(false) + }).toHaveBoolean('memberName'); + }); + }); + }); +}); + +describe('toHaveCalculable', function() { + describeToHaveX('toHaveCalculable', function() { + describe('when subject CAN be coerced to be used in mathematical operations', function() { + it('should confirm', function() { + expect({ + memberName: '1' + }).toHaveCalculable('memberName'); + expect({ + memberName: '' + }).toHaveCalculable('memberName'); + expect({ + memberName: null + }).toHaveCalculable('memberName'); + }); + }); + describe('when subject can NOT be coerced by JavaScript to be used in mathematical operations', function() { + it('should deny', function() { + expect({ + memberName: {} + }).not.toHaveCalculable('memberName'); + expect({ + memberName: NaN + }).not.toHaveCalculable('memberName'); + }); + }); + }); +}); + +describe('toHaveDate', function() { + var mockDate; + beforeEach(function() { + mockDate = { + any: new Date(), + early: new Date('2013-01-01T00:00:00.000Z'), + late: new Date('2013-01-01T01:00:00.000Z') + }; + }); + describeToHaveX('toHaveDate', function() { + describe('when member is an instance of Date', function() { + it('should confirm', function() { + expect({ + memberName: mockDate.any + }).toHaveDate('memberName'); + }); + }); + describe('when member is NOT an instance of Date', function() { + it('should deny', function() { + expect({ + memberName: null + }).not.toHaveDate('memberName'); + }); + }); + }); +}); + +describe('toHaveDateAfter', function() { + var mockDate; + beforeEach(function() { + mockDate = { + any: new Date(), + early: new Date('2013-01-01T00:00:00.000Z'), + late: new Date('2013-01-01T01:00:00.000Z') + }; + }); + describeToHaveX('toHaveDateAfter', function() { + describe('when member is an instance of Date', function() { + describe('when date occurs before another', function() { + it('should confirm', function() { + expect({ + memberName: mockDate.late + }).toHaveDateAfter('memberName', mockDate.early); + }); + }); + describe('when date does NOT occur before another', function() { + it('should deny', function() { + expect({ + memberName: mockDate.early + }).not.toHaveDateAfter('memberName', mockDate.late); + }); + }); + }); + describe('when member is NOT an instance of Date', function() { + it('should deny', function() { + expect({ + memberName: null + }).not.toHaveDateAfter('memberName', mockDate.any); + }); + }); + }); +}); + +describeToHaveX('toHaveDateBefore', function() { + var mockDate; + beforeEach(function() { + mockDate = { + any: new Date(), + early: new Date('2013-01-01T00:00:00.000Z'), + late: new Date('2013-01-01T01:00:00.000Z') + }; + }); + describe('when member is an instance of Date', function() { + describe('when date occurs before another', function() { + it('should confirm', function() { + expect({ + memberName: mockDate.early + }).toHaveDateBefore('memberName', mockDate.late); + }); + }); + describe('when date does NOT occur before another', function() { + it('should deny', function() { + expect({ + memberName: mockDate.late + }).not.toHaveDateBefore('memberName', mockDate.early); + }); + }); + }); + describe('when member is NOT an instance of Date', function() { + it('should deny', function() { + expect({ + memberName: null + }).not.toHaveDateBefore('memberName', mockDate.any); + }); + }); +}); + +describe('toHaveEmptyArray', function() { + describeToHaveArrayX('toHaveEmptyArray', function() { + describe('when named array has members', function() { + it('should deny', function() { + expect({ + memberName: [1, 2, 3] + }).not.toHaveEmptyArray('memberName'); + expect({ + memberName: '' + }).not.toHaveEmptyArray('memberName'); + }); + }); + describe('when named array has no members', function() { + it('should confirm', function() { + expect({ + memberName: [] + }).toHaveEmptyArray('memberName'); + }); + }); + }); +}); + +describe('toHaveEmptyObject', function() { + beforeEach(function() { + this.Foo = function() {}; + }); + describeToHaveX('toHaveEmptyObject', function() { + describe('when subject IS an Object with no instance members', function() { + beforeEach(function() { + this.Foo.prototype = { + b: 2 + }; + }); + it('should confirm', function() { + expect({ + memberName: new this.Foo() + }).toHaveEmptyObject('memberName'); + expect({ + memberName: {} + }).toHaveEmptyObject('memberName'); + }); + }); + describe('when subject is NOT an Object with no instance members', function() { + it('should deny', function() { + expect({ + memberName: { + a: 1 + } + }).not.toHaveEmptyObject('memberName'); + expect({ + memberName: null + }).not.toHaveNonEmptyObject('memberName'); + }); + }); + }); +}); + +describe('toHaveEmptyString', function() { + describeToHaveX('toHaveEmptyString', function() { + describe('when subject IS a string with no characters', function() { + it('should confirm', function() { + expect({ + memberName: '' + }).toHaveEmptyString('memberName'); + }); + }); + describe('when subject is NOT a string with no characters', function() { + it('should deny', function() { + expect({ + memberName: ' ' + }).not.toHaveEmptyString('memberName'); + }); + }); + }); +}); + +describe('toHaveEvenNumber', function() { + describeToHaveX('toHaveEvenNumber', function() { + describe('when subject IS an even number', function() { + it('should confirm', function() { + expect({ + memberName: 2 + }).toHaveEvenNumber('memberName'); + }); + }); + describe('when subject is NOT an even number', function() { + it('should deny', function() { + expect({ + memberName: 1 + }).not.toHaveEvenNumber('memberName'); + expect({ + memberName: NaN + }).not.toHaveEvenNumber('memberName'); + }); + }); + }); +}); + +describe('toHaveFalse', function() { + describeToHaveBooleanX('toHaveFalse', function() { + describe('when primitive', function() { + describe('when true', function() { + it('should deny', function() { + expect({ + memberName: true + }).not.toHaveFalse('memberName'); + }); + }); + describe('when false', function() { + it('should confirm', function() { + expect({ + memberName: false + }).toHaveFalse('memberName'); + }); + }); + }); + describe('when Boolean object', function() { + describe('when true', function() { + it('should deny', function() { + expect({ + memberName: new Boolean(true) + }).not.toHaveFalse('memberName'); + }); + }); + describe('when false', function() { + it('should confirm', function() { + expect({ + memberName: new Boolean(false) + }).toHaveFalse('memberName'); + }); + }); + }); + }); +}); + +describe('toHaveHtmlString', function() { + describeToHaveX('toHaveHtmlString', function() { + describe('when subject IS a string of HTML markup', function() { + beforeEach(function() { + this.ngMultiLine = ''; + this.ngMultiLine += ''; + this.ngMultiLine += '\n'; + this.ngMultiLine += ' Watch with Google TV'; + this.ngMultiLine += '\n'; + this.ngMultiLine += ''; + this.ngMultiLine += '\n'; + }); + it('should confirm', function() { + expect({ + memberName: 'text' + }).toHaveHtmlString('memberName'); + expect({ + memberName: 'baz' + }).toHaveHtmlString('memberName'); + expect({ + memberName: '
    ' + }).toHaveHtmlString('memberName'); + expect({ + memberName: '
  • ' + }).toHaveHtmlString('memberName'); + expect({ + memberName: this.ngMultiLine + }).toHaveHtmlString('memberName'); + }); + }); + describe('when subject is NOT a string of HTML markup', function() { + it('should deny', function() { + expect({ + memberName: 'div' + }).not.toHaveHtmlString('memberName'); + expect({ + memberName: null + }).not.toHaveHtmlString('memberName'); + }); + }); + }); +}); + +describe('toHaveIso8601', function() { + describeToHaveX('toHaveIso8601', function() { + describe('when member is a Date String conforming to the ISO 8601 standard', + function() { + describe('when specified date is valid', function() { + it('should confirm', function() { + expect({ + memberName: '2013-07-08T07:29:15.863Z' + }).toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07:29:15.863' + }).toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07:29:15' + }).toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07:29' + }).toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08' + }).toHaveIso8601('memberName'); + }); + }); + describe('when specified date is NOT valid', function() { + it('should deny', function() { + expect({ + memberName: '2013-99-12T00:00:00.000Z' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-12-99T00:00:00.000Z' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-01-01T99:00:00.000Z' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-01-01T99:99:00.000Z' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-01-01T00:00:99.000Z' + }).not.toHaveIso8601('memberName'); + }); + }); + }); + describe('when member is a String NOT conforming to the ISO 8601 standard', + function() { + it('should deny', function() { + expect({ + memberName: '2013-07-08T07:29:15.' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07:29:' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07:2' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07:' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T07' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-08T' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-0' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07-' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-07' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-0' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013-' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2013' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '201' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '20' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '2' + }).not.toHaveIso8601('memberName'); + expect({ + memberName: '' + }).not.toHaveIso8601('memberName'); + }); + }); + }); +}); + +describe('toHaveJsonString', function() { + describeToHaveX('toHaveJsonString', function() { + describe('when subject IS a string of parseable JSON', function() { + it('should confirm', function() { + expect({ + memberName: '{}' + }).toHaveJsonString('memberName'); + expect({ + memberName: '[]' + }).toHaveJsonString('memberName'); + expect({ + memberName: '[1]' + }).toHaveJsonString('memberName'); + }); + }); + describe('when subject is NOT a string of parseable JSON', function() { + it('should deny', function() { + expect({ + memberName: '[1,]' + }).not.toHaveJsonString('memberName'); + expect({ + memberName: '<>' + }).not.toHaveJsonString('memberName'); + expect({ + memberName: null + }).not.toHaveJsonString('memberName'); + expect({ + memberName: '' + }).not.toHaveJsonString('memberName'); + expect({ + memberName: _undefined + }).not.toHaveJsonString('memberName'); + }); + }); + }); +}); + +describe('toHaveMember', function() { + describeToHaveX('toHaveMember', function() {}); +}); + +describe('toHaveMethod', function() { + describeToHaveX('toHaveMethod', function() { + describe('when subject IS a function', function() { + it('should confirm', function() { + expect({ + memberName: function() {} + }).toHaveMethod('memberName'); + }); + }); + describe('when subject is NOT a function', function() { + it('should deny', function() { + expect({ + memberName: /regexp/ + }).not.toHaveMethod('memberName'); + }); + }); + }); +}); + +describe('toHaveNonEmptyArray', function() { + describeToHaveArrayX('toHaveNonEmptyArray', function() { + describe('when named array has no members', function() { + it('should deny', function() { + expect({ + memberName: [] + }).not.toHaveNonEmptyArray('memberName'); + }); + }); + describe('when named array has members', function() { + it('should confirm', function() { + expect({ + memberName: [1, 2, 3] + }).toHaveNonEmptyArray('memberName'); + }); + }); + }); +}); + +describe('toHaveNonEmptyObject', function() { + describeToHaveX('toHaveNonEmptyObject', function() { + beforeEach(function() { + this.Foo = function() {}; + }); + describe('when subject IS an Object with at least one instance member', function() { + it('should confirm', function() { + expect({ + memberName: { + a: 1 + } + }).toHaveNonEmptyObject('memberName'); + }); + }); + describe('when subject is NOT an Object with at least one instance member', function() { + beforeEach(function() { + this.Foo.prototype = { + b: 2 + }; + }); + it('should deny', function() { + expect({ + memberName: new this.Foo() + }).not.toHaveNonEmptyObject('memberName'); + expect({ + memberName: {} + }).not.toHaveNonEmptyObject('memberName'); + expect({ + memberName: null + }).not.toHaveNonEmptyObject('memberName'); + }); + }); + }); +}); + +describe('toHaveNonEmptyString', function() { + describeToHaveX('toHaveNonEmptyString', function() { + describe('when subject IS a string with at least one character', function() { + it('should confirm', function() { + expect({ + memberName: ' ' + }).toHaveNonEmptyString('memberName'); + }); + }); + describe('when subject is NOT a string with at least one character', function() { + it('should deny', function() { + expect({ + memberName: '' + }).not.toHaveNonEmptyString('memberName'); + expect({ + memberName: null + }).not.toHaveNonEmptyString('memberName'); + }); + }); + }); +}); + +describe('toHaveNumber', function() { + describeToHaveX('toHaveNumber', function() { + describe('when subject IS a number', function() { + it('should confirm', function() { + expect({ + memberName: 1 + }).toHaveNumber('memberName'); + expect({ + memberName: 1.11 + }).toHaveNumber('memberName'); + expect({ + memberName: 1e3 + }).toHaveNumber('memberName'); + expect({ + memberName: 0.11 + }).toHaveNumber('memberName'); + expect({ + memberName: -11 + }).toHaveNumber('memberName'); + }); + }); + describe('when subject is NOT a number', function() { + it('should deny', function() { + expect({ + memberName: '1' + }).not.toHaveNumber('memberName'); + expect({ + memberName: NaN + }).not.toHaveNumber('memberName'); + }); + }); + }); +}); + +describe('toHaveNumberWithinRange', function() { + describeToHaveX('toHaveNumberWithinRange', function() { + describe('when subject IS a number >= floor and <= ceiling', function() { + it('should confirm', function() { + expect({ + memberName: 0 + }).toHaveNumberWithinRange('memberName', 0, 2); + expect({ + memberName: 1 + }).toHaveNumberWithinRange('memberName', 0, 2); + expect({ + memberName: 2 + }).toHaveNumberWithinRange('memberName', 0, 2); + }); + }); + describe('when subject is NOT a number >= floor and <= ceiling', function() { + it('should deny', function() { + expect({ + memberName: -3 + }).not.toHaveNumberWithinRange('memberName', 0, 2); + expect({ + memberName: -2 + }).not.toHaveNumberWithinRange('memberName', 0, 2); + expect({ + memberName: -1 + }).not.toHaveNumberWithinRange('memberName', 0, 2); + expect({ + memberName: 3 + }).not.toHaveNumberWithinRange('memberName', 0, 2); + expect({ + memberName: NaN + }).not.toHaveNumberWithinRange('memberName', 0, 2); + }); + }); + }); +}); + +describe('toHaveObject', function() { + describeToHaveX('toHaveObject', function() { + beforeEach(function() { + this.Foo = function() {}; + }); + describe('when subject IS an Object', function() { + it('should confirm', function() { + expect({ + memberName: new Object() + }).toHaveObject('memberName'); + expect({ + memberName: new this.Foo() + }).toHaveObject('memberName'); + expect({ + memberName: {} + }).toHaveObject('memberName'); + }); + }); + describe('when subject is NOT an Object', function() { + it('should deny', function() { + expect({ + memberName: null + }).not.toHaveObject('memberName'); + expect({ + memberName: 123 + }).not.toHaveObject('memberName'); + expect({ + memberName: '[object Object]' + }).not.toHaveObject('memberName'); + }); + }); + }); +}); + +describe('toHaveOddNumber', function() { + describeToHaveX('toHaveOddNumber', function() { + describe('when subject IS an odd number', function() { + it('should confirm', function() { + expect({ + memberName: 1 + }).toHaveOddNumber('memberName'); + }); + }); + describe('when subject is NOT an odd number', function() { + it('should deny', function() { + expect({ + memberName: 2 + }).not.toHaveOddNumber('memberName'); + expect({ + memberName: NaN + }).not.toHaveOddNumber('memberName'); + }); + }); + }); +}); + +describe('toHaveString', function() { + describeToHaveX('toHaveString', function() { + describe('when subject IS a string of any length', function() { + it('should confirm', function() { + expect({ + memberName: '' + }).toHaveString('memberName'); + expect({ + memberName: ' ' + }).toHaveString('memberName'); + }); + }); + describe('when subject is NOT a string of any length', function() { + it('should deny', function() { + expect({ + memberName: null + }).not.toHaveString('memberName'); + }); + }); + }); +}); + +describe('toHaveStringLongerThan', function() { + describeToHaveX('toHaveStringLongerThan', function() { + describe('when the subject and comparison ARE both strings', function() { + describe('when the subject IS longer than the comparision string', function() { + it('should confirm', function() { + expect({ + memberName: 'abc' + }).toHaveStringLongerThan('memberName', 'ab'); + expect({ + memberName: 'a' + }).toHaveStringLongerThan('memberName', ''); + }); + }); + describe('when the subject is NOT longer than the comparision string', function() { + it('should deny', function() { + expect({ + memberName: 'ab' + }).not.toHaveStringLongerThan('memberName', 'abc'); + expect({ + memberName: '' + }).not.toHaveStringLongerThan('memberName', 'a'); + }); + }); + }); + describe('when the subject and comparison are NOT both strings', function() { + it('should deny (we are asserting the relative lengths of two strings)', function() { + expect({ + memberName: 'truthy' + }).not.toHaveStringLongerThan('memberName', _undefined); + expect({ + memberName: _undefined + }).not.toHaveStringLongerThan('memberName', 'truthy'); + expect({ + memberName: '' + }).not.toHaveStringLongerThan('memberName', _undefined); + expect({ + memberName: _undefined + }).not.toHaveStringLongerThan('memberName', ''); + }); + }); + }); +}); + +describe('toHaveStringSameLengthAs', function() { + describeToHaveX('toHaveStringSameLengthAs', function() { + describe('when the subject and comparison ARE both strings', function() { + describe('when the subject IS the same length as the comparision string', function() { + it('should confirm', function() { + expect({ + memberName: 'ab' + }).toHaveStringSameLengthAs('memberName', 'ab'); + }); + }); + describe('when the subject is NOT the same length as the comparision string', function() { + it('should deny', function() { + expect({ + memberName: 'abc' + }).not.toHaveStringSameLengthAs('memberName', 'ab'); + expect({ + memberName: 'a' + }).not.toHaveStringSameLengthAs('memberName', ''); + expect({ + memberName: '' + }).not.toHaveStringSameLengthAs('memberName', 'a'); + }); + }); + }); + describe('when the subject and comparison are NOT both strings', function() { + it('should deny (we are asserting the relative lengths of two strings)', function() { + expect({ + memberName: 'truthy' + }).not.toHaveStringSameLengthAs('memberName', _undefined); + expect({ + memberName: _undefined + }).not.toHaveStringSameLengthAs('memberName', 'truthy'); + expect({ + memberName: '' + }).not.toHaveStringSameLengthAs('memberName', _undefined); + expect({ + memberName: _undefined + }).not.toHaveStringSameLengthAs('memberName', ''); + }); + }); + }); +}); + +describe('toHaveStringShorterThan', function() { + describeToHaveX('toHaveStringShorterThan', function() { + describe('when the subject and comparison ARE both strings', function() { + describe('when the subject IS shorter than the comparision string', function() { + it('should confirm', function() { + expect({ + memberName: 'ab' + }).toHaveStringShorterThan('memberName', 'abc'); + expect({ + memberName: '' + }).toHaveStringShorterThan('memberName', 'a'); + }); + }); + describe('when the subject is NOT shorter than the comparision string', function() { + it('should deny', function() { + expect({ + memberName: 'abc' + }).not.toHaveStringShorterThan('memberName', 'ab'); + expect({ + memberName: 'a' + }).not.toHaveStringShorterThan('memberName', ''); + }); + }); + }); + describe('when the subject and comparison are NOT both strings', function() { + it('should deny (we are asserting the relative lengths of two strings)', function() { + expect({ + memberName: 'truthy' + }).not.toHaveStringShorterThan('memberName', _undefined); + expect({ + memberName: _undefined + }).not.toHaveStringShorterThan('memberName', 'truthy'); + expect({ + memberName: '' + }).not.toHaveStringShorterThan('memberName', _undefined); + expect({ + memberName: _undefined + }).not.toHaveStringShorterThan('memberName', ''); + }); + }); + }); +}); + + +describe('toHaveTrue', function() { + describeToHaveBooleanX('toHaveTrue', function() { + describe('when primitive', function() { + describe('when true', function() { + it('should confirm', function() { + expect({ + memberName: true + }).toHaveTrue('memberName'); + }); + }); + describe('when false', function() { + it('should deny', function() { + expect({ + memberName: false + }).not.toHaveTrue('memberName'); + }); + }); + }); + describe('when Boolean object', function() { + describe('when true', function() { + it('should confirm', function() { + expect({ + memberName: new Boolean(true) + }).toHaveTrue('memberName'); + }); + }); + describe('when false', function() { + it('should deny', function() { + expect({ + memberName: new Boolean(false) + }).not.toHaveTrue('memberName'); + }); + }); + }); + }); +}); + +describe('toHaveWhitespaceString', function() { + describeToHaveX('toHaveWhitespaceString', function() { + describe('when subject IS a string containing only tabs, spaces, returns etc', function() { + it('should confirm', function() { + expect({ + memberName: ' ' + }).toHaveWhitespaceString('memberName'); + expect({ + memberName: '' + }).toHaveWhitespaceString('memberName'); + }); + }); + describe('when subject is NOT a string containing only tabs, spaces, returns etc', function() { + it('should deny', function() { + expect({ + memberName: 'has-no-whitespace' + }).not.toHaveWhitespaceString('memberName'); + expect({ + memberName: 'has whitespace' + }).not.toHaveWhitespaceString('memberName'); + expect({ + memberName: null + }).not.toHaveWhitespaceString('memberName'); + }); + }); + }); +}); + +describe('toHaveWholeNumber', function() { + describeToHaveX('toHaveWholeNumber', function() { + describe('when subject IS a number with no positive decimal places', function() { + it('should confirm', function() { + expect({ + memberName: 1 + }).toHaveWholeNumber('memberName'); + expect({ + memberName: 0 + }).toHaveWholeNumber('memberName'); + expect({ + memberName: 0.0 + }).toHaveWholeNumber('memberName'); + }); + }); + describe('when subject is NOT a number with no positive decimal places', function() { + it('should deny', function() { + expect({ + memberName: NaN + }).not.toHaveWholeNumber('memberName'); + expect({ + memberName: 1.1 + }).not.toHaveWholeNumber('memberName'); + expect({ + memberName: 0.1 + }).not.toHaveWholeNumber('memberName'); + }); + }); + }); +}); + +describe('toImplement', function() { + describe('when invoked', function() { + describe('when subject IS an Object containing all of the supplied members', function() { + it('should confirm', function() { + expect({ + a: 1, + b: 2 + }).toImplement({ + a: 1, + b: 2 + }); + expect({ + a: 1, + b: 2 + }).toImplement({ + a: 1 + }); + }); + }); + describe('when subject is NOT an Object containing all of the supplied members', function() { + it('should deny', function() { + expect({ + a: 1 + }).not.toImplement({ + c: 3 + }); + expect(null).not.toImplement({ + a: 1 + }); + }); + }); + }); +}); + +describe('toStartWith', function() { + describe('when invoked', function() { + describe('when subject is NOT an undefined or empty string', function() { + describe('when subject is a string whose leading characters match the expected string', function() { + it('should confirm', function() { + expect('jamie').toStartWith('jam'); + }); + }); + describe('when subject is a string whose leading characters DO NOT match the expected string', function() { + it('should deny', function() { + expect(' jamie').not.toStartWith('jam'); + expect('Jamie').not.toStartWith('jam'); + }); + }); + }); + describe('when subject IS an undefined or empty string', function() { + it('should deny', function() { + expect('').not.toStartWith(''); + expect(_undefined).not.toStartWith(''); + expect(_undefined).not.toStartWith('undefined'); + expect('undefined').not.toStartWith(_undefined); + }); + }); + }); +}); + + +describe('toThrowAnyError', function() { + describe('when supplied a function', function() { + describe('when function errors when invoked', function() { + beforeEach(function() { + this.throwError = function() { + throw new Error('wut?'); + }; + this.badReference = function() { + return badReference.someValue; + }; + }); + it('should confirm', function() { + expect(this.throwError).toThrowAnyError(); + expect(this.badReference).toThrowAnyError(); + }); + }); + describe('when function does NOT error when invoked', function() { + beforeEach(function() { + this.noErrors = function() {}; + }); + it('should deny', function() { + expect(this.noErrors).not.toThrowAnyError(); + }); + }); + }); +}); + + +describe('toThrowErrorOfType', function() { + describe('when supplied a function', function() { + describe('when function errors when invoked', function() { + beforeEach(function() { + this.throwError = function() { + throw new Error('wut?'); + }; + this.badReference = function() { + return badReference.someValue; + }; + }); + describe('when the error is of the expected type', function() { + it('should confirm', function() { + expect(this.throwError).toThrowErrorOfType('Error'); + expect(this.badReference).toThrowErrorOfType('ReferenceError'); + }); + }); + describe('when the error is NOT of the expected type', function() { + it('should confirm', function() { + expect(this.throwError).not.toThrowErrorOfType('ReferenceError'); + expect(this.badReference).not.toThrowErrorOfType('Error'); + }); + }); + }); + }); +}); diff --git a/jasmine-matchers/jamiemason-jasmine-matchers.d.ts b/jasmine-matchers/jamiemason-jasmine-matchers.d.ts index 6a2b8a49a..e293496c6 100644 --- a/jasmine-matchers/jamiemason-jasmine-matchers.d.ts +++ b/jasmine-matchers/jamiemason-jasmine-matchers.d.ts @@ -25,84 +25,84 @@ declare module jasmine { interface Matchers { // These functions are written in the order defined in the src directory of jasmine-matchers // The type system is used smartly whenever it can provide value (by looking at the code of every matcher) - toBeAfter(otherDate: Date, actualDate: Date): boolean; // - toBeArray(actualArray: any[]): boolean; // - toBeArrayOfBooleans(actualArray: any[]): boolean; // - toBeArrayOfNumbers(actualArray: any[]): boolean; - toBeArrayOfObjects(actualArray: any[]): boolean; - toBeArrayOfSize(size: number, actualArray: any[]): boolean; - toBeArrayOfStrings(actualArray: any[]): boolean; - toBeBefore(otherDate: Date, actualDate: Date): boolean; // - toBeBoolean(actual: boolean): boolean; - toBeCalculable(actual: number): boolean; - toBeDate(actual: Date): boolean; - toBeEmptyArray(actualArray: any[]): boolean; - toBeEmptyObject(actual: {}): boolean; - toBeEmptyString(actual: string): boolean; - toBeEvenNumber(actual: number): boolean; - toBeFalse(actual: boolean): boolean; - toBeFunction(actual: any): boolean; - toBeHtmlString(actual: string): boolean; - toBeIso8601(actual: string): boolean; - toBeJsonString(actual: string): boolean; - toBeLongerThan(actual: string): boolean; - toBeNonEmptyArray(actualArray: any[]): boolean; - toBeNonEmptyObject(actual: {}): boolean; - toBeNonEmptyString(actual: string): boolean; - toBeNumber(actual: number): boolean; - toBeObject(actual: {}): boolean; - toBeOddNumber(actual: number): boolean; - toBeSameLengthAs(other: string, actual: string): boolean; - toBeShorterThan(other: string, actual: string): boolean; - toBeString(actual: string): boolean; - toBeTrue(actual: boolean): boolean; - toBeWhitespace(actual: string): boolean; - toBeWholeNumber(actual: number): boolean; - toBeWithinRange(floor: number, ceiling: number, actual: number): boolean; + toBeAfter(otherDate: Date): boolean; // + toBeArray(): boolean; // + toBeArrayOfBooleans(): boolean; // + toBeArrayOfNumbers(): boolean; + toBeArrayOfObjects(): boolean; + toBeArrayOfSize(size: number): boolean; + toBeArrayOfStrings(): boolean; + toBeBefore(otherDate: Date): boolean; // + toBeBoolean(): boolean; + toBeCalculable(): boolean; + toBeDate(): boolean; + toBeEmptyArray(): boolean; + toBeEmptyObject(): boolean; + toBeEmptyString(): boolean; + toBeEvenNumber(): boolean; + toBeFalse(): boolean; + toBeFunction(): boolean; + toBeHtmlString(): boolean; + toBeIso8601(): boolean; + toBeJsonString(): boolean; + toBeLongerThan(other: string): boolean; + toBeNonEmptyArray(): boolean; + toBeNonEmptyObject(): boolean; + toBeNonEmptyString(): boolean; + toBeNumber(): boolean; + toBeObject(): boolean; + toBeOddNumber(): boolean; + toBeSameLengthAs(other: string): boolean; + toBeShorterThan(other: string): boolean; + toBeString(): boolean; + toBeTrue(): boolean; + toBeWhitespace(): boolean; + toBeWholeNumber(): boolean; + toBeWithinRange(floor: number, ceiling: number): boolean; - toEndWith(subString: string, actual: string): boolean; + toEndWith(subString: string): boolean; - toHaveArray(key: string, actual: {}): boolean; - toHaveArrayOfBooleans(key: string, actual: {}): boolean; - toHaveArrayOfNumbers(key: string, actual: {}): boolean; - toHaveArrayOfObjects(key: string, actual: {}): boolean; - toHaveArrayOfSize(key: string, size: number, actual: {}): boolean; - toHaveArrayOfStrings(key: string, actual: {}): boolean; - toHaveBoolean(key: string, actual: {}): boolean; - toHaveCalculable(key: string, actual: {}): boolean; - toHaveDate(key: string, actual: {}): boolean; - toHaveDateAfter(key: string, actual: {}): boolean; - toHaveDateBefore(key: string, actual: {}): boolean; - toHaveEmptyArray(key: string, actual: {}): boolean; - toHaveEmptyObject(key: string, actual: {}): boolean; - toHaveEmptyString(key: string, actual: {}): boolean; - toHaveEvenNumber(key: string, actual: {}): boolean; - toHaveFalse(key: string, actual: {}): boolean; - toHaveHtmlString(key: string, actual: {}): boolean; - toHaveIso8601(key: string, actual: {}): boolean; - toHaveJsonString(key: string, actual: {}): boolean; - toHaveMember(key: string, actual: {}): boolean; - toHaveMethod(key: string, actual: {}): boolean; - toHaveNonEmptyArray(key: string, actual: {}): boolean; - toHaveNonEmptyObject(key: string, actual: {}): boolean; - toHaveNonEmptyString(key: string, actual: {}): boolean; - toHaveNumber(key: string, actual: {}): boolean; - toHaveNumberWithinRange(key: string, actual: {}): boolean; - toHaveObject(key: string, actual: {}): boolean; - toHaveOddNumber(key: string, actual: {}): boolean; - toHaveString(key: string, actual: {}): boolean; - toHaveStringLongerThan(key: string, actual: {}): boolean; - toHaveStringSameLengthAs(key: string, actual: {}): boolean; - toHaveStringShorterThan(key: string, actual: {}): boolean; - toHaveTrue(key: string, actual: {}): boolean; - toHaveWhitespaceString(key: string, actual: {}): boolean; - toHaveWholeNumber(key: string, actual: {}): boolean; + toHaveArray(key: string): boolean; + toHaveArrayOfBooleans(key: string): boolean; + toHaveArrayOfNumbers(key: string): boolean; + toHaveArrayOfObjects(key: string): boolean; + toHaveArrayOfSize(key: string, size?: number): boolean; + toHaveArrayOfStrings(key: string): boolean; + toHaveBoolean(key: string): boolean; + toHaveCalculable(key: string): boolean; + toHaveDate(key: string): boolean; + toHaveDateAfter(key: string, otherDate: Date): boolean; + toHaveDateBefore(key: string, otherDate: Date): boolean; + toHaveEmptyArray(key: string): boolean; + toHaveEmptyObject(key: string): boolean; + toHaveEmptyString(key: string): boolean; + toHaveEvenNumber(key: string): boolean; + toHaveFalse(key: string): boolean; + toHaveHtmlString(key: string): boolean; + toHaveIso8601(key: string): boolean; + toHaveJsonString(key: string): boolean; + toHaveMember(key: string): boolean; + toHaveMethod(key: string): boolean; + toHaveNonEmptyArray(key: string): boolean; + toHaveNonEmptyObject(key: string): boolean; + toHaveNonEmptyString(key: string): boolean; + toHaveNumber(key: string): boolean; + toHaveNumberWithinRange(key: string, floor: number, ceiling: number): boolean; + toHaveObject(key: string): boolean; + toHaveOddNumber(key: string): boolean; + toHaveString(key: string): boolean; + toHaveStringLongerThan(key: string, other: string): boolean; + toHaveStringSameLengthAs(key: string, other: string): boolean; + toHaveStringShorterThan(key: string, other: string): boolean; + toHaveTrue(key: string): boolean; + toHaveWhitespaceString(key: string): boolean; + toHaveWholeNumber(key: string): boolean; - toImplement(api: {}, actual: {}): boolean; + toImplement(api: {}): boolean; - toStartWith(subString: string, actual: string): boolean; + toStartWith(subString: string): boolean; - toThrowAnyError(throwerFn: () => any): boolean; - toThrowErrorOfType(type: string, throwerFn: () => any): boolean; + toThrowAnyError(): boolean; + toThrowErrorOfType(type: string): boolean; } }