`assert.deepEqual()` report difference between promises during `test`

[regseb]

Version

v22.9.0

Platform

Linux regseblaptop 6.8.0-45-generic #45-Ubuntu SMP PREEMPT_DYNAMIC Fri Aug 30 12:02:04 UTC 2024 x86_64 x86_64 x86_64 GNU/Linux

Subsystem

Ubuntu 24.04.1 LTS

What steps will reproduce the bug?

1. Create test.mjs

import assert from "node:assert/strict";
import { mock, test } from "node:test";

test("promise", () => {
 assert.deepEqual(Promise.resolve("foo"), Promise.resolve("foo"));
});

test("mock, promise and await", async () => {
 const fn = mock.fn(() => "foo");
 await fn(Promise.resolve("bar"));
 assert.deepEqual(fn.mock.calls[0].arguments[0], Promise.resolve("bar"));
});

2. node --test test.mjs

How often does it reproduce? Is there a required condition?

Always.

What is the expected behavior? Why is that the expected behavior?

The assert.deepEqual() doesn't report difference between the two identical promises.

✔ promise (1.830551ms)
✔ mock, promise and await (0.533274ms)
ℹ tests 2
ℹ suites 0
ℹ pass 2
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 75.905452

What do you see instead?

The assert.deepEqual() find difference between the two identical promises.

✖ promise (5.761508ms)
 AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
 + actual - expected
 
 Promise {
 'foo',
 + [Symbol(async_id_symbol)]: 39,
 - [Symbol(async_id_symbol)]: 40,
 [Symbol(trigger_async_id_symbol)]: 17
 }
 at TestContext.<anonymous> (file:///home/regseb/dev/tc/mock/test.mjs:5:12)
 at Test.runInAsyncScope (node:async_hooks:211:14)
 at Test.run (node:internal/test_runner/test:930:25)
 at Test.start (node:internal/test_runner/test:829:17)
 at startSubtestAfterBootstrap (node:internal/test_runner/harness:289:17) {
 generatedMessage: true,
 code: 'ERR_ASSERTION',
 actual: [Promise],
 expected: [Promise],
 operator: 'deepStrictEqual'
 }

✖ mock, promise and await (0.791194ms)
 AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
 + actual - expected
 
 Promise {
 'bar',
 + [Symbol(async_id_symbol)]: 52,
 + [Symbol(trigger_async_id_symbol)]: 20
 - [Symbol(async_id_symbol)]: 66,
 - [Symbol(trigger_async_id_symbol)]: 54
 }
 at TestContext.<anonymous> (file:///home/regseb/dev/tc/mock/test.mjs:11:12)
 at async Test.run (node:internal/test_runner/test:931:9)
 at async Test.processPendingSubtests (node:internal/test_runner/test:629:7) {
 generatedMessage: true,
 code: 'ERR_ASSERTION',
 actual: [Promise],
 expected: [Promise],
 operator: 'deepStrictEqual'
 }

ℹ tests 2
ℹ suites 0
ℹ pass 0
ℹ fail 2
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 82.541815

✖ failing tests:

test at test.mjs:4:1
✖ promise (5.761508ms)
 AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
 + actual - expected
 
 Promise {
 'foo',
 + [Symbol(async_id_symbol)]: 39,
 - [Symbol(async_id_symbol)]: 40,
 [Symbol(trigger_async_id_symbol)]: 17
 }
 at TestContext.<anonymous> (file:///home/regseb/dev/tc/mock/test.mjs:5:12)
 at Test.runInAsyncScope (node:async_hooks:211:14)
 at Test.run (node:internal/test_runner/test:930:25)
 at Test.start (node:internal/test_runner/test:829:17)
 at startSubtestAfterBootstrap (node:internal/test_runner/harness:289:17) {
 generatedMessage: true,
 code: 'ERR_ASSERTION',
 actual: [Promise],
 expected: [Promise],
 operator: 'deepStrictEqual'
 }

test at test.mjs:8:1
✖ mock, promise and await (0.791194ms)
 AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
 + actual - expected
 
 Promise {
 'bar',
 + [Symbol(async_id_symbol)]: 52,
 + [Symbol(trigger_async_id_symbol)]: 20
 - [Symbol(async_id_symbol)]: 66,
 - [Symbol(trigger_async_id_symbol)]: 54
 }
 at TestContext.<anonymous> (file:///home/regseb/dev/tc/mock/test.mjs:11:12)
 at async Test.run (node:internal/test_runner/test:931:9)
 at async Test.processPendingSubtests (node:internal/test_runner/test:629:7) {
 generatedMessage: true,
 code: 'ERR_ASSERTION',
 actual: [Promise],
 expected: [Promise],
 operator: 'deepStrictEqual'
 }

Additional information

The problem only occurs in test. #55198 (comment)

1. Create index.mjs

import assert from "node:assert/strict";
import { mock } from "node:test";

assert.deepEqual(Promise.resolve("foo"), Promise.resolve("foo"));

const fn = mock.fn(() => "foo");
await fn(Promise.resolve("bar"));
assert.deepEqual(fn.mock.calls[0].arguments[0], Promise.resolve("bar"));

2. node index.mjs
3. The assert.deepEqual() doesn't report difference between the two identical promises. 👍

[avivkeller]

I've preemptively added the known limitation Issues that are identified as known limitations. label, as this seems to be WAI. The test runner uses promises behind the scene, so they are probably interfering. I doubt there's anything that will fix that?

[avivkeller]

CC @nodejs/test_runner

[avivkeller]

FWIW

import assert from 'node:assert';

const a = Promise.resolve('foo');
const b = Promise.resolve('bar');

assert.deepStrictEqual(a, b);

Also doesn't report anything so maybe that's a seperate bug 🤔

[cjihrig]

Fixing this will require refactoring https://github.com/nodejs/node/blob/main/lib/internal/test_runner/harness.js to remove async_hooks (which should probably be done anyway). Commenting out this line fixes the issue.

[targos]

This isn't specific to the test runner, though:

import assert from 'node:assert';
import asyncHooks from 'async_hooks';

const hook = asyncHooks.createHook({ promiseResolve() {} });
hook.enable();

const a = Promise.resolve('foo');
const b = Promise.resolve('bar');

assert.deepStrictEqual(a, b);

$ node test.mjs
node:internal/modules/run_main:123
 triggerUncaughtException(
 ^

AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected

 Promise {
+ 'foo',
+ [Symbol(async_id_symbol)]: 9,
- 'bar',
- [Symbol(async_id_symbol)]: 10,
 [Symbol(trigger_async_id_symbol)]: 0
 }

[BridgeAR]

We use symbols, when we want to have something internal. Enumerable symbol properties are however always compared by assert.deepStrictEqual. I personally would like to mark them as non-enumerable or use actual private properties. That way the internals would not be compared anymore.

[cjihrig]

I was hoping we could migrate to AsyncLocalStorage, but it (I guess unsurprisingly) has the same issue:

'use strict';
const { AsyncLocalStorage } = require('node:async_hooks');
const { deepEqual } = require('node:assert/strict');
const asyncLocalStorage = new AsyncLocalStorage();

asyncLocalStorage.run({}, () => {
 deepEqual(Promise.resolve('foo'), Promise.resolve('foo'));
});

[targos]

The issue goes away with AsyncLocalStorage if used with --experimental-async-context-frame