@JacobLey I can't figure out how to reproduce this locally. I believe you that it is a real bug 😄 but need an isolated reproduction to test it with. What's the simplest way to get this to happen in a clean/new repository?

For reference, trying this with "type": "module":

import { expect } from 'chai';

describe('Compare imports', () => {
  it('different imports', async () => {
    const modA = await import('dedent');
    const modB = await import('once');
    // throws
    expect(modA).to.eq(modB);
  });
  it('always true', () => {
    console.log('This will never run');
  });
});

...I get fine looking failures:

$ npx mocha test.js

  Compare imports
    1) different imports
This will never run
    ✔ always true


  1 passing (5ms)
  1 failing

  1) Compare imports
       different imports:

      AssertionError: expected { default: [Function dedent], …(1) } to equal { default: [Function wrapper], …(1), …(1) }
      + expected - actual


      at Context.<anonymous> (file:///Users/josh/repos/mocha-context-only-bug/test.js:8:21)

Same with switching to "type": "commonjs" with a require and chai@4.

I've finally gotten around to trying to reproduce!

Sorry there was a minor mistake in my example. Change the code to instead be

expect({ a: modA }).to.deep.equal({ b: modB });

Now the module is not the "top level" object and experiences the issue.

So when stringify-ing the error, https://github.com/mochajs/mocha/blob/master/lib/utils.js#L242 this will attempt the "canonicalize" the top-level object.

Which internally runs this loop over the keys and tries to "implicitly stringify" the module: https://github.com/mochajs/mocha/blob/master/lib/utils.js#L408

The error didn't show up in my original example, because Mocha correctly handles "Module" in that case. Not using the suggested approach above, but handles it nonetheless.

In that case it jumps straight to the json stringification https://github.com/mochajs/mocha/blob/master/lib/utils.js#L235

Which falls back on native JSON.stringify https://github.com/mochajs/mocha/blob/master/lib/utils.js#L315 which works

Looking back at my original suggested solution, it should resolve the issue: https://github.com/mochajs/mocha/pull/5040/files

Did a little bit more research and actually think proposed solution does not go far enough...

Basically the two curveballs that are happening are:

• Module instances have a null prototype.
  • This causes the implicit stringification to fail
• Module instances have a custom toString implementation
  • This is what avoids the object handling

So you could actually recreate this with any instance that fulfills those requirements.

import { expect } from 'chai';
import { describe, it } from 'mocha';

describe('Compare imports', () => {
  it('different imports', async () => {

    const foo = Object.create(null, { 
      [Symbol.toStringTag]: { value: 'Foo' }, 
      bing: { get: () => 'bong', enumerable: true }
    });
    const bar = Object.create(null, { 
      [Symbol.toStringTag]: { value: 'Bar' }, 
      bing: { get: () => 'boing', enumerable: true }
    });

    // throws
    expect({ a: foo }).to.deep.equal({ b: bar });
  });
  it('always true', () => {
    console.log('This will never run');
  });
});

Similar to above, JSON.stringify() of foo and bar works as expected, so need to wrap the data in an object to trigger the failure.

Updated PR with comments as well.

Easily reproducible version for anyone that wants to test out: https://github.com/JacobLey/issue-recreator/tree/mocha-esm