FazBrowse GitHub Viewer | Trending |
URL:
| Home
Tools: [Download Repo ZIP]   [Original HTTPS Page]

typings: add JSDoc typings for assert · nodejs/node@82d5988 · GitHub

/ node Public

Commit 82d5988

Browse files
VoltrexKeyva
authored and
targos
committed
typings: add JSDoc typings for assert
PR-URL: #38188 Reviewed-By: Bradley Farias <bradley.meck@gmail.com> Reviewed-By: Michaël Zasso <targos@protonmail.com>
1 parent c3a5e15 commit 82d5988

1 file changed

Lines changed: 123 additions & 8 deletions

File tree

‎lib/assert.js‎

Lines changed: 123 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -123,6 +123,14 @@ function innerFail(obj) {
123123
throw new AssertionError(obj);
124124
}
125125

126+
/**
127+
* @param {any} actual
128+
* @param {any} expected
129+
* @param {string | Error} [message]
130+
* @param {string} [operator]
131+
* @param {Function} [stackStartFn]
132+
* @returns {never}
133+
*/
126134
function fail(actual, expected, message, operator, stackStartFn) {
127135
const argsLen = arguments.length;
128136

@@ -405,14 +413,24 @@ function innerOk(fn, argLen, value, message) {
405413
}
406414
}
407415

408-
// Pure assertion tests whether a value is truthy, as determined
409-
// by !!value.
416+
/**
417+
* Pure assertion tests whether a value is truthy, as determined
418+
* by !!value.
419+
* @param {...any} args
420+
* @returns {void}
421+
*/
410422
function ok(...args) {
411423
innerOk(ok, args.length, ...args);
412424
}
413425
assert.ok = ok;
414426

415-
// The equality assertion tests shallow, coercive equality with ==.
427+
/**
428+
* The equality assertion tests shallow, coercive equality with ==.
429+
* @param {any} actual
430+
* @param {any} expected
431+
* @param {string | Error} [message]
432+
* @returns {void}
433+
*/
416434
/* eslint-disable no-restricted-properties */
417435
assert.equal = function equal(actual, expected, message) {
418436
if (arguments.length < 2) {
@@ -430,8 +448,14 @@ assert.equal = function equal(actual, expected, message) {
430448
}
431449
};
432450

433-
// The non-equality assertion tests for whether two objects are not
434-
// equal with !=.
451+
/**
452+
* The non-equality assertion tests for whether two objects are not
453+
* equal with !=.
454+
* @param {any} actual
455+
* @param {any} expected
456+
* @param {string | Error} [message]
457+
* @returns {void}
458+
*/
435459
assert.notEqual = function notEqual(actual, expected, message) {
436460
if (arguments.length < 2) {
437461
throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -448,7 +472,13 @@ assert.notEqual = function notEqual(actual, expected, message) {
448472
}
449473
};
450474

451-
// The equivalence assertion tests a deep equality relation.
475+
/**
476+
* The deep equivalence assertion tests a deep equality relation.
477+
* @param {any} actual
478+
* @param {any} expected
479+
* @param {string | Error} [message]
480+
* @returns {void}
481+
*/
452482
assert.deepEqual = function deepEqual(actual, expected, message) {
453483
if (arguments.length < 2) {
454484
throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -465,7 +495,13 @@ assert.deepEqual = function deepEqual(actual, expected, message) {
465495
}
466496
};
467497

468-
// The non-equivalence assertion tests for any deep inequality.
498+
/**
499+
* The deep non-equivalence assertion tests for any deep inequality.
500+
* @param {any} actual
501+
* @param {any} expected
502+
* @param {string | Error} [message]
503+
* @returns {void}
504+
*/
469505
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
470506
if (arguments.length < 2) {
471507
throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -483,6 +519,14 @@ assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
483519
};
484520
/* eslint-enable */
485521

522+
/**
523+
* The deep strict equivalence assertion tests a deep strict equality
524+
* relation.
525+
* @param {any} actual
526+
* @param {any} expected
527+
* @param {string | Error} [message]
528+
* @returns {void}
529+
*/
486530
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
487531
if (arguments.length < 2) {
488532
throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -499,6 +543,14 @@ assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
499543
}
500544
};
501545

546+
/**
547+
* The deep strict non-equivalence assertion tests for any deep strict
548+
* inequality.
549+
* @param {any} actual
550+
* @param {any} expected
551+
* @param {string | Error} [message]
552+
* @returns {void}
553+
*/
502554
assert.notDeepStrictEqual = notDeepStrictEqual;
503555
function notDeepStrictEqual(actual, expected, message) {
504556
if (arguments.length < 2) {
@@ -516,6 +568,13 @@ function notDeepStrictEqual(actual, expected, message) {
516568
}
517569
}
518570

571+
/**
572+
* The strict equivalence assertion tests a strict equality relation.
573+
* @param {any} actual
574+
* @param {any} expected
575+
* @param {string | Error} [message]
576+
* @returns {void}
577+
*/
519578
assert.strictEqual = function strictEqual(actual, expected, message) {
520579
if (arguments.length < 2) {
521580
throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -531,6 +590,13 @@ assert.strictEqual = function strictEqual(actual, expected, message) {
531590
}
532591
};
533592

593+
/**
594+
* The strict non-equivalence assertion tests for any strict inequality.
595+
* @param {any} actual
596+
* @param {any} expected
597+
* @param {string | Error} [message]
598+
* @returns {void}
599+
*/
534600
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
535601
if (arguments.length < 2) {
536602
throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -839,22 +905,51 @@ function expectsNoError(stackStartFn, actual, error, message) {
839905
throw actual;
840906
}
841907

908+
/**
909+
* Expects the function `promiseFn` to throw an error.
910+
* @param {() => any} promiseFn
911+
* @param {...any} [args]
912+
* @returns {void}
913+
*/
842914
assert.throws = function throws(promiseFn, ...args) {
843915
expectsError(throws, getActual(promiseFn), ...args);
844916
};
845917

918+
/**
919+
* Expects `promiseFn` function or its value to reject.
920+
* @param {() => Promise<any>} promiseFn
921+
* @param {...any} [args]
922+
* @returns {Promise<void>}
923+
*/
846924
assert.rejects = async function rejects(promiseFn, ...args) {
847925
expectsError(rejects, await waitForActual(promiseFn), ...args);
848926
};
849927

928+
/**
929+
* Asserts that the function `fn` does not throw an error.
930+
* @param {() => any} fn
931+
* @param {...any} [args]
932+
* @returns {void}
933+
*/
850934
assert.doesNotThrow = function doesNotThrow(fn, ...args) {
851935
expectsNoError(doesNotThrow, getActual(fn), ...args);
852936
};
853937

938+
/**
939+
* Expects `fn` or its value to not reject.
940+
* @param {() => Promise<any>} fn
941+
* @param {...any} [args]
942+
* @returns {Promise<void>}
943+
*/
854944
assert.doesNotReject = async function doesNotReject(fn, ...args) {
855945
expectsNoError(doesNotReject, await waitForActual(fn), ...args);
856946
};
857947

948+
/**
949+
* Throws `value` if the value is not `null` or `undefined`.
950+
* @param {any} err
951+
* @returns {void}
952+
*/
858953
assert.ifError = function ifError(err) {
859954
if (err !== null && err !== undefined) {
860955
let message = 'ifError got unwanted exception: ';
@@ -939,24 +1034,44 @@ function internalMatch(string, regexp, message, fn) {
9391034
}
9401035
}
9411036

1037+
/**
1038+
* Expects the `string` input to match the regular expression.
1039+
* @param {string} string
1040+
* @param {RegExp} regexp
1041+
* @param {string | Error} [message]
1042+
* @returns {void}
1043+
*/
9421044
assert.match = function match(string, regexp, message) {
9431045
internalMatch(string, regexp, message, match);
9441046
};
9451047

1048+
/**
1049+
* Expects the `string` input not to match the regular expression.
1050+
* @param {string} string
1051+
* @param {RegExp} regexp
1052+
* @param {string | Error} [message]
1053+
* @returns {void}
1054+
*/
9461055
assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
9471056
internalMatch(string, regexp, message, doesNotMatch);
9481057
};
9491058

9501059
assert.CallTracker = CallTracker;
9511060

952-
// Expose a strict only variant of assert
1061+
/**
1062+
* Expose a strict only variant of assert.
1063+
* @param {...any} args
1064+
* @returns {void}
1065+
*/
9531066
function strict(...args) {
9541067
innerOk(strict, args.length, ...args);
9551068
}
1069+
9561070
assert.strict = ObjectAssign(strict, assert, {
9571071
equal: assert.strictEqual,
9581072
deepEqual: assert.deepStrictEqual,
9591073
notEqual: assert.notStrictEqual,
9601074
notDeepEqual: assert.notDeepStrictEqual
9611075
});
1076+
9621077
assert.strict.strict = assert.strict;

0 commit comments

Comments
 (0)
Back | FazBrowse Home | New Git URL