From b106a37f1991253ee71d4ca0ff0281300783369b Mon Sep 17 00:00:00 2001 From: Alex Varju Date: Fri, 6 Sep 2013 18:00:38 -0700 Subject: [PATCH] Definitions for should.js 1.2.2 --- should/should-tests.ts | 171 +++++++++++++++++++++++++++++++++++++++++ should/should.d.ts | 85 ++++++++++++++++++++ 2 files changed, 256 insertions(+) create mode 100644 should/should-tests.ts create mode 100644 should/should.d.ts diff --git a/should/should-tests.ts b/should/should-tests.ts new file mode 100644 index 0000000000..c390aa323c --- /dev/null +++ b/should/should-tests.ts @@ -0,0 +1,171 @@ +/// + +import should = require('should'); + +should.fail('actual', 'expected', 'msg', 'operator'); +should.assert('value', 'msg'); +should.ok('value'); +should.equal('actual', 'expected'); +should.notEqual('actual', 'expected'); +should.deepEqual('actual', 'expected'); +should.notDeepEqual('actual', 'expected'); +should.strictEqual('actual', 'expected'); +should.notStrictEqual('actual', 'expected'); +should.throws(() => {}); +should.doesNotThrow(() => {}); +should.ifError('value'); + + +class User { + name: string; + pets: string[]; + age: number; +} + +var user = { + name: 'tj', + pets: ['tobi', 'loki', 'jane', 'bandit'], + age: 17 +}; + +user.should.have.property('name', 'tj'); +user.should.have.property('pets').with.lengthOf(4); + +should.exist('hello'); +should.exist([]); +should.exist(null); + +should.not.exist(false); +should.not.exist(''); +should.not.exist({}); + +user.should.have.property('pets').with.lengthOf(4); +user.pets.should.have.lengthOf(4); +user.should.be.a('object').and.have.property('name', 'tj'); + +'foo'.should.equal('bar'); + +should.exist({}); +should.exist([]); +should.exist(''); +should.exist(0); +should.exist(null); +should.exist(undefined); + +should.not.exist(undefined); +should.not.exist(null); +should.not.exist(''); +should.not.exist({}); + +true.should.be.ok; +'yay'.should.be.ok; +(1).should.be.ok; + +false.should.not.be.ok; +''.should.not.be.ok; +(0).should.not.be.ok; + +true.should.be.true +'1'.should.not.be.true +false + +false.should.be.false; +(0).should.not.be.false; + +var args = (a: string, b: string, c: string) => { return arguments; }; +args.should.be.arguments; +['a'].should.not.be.arguments; + +['a'].should.be.empty; +''.should.be.empty; +({ length: 0 }).should.be.empty; + +({ foo: 'bar' }).should.eql({ foo: 'bar' }); +[1, 2, 3].should.eql([1, 2, 3]); + +(4).should.equal(4); +'test'.should.equal('test'); +[1, 2, 3].should.not.equal([1, 2, 3]); + +user.age.should.be.within(5, 50); + +user.should.be.a('object'); +'test'.should.be.a('string'); + +user.should.be.an.instanceof(User); +['a'].should.be.an.instanceOf(Array); + +user.age.should.be.above(5); +user.age.should.not.be.above(100); + +user.age.should.be.below(100); +user.age.should.not.be.below(5); + +'username'.should.match(/^\w+$/); + +user.pets.should.have.length(5); +user.pets.should.have.lengthOf(5); + +user.should.have.property('name'); +user.should.have.property('age', 15); +user.should.not.have.property('rawr'); +user.should.not.have.property('age', 0); + +({ foo: 'bar' }).should.have.ownProperty('foo'); + +var res = {}; +res.should.have.status(200); + +res.should.have.header('content-length'); +res.should.have.header('Content-Length', '123'); +res.should.have.header('content-length', '123'); + +res.should.be.json; + +res.should.be.html; + +[1, 2, 3].should.include(3); +[1, 2, 3].should.include(2); +[1, 2, 3].should.not.include(4); + +'foo bar baz'.should.include('foo'); +'foo bar baz'.should.include('bar'); +'foo bar baz'.should.include('baz'); +'foo bar baz'.should.not.include('FOO'); + +var tobi = { name: 'Tobi', age: 1 }; +var jane = { name: 'Jane', age: 5 }; +var tj = { name: 'TJ', pet: tobi }; +tj.should.include({ pet: tobi }); +tj.should.include({ pet: tobi, name: 'TJ' }); +tj.should.not.include({ pet: jane }); +tj.should.not.include({ name: 'Someone' }); + +[[1], [2], [3]].should.includeEql([3]); +[[1], [2], [3]].should.includeEql([2]); +[[1], [2], [3]].should.not.includeEql([4]); + +(function () { + throw new Error('fail'); +}).should.throw(); + +(function () { +}).should.not.throw(); + +(function () { + throw new Error('fail'); +}).should.throw('fail'); + +(function () { + throw new Error('failed to foo'); +}).should.throw(/^fail/); + +(function () { + throw new Error('failed to baz'); +}).should.throwError(/^fail.*/); + +var obj = { foo: 'bar', baz: 'raz' }; +obj.should.have.keys('foo', 'bar'); +obj.should.have.keys(['foo', 'bar']); + +(1).should.eql(0, 'some useful description'); diff --git a/should/should.d.ts b/should/should.d.ts new file mode 100644 index 0000000000..ccf6a871f0 --- /dev/null +++ b/should/should.d.ts @@ -0,0 +1,85 @@ +// Type definitions for should.js 1.2.2 +// Project: https://github.com/visionmedia/should.js +// Definitions by: Alex Varju +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +interface Object { + should: ShouldAssertion; +} + +interface ShouldAssertion { + // basic grammar + an: ShouldAssertion; + // a: ShouldAssertion; + and: ShouldAssertion; + be: ShouldAssertion; + have: ShouldAssertion; + with: ShouldAssertion; + not: ShouldAssertion; + + // validators + arguments: ShouldAssertion; + empty: ShouldAssertion; + ok: ShouldAssertion; + true: ShouldAssertion; + false: ShouldAssertion; + eql(expected: any, description?: string): ShouldAssertion; + equal(expected: any, description?: string): ShouldAssertion; + within(start: number, finish: number, description?: string): ShouldAssertion; + approximately(value: number, delta: number, description?: string): ShouldAssertion; + a(expected: any, description?: string): ShouldAssertion; + instanceof(constructor: Function, description?: string): ShouldAssertion; + above(n: number, description?: string): ShouldAssertion; + below(n: number, description?: string): ShouldAssertion; + match(regexp: RegExp, description?: string): ShouldAssertion; + length(n: number, description?: string): ShouldAssertion; + property(name: string, description?: string): ShouldAssertion; + property(name: string, val: any, description?: string): ShouldAssertion; + ownProperty(name: string, description?: string): ShouldAssertion; + include(obj: any, description?: string): ShouldAssertion; + includeEql(obj: Array, description?: string): ShouldAssertion; + contain(obj: any): ShouldAssertion; + keys(...allKeys: string[]): ShouldAssertion; + keys(allKeys: string[]): ShouldAssertion; + header(field: string, val?: string): ShouldAssertion; + status(code: number): ShouldAssertion; + json: ShouldAssertion; + html: ShouldAssertion; + throw(message?: any): ShouldAssertion; + + // aliases + instanceOf(constructor: Function, description?: string): ShouldAssertion; + throwError(message?: any): ShouldAssertion; + lengthOf(n: number, description?: string): ShouldAssertion; + key(key: string): ShouldAssertion; + haveOwnProperty(name: string, description?: string): ShouldAssertion; + greaterThan(n: number, description?: string): ShouldAssertion; + lessThan(n: number, description?: string): ShouldAssertion; +} + +interface ShouldInternal { + // should.js's extras + exist(actual: any): void; + exists(actual: any): void; + not: ShouldInternal; +} + +interface Internal extends ShouldInternal { + // node.js's assert functions + fail(actual: any, expected: any, message: string, operator: string): void; + assert(value: any, message: string): void; + ok(value: any, message?: string): void; + equal(actual: any, expected: any, message?: string): void; + notEqual(actual: any, expected: any, message?: string): void; + deepEqual(actual: any, expected: any, message?: string): void; + notDeepEqual(actual: any, expected: any, message?: string): void; + strictEqual(actual: any, expected: any, message?: string): void; + notStrictEqual(actual: any, expected: any, message?: string): void; + throws(block: any, error?: any, message?: string): void; + doesNotThrow(block: any, message?: string): void; + ifError(value: any): void; +} + +declare module "should" { + export = Internal; +}