Skip to content
Browse files

Added qunit documentation to facilitate Visual Studio intellisense.

  • Loading branch information...
1 parent 8a17feb commit 4651ce7843df28f7c37c63971bff5b0a9ecbfe5e @Diullei Diullei committed
Showing with 558 additions and 6 deletions.
  1. +558 −6 qunit/qunit.d.ts
View
564 qunit/qunit.d.ts
@@ -5,44 +5,127 @@
interface DoneCallbackObject {
+ /**
+ * The number of failed assertions
+ */
failed: number;
+
+ /**
+ * The number of passed assertions
+ */
passed: number;
+
+ /**
+ * The total number of assertions
+ */
total: number;
+
+ /**
+ * The time in milliseconds it took tests to run from start to finish.
+ */
runtime: number;
}
interface LogCallbackObject {
+ /**
+ * The boolean result of an assertion, true means passed, false means failed.
+ */
result: bool;
+
+ /**
+ * One side of a comparision assertion. Can be undefined when ok() is used.
+ */
actual: Object;
+
+ /**
+ * One side of a comparision assertion. Can be undefined when ok() is used.
+ */
expected: Object;
+
+ /**
+ * A string description provided by the assertion.
+ */
message: string;
+
+ /**
+ * The associated stacktrace, either from an exception or pointing to the source
+ * of the assertion. Depends on browser support for providing stacktraces, so can be
+ * undefined.
+ */
+ source: string;
}
interface ModuleStartCallbackObject {
+ /**
+ * Name of the next module to run
+ */
name: string;
}
interface ModuleDoneCallbackObject {
+ /**
+ * Name of this module
+ */
name: string;
+
+ /**
+ * The number of failed assertions
+ */
failed: number;
+
+ /**
+ * The number of passed assertions
+ */
passed: number;
+
+ /**
+ * The total number of assertions
+ */
total: number;
}
interface TestDoneCallbackObject {
+ /**
+ * TName of the next test to run
+ */
name: string;
+
+ /**
+ * Name of the current module
+ */
module: string;
+
+ /**
+ * The number of failed assertions
+ */
failed: number;
+
+ /**
+ * The number of passed assertions
+ */
passed: number;
+
+ /**
+ * The total number of assertions
+ */
total: number;
+
+ /**
+ * The total runtime, including setup and teardown
+ */
+ duration: number;
}
interface TestStartCallbackObject {
+ /**
+ * Name of the next test to run
+ */
name: string;
+
+ /**
+ * Name of the current module
+ */
module: string;
- failed: number;
- passed: number;
- total: number;
}
interface Config {
@@ -56,7 +139,14 @@ interface Config {
}
interface LifecycleObject {
+ /**
+ * Runs before each test
+ */
setup?: () => any;
+
+ /**
+ * Runs after each test
+ */
teardown?: () => any;
}
@@ -66,92 +156,554 @@ interface QUnitAssert {
current_testEnvironment: any;
jsDump: any;
+ /**
+ * A deep recursive comparison assertion, working on primitive types, arrays, objects,
+ * regular expressions, dates and functions.
+ *
+ * The deepEqual() assertion can be used just like equal() when comparing the value of
+ * objects, such that { key: value } is equal to { key: value }. For non-scalar values,
+ * identity will be disregarded by deepEqual.
+ *
+ * @param actual Object or Expression being tested
+ * @param expected Known comparison value
+ * @param message A short description of the assertion
+ */
deepEqual(actual: any, expected: any, message?: string);
+
+ /**
+ * A non-strict comparison assertion, roughly equivalent to JUnit assertEquals.
+ *
+ * The equal assertion uses the simple comparison operator (==) to compare the actual
+ * and expected arguments. When they are equal, the assertion passes; otherwise, it fails.
+ * When it fails, both actual and expected values are displayed in the test result,
+ * in addition to a given message.
+ *
+ * @param actual Expression being tested
+ * @param expected Known comparison value
+ * @param message A short description of the assertion
+ */
equal(actual: any, expected: any, message?: string);
+
+ /**
+ * An inverted deep recursive comparison assertion, working on primitive types,
+ * arrays, objects, regular expressions, dates and functions.
+ *
+ * The notDeepEqual() assertion can be used just like equal() when comparing the
+ * value of objects, such that { key: value } is equal to { key: value }. For non-scalar
+ * values, identity will be disregarded by notDeepEqual.
+ *
+ * @param actual Object or Expression being tested
+ * @param expected Known comparison value
+ * @param message A short description of the assertion
+ */
notDeepEqual(actual: any, expected: any, message?: string);
+
+ /**
+ * A non-strict comparison assertion, checking for inequality.
+ *
+ * The notEqual assertion uses the simple inverted comparison operator (!=) to compare
+ * the actual and expected arguments. When they aren't equal, the assertion passes;
+ * otherwise, it fails. When it fails, both actual and expected values are displayed
+ * in the test result, in addition to a given message.
+ *
+ * @param actual Expression being tested
+ * @param expected Known comparison value
+ * @param message A short description of the assertion
+ */
notEqual(actual: any, expected: any, message?: string);
+
notPropEqual(actual: any, expected: any, message?: string);
+
propEqual(actual: any, expected: any, message?: string);
+
+ /**
+ * A non-strict comparison assertion, checking for inequality.
+ *
+ * The notStrictEqual assertion uses the strict inverted comparison operator (!==)
+ * to compare the actual and expected arguments. When they aren't equal, the assertion
+ * passes; otherwise, it fails. When it fails, both actual and expected values are
+ * displayed in the test result, in addition to a given message.
+ *
+ * @param actual Expression being tested
+ * @param expected Known comparison value
+ * @param message A short description of the assertion
+ */
notStrictEqual(actual: any, expected: any, message?: string);
+
+ /**
+ * A boolean assertion, equivalent to CommonJS’s assert.ok() and JUnit’s assertTrue().
+ * Passes if the first argument is truthy.
+ *
+ * The most basic assertion in QUnit, ok() requires just one argument. If the argument
+ * evaluates to true, the assertion passes; otherwise, it fails. If a second message
+ * argument is provided, it will be displayed in place of the result.
+ *
+ * @param state Expression being tested
+ * @param message A short description of the assertion
+ */
ok(state: any, message?: string);
+
+ /**
+ * A strict type and value comparison assertion.
+ *
+ * The strictEqual() assertion provides the most rigid comparison of type and value with
+ * the strict equality operator (===)
+ *
+ * @param actual Expression being tested
+ * @param expected Known comparison value
+ * @param message A short description of the assertion
+ */
strictEqual(actual: any, expected: any, message?: string);
+
+ /**
+ * Assertion to test if a callback throws an exception when run.
+ *
+ * When testing code that is expected to throw an exception based on a specific set of
+ * circumstances, use throws() to catch the error object for testing and comparison.
+ *
+ * @param block Function to execute
+ * @param expected Error Object to compare
+ * @param message A short description of the assertion
+ */
throws(block: () => any, expected: any, message?: string);
+
+ /**
+ * @param block Function to execute
+ * @param message A short description of the assertion
+ */
throws(block: () => any, message?: string);
}
interface QUnitStatic extends QUnitAssert{
/* ASYNC CONTROL */
+
+ /**
+ * Start running tests again after the testrunner was stopped. See stop().
+ *
+ * When your async test has multiple exit points, call start() for the corresponding number of stop() increments.
+ *
+ * @param decrement Optional argument to merge multiple start() calls into one. Use with multiple corrsponding stop() calls.
+ */
start(decrement?: number);
+
+ /**
+ * Stop the testrunner to wait for async tests to run. Call start() to continue.
+ *
+ * When your async test has multiple exit points, call stop() with the increment argument, corresponding to the number of start() calls you need.
+ *
+ * On Blackberry 5.0, window.stop is a native read-only function. If you deal with that browser, use QUnit.stop() instead, which will work anywhere.
+ *
+ * @param decrement Optional argument to merge multiple stop() calls into one. Use with multiple corrsponding start() calls.
+ */
stop(increment? : number);
/* CALLBACKS */
+
+ /**
+ * Register a callback to fire whenever the test suite begins.
+ *
+ * QUnit.begin() is called once before running any tests. (a better would've been QUnit.start,
+ * but thats already in use elsewhere and can't be changed.)
+ *
+ * @param callback Callback to execute
+ */
begin(callback: () => any);
+
+ /**
+ * Register a callback to fire whenever the test suite ends.
+ *
+ * @param callback Callback to execute.
+ */
done(callback: (details: DoneCallbackObject) => any);
+
+ /**
+ * Register a callback to fire whenever an assertion completes.
+ *
+ * This is one of several callbacks QUnit provides. Its intended for integration scenarios like
+ * PhantomJS or Jenkins. The properties of the details argument are listed below as options.
+ *
+ * @param callback Callback to execute.
+ */
log(callback: (details: LogCallbackObject) => any);
+
+ /**
+ * Register a callback to fire whenever a module ends.
+ *
+ * @param callback Callback to execute.
+ */
moduleDone(callback: (details: ModuleDoneCallbackObject) => any);
+
+ /**
+ * Register a callback to fire whenever a module begins.
+ *
+ * @param callback Callback to execute.
+ */
moduleStart(callback: (details: ModuleStartCallbackObject) => any);
+
+ /**
+ * Register a callback to fire whenever a test ends.
+ *
+ * @param callback Callback to execute.
+ */
testDone(callback: (details: TestDoneCallbackObject) => any);
+
+ /**
+ * Register a callback to fire whenever a test begins.
+ *
+ * @param callback Callback to execute.
+ */
testStart(callback: (details: TestStartCallbackObject) => any);
/* CONFIGURATION */
+
+ /**
+ * QUnit has a bunch of internal configuration defaults, some of which are
+ * useful to override. Check the description for each option for details.
+ */
config: Config;
/* TEST */
+
+ /**
+ * Add an asynchronous test to run. The test must include a call to start().
+ *
+ * For testing asynchronous code, asyncTest will automatically stop the test runner
+ * and wait for your code to call start() to continue.
+ *
+ * @param name Title of unit being tested
+ * @param expected Number of assertions in this test
+ * @param test Function to close over assertions
+ */
asyncTest(name: string, expected: number, test: () => any);
+
+ /**
+ * Add an asynchronous test to run. The test must include a call to start().
+ *
+ * For testing asynchronous code, asyncTest will automatically stop the test runner
+ * and wait for your code to call start() to continue.
+ *
+ * @param name Title of unit being tested
+ * @param test Function to close over assertions
+ */
asyncTest(name: string, test: () => any);
+
+ /**
+ * Specify how many assertions are expected to run within a test.
+ *
+ * To ensure that an explicit number of assertions are run within any test, use
+ * expect( number ) to register an expected count. If the number of assertions
+ * run does not match the expected count, the test will fail.
+ *
+ * @param amount Number of assertions in this test.
+ */
expect(amount: number);
+
+ /**
+ * Group related tests under a single label.
+ *
+ * All tests that occur after a call to module() will be grouped into that module.
+ * The test names will all be preceded by the module name in the test results.
+ * You can then use that module name to select tests to run.
+ *
+ * @param name Label for this group of tests
+ * @param lifecycle Callbacks to run before and after each test
+ */
module(name: string, lifecycle?: LifecycleObject);
+
+ /**
+ * Add a test to run.
+ *
+ * When testing the most common, synchronous code, use test().
+ * The assert argument to the callback contains all of QUnit's assertion methods.
+ * If you are avoiding using any of QUnit's globals, you can use the assert
+ * argument instead.
+ *
+ * @param title Title of unit being tested
+ * @param expected Number of assertions in this test
+ * @param test Function to close over assertions
+ */
test(title: string, expected: number, test: (assert: QUnitAssert) => any);
+
+ /**
+ * @param title Title of unit being tested
+ * @param test Function to close over assertions
+ */
test(title: string, test: (assert: QUnitAssert) => any);
- // https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L1568
+ /**
+ * https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L1568
+ */
equiv(a: any, b: any);
// https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L661
raises: any;
- // https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L897
+ /**
+ * https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L897
+ */
push(result, actual, expected, message): any;
- // https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L839
+ /**
+ * https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L839
+ */
reset(): any;
}
/* ASSERT */
+
+/**
+* A deep recursive comparison assertion, working on primitive types, arrays, objects,
+* regular expressions, dates and functions.
+*
+* The deepEqual() assertion can be used just like equal() when comparing the value of
+* objects, such that { key: value } is equal to { key: value }. For non-scalar values,
+* identity will be disregarded by deepEqual.
+*
+* @param actual Object or Expression being tested
+* @param expected Known comparison value
+* @param message A short description of the assertion
+*/
declare function deepEqual(actual: any, expected: any, message?: string);
+
+/**
+* A non-strict comparison assertion, roughly equivalent to JUnit assertEquals.
+*
+* The equal assertion uses the simple comparison operator (==) to compare the actual
+* and expected arguments. When they are equal, the assertion passes; otherwise, it fails.
+* When it fails, both actual and expected values are displayed in the test result,
+* in addition to a given message.
+*
+* @param actual Expression being tested
+* @param expected Known comparison value
+* @param message A short description of the assertion
+*/
declare function equal(actual: any, expected: any, message?: string);
+
+/**
+* An inverted deep recursive comparison assertion, working on primitive types,
+* arrays, objects, regular expressions, dates and functions.
+*
+* The notDeepEqual() assertion can be used just like equal() when comparing the
+* value of objects, such that { key: value } is equal to { key: value }. For non-scalar
+* values, identity will be disregarded by notDeepEqual.
+*
+* @param actual Object or Expression being tested
+* @param expected Known comparison value
+* @param message A short description of the assertion
+*/
declare function notDeepEqual(actual: any, expected: any, message?: string);
+
+/**
+* A non-strict comparison assertion, checking for inequality.
+*
+* The notEqual assertion uses the simple inverted comparison operator (!=) to compare
+* the actual and expected arguments. When they aren't equal, the assertion passes;
+* otherwise, it fails. When it fails, both actual and expected values are displayed
+* in the test result, in addition to a given message.
+*
+* @param actual Expression being tested
+* @param expected Known comparison value
+* @param message A short description of the assertion
+*/
declare function notEqual(actual: any, expected: any, message?: string);
+
+/**
+* A non-strict comparison assertion, checking for inequality.
+*
+* The notStrictEqual assertion uses the strict inverted comparison operator (!==)
+* to compare the actual and expected arguments. When they aren't equal, the assertion
+* passes; otherwise, it fails. When it fails, both actual and expected values are
+* displayed in the test result, in addition to a given message.
+*
+* @param actual Expression being tested
+* @param expected Known comparison value
+* @param message A short description of the assertion
+*/
declare function notStrictEqual(actual: any, expected: any, message?: string);
+
+/**
+* A boolean assertion, equivalent to CommonJS’s assert.ok() and JUnit’s assertTrue().
+* Passes if the first argument is truthy.
+*
+* The most basic assertion in QUnit, ok() requires just one argument. If the argument
+* evaluates to true, the assertion passes; otherwise, it fails. If a second message
+* argument is provided, it will be displayed in place of the result.
+*
+* @param state Expression being tested
+* @param message A short description of the assertion
+*/
declare function ok(state: any, message?: string);
+
+/**
+* A strict type and value comparison assertion.
+*
+* The strictEqual() assertion provides the most rigid comparison of type and value with
+* the strict equality operator (===)
+*
+* @param actual Expression being tested
+* @param expected Known comparison value
+* @param message A short description of the assertion
+*/
declare function strictEqual(actual: any, expected: any, message?: string);
+
+/**
+* Assertion to test if a callback throws an exception when run.
+*
+* When testing code that is expected to throw an exception based on a specific set of
+* circumstances, use throws() to catch the error object for testing and comparison.
+*
+* @param block Function to execute
+* @param expected Error Object to compare
+* @param message A short description of the assertion
+*/
declare function throws(block: () => any, expected: any, message?: string);
+
+/**
+* @param block Function to execute
+* @param message A short description of the assertion
+*/
declare function throws(block: () => any, message?: string);
/* ASYNC CONTROL */
+
+/**
+* Start running tests again after the testrunner was stopped. See stop().
+*
+* When your async test has multiple exit points, call start() for the corresponding number of stop() increments.
+*
+* @param decrement Optional argument to merge multiple start() calls into one. Use with multiple corrsponding stop() calls.
+*/
declare function start(decrement?: number);
+
+/**
+* Stop the testrunner to wait for async tests to run. Call start() to continue.
+*
+* When your async test has multiple exit points, call stop() with the increment argument, corresponding to the number of start() calls you need.
+*
+* On Blackberry 5.0, window.stop is a native read-only function. If you deal with that browser, use QUnit.stop() instead, which will work anywhere.
+*
+* @param decrement Optional argument to merge multiple stop() calls into one. Use with multiple corrsponding start() calls.
+*/
declare function stop(increment? : number);
/* CALLBACKS */
+
+/**
+* Register a callback to fire whenever the test suite begins.
+*
+* QUnit.begin() is called once before running any tests. (a better would've been QUnit.start,
+* but thats already in use elsewhere and can't be changed.)
+*
+* @param callback Callback to execute
+*/
declare function begin(callback: () => any);
+
+/**
+* Register a callback to fire whenever the test suite ends.
+*
+* @param callback Callback to execute.
+*/
declare function done(callback: (details: DoneCallbackObject) => any);
+
+/**
+* Register a callback to fire whenever an assertion completes.
+*
+* This is one of several callbacks QUnit provides. Its intended for integration scenarios like
+* PhantomJS or Jenkins. The properties of the details argument are listed below as options.
+*
+* @param callback Callback to execute.
+*/
declare function log(callback: (details: LogCallbackObject) => any);
+
+/**
+* Register a callback to fire whenever a module ends.
+*
+* @param callback Callback to execute.
+*/
declare function moduleDone(callback: (details: ModuleDoneCallbackObject) => any);
+
+/**
+* Register a callback to fire whenever a module begins.
+*
+* @param callback Callback to execute.
+*/
declare function moduleStart(callback: (name: string) => any);
+
+/**
+* Register a callback to fire whenever a test ends.
+*
+* @param callback Callback to execute.
+*/
declare function testDone(callback: (details: TestDoneCallbackObject) => any);
+
+/**
+* Register a callback to fire whenever a test begins.
+*
+* @param callback Callback to execute.
+*/
declare function testStart(callback: (details: TestStartCallbackObject) => any);
/* TEST */
+
+/**
+* Add an asynchronous test to run. The test must include a call to start().
+*
+* For testing asynchronous code, asyncTest will automatically stop the test runner
+* and wait for your code to call start() to continue.
+*
+* @param name Title of unit being tested
+* @param expected Number of assertions in this test
+* @param test Function to close over assertions
+*/
declare function asyncTest(name: string, expected?: any, test?: () => any);
+
+/**
+* Add an asynchronous test to run. The test must include a call to start().
+*
+* For testing asynchronous code, asyncTest will automatically stop the test runner
+* and wait for your code to call start() to continue.
+*
+* @param name Title of unit being tested
+* @param test Function to close over assertions
+*/
+declare function asyncTest(name: string, test: () => any);
+
+/**
+* Specify how many assertions are expected to run within a test.
+*
+* To ensure that an explicit number of assertions are run within any test, use
+* expect( number ) to register an expected count. If the number of assertions
+* run does not match the expected count, the test will fail.
+*
+* @param amount Number of assertions in this test.
+*/
declare function expect(amount: number);
// ** conflict with TypeScript module keyword. Must be used on QUnit namespace
//declare var module: (name: string, lifecycle?: LifecycleObject) => any;
+/**
+* Add a test to run.
+*
+* When testing the most common, synchronous code, use test().
+* The assert argument to the callback contains all of QUnit's assertion methods.
+* If you are avoiding using any of QUnit's globals, you can use the assert
+* argument instead.
+*
+* @param title Title of unit being tested
+* @param expected Number of assertions in this test
+* @param test Function to close over assertions
+*/
declare function test(title: string, expected: number, test: (assert?: QUnitAssert) => any);
+
+/**
+* @param title Title of unit being tested
+* @param test Function to close over assertions
+*/
declare function test(title: string, test: (assert?: QUnitAssert) => any);
declare function notPropEqual(actual: any, expected: any, message?: string);
+
declare function propEqual(actual: any, expected: any, message?: string);
// https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L1568

0 comments on commit 4651ce7

Please sign in to comment.
Something went wrong with that request. Please try again.