QUnit.dump.parse returns an empty object for Maps

[deepestblue]

Version: 2.20.1
Test browser: Chrome 141.0.7390.55

Test cases:

> QUnit.dump.parse([1,3,4])
'[\n  1,\n  3,\n  4\n]'

^^ looks reasonable.

> QUnit.dump.parse({foo: "bar", baz: 2})
'{\n  "baz": 2,\n  "foo": "bar"\n}'

^^ likewise.

> QUnit.dump.parse(new Map([["a","b"], ["c","d"]]))
'{}'

^^ feels like a bug.

[Krinkle]

Yep. That's a bug.

The result from assert.deepEqual and QUnit.equiv is correct, but the presentation shown during a test failure is lacking any detail, making debugging needlessly hard.

https://codepen.io/Krinkle/pen/NPxjLrg

[deepestblue]

Question: why does the

message += "<tr class='test-message'><th>Message: </th><td>" + 'Diff suppressed as the expected and actual results have an equivalent' + ' serialization</td></tr>';

case exist in that QUnit.log(...) call? Maybe I'm not following the cases, but why should the actual and expected be different and yet have equivalent serialisations?

[Krinkle]

@deepestblue

This message is shown when the textual representation does not (or cannot) include something that the assertion does consider. I'll mention three examples:

1. Identity

   var actual = { a: 1 };
   assert.strictEqual(actual,  { a: 1 }); // fail, but no diff

   Both serialize to { "a": 1 }, leaving no difference in textual representation.

2. Special handling in an assertion. You might have an assertion plug-in like this:

   function User(name) {
     this.getName = function () {
       return name;
     };
   }
   QUnit.assert.equalUserName = function (actual, expected, message) {
     this.pushResult({
         result: actual.getName() === expected.getName(),
         actual: actual,
         expected: expected,
         message: message
     });
   };
   QUnit.test('example', function (assert) {
     assert.equalUserName(new User('Alice'), new User('Alice'));
   });

   In this case, if the result is false, the actual/expected serialize to {} without diff, because the User object hides its data in lexical scope instead of in properties. This could be improved by changing the source code to use properties. Or, by fixing the assertion to pass getName() to actual/expected instead. It's hard to fit a more realistic example here, but you get the idea.

3. Special handling in assert.deepEqual absent from QUnit.dump.

By default, deepEqual treats all objects the same way. It compares the own properties, and then the prototype (i.e. class) that the object is an instance of. However, classes like Map, Set and even the old Date hide the values you care about in private state instead of in properties. So they look like empty objects and have an equal prototype.

QUnit.dump(new Date);
// Normally:
//> "Fri Apr 01 2011 09:00:00 GMT+0000 (Coordinated Universal Time)"

delete QUnit.dump.parsers.date;
QUnit.dump.typeOf = (x) => x === null ? 'null' : typeof x;
QUnit.dump(new Date);
// If we did not have special handling for Date:
//> "{}"

Both deepEqual and dump have special handling for Date, so no problem there. Back in 2015 we added special handling for Map and Set to assert.deepEqual. But, we did not yet add it to dump. As you demonstrated, Map and Set serialize to "{}" because they have no own properties to compare. Thus, they have no diff.

[Krinkle]

You can see the same in JSON.stringify():

JSON.stringify(new Set(['x']))
//> "{}"
JSON.stringify(new Map([['x', 'y']]))
//> "{}" 

Or to get a sense of what all dump/deepEqual/stringify all do internally, try it yourself with a for-loop:

var a = { a: 1, b: 2 };
var b = [ 'helllo', 'world' ];
var c = new Set(['x']);
var d = new Map([['x', 'y']]);

function dump(obj) {
  let str = '{';
  for (const key in obj) {
    if (str === '{') str += '\n';
    str += '  ' + key + ': ' + obj[key] + ',\n';
  }
  str += '}';
  return str;
}

console.log(dump(a)); // { a: 1, b: 2, }
console.log(dump(d)); // {}