test_runner: add missing coverage for assertion prototype metadata

Author: inoway46

test/parallel/test-runner-v8-deserializer.mjs

@@ -8,6 +8,8 @@ import { DefaultSerializer } from 'node:v8';
 import serializer from 'internal/test_runner/reporter/v8-serializer';
 import runner from 'internal/test_runner/runner';
 
+class ExtendedArray extends Array {}
+
 async function toArray(chunks) {
   const arr = [];
   for await (const i of chunks) arr.push(i);
@@ -77,6 +79,26 @@ describe('v8 deserializer', common.mustCall(() => {
     ]);
   });
 
+  it('should restore assertion metadata without leaking internal transport fields', async () => {
+    let assertionError;
+    try {
+      assert.deepStrictEqual(new ExtendedArray('hello'), ['hello']);
+    } catch (error) {
+      assertionError = error;
+    }
+    assert(assertionError);
+
+    const [chunk] = await toArray(serializer([{
+      type: 'test:diagnostic',
+      data: { nesting: 0, details: { error: assertionError }, message: 'diagnostic' },
+    }]));
+
+    const reported = await collectReported([chunk]);
+    const detailError = reported[0].data.details.error;
+    assert.strictEqual(detailError.actual.constructor.name, 'ExtendedArray');
+    assert.strictEqual(Object.hasOwn(reported[0].data.details, 'assertionPrototypeMetadata'), false);
+  });
+
   const headerPosition = headerLength * 2 + 4;
   for (let i = 0; i < headerPosition + 5; i++) {
     const message = `should deserialize a serialized message split into two chunks {...${i},${i + 1}...}`;

test/sequential/test-runner-assertion-error-prototype.js

@@ -13,25 +13,79 @@ const {
 } = require('internal/test_runner/assertion_error_prototype');
 
 class ExtendedArray extends Array {}
+class ExtendedObject {
+  constructor(value) {
+    this.value = value;
+  }
+}
 
-function createAssertionError() {
+function createAssertionError(actual, expected) {
   try {
-    assert.deepStrictEqual(new ExtendedArray('hello'), ['hello']);
+    assert.deepStrictEqual(actual, expected);
   } catch (error) {
     return error;
   }
   assert.fail('Expected AssertionError');
 }
 
-const assertionError = createAssertionError();
-const assertionPrototypeMetadata = collectAssertionPrototypeMetadata(assertionError);
-assert.ok(assertionPrototypeMetadata);
-assert.strictEqual(assertionPrototypeMetadata.actual.constructorName, 'ExtendedArray');
+const arrayAssertionError = createAssertionError(new ExtendedArray('hello'), ['hello']);
+const arrayPrototypeMetadata = collectAssertionPrototypeMetadata(arrayAssertionError);
+assert.ok(arrayPrototypeMetadata);
+assert.strictEqual(arrayPrototypeMetadata.actual.constructorName, 'ExtendedArray');
 
-const defaultSerializedError = deserializeError(serializeError(assertionError));
-assert.strictEqual(defaultSerializedError.actual.constructor.name, 'Array');
+const defaultSerializedArrayError = deserializeError(serializeError(arrayAssertionError));
+assert.strictEqual(defaultSerializedArrayError.actual.constructor.name, 'Array');
 
-applyAssertionPrototypeMetadata(defaultSerializedError, assertionPrototypeMetadata);
+applyAssertionPrototypeMetadata(defaultSerializedArrayError, arrayPrototypeMetadata);
 // Must be idempotent when metadata application is triggered more than once.
-applyAssertionPrototypeMetadata(defaultSerializedError, assertionPrototypeMetadata);
-assert.strictEqual(defaultSerializedError.actual.constructor.name, 'ExtendedArray');
+applyAssertionPrototypeMetadata(defaultSerializedArrayError, arrayPrototypeMetadata);
+assert.strictEqual(defaultSerializedArrayError.actual.constructor.name, 'ExtendedArray');
+
+const objectAssertionError = createAssertionError(new ExtendedObject(42), { value: 42 });
+const objectPrototypeMetadata = collectAssertionPrototypeMetadata(objectAssertionError);
+assert.ok(objectPrototypeMetadata);
+assert.strictEqual(objectPrototypeMetadata.actual.constructorName, 'ExtendedObject');
+
+const defaultSerializedObjectError = deserializeError(serializeError(objectAssertionError));
+assert.strictEqual(defaultSerializedObjectError.actual.constructor.name, 'Object');
+
+applyAssertionPrototypeMetadata(defaultSerializedObjectError, objectPrototypeMetadata);
+assert.strictEqual(defaultSerializedObjectError.actual.constructor.name, 'ExtendedObject');
+
+const expectedArrayAssertionError = createAssertionError(['hello'], new ExtendedArray('hello'));
+const expectedArrayPrototypeMetadata = collectAssertionPrototypeMetadata(expectedArrayAssertionError);
+assert.ok(expectedArrayPrototypeMetadata);
+assert.strictEqual(expectedArrayPrototypeMetadata.actual, undefined);
+assert.strictEqual(expectedArrayPrototypeMetadata.expected.constructorName, 'ExtendedArray');
+
+const defaultSerializedExpectedArrayError = deserializeError(serializeError(expectedArrayAssertionError));
+assert.strictEqual(defaultSerializedExpectedArrayError.actual.constructor.name, 'Array');
+assert.strictEqual(defaultSerializedExpectedArrayError.expected.constructor.name, 'Array');
+
+applyAssertionPrototypeMetadata(defaultSerializedExpectedArrayError, expectedArrayPrototypeMetadata);
+assert.strictEqual(defaultSerializedExpectedArrayError.actual.constructor.name, 'Array');
+assert.strictEqual(defaultSerializedExpectedArrayError.expected.constructor.name, 'ExtendedArray');
+
+// AssertionError wrapped in ERR_TEST_FAILURE should still be supported.
+const wrappedMetadata = collectAssertionPrototypeMetadata({
+  code: 'ERR_TEST_FAILURE',
+  cause: arrayAssertionError,
+});
+assert.deepStrictEqual(wrappedMetadata, arrayPrototypeMetadata);
+
+// Unsupported metadata shapes must be ignored safely.
+assert.doesNotThrow(() => applyAssertionPrototypeMetadata(arrayAssertionError, null));
+assert.doesNotThrow(() => applyAssertionPrototypeMetadata(arrayAssertionError, {
+  actual: { baseType: 'map', constructorName: 'ExtendedMap' },
+}));
+
+// Base type mismatch should not rewrite the value prototype.
+const mismatchError = deserializeError(serializeError(objectAssertionError));
+applyAssertionPrototypeMetadata(mismatchError, {
+  actual: {
+    __proto__: null,
+    baseType: 'array',
+    constructorName: 'ExtendedArray',
+  },
+});
+assert.strictEqual(mismatchError.actual.constructor.name, 'Object');