Tests are failing because GCC does not like using the setTimeout global

It's because you have a local variable that's called the same thing. Rename to something else (localSetTimeout) and should work.

Comparing: 1a2d792...0bbcfc2

Critical size changes

Includes critical production bundles, as well as any change greater than 2%:

Significant size changes

Includes any change greater than 0.2%:

Generated by 🚫 dangerJS against 0bbcfc2

Do we know why CI fails?

@gaearon yes, it's failing because the test is now using setImmediate instead of setTimeout, and for some reason that semantic change causes this test:

it('resets correctly across renderers', async () => {
  function Effecty() {
    React.useEffect(() => {}, []);
    return null;
  }
  TestUtils.act(() => {
    TestRenderer.act(() => {});
    expect(() => {
      TestRenderer.create(<Effecty />);
    }).toWarnDev(["It looks like you're using the wrong act()"], {
      withoutStack: true,
    });
  });
});

to throw this error:

The document global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in componentWillUnmount), or you can change the test itself to be asynchronous.

Note that changing the test to use async act fixes the failure, but I'm concerned about just doing that without understanding the cause.

I have a vague memory of (maybe?) writing that error message a few years ago but I have no recollection of what it was about. I’ll need to take a closer look.

So I confirmed that this failure is due to differences between setTimeout and setImmediate in Node and Jest.

For example, consider this test (repl):

it("crashes", () => {
  let document = {};

  setTimeout(() => {
    // This is never hit
    document.foo;
  });
  setImmediate(() => {
    // This is hit and will crash the test
    document.foo
  });

  document = null;
});

Here, the setTimeout will not crash the test, but setImmediate will.

I believe this is happening because of how the Node event loop processes setImmediate vs setTimeout. Specifically, setTimeout is processed after the close callbacks and after Jest cleans up the test environment. But setImmediate is called before close callbacks, and after Jest cleans up the test. The result is that work scheduled in setTimeout is not processed, but work in setImmediate it. Since Jest has already cleaned up the environment, the document is gone, and we error.

The fix here is to use async act so that Jest doesn't clean up the environment before all of the work is flushed. That turns the above into essentially this, which passes:

it("should pass", async () => {
  let document = {};

  setTimeout(() => {
    // This is never hit
    document.foo;
  });
  
  await new Promise((resolve) => {
    setImmediate(() => {
      // This is hit but the document is available
      document.foo;
      resolve();
    });
  });

  document = null;
});

That fixes the issue here, but makes the setImmediate change more of a breaking change than expected.

I've reduced this down to this test, which shows it's happens when:

• Rendering a component with an effect
• With either ReactDOM or TestRenderer
• Using real timers

jest.useRealTimers();

it('fails', () => {
  function Effecty() {
    React.useEffect(() => {}, []);
    return null;
  }

  TestRenderer.create(<Effecty />);
  
  // Or:
  // ReactDOM.render(<Effecty />, document.createElement('div'));
});

This will fail both internally and in the fixture (in different ways where document is not defined).