Fix TextEncoder.encode not referencing same global Uint8Array constructor

[wsmd]

Summary

Fixes #9204

This is a follow up for my comment: #9204 (comment)

Currently the following tests are failing in Jest:

• Using global TextEncoder (node v11 and above)

it('TextEncoder.encode references the same global Uint8Array constructor', () => {
  const actual = new TextEncoder().encode('foo');
  expect(actual).toEqual(new Uint8Array([102, 111, 111])); // fails
  expect(actual).toBeInstanceOf(Uint8Array); // fails
});

• Importing TextEncoder from the 'util' module (not using global TextEncoder)

const {TextEncoder} = require('util');

it('TextEncoder.encode references the same global Uint8Array constructor', () => {
  const actual = new TextEncoder().encode('foo');
  expect(actual).toEqual(new Uint8Array([102, 111, 111])); // fails
  expect(actual).toBeInstanceOf(Uint8Array); // fails
});

---

It seems that the constructor of the Uint8Array returned from TextEncoder.prototype.encode and the global Uint8Array constructor are not the same (causing some matchers to fail via the iterableEquality); note that this only happens in the jest node environment.

// in Jest (using the node environment)
new TextEncoder().encode('').constructor === Uint8Array // false

// outside Jest (regular node runtime)
new TextEncoder().encode('').constructor === Uint8Array // true

I'm not exactly sure why these two are referencing different constructors, or where either one of them is referencing a different one. I'm wondering if anyone has any pointers on this – I'm really curious!

That said, updating jest-environment-node's global to reference the actual Uint8Array seems to resolve this issue.

Test plan

The following test should pass on this branch:

test('TextEncoder references the same global Uint8Array constructor', () => {
  expect(new TextEncoder().encode('abc')).toBeInstanceOf(Uint8Array);
});

I added some new tests that would have failed outside of this PR.

[thymikee]

This needs its own if block to check whether typeof Uint8Array !== 'undefined' is true. Feel free to also leave a comment on which Node version supports it, like it's done for other globals

[wsmd]

@thymikee that's not a bad idea!

My initial thinking was that this is only a workaround specific to the TextDecoder as it seems to be referencing a different Uint8Array constructor, so I grouped them all together in the same block. If TextEncoder isn't defined then re-assigning Uint8Array isn't really needed (#9261 (comment)).

// in Jest (using the node environment)
new TextEncoder().encode('').constructor === Uint8Array // false

// outside Jest (regular node runtime)
new TextEncoder().encode('').constructor === Uint8Array // true

Could you please help me understand under what conditions Uint8Array would be undefined? I think this helps me better understand the Jest architecture =)

Uint8Array is very well supported since node v0.10, unlike TextEncoder that was only made available in the global namespace with node v11.0.0 (which is relatively recent). I'm not sure if there will be a case where Uint8Array isn't defined (v0.10 dates back to 2013).

Isn't this similar? We're not checking for ArrayBuffers here:

https://github.com/facebook/jest/blob/c4e342f86cac12a965ce3974212102a88d0fef55/packages/jest-environment-node/src/index.ts#L47-L49

[thymikee]

We should be good with adding Uint8Array next to the ArrayBuffer then, wdyt @SimenB?

[wsmd]

Hey hey! this conversation made me realize that this issue does not only occur with the global TextEncoder (in Node v11), but also with require('util').TextEncoder (in any version of node)! 😬

In Node v10 (or older), this test would still fail for the same reason:

// node v10 (importing TextEncoder from the 'util' module)
const {TextEncoder} = require('util');

test('TextEncoder.encode references the same global Uint8Array constructor', () => {
  expect(new TextEncoder().encode('')).toBeInstanceOf(Uint8Array)
});

 FAIL  ./TextEncoder.test.js
  ✕ TextEncoder.encode references the same global Uint8Array constructor (5ms)

  ● TextEncoder.encode references the same global Uint8Array constructor

    expect(received).toBeInstanceOf(expected)

    Expected constructor: Uint8Array
    Received constructor: Uint8Array

      2 | 
      3 | test('TextEncoder.encode references the same global Uint8Array constructor', () => {
    > 4 |   expect(new TextEncoder().encode()).toBeInstanceOf(Uint8Array)
        |                                      ^
      5 | });

      at Object.toBeInstanceOf (TextEncoder.test.js:4:38)

We should be good with adding Uint8Array next to the ArrayBuffer then

Looks like after all we actually need to assign global.Uint8Array regardless of TextEncoder being global or not to support both cases 😅..

I'll go ahead and push the changes 👍

[github-actions]

This pull request has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.
Please note this issue tracker is not a help forum. We recommend using StackOverflow or our discord channel for questions.