Function serverAct

packages/internal-test-utils/internalAct.js:231–297

(scope: () => Thenable<T>)

}

export async function serverAct<T>(scope: () => Thenable<T>): Thenable<T> {
  // We require every `act` call to assert console logs
  // with one of the assertion helpers. Fails if not empty.
  assertConsoleLogsCleared();

  // $FlowFixMe[cannot-resolve-name]: Flow doesn't know about global Jest object
  if (!jest.isMockFunction(setTimeout)) {
    throw Error(
      "This version of `act` requires Jest's timer mocks " +
        '(i.e. jest.useFakeTimers).',
    );
  }

  // Create the error object before doing any async work, to get a better
  // stack trace.
  const error = new Error();
  Error.captureStackTrace(error, act);

  // Call the provided scope function after an async gap. This is an extra
  // precaution to ensure that our tests do not accidentally rely on the act
  // scope adding work to the queue synchronously. We don't do this in the
  // public version of `act`, though we maybe should in the future.
  await waitForMicrotasks();

  const errorHandlerNode = function (err: mixed) {
    thrownErrors.push(err);
  };
  // We track errors that were logged globally as if they occurred in this scope and then rethrow them.
  if (typeof process === 'object') {
    // Node environment
    process.on('uncaughtException', errorHandlerNode);
  } else if (
    typeof window === 'object' &&
    typeof window.addEventListener === 'function'
  ) {
    throw new Error('serverAct is not supported in JSDOM environments');
  }

  try {
    const promise = scope();
    // $FlowFixMe[prop-missing]
    if (promise && typeof promise.catch === 'function') {
      // $FlowFixMe[incompatible-use]
      promise.catch(() => {}); // Handle below
    }
    // See if we need to do some work to unblock the promise first.
    await waitForTasksAndTimers(error);
    const result = await promise;
    // Then wait to flush the result.
    await waitForTasksAndTimers(error);

    if (thrownErrors.length > 0) {
      // Rethrow any errors logged by the global error handling.
      const thrownError = aggregateErrors(thrownErrors);
      thrownErrors.length = 0;
      throw thrownError;
    }