Function createGlobalFetchMock

tests/utils/TestHelper.ts:220–284

* Use for situations where fetch() is required. This mock is stateful and has some additional methods to control its behavior: * * - pause() – stop resolving promises until you call resume() * - resume() - flush the queue of promises, and start resolving new promises immediately * - fail() - sta

(mockResponse?: Partial<Response>)

 * - success() - go back to returning a success response
 */
function createGlobalFetchMock(mockResponse?: Partial<Response>): MockFetch {
    let queue: QueueItem[] = [];
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    let responses = new Map<string, (params: any) => OnyxResponse<any>>();
    let isPaused = false;
    let shouldFail = false;

    const getResponse = (input: RequestInfo, options?: RequestInit): Partial<Response> =>
        shouldFail
            ? {
                  ok: true,
                  json: () => Promise.resolve({jsonCode: 400}),
              }
            : {
                  ok: true,
                  json: async () => {
                      const commandMatch = typeof input === 'string' ? input.match(/https:\/\/www.expensify.com.dev\/api\/(\w+)\?/) : null;
                      const command = commandMatch ? commandMatch[1] : null;

                      const responseHandler = command ? responses.get(command) : null;
                      if (responseHandler) {
                          const requestData = options?.body instanceof FormData ? Object.fromEntries(options.body) : {};
                          return Promise.resolve({jsonCode: 200, ...responseHandler(requestData)});
                      }

                      return Promise.resolve({jsonCode: 200});
                  },
                  ...mockResponse,
              };

    const mockFetch = jest.fn().mockImplementation((input: RequestInfo, options?: RequestInit) => {
        if (!isPaused) {
            return Promise.resolve(getResponse(input, options));
        }
        return new Promise((resolve) => {
            queue.push({resolve, input, options});
        });
    }) as MockFetch;

    const baseMockReset = mockFetch.mockReset.bind(mockFetch);
    mockFetch.mockReset = () => {
        baseMockReset();
        queue = [];
        responses = new Map();
        isPaused = false;
        shouldFail = false;
        return mockFetch;
    };

    mockFetch.pause = () => (isPaused = true);
    mockFetch.resume = () => {
        isPaused = false;
        for (const {resolve, input} of queue) {
            resolve(getResponse(input));
        }
        return waitForBatchedUpdates();
    };
    mockFetch.fail = () => (shouldFail = true);