Skip to content

Commit 1d859ef

Browse files
BridgeARBridgeAR
committed
assert: improve loose assertion message
So far the error message from a loose assertion is not always very informative and could be misleading. This is fixed by: * showing more from the actual error message * having a better error description * not using custom inspection * inspecting a higher depth * inspecting the full array instead of up to 100 entries PR-URL: #22155 Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
1 parent 566d11a commit 1d859ef

File tree

2 files changed

+88
-110
lines changed

2 files changed

+88
-110
lines changed

‎lib/internal/assert.js

+34-13
Original file line numberDiff line numberDiff line change
@@ -12,9 +12,13 @@ let white = '';
1212

1313
const kReadableOperator = {
1414
deepStrictEqual: 'Expected inputs to be strictly deep-equal:',
15-
notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
1615
strictEqual: 'Expected inputs to be strictly equal:',
16+
deepEqual: 'Expected inputs to be loosely deep-equal:',
17+
equal: 'Expected inputs to be loosely equal:',
18+
notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
1719
notStrictEqual: 'Expected "actual" to be strictly unequal to:',
20+
notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
21+
notEqual: 'Expected "actual" to be loosely unequal to:',
1822
notIdentical: 'Inputs identical but not reference equal:',
1923
};
2024

@@ -50,7 +54,7 @@ function inspectValue(val) {
5054
// Assert does not detect proxies currently.
5155
showProxy: false
5256
}
53-
).split('\n');
57+
);
5458
}
5559

5660
function createErrDiff(actual, expected, operator) {
@@ -59,8 +63,9 @@ function createErrDiff(actual, expected, operator) {
5963
let lastPos = 0;
6064
let end = '';
6165
let skipped = false;
62-
const actualLines = inspectValue(actual);
63-
const expectedLines = inspectValue(expected);
66+
const actualInspected = inspectValue(actual);
67+
const actualLines = actualInspected.split('\n');
68+
const expectedLines = inspectValue(expected).split('\n');
6469
const msg = kReadableOperator[operator] +
6570
`\n${green}+ actual${white} ${red}- expected${white}`;
6671
const skippedMsg = ` ${blue}...${white} Lines skipped`;
@@ -126,7 +131,7 @@ function createErrDiff(actual, expected, operator) {
126131
// E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })
127132
if (maxLines === 0) {
128133
// We have to get the result again. The lines were all removed before.
129-
const actualLines = inspectValue(actual);
134+
const actualLines = actualInspected.split('\n');
130135

131136
// Only remove lines in case it makes sense to collapse those.
132137
// TODO: Accept env to always show the full error.
@@ -268,7 +273,7 @@ class AssertionError extends Error {
268273
operator === 'notStrictEqual') {
269274
// In case the objects are equal but the operator requires unequal, show
270275
// the first object and say A equals B
271-
const res = inspectValue(actual);
276+
const res = inspectValue(actual).split('\n');
272277
const base = kReadableOperator[operator];
273278

274279
// Only remove lines in case it makes sense to collapse those.
@@ -287,13 +292,29 @@ class AssertionError extends Error {
287292
super(`${base}\n\n${res.join('\n')}\n`);
288293
}
289294
} else {
290-
let res = inspect(actual);
291-
let other = inspect(expected);
292-
if (res.length > 128)
293-
res = `${res.slice(0, 125)}...`;
294-
if (other.length > 128)
295-
other = `${other.slice(0, 125)}...`;
296-
super(`${res} ${operator} ${other}`);
295+
let res = inspectValue(actual);
296+
let other = '';
297+
const knownOperators = kReadableOperator[operator];
298+
if (operator === 'notDeepEqual' || operator === 'notEqual') {
299+
res = `${kReadableOperator[operator]}\n\n${res}`;
300+
if (res.length > 1024) {
301+
res = `${res.slice(0, 1021)}...`;
302+
}
303+
} else {
304+
other = `${inspectValue(expected)}`;
305+
if (res.length > 512) {
306+
res = `${res.slice(0, 509)}...`;
307+
}
308+
if (other.length > 512) {
309+
other = `${other.slice(0, 509)}...`;
310+
}
311+
if (operator === 'deepEqual' || operator === 'equal') {
312+
res = `${knownOperators}\n\n${res}\n\nshould equal\n\n`;
313+
} else {
314+
other = ` ${operator} ${other}`;
315+
}
316+
}
317+
super(`${res}${other}`);
297318
}
298319
}
299320

‎test/parallel/test-assert-deep.js

+54-97
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
'use strict';
22

3-
const common = require('../common');
3+
require('../common');
44
const assert = require('assert');
55
const util = require('util');
66
const { AssertionError } = assert;
@@ -16,18 +16,23 @@ if (process.stdout.isTTY)
1616
// Template tag function turning an error message into a RegExp
1717
// for assert.throws()
1818
function re(literals, ...values) {
19-
let result = literals[0];
20-
const escapeRE = /[\\^$.*+?()[\]{}|=!<>:-]/g;
19+
let result = 'Expected inputs to be loosely deep-equal:\n\n';
2120
for (const [i, value] of values.entries()) {
22-
const str = util.inspect(value);
21+
const str = util.inspect(value, {
22+
compact: false,
23+
depth: 1000,
24+
customInspect: false,
25+
maxArrayLength: Infinity,
26+
breakLength: Infinity
27+
});
2328
// Need to escape special characters.
24-
result += str.replace(escapeRE, '\\$&');
29+
result += str;
2530
result += literals[i + 1];
2631
}
27-
return common.expectsError({
32+
return {
2833
code: 'ERR_ASSERTION',
29-
message: new RegExp(`^${result}$`)
30-
});
34+
message: result
35+
};
3136
}
3237

3338
// The following deepEqual tests might seem very weird.
@@ -173,13 +178,6 @@ assert.throws(
173178
}
174179
}
175180

176-
common.expectsError(() => {
177-
assert.deepEqual(new Set([{ a: 0 }]), new Set([{ a: 1 }]));
178-
}, {
179-
code: 'ERR_ASSERTION',
180-
message: /^Set { { a: 0 } } deepEqual Set { { a: 1 } }$/
181-
});
182-
183181
function assertDeepAndStrictEqual(a, b) {
184182
assert.deepEqual(a, b);
185183
assert.deepStrictEqual(a, b);
@@ -189,13 +187,19 @@ function assertDeepAndStrictEqual(a, b) {
189187
}
190188

191189
function assertNotDeepOrStrict(a, b, err) {
192-
assert.throws(() => assert.deepEqual(a, b), err || re`${a} deepEqual ${b}`);
190+
assert.throws(
191+
() => assert.deepEqual(a, b),
192+
err || re`${a}\n\nshould equal\n\n${b}`
193+
);
193194
assert.throws(
194195
() => assert.deepStrictEqual(a, b),
195196
err || { code: 'ERR_ASSERTION' }
196197
);
197198

198-
assert.throws(() => assert.deepEqual(b, a), err || re`${b} deepEqual ${a}`);
199+
assert.throws(
200+
() => assert.deepEqual(b, a),
201+
err || re`${b}\n\nshould equal\n\n${a}`
202+
);
199203
assert.throws(
200204
() => assert.deepStrictEqual(b, a),
201205
err || { code: 'ERR_ASSERTION' }
@@ -225,6 +229,7 @@ assertNotDeepOrStrict(new Set([1, 2, 3]), new Set([1, 2, 3, 4]));
225229
assertNotDeepOrStrict(new Set([1, 2, 3, 4]), new Set([1, 2, 3]));
226230
assertDeepAndStrictEqual(new Set(['1', '2', '3']), new Set(['1', '2', '3']));
227231
assertDeepAndStrictEqual(new Set([[1, 2], [3, 4]]), new Set([[3, 4], [1, 2]]));
232+
assertNotDeepOrStrict(new Set([{ a: 0 }]), new Set([{ a: 1 }]));
228233

229234
{
230235
const a = [ 1, 2 ];
@@ -626,41 +631,16 @@ assert.throws(
626631

627632
assert.notDeepEqual(new Date(), new Date(2000, 3, 14));
628633

629-
assert.deepEqual(/a/, /a/);
630-
assert.deepEqual(/a/g, /a/g);
631-
assert.deepEqual(/a/i, /a/i);
632-
assert.deepEqual(/a/m, /a/m);
633-
assert.deepEqual(/a/igm, /a/igm);
634-
assert.throws(() => assert.deepEqual(/ab/, /a/),
635-
{
636-
code: 'ERR_ASSERTION',
637-
name: 'AssertionError [ERR_ASSERTION]',
638-
message: '/ab/ deepEqual /a/'
639-
});
640-
assert.throws(() => assert.deepEqual(/a/g, /a/),
641-
{
642-
code: 'ERR_ASSERTION',
643-
name: 'AssertionError [ERR_ASSERTION]',
644-
message: '/a/g deepEqual /a/'
645-
});
646-
assert.throws(() => assert.deepEqual(/a/i, /a/),
647-
{
648-
code: 'ERR_ASSERTION',
649-
name: 'AssertionError [ERR_ASSERTION]',
650-
message: '/a/i deepEqual /a/'
651-
});
652-
assert.throws(() => assert.deepEqual(/a/m, /a/),
653-
{
654-
code: 'ERR_ASSERTION',
655-
name: 'AssertionError [ERR_ASSERTION]',
656-
message: '/a/m deepEqual /a/'
657-
});
658-
assert.throws(() => assert.deepEqual(/a/igm, /a/im),
659-
{
660-
code: 'ERR_ASSERTION',
661-
name: 'AssertionError [ERR_ASSERTION]',
662-
message: '/a/gim deepEqual /a/im'
663-
});
634+
assertDeepAndStrictEqual(/a/, /a/);
635+
assertDeepAndStrictEqual(/a/g, /a/g);
636+
assertDeepAndStrictEqual(/a/i, /a/i);
637+
assertDeepAndStrictEqual(/a/m, /a/m);
638+
assertDeepAndStrictEqual(/a/igm, /a/igm);
639+
assertNotDeepOrStrict(/ab/, /a/);
640+
assertNotDeepOrStrict(/a/g, /a/);
641+
assertNotDeepOrStrict(/a/i, /a/);
642+
assertNotDeepOrStrict(/a/m, /a/);
643+
assertNotDeepOrStrict(/a/igm, /a/im);
664644

665645
{
666646
const re1 = /a/g;
@@ -720,23 +700,32 @@ nameBuilder2.prototype = Object;
720700
nb2 = new nameBuilder2('Ryan', 'Dahl');
721701
assert.deepEqual(nb1, nb2);
722702

723-
// Primitives and object.
724-
assert.throws(() => assert.deepEqual(null, {}), AssertionError);
725-
assert.throws(() => assert.deepEqual(undefined, {}), AssertionError);
726-
assert.throws(() => assert.deepEqual('a', ['a']), AssertionError);
727-
assert.throws(() => assert.deepEqual('a', { 0: 'a' }), AssertionError);
728-
assert.throws(() => assert.deepEqual(1, {}), AssertionError);
729-
assert.throws(() => assert.deepEqual(true, {}), AssertionError);
730-
assert.throws(() => assert.deepEqual(Symbol(), {}), AssertionError);
703+
// Primitives
704+
assertNotDeepOrStrict(null, {});
705+
assertNotDeepOrStrict(undefined, {});
706+
assertNotDeepOrStrict('a', ['a']);
707+
assertNotDeepOrStrict('a', { 0: 'a' });
708+
assertNotDeepOrStrict(1, {});
709+
assertNotDeepOrStrict(true, {});
710+
assertNotDeepOrStrict(Symbol(), {});
711+
assertNotDeepOrStrict(Symbol(), Symbol());
712+
713+
assertOnlyDeepEqual(4, '4');
714+
assertOnlyDeepEqual(true, 1);
715+
716+
{
717+
const s = Symbol();
718+
assertDeepAndStrictEqual(s, s);
719+
}
731720

732721
// Primitive wrappers and object.
733-
assert.deepEqual(new String('a'), ['a']);
734-
assert.deepEqual(new String('a'), { 0: 'a' });
735-
assert.deepEqual(new Number(1), {});
736-
assert.deepEqual(new Boolean(true), {});
722+
assertOnlyDeepEqual(new String('a'), ['a']);
723+
assertOnlyDeepEqual(new String('a'), { 0: 'a' });
724+
assertOnlyDeepEqual(new Number(1), {});
725+
assertOnlyDeepEqual(new Boolean(true), {});
737726

738727
// Same number of keys but different key names.
739-
assert.throws(() => assert.deepEqual({ a: 1 }, { b: 1 }), AssertionError);
728+
assertNotDeepOrStrict({ a: 1 }, { b: 1 });
740729

741730
assert.deepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14));
742731

@@ -757,11 +746,6 @@ assert.throws(
757746

758747
assert.notDeepStrictEqual(new Date(), new Date(2000, 3, 14));
759748

760-
assert.deepStrictEqual(/a/, /a/);
761-
assert.deepStrictEqual(/a/g, /a/g);
762-
assert.deepStrictEqual(/a/i, /a/i);
763-
assert.deepStrictEqual(/a/m, /a/m);
764-
assert.deepStrictEqual(/a/igm, /a/igm);
765749
assert.throws(
766750
() => assert.deepStrictEqual(/ab/, /a/),
767751
{
@@ -871,33 +855,6 @@ obj2 = new Constructor2('Ryan', 'Dahl');
871855

872856
assert.deepStrictEqual(obj1, obj2);
873857

874-
// primitives
875-
assert.throws(() => assert.deepStrictEqual(4, '4'), AssertionError);
876-
assert.throws(() => assert.deepStrictEqual(true, 1), AssertionError);
877-
assert.throws(() => assert.deepStrictEqual(Symbol(), Symbol()),
878-
AssertionError);
879-
880-
const s = Symbol();
881-
assert.deepStrictEqual(s, s);
882-
883-
// Primitives and object.
884-
assert.throws(() => assert.deepStrictEqual(null, {}), AssertionError);
885-
assert.throws(() => assert.deepStrictEqual(undefined, {}), AssertionError);
886-
assert.throws(() => assert.deepStrictEqual('a', ['a']), AssertionError);
887-
assert.throws(() => assert.deepStrictEqual('a', { 0: 'a' }), AssertionError);
888-
assert.throws(() => assert.deepStrictEqual(1, {}), AssertionError);
889-
assert.throws(() => assert.deepStrictEqual(true, {}), AssertionError);
890-
assert.throws(() => assert.deepStrictEqual(Symbol(), {}), AssertionError);
891-
892-
// Primitive wrappers and object.
893-
assert.throws(() => assert.deepStrictEqual(new String('a'), ['a']),
894-
AssertionError);
895-
assert.throws(() => assert.deepStrictEqual(new String('a'), { 0: 'a' }),
896-
AssertionError);
897-
assert.throws(() => assert.deepStrictEqual(new Number(1), {}), AssertionError);
898-
assert.throws(() => assert.deepStrictEqual(new Boolean(true), {}),
899-
AssertionError);
900-
901858
// Check extra properties on errors.
902859
{
903860
const a = new TypeError('foo');

0 commit comments

Comments
 (0)