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

test: refactor assert test · nodejs/node@5478746 · GitHub

/ node Public

Commit 5478746

Browse files
BridgeAR
authored and
MylesBorins
committed
test: refactor assert test
This adds puctiations to the comments, uses a capital letters for the first character, removes a few obsolete comments and switches to assert.ok when suitable. It also moves all `assert.deepEqual()` and `assert.deepStrictEqual()` tests to the appropriate file. Backport-PR-URL: #19244 PR-URL: #18610 Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
1 parent 4e9279d commit 5478746

2 files changed

Lines changed: 345 additions & 383 deletions

File tree

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

Lines changed: 297 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,9 @@
11
'use strict';
2+
23
const common = require('../common');
34
const assert = require('assert');
45
const util = require('util');
6+
const { AssertionError } = assert;
57

68
// Template tag function turning an error message into a RegExp
79
// for assert.throws()
@@ -25,7 +27,7 @@ function re(literals, ...values) {
2527
// That is why we discourage using deepEqual in our own tests.
2628

2729
// Turn off no-restricted-properties because we are testing deepEqual!
28-
/* eslint-disable no-restricted-properties */
30+
/* eslint-disable no-restricted-properties, prefer-common-expectserror */
2931

3032
const arr = new Uint8Array([120, 121, 122, 10]);
3133
const buf = Buffer.from(arr);
@@ -545,4 +547,298 @@ assertDeepAndStrictEqual(-0, -0);
545547
assertDeepAndStrictEqual(a, b);
546548
}
547549

550+
assert.doesNotThrow(
551+
() => assert.deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)),
552+
'deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))');
553+
554+
assert.throws(() => assert.deepEqual(new Date(), new Date(2000, 3, 14)),
555+
AssertionError,
556+
'deepEqual(new Date(), new Date(2000, 3, 14))');
557+
558+
assert.throws(
559+
() => assert.notDeepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)),
560+
AssertionError,
561+
'notDeepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))'
562+
);
563+
564+
assert.doesNotThrow(
565+
() => assert.notDeepEqual(new Date(), new Date(2000, 3, 14)),
566+
'notDeepEqual(new Date(), new Date(2000, 3, 14))'
567+
);
568+
569+
assert.deepEqual(/a/, /a/);
570+
assert.deepEqual(/a/g, /a/g);
571+
assert.deepEqual(/a/i, /a/i);
572+
assert.deepEqual(/a/m, /a/m);
573+
assert.deepEqual(/a/igm, /a/igm);
574+
common.expectsError(() => assert.deepEqual(/ab/, /a/),
575+
{
576+
code: 'ERR_ASSERTION',
577+
name: 'AssertionError [ERR_ASSERTION]',
578+
message: '/ab/ deepEqual /a/'
579+
});
580+
common.expectsError(() => assert.deepEqual(/a/g, /a/),
581+
{
582+
code: 'ERR_ASSERTION',
583+
name: 'AssertionError [ERR_ASSERTION]',
584+
message: '/a/g deepEqual /a/'
585+
});
586+
common.expectsError(() => assert.deepEqual(/a/i, /a/),
587+
{
588+
code: 'ERR_ASSERTION',
589+
name: 'AssertionError [ERR_ASSERTION]',
590+
message: '/a/i deepEqual /a/'
591+
});
592+
common.expectsError(() => assert.deepEqual(/a/m, /a/),
593+
{
594+
code: 'ERR_ASSERTION',
595+
name: 'AssertionError [ERR_ASSERTION]',
596+
message: '/a/m deepEqual /a/'
597+
});
598+
common.expectsError(() => assert.deepEqual(/a/igm, /a/im),
599+
{
600+
code: 'ERR_ASSERTION',
601+
name: 'AssertionError [ERR_ASSERTION]',
602+
message: '/a/gim deepEqual /a/im'
603+
});
604+
605+
{
606+
const re1 = /a/g;
607+
re1.lastIndex = 3;
608+
assert.doesNotThrow(() => assert.deepEqual(re1, /a/g));
609+
}
610+
611+
assert.doesNotThrow(() => assert.deepEqual(4, '4'), 'deepEqual(4, \'4\')');
612+
assert.doesNotThrow(() => assert.deepEqual(true, 1), 'deepEqual(true, 1)');
613+
assert.throws(() => assert.deepEqual(4, '5'),
614+
AssertionError,
615+
'deepEqual( 4, \'5\')');
616+
617+
// Having the same number of owned properties && the same set of keys.
618+
assert.doesNotThrow(() => assert.deepEqual({ a: 4 }, { a: 4 }));
619+
assert.doesNotThrow(() => assert.deepEqual({ a: 4, b: '2' }, { a: 4, b: '2' }));
620+
assert.doesNotThrow(() => assert.deepEqual([4], ['4']));
621+
assert.throws(
622+
() => assert.deepEqual({ a: 4 }, { a: 4, b: true }), AssertionError);
623+
assert.doesNotThrow(() => assert.deepEqual(['a'], { 0: 'a' }));
624+
assert.doesNotThrow(() => assert.deepEqual({ a: 4, b: '1' }, { b: '1', a: 4 }));
625+
const a1 = [1, 2, 3];
626+
const a2 = [1, 2, 3];
627+
a1.a = 'test';
628+
a1.b = true;
629+
a2.b = true;
630+
a2.a = 'test';
631+
assert.throws(() => assert.deepEqual(Object.keys(a1), Object.keys(a2)),
632+
AssertionError);
633+
assert.doesNotThrow(() => assert.deepEqual(a1, a2));
634+
635+
// Having an identical prototype property.
636+
const nbRoot = {
637+
toString() { return `${this.first} ${this.last}`; }
638+
};
639+
640+
function nameBuilder(first, last) {
641+
this.first = first;
642+
this.last = last;
643+
return this;
644+
}
645+
nameBuilder.prototype = nbRoot;
646+
647+
function nameBuilder2(first, last) {
648+
this.first = first;
649+
this.last = last;
650+
return this;
651+
}
652+
nameBuilder2.prototype = nbRoot;
653+
654+
const nb1 = new nameBuilder('Ryan', 'Dahl');
655+
let nb2 = new nameBuilder2('Ryan', 'Dahl');
656+
657+
assert.doesNotThrow(() => assert.deepEqual(nb1, nb2));
658+
659+
nameBuilder2.prototype = Object;
660+
nb2 = new nameBuilder2('Ryan', 'Dahl');
661+
assert.doesNotThrow(() => assert.deepEqual(nb1, nb2));
662+
663+
// Primitives and object.
664+
assert.throws(() => assert.deepEqual(null, {}), AssertionError);
665+
assert.throws(() => assert.deepEqual(undefined, {}), AssertionError);
666+
assert.throws(() => assert.deepEqual('a', ['a']), AssertionError);
667+
assert.throws(() => assert.deepEqual('a', { 0: 'a' }), AssertionError);
668+
assert.throws(() => assert.deepEqual(1, {}), AssertionError);
669+
assert.throws(() => assert.deepEqual(true, {}), AssertionError);
670+
assert.throws(() => assert.deepEqual(Symbol(), {}), AssertionError);
671+
672+
// Primitive wrappers and object.
673+
assert.doesNotThrow(() => assert.deepEqual(new String('a'), ['a']),
674+
AssertionError);
675+
assert.doesNotThrow(() => assert.deepEqual(new String('a'), { 0: 'a' }),
676+
AssertionError);
677+
assert.doesNotThrow(() => assert.deepEqual(new Number(1), {}), AssertionError);
678+
assert.doesNotThrow(() => assert.deepEqual(new Boolean(true), {}),
679+
AssertionError);
680+
681+
// Same number of keys but different key names.
682+
assert.throws(() => assert.deepEqual({ a: 1 }, { b: 1 }), AssertionError);
683+
684+
assert.doesNotThrow(
685+
() => assert.deepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)),
686+
'deepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))'
687+
);
688+
689+
assert.throws(
690+
() => assert.deepStrictEqual(new Date(), new Date(2000, 3, 14)),
691+
AssertionError,
692+
'deepStrictEqual(new Date(), new Date(2000, 3, 14))'
693+
);
694+
695+
assert.throws(
696+
() => assert.notDeepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)),
697+
AssertionError,
698+
'notDeepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))'
699+
);
700+
701+
assert.doesNotThrow(
702+
() => assert.notDeepStrictEqual(new Date(), new Date(2000, 3, 14)),
703+
'notDeepStrictEqual(new Date(), new Date(2000, 3, 14))'
704+
);
705+
706+
assert.deepStrictEqual(/a/, /a/);
707+
assert.deepStrictEqual(/a/g, /a/g);
708+
assert.deepStrictEqual(/a/i, /a/i);
709+
assert.deepStrictEqual(/a/m, /a/m);
710+
assert.deepStrictEqual(/a/igm, /a/igm);
711+
common.expectsError(
712+
() => assert.deepStrictEqual(/ab/, /a/),
713+
{
714+
code: 'ERR_ASSERTION',
715+
name: 'AssertionError [ERR_ASSERTION]',
716+
message: '/ab/ deepStrictEqual /a/'
717+
});
718+
common.expectsError(
719+
() => assert.deepStrictEqual(/a/g, /a/),
720+
{
721+
code: 'ERR_ASSERTION',
722+
name: 'AssertionError [ERR_ASSERTION]',
723+
message: '/a/g deepStrictEqual /a/'
724+
});
725+
common.expectsError(
726+
() => assert.deepStrictEqual(/a/i, /a/),
727+
{
728+
code: 'ERR_ASSERTION',
729+
name: 'AssertionError [ERR_ASSERTION]',
730+
message: '/a/i deepStrictEqual /a/'
731+
});
732+
common.expectsError(
733+
() => assert.deepStrictEqual(/a/m, /a/),
734+
{
735+
code: 'ERR_ASSERTION',
736+
name: 'AssertionError [ERR_ASSERTION]',
737+
message: '/a/m deepStrictEqual /a/'
738+
});
739+
common.expectsError(
740+
() => assert.deepStrictEqual(/a/igm, /a/im),
741+
{
742+
code: 'ERR_ASSERTION',
743+
name: 'AssertionError [ERR_ASSERTION]',
744+
message: '/a/gim deepStrictEqual /a/im'
745+
});
746+
747+
{
748+
const re1 = /a/;
749+
re1.lastIndex = 3;
750+
assert.doesNotThrow(() => assert.deepStrictEqual(re1, /a/));
751+
}
752+
753+
assert.throws(() => assert.deepStrictEqual(4, '4'),
754+
AssertionError,
755+
'deepStrictEqual(4, \'4\')');
756+
757+
assert.throws(() => assert.deepStrictEqual(true, 1),
758+
AssertionError,
759+
'deepStrictEqual(true, 1)');
760+
761+
assert.throws(() => assert.deepStrictEqual(4, '5'),
762+
AssertionError,
763+
'deepStrictEqual(4, \'5\')');
764+
765+
// Having the same number of owned properties && the same set of keys.
766+
assert.deepStrictEqual({ a: 4 }, { a: 4 });
767+
assert.deepStrictEqual({ a: 4, b: '2' }, { a: 4, b: '2' });
768+
common.expectsError(() => assert.deepStrictEqual([4], ['4']),
769+
{
770+
code: 'ERR_ASSERTION',
771+
name: 'AssertionError [ERR_ASSERTION]',
772+
message: "[ 4 ] deepStrictEqual [ '4' ]"
773+
});
774+
common.expectsError(() => assert.deepStrictEqual({ a: 4 }, { a: 4, b: true }),
775+
{
776+
code: 'ERR_ASSERTION',
777+
name: 'AssertionError [ERR_ASSERTION]',
778+
message: '{ a: 4 } deepStrictEqual { a: 4, b: true }'
779+
});
780+
common.expectsError(() => assert.deepStrictEqual(['a'], { 0: 'a' }),
781+
{
782+
code: 'ERR_ASSERTION',
783+
name: 'AssertionError [ERR_ASSERTION]',
784+
message: "[ 'a' ] deepStrictEqual { '0': 'a' }"
785+
});
786+
548787
/* eslint-enable */
788+
789+
assert.doesNotThrow(
790+
() => assert.deepStrictEqual({ a: 4, b: '1' }, { b: '1', a: 4 }));
791+
792+
assert.throws(
793+
() => assert.deepStrictEqual([0, 1, 2, 'a', 'b'], [0, 1, 2, 'b', 'a']),
794+
AssertionError);
795+
796+
assert.doesNotThrow(() => assert.deepStrictEqual(a1, a2));
797+
798+
// Prototype check.
799+
function Constructor1(first, last) {
800+
this.first = first;
801+
this.last = last;
802+
}
803+
804+
function Constructor2(first, last) {
805+
this.first = first;
806+
this.last = last;
807+
}
808+
809+
const obj1 = new Constructor1('Ryan', 'Dahl');
810+
let obj2 = new Constructor2('Ryan', 'Dahl');
811+
812+
assert.throws(() => assert.deepStrictEqual(obj1, obj2), AssertionError);
813+
814+
Constructor2.prototype = Constructor1.prototype;
815+
obj2 = new Constructor2('Ryan', 'Dahl');
816+
817+
assert.doesNotThrow(() => assert.deepStrictEqual(obj1, obj2));
818+
819+
// primitives
820+
assert.throws(() => assert.deepStrictEqual(4, '4'), AssertionError);
821+
assert.throws(() => assert.deepStrictEqual(true, 1), AssertionError);
822+
assert.throws(() => assert.deepStrictEqual(Symbol(), Symbol()),
823+
AssertionError);
824+
825+
const s = Symbol();
826+
assert.doesNotThrow(() => assert.deepStrictEqual(s, s));
827+
828+
// Primitives and object.
829+
assert.throws(() => assert.deepStrictEqual(null, {}), AssertionError);
830+
assert.throws(() => assert.deepStrictEqual(undefined, {}), AssertionError);
831+
assert.throws(() => assert.deepStrictEqual('a', ['a']), AssertionError);
832+
assert.throws(() => assert.deepStrictEqual('a', { 0: 'a' }), AssertionError);
833+
assert.throws(() => assert.deepStrictEqual(1, {}), AssertionError);
834+
assert.throws(() => assert.deepStrictEqual(true, {}), AssertionError);
835+
assert.throws(() => assert.deepStrictEqual(Symbol(), {}), AssertionError);
836+
837+
// Primitive wrappers and object.
838+
assert.throws(() => assert.deepStrictEqual(new String('a'), ['a']),
839+
AssertionError);
840+
assert.throws(() => assert.deepStrictEqual(new String('a'), { 0: 'a' }),
841+
AssertionError);
842+
assert.throws(() => assert.deepStrictEqual(new Number(1), {}), AssertionError);
843+
assert.throws(() => assert.deepStrictEqual(new Boolean(true), {}),
844+
AssertionError);

0 commit comments

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