diff --git a/types/qunit/index.d.ts b/types/qunit/index.d.ts index c5e677d187..120c61d667 100644 --- a/types/qunit/index.d.ts +++ b/types/qunit/index.d.ts @@ -7,14 +7,14 @@ interface Assert { /** * Instruct QUnit to wait for an asynchronous operation. - * + * * The callback returned from `assert.async()` will throw an Error if it is * invoked more than once (or more often than the accepted call count, if * provided). * * This replaces functionality previously provided by `QUnit.stop()` and * `QUnit.start()`. - * + * * @param {number} [acceptCallCount=1] Number of expected callbacks before the test is done. */ async(acceptCallCount?: number): () => void; @@ -22,179 +22,179 @@ interface Assert { /** * A deep recursive comparison, 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. - * + * * `notDeepEqual()` can be used to explicitly test deep, strict inequality. - * + * * @param actual Object or Expression being tested * @param expected Known comparision value - * @param {string} [message] A short description of the assertion + * @param {string} [message] A short description of the assertion */ - deepEqual(actual: any, expected: any, message?: string): void; - + deepEqual(actual: T, expected: T, message?: string): void; + /** * A non-strict comparison, roughly equivalent to JUnit's 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. - * + * * `notEqual()` can be used to explicitly test inequality. - * + * * `strictEqual()` can be used to test strict equality. - * + * * @param actual Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ equal(actual: any, expected: any, message?: string): void; - + /** * 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 `assert.expect( number )` to register an expected count. If the * number of assertions run does not match the expected count, the test will * fail. - * + * * @param {number} amount Number of assertions in this test. */ expect(amount: number): void; - + /** * An inverted deep recursive comparison, working on primitive types, * arrays, objects, regular expressions, dates and functions. - * + * * @param actual Object or Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ notDeepEqual(actual: any, expected: any, message?: string): void; - + /** * A non-strict comparison, 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. - * + * * `equal()` can be used to test equality. - * + * * `notStrictEqual()` can be used to test strict inequality. - * + * * @param actual Object or Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ notEqual(actual: any, expected: any, message?: string): void; - + /** * A boolean check, inverse of `ok()` and CommonJS's `assert.ok()`, and * equivalent to JUnit's `assertFalse()`. Passes if the first argument is * falsy. - * + * * `notOk()` requires just one argument. If the argument evaluates to false, * 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 {string} [message] A short description of the assertion */ notOk(state: any, message?: string): void; - + /** * A strict comparison of an object's own properties, checking for inequality. - * + * * The `notPropEqual` assertion uses the strict inverted comparison operator * (`!==`) to compare the actual and expected arguments as Objects regarding * only their properties but not their constructors. - * + * * 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. - * + * * `equal()` can be used to test equality. - * + * * `propEqual()` can be used to test strict equality of an Object properties. - * + * * @param actual Object or Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ notPropEqual(actual: any, expected: any, message?: string): void; - + /** * A strict comparison, 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. - * + * * `equal()` can be used to test equality. - * + * * `strictEqual()` can be used to test strict equality. - * + * * @param actual Object or Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ notStrictEqual(actual: any, expected: any, message?: string): void; - + /** * A boolean check, 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 {string} message A short description of the assertion */ ok(state: any, message?: string): void; - + /** * A strict type and value comparison of an object's own properties. - * + * * The `propEqual()` assertion provides strictly (`===`) comparison of * Object properties. Unlike `deepEqual()`, this assertion can be used to * compare two objects made with different constructors and prototype. - * + * * `strictEqual()` can be used to test strict equality. - * + * * `notPropEqual()` can be used to explicitly test strict inequality of * Object properties. - * + * * @param actual Object or Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ propEqual(actual: any, expected: any, message?: string): void; - + /** * Report the result of a custom assertion - * + * * Some test suites may need to express an expectation that is not defined * by any of QUnit's built-in assertions. This need may be met by * encapsulating the expectation in a JavaScript function which returns a * `Boolean` value representing the result; this value can then be passed * into QUnit's `ok` assertion. - * + * * A more readable solution would involve defining a custom assertion. If * the expectation function invokes `pushResult`, QUnit will be notified of * the result and report it accordingly. - * + * * @param assertionResult The assertion result */ pushResult(assertResult: { @@ -203,31 +203,31 @@ interface Assert { expected: any; message: string; }): void; - + /** * A strict type and value comparison. - * + * * The `strictEqual()` assertion provides the most rigid comparison of type * and value with the strict equality operator (`===`). - * + * * `equal()` can be used to test non-strict equality. - * + * * `notStrictEqual()` can be used to explicitly test strict inequality. - * + * * @param actual Object or Expression being tested * @param expected Known comparison value * @param {string} [message] A short description of the assertion */ - strictEqual(actual: any, expected: any, message?: string): void; - + strictEqual(actual: T, expected: T, message?: string): void; + /** * Test if a callback throws an exception, and optionally compare the thrown * error. - * + * * When testing code that is expected to throw an exception based on a * specific set of circumstances, use assert.throws() to catch the error * object for testing and comparison. - * + * * In very few environments, like Closure Compiler, throws is considered a * reserved word and will cause an error. For that case, an alias is bundled * called `raises`. It has the same signature and behaviour, just a @@ -238,30 +238,30 @@ interface Assert { /** * A marker for progress in a given test. - * - * The `step()` assertion registers a passing assertion with a provided message. This makes - * it easy to check that specific portions of code are being executed, especially in - * asynchronous test cases and when used with `verifySteps()`. - * + * + * The `step()` assertion registers a passing assertion with a provided message. This makes + * it easy to check that specific portions of code are being executed, especially in + * asynchronous test cases and when used with `verifySteps()`. + * * Together with the `verifySteps()` method, `step()` assertions give you an easy way * to verify both the count and order of code execution. - * + * * @param message Message to display for the step */ step(message: string): void; /** * A helper assertion to verify the order and number of steps in a test. - * + * * The assert.verifySteps() assertion compares a given array of string values (representing steps) * with the order and values of previous step() calls. This assertion is helpful for verifying * the order and count of portions of code paths, especially asynchronous ones. - * + * * @param steps Array of strings representing steps to verify * @param message A short description of the assertion */ verifySteps(steps: string[], message?: string): void; - + } interface Config { @@ -296,7 +296,7 @@ interface Hooks { /** * Runs after the last test. If additional tests are defined after the * module's queue has emptied, it will not run this hook again. - */ + */ after?: (assert: Assert) => void; /** @@ -320,7 +320,7 @@ interface NestedHooks { /** * Runs after the last test. If additional tests are defined after the * module's queue has emptied, it will not run this hook again. - */ + */ after: (fn: (assert: Assert) => void) => void; /** @@ -337,7 +337,7 @@ interface NestedHooks { * Runs before each test. */ beforeEach: (fn: (assert: Assert) => void) => void; - + } declare namespace QUnit { @@ -373,30 +373,30 @@ declare namespace QUnit { } interface QUnit { - + /** * Namespace for QUnit assertions - * + * * QUnit's built-in assertions are defined on the `QUnit.assert` object. An * instance of this object is passed as the only argument to the `QUnit.test` * function callback. - * + * * This object has properties for each of QUnit's built-in assertion methods. */ assert: Assert; /** * Register a callback to fire whenever the test suite begins. - * + * * `QUnit.begin()` is called once before running any tests. - * + * * @callback callback Callback to execute. */ begin(callback: (details: QUnit.BeginDetails) => void): void; /** * Configuration for QUnit - * + * * QUnit has a bunch of internal configuration defaults, some of which are * useful to override. Check the description for each option for details. */ @@ -404,23 +404,23 @@ interface QUnit { /** * Register a callback to fire whenever the test suite ends. - * + * * @param callback Callback to execute */ done(callback: (details: QUnit.DoneDetails) => void): void; /** * Advanced and extensible data dumping for JavaScript. - * + * * This method does string serialization by parsing data structures and * objects. It parses DOM elements to a string representation of their outer * HTML. By default, nested structures will be displayed up to five levels * deep. Anything beyond that is replaced by `[object Object]` and * `[object Array]` placeholders. - * + * * If you need more or less output, change the value of `QUnit.dump.maxDepth`, * representing how deep the elements should be parsed. - * + * * Note: This method used to be in QUnit.jsDump, which was changed to * QUnit.dump. The old property will be removed in QUnit 3.0. */ @@ -431,12 +431,12 @@ interface QUnit { /** * Copy the properties defined by the `mixin` object into the `target` object. - * + * * This method will modify the `target` object to contain the "own" properties * defined by the `mixin`. If the `mixin` object specifies the value of any * attribute as undefined, this property will instead be removed from the * `target` object. - * + * * @param target An object whose properties are to be modified * @param mixin An object describing which properties should be modified */ @@ -444,12 +444,12 @@ interface QUnit { /** * 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 + * + * @param callback Callback to execute */ log(callback: (details: QUnit.LogDetails) => void): void; @@ -457,36 +457,36 @@ interface QUnit { * Group related tests under a single label. * * You can use the module name to organize, select, and filter tests to run. - * + * * All tests inside a module callback function will be grouped into that * module. The test names will all be preceded by the module name in the * test results. Other modules can be nested inside this callback function, * where their tests' names will be labeled by their names recursively * prefixed by their parent modules. - * + * * If `QUnit.module` is defined without a `nested` callback argument, all * subsequently defined tests will be grouped into the module until another * module is defined. - * + * * Modules with test group functions allow you to define nested modules, and * QUnit will run tests on the parent module before going deep on the nested * ones, even if they're declared first. Additionally, any hook callbacks on * a parent module will wrap the hooks on a nested module. In other words, * `before` and `beforeEach` callbacks will form a queue while the * `afterEach` and `after` callbacks will form a stack. - * + * * You can specify code to run before and after tests using the hooks * argument, and also to create properties that will be shared on the * testing context. Any additional properties on the `hooks` object will be * added to that context. The `hooks` argument is still optional if you call * `QUnit.module` with a callback argument. - * + * * The module's callback is invoked with the test environment as its `this` * context, with the environment's properties copied to the module's tests, * hooks, and nested modules. Note that changes on tests' `this` are not * preserved between sibling tests, where `this` will be reset to the initial * value for each test. - * + * * @param {string} name Label for this group of tests * @param hookds Callbacks to run during test execution * @param nested A callback with grouped tests and nested modules to run under the current module label @@ -496,31 +496,31 @@ interface QUnit { /** * Register a callback to fire whenever a module ends. - * + * * @param callback Callback to execute */ moduleDone(callback: (details: QUnit.ModuleDoneDetails) => void): void; /** * Register a callback to fire whenever a module begins. - * + * * @param callback Callback to execute */ moduleStart(callback: (details: QUnit.ModuleStartDetails) => void): void; /** * Adds a test to exclusively run, preventing all other tests from running. - * + * * Use this method to focus your test suite on a specific test. QUnit.only * will cause any other tests in your suite to be ignored. - * + * * Note, that if more than one QUnit.only is present only the first instance * will run. - * + * * This is an alternative to filtering tests to run in the HTML reporter. It * is especially useful when you use a console reporter or in a codebase * with a large set of long running tests. - * + * * @param {string} name Title of unit being tested * @param callback Function to close over assertions */ @@ -528,48 +528,48 @@ interface QUnit { /** * DEPRECATED: Report the result of a custom assertion. - * + * * This method is deprecated and it's recommended to use pushResult on its * direct reference in the assertion context. - * + * * QUnit.push reflects to the current running test, and it may leak * assertions in asynchronous mode. Checkout assert.pushResult() to set a * proper custom assertion. - * + * * Invoking QUnit.push allows to create a readable expectation that is not * defined by any of QUnit's built-in assertions. - * + * * @deprecated */ push(result: boolean, actual: any, expected: any, message: string): void; /** * Adds a test like object to be skipped. - * + * * Use this method to replace QUnit.test() instead of commenting out entire * tests. - * + * * This test's prototype will be listed on the suite as a skipped test, * ignoring the callback argument and the respective global and module's * hooks. - * + * * @param {string} Title of unit being tested */ skip(name: string, callback?: (assert: Assert) => void): void; /** * Returns a single line string representing the stacktrace (call stack). - * + * * This method returns a single line string representing the stacktrace from * where it was called. According to its offset argument, `QUnit.stack()` will * return the correspondent line from the call stack. - * + * * The default `offset` is `0` and will return the current location where it * was called. - * + * * Not all browsers support retrieving stracktraces. In those, `QUnit.stack()` * will return undefined. - * + * * @param {number} offset Set the stacktrace line offset. */ stack(offset?: number): string; @@ -577,10 +577,10 @@ interface QUnit { /** * `QUnit.start()` must be used to start a test run that has * `QUnit.config.autostart` set to `false`. - * + * * This method was previously used to control async tests on text contexts * along with QUnit.stop. For asynchronous tests, use assert.async instead. - * + * * When your async test has multiple exit points, call `QUnit.start()` for the * corresponding number of `QUnit.stop()` increments. */ @@ -588,16 +588,16 @@ interface QUnit { /** * Add a test to run. - * + * * Add a test to run using `QUnit.test()`. - * + * * The `assert` argument to the callback contains all of QUnit's assertion * methods. Use this argument to call your test assertions. * * `QUnit.test()` can automatically handle the asynchronous resolution of a * Promise on your behalf if you return a thenable Promise as the result of * your callback function. - * + * * @param {string} Title of unit being tested * @param callback Function to close over assertions */ @@ -605,7 +605,7 @@ interface QUnit { /** * Register a callback to fire whenever a test ends. - * + * * @param callback Callback to execute */ testDone(callback: (details: { @@ -619,7 +619,7 @@ interface QUnit { /** * Register a callback to fire whenever a test begins. - * + * * @param callback Callback to execute */ testStart(callback: (details: QUnit.TestStartDetails) => void): void; @@ -649,7 +649,7 @@ interface QUnit { /** * Are the test running from the server or not. - */ + */ isLocal: boolean; /**