Support for BigInt

[fubar]

Chai still doesn't support BigInts.

expect(BigInt(1)).to.equal(BigInt(2));

Results in TypeError: Do not know how to serialize a BigInt (triggered by JSON.stringify).

BigInt is now a standard primitive and it would be great if Chai supported it out of the box.

Stale/closed issue: #1195. The roadmap has that issue in todo but it has not been updated since Apr 2019: https://github.com/chaijs/chai/projects/2

[dwelle]

Serialization can be solved by doing something like:

BigInt.prototype.toJSON = val => `${val}n`;

But assertions will also fail because chai boxes bigints into some kind of object (when storing it to __flags.object.

[keithamus]

I'm going to close this, as it is a dupe of #1195. The roadmap is the preferred way to track progress for us. The current in flight project is loupe - which was deemed in most need of attention, and the last commit was 22nd Apr 2020. Once we're happy with loupe we'll be moving onto the next todo item.

If you uncover any bugs please feel free to file more issues, but rest assured we're aware of a lack of support for ES6+ types and are working hard to fix that.

[dwelle]

@keithamus if it's not too much trouble, can you give me a hint where chai boxes BigInts (and I reckon any types it doesn't know about) into [BigInt: 122054031626471353n] when I log utils.flag(this, 'object')? I'm getting lost in the source, and could use some help for a fork before chai v2 is ready. Thanks!

EDIT: I guess I can hack it by monkey-patching the utils.flag getter/setter.

[keithamus]

Just FYI we support BigInts for assertions like .to.be.equal. If you run expect(0n).to.equal(0n) you'll get a passing assertion. I don't know where the OP saw the error TypeError: Do not know how to serialize a BigInt (perhaps from a plugin or some kind of monkey-patch on BigInt?), but if I run expect(0n).to.equal(1n) I get AssertionError: expected {} to equal {}

Chai doesn't box the values in any way. Expect just wraps the given argument in a new Assertion type:

chai/lib/chai/interface/expect.js

Lines 7 to 9 in e54d834

	module.exports = function (chai, util) {
	chai.expect = function (val, message) {
	return new chai.Assertion(val, message);

Assertion just sets the object flag to whatever is given to it:

chai/lib/chai/assertion.js

Lines 62 to 66 in e54d834

	function Assertion (obj, msg, ssfi, lockSsfi) {
	flag(this, 'ssfi', ssfi || Assertion);
	flag(this, 'lockSsfi', lockSsfi);
	flag(this, 'object', obj);
	flag(this, 'message', msg);

Each assertion then does its own thing. When equal() is called, it pulls out the flag and runs X === Y:

chai/lib/chai/core/assertions.js

Lines 1022 to 1044 in e54d834

	function assertEqual (val, msg) {
	if (msg) flag(this, 'message', msg);
	var obj = flag(this, 'object');
	if (flag(this, 'deep')) {
	var prevLockSsfi = flag(this, 'lockSsfi');
	flag(this, 'lockSsfi', true);
	this.eql(val);
	flag(this, 'lockSsfi', prevLockSsfi);
	} else {
	this.assert(
	val === obj
	, 'expected #{this} to equal #{exp}'
	, 'expected #{this} to not equal #{exp}'
	, val
	, this._obj
	, true
	);
	}
	}
	Assertion.addMethod('equal', assertEqual);
	Assertion.addMethod('equals', assertEqual);
	Assertion.addMethod('eq', assertEqual);

The failure message of AssertionError: expected {} to equal {} is the bit that sucks at the moment; and that's because of our inspection engine (which is why we're working on loupe, which is a rewrite of the inspection engine to be much faster and better). The error string from .equal (L1033) gets passed to getMessage which separates out the #{this} string, and calls objDisplay on that, which in turn calls inspect which in turn goes through a bunch of type checks, fails, and just returns {}.

[dwelle]

Thanks for the detailed writeup. I've been through most of those places in the codebase myself, and as such couldn't figure out where that "boxing" (or what it is) is coming from. It must not be chai then. I'll investigate when I get time and get back to you if I find the culprit.

[dwelle]

Ok, so it seems it's related only to should assertions:

const chai = require("chai");

chai.should();

chai.use(function (chai, utils) {
    chai.Assertion.addMethod('eq', function (expected) {
        console.log(utils.flag(this, 'object'))
    });
});

(10n).should.eq(10n); // logs [BigInt: 10n]

This is what the Assertion object looks like for should interface:

console.log((10n).should)

// Assertion {
//   __flags: [Object: null prototype] {
//     ssfi: [Function: shouldGetter],
//     lockSsfi: undefined,
//     object: [BigInt: 10n],
//     message: null
//   }
// }

as opposed to expect:

console.log(chai.expect(10n))

// Assertion {
//   __flags: [Object: null prototype] {
//     ssfi: [Function: Assertion] {
//       addProperty: [Function],
//       addMethod: [Function],
//       addChainableMethod: [Function],
//       overwriteProperty: [Function],
//       overwriteMethod: [Function],
//       overwriteChainableMethod: [Function]
//     },
//     lockSsfi: undefined,
//     object: 10n,
//     message: undefined
//   }
// }

[dwelle]

Mhm.. turns out this has nothing to do with Chai, but JS. this refers to the boxed primitive value:

Object.defineProperty(Object.prototype, 'should', {
    get: function () {
        return this; // boxed value for primitives
    }
});

Chai accounts for this by unboxing primitive values, but bigint isn't in the list right now (obviously):

chai/lib/chai/interface/should.js

Lines 12 to 18 in e54d834

	function shouldGetter() {
	if (this instanceof String
	|| this instanceof Number
	|| this instanceof Boolean
	|| typeof Symbol === 'function' && this instanceof Symbol) {
	return new Assertion(this.valueOf(), null, shouldGetter);
	}

[dwelle]

I can open a PR for this one change if that's ok?

[keithamus]

Yes! Please do so!