From f93555c8e494d8578179354db9b3ca8f0ba4c4b8 Mon Sep 17 00:00:00 2001
From: zhenweijin <zhenwei.jin@intel.com>
Date: Mon, 19 Feb 2024 17:02:12 +0800
Subject: [PATCH] assert: add deep equal check for more Error type

---
 doc/api/assert.md                 | 18 ++++++++++++++----
 lib/internal/util/comparisons.js  | 20 +++++++++++++++++---
 test/parallel/test-assert-deep.js | 23 +++++++++++++++++++++++
 3 files changed, 54 insertions(+), 7 deletions(-)

diff --git a/doc/api/assert.md b/doc/api/assert.md
index 92121c42f20a46..23c588a3d55cc8 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -555,6 +555,10 @@ An alias of [`assert.ok()`][].
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/51805
+    description: Error cause property is now compared as well, For AggregateError,
+                 errors property is also compared.
   - version: v18.0.0
     pr-url: https://github.com/nodejs/node/pull/41020
     description: Regular expressions lastIndex property is now compared as well.
@@ -621,8 +625,9 @@ are also recursively evaluated by the following rules.
   both sides are `NaN`.
 * [Type tags][Object.prototype.toString()] of objects should be the same.
 * Only [enumerable "own" properties][] are considered.
-* [`Error`][] names and messages are always compared, even if these are not
-  enumerable properties.
+* [`Error`][] names, messages and causes are always compared, even if these are
+  not enumerable properties. For `AggregateError`, non-enumerable property
+  `errors` is also compared.
 * [Object wrappers][] are compared both as objects and unwrapped values.
 * `Object` properties are compared unordered.
 * [`Map`][] keys and [`Set`][] items are compared unordered.
@@ -736,6 +741,10 @@ parameter is an instance of an [`Error`][] then it will be thrown instead of the
 <!-- YAML
 added: v1.2.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/51805
+    description: Error cause property is now compared as well, For AggregateError,
+                 errors property is also compared.
   - version: v18.0.0
     pr-url: https://github.com/nodejs/node/pull/41020
     description: Regular expressions lastIndex property is now compared as well.
@@ -783,8 +792,9 @@ are recursively evaluated also by the following rules.
 * [`[[Prototype]]`][prototype-spec] of objects are compared using
   the [`===` operator][].
 * Only [enumerable "own" properties][] are considered.
-* [`Error`][] names and messages are always compared, even if these are not
-  enumerable properties.
+* [`Error`][] names, messages and causes are always compared, even if these are
+  not enumerable properties. For `AggregateError`, non-enumerable property
+  `errors` is also compared.
 * Enumerable own [`Symbol`][] properties are compared as well.
 * [Object wrappers][] are compared both as objects and unwrapped values.
 * `Object` properties are compared unordered.
diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js
index f9354d01ce5730..f95ae7d81f19d5 100644
--- a/lib/internal/util/comparisons.js
+++ b/lib/internal/util/comparisons.js
@@ -235,9 +235,23 @@ function innerDeepEqual(val1, val2, strict, memos) {
   } else if (isNativeError(val1) || val1 instanceof Error) {
     // Do not compare the stack as it might differ even though the error itself
     // is otherwise identical.
-    if ((!isNativeError(val2) && !(val2 instanceof Error)) ||
-        val1.message !== val2.message ||
-        val1.name !== val2.name) {
+    if (!isNativeError(val2) && !(val2 instanceof Error)) {
+      return false;
+    }
+
+    const message1Enumerable = ObjectPrototypePropertyIsEnumerable(val1, 'message');
+    const name1Enumerable = ObjectPrototypePropertyIsEnumerable(val1, 'name');
+    const cause1Enumerable = ObjectPrototypePropertyIsEnumerable(val1, 'cause');
+    const errors1Enumerable = ObjectPrototypePropertyIsEnumerable(val1, 'errors');
+
+    if ((message1Enumerable !== ObjectPrototypePropertyIsEnumerable(val2, 'message') ||
+          (!message1Enumerable && val1.message !== val2.message)) ||
+        (name1Enumerable !== ObjectPrototypePropertyIsEnumerable(val2, 'name') ||
+          (!name1Enumerable && val1.name !== val2.name)) ||
+        (cause1Enumerable !== ObjectPrototypePropertyIsEnumerable(val2, 'cause') ||
+          (!cause1Enumerable && !innerDeepEqual(val1.cause, val2.cause, strict, memos))) ||
+        (errors1Enumerable !== ObjectPrototypePropertyIsEnumerable(val2, 'errors') ||
+         (!errors1Enumerable && !innerDeepEqual(val1.errors, val2.errors, strict, memos)))) {
       return false;
     }
   } else if (isBoxedPrimitive(val1)) {
diff --git a/test/parallel/test-assert-deep.js b/test/parallel/test-assert-deep.js
index f147be1b41f2a8..28f6bedfb8f54f 100644
--- a/test/parallel/test-assert-deep.js
+++ b/test/parallel/test-assert-deep.js
@@ -1111,6 +1111,29 @@ assert.throws(
   assert.notDeepStrictEqual(err, err2);
 }
 
+// Check for Errors with cause property
+{
+  const e1 = new Error('err', { cause: new Error('cause e1') });
+  const e2 = new Error('err', { cause: new Error('cause e2') });
+  assertNotDeepOrStrict(e1, e2, AssertionError);
+  assertNotDeepOrStrict(e1, new Error('err'), AssertionError);
+  assertDeepAndStrictEqual(e1, new Error('err', { cause: new Error('cause e1') }));
+}
+
+// Check for AggregateError
+{
+  const e1 = new Error('e1');
+  const e1duplicate = new Error('e1');
+  const e2 = new Error('e2');
+
+  const e3 = new AggregateError([e1duplicate, e2], 'Aggregate Error');
+  const e3duplicate = new AggregateError([e1, e2], 'Aggregate Error');
+  const e4 = new AggregateError([e1], 'Aggregate Error');
+  assertNotDeepOrStrict(e1, e3, AssertionError);
+  assertNotDeepOrStrict(e3, e4, AssertionError);
+  assertDeepAndStrictEqual(e3, e3duplicate);
+}
+
 // Verify that `valueOf` is not called for boxed primitives.
 {
   const a = new Number(5);