@apollo/gateway 2.0.2-alpha.1 → 2.0.3

package/src/supergraphManagers/UplinkFetcher/__tests__/loadSupergraphSdlFromStorage.test.ts

@@ -3,7 +3,7 @@ import {
   loadSupergraphSdlFromUplinks,
   UplinkFetcherError,
 } from '../loadSupergraphSdlFromStorage';
-import { getDefaultFetcher } from '../../..';
+import fetcher from 'make-fetch-happen';
 import {
   graphRef,
   apiKey,
@@ -14,10 +14,13 @@ import {
   mockOutOfBandReportRequestSuccess,
   mockSupergraphSdlRequestSuccess,
   mockSupergraphSdlRequestIfAfterUnchanged,
-  mockSupergraphSdlRequestIfAfter
+  mockSupergraphSdlRequestIfAfter,
 } from '../../../__tests__/integration/nockMocks';
-import { getTestingSupergraphSdl } from "../../../__tests__/execution-utils";
-import { nockAfterEach, nockBeforeEach } from '../../../__tests__/nockAssertions';
+import { getTestingSupergraphSdl } from '../../../__tests__/execution-utils';
+import {
+  nockAfterEach,
+  nockBeforeEach,
+} from '../../../__tests__/nockAssertions';
 
 describe('loadSupergraphSdlFromStorage', () => {
   beforeEach(nockBeforeEach);
@@ -25,7 +28,6 @@ describe('loadSupergraphSdlFromStorage', () => {
 
   it('fetches Supergraph SDL as expected', async () => {
     mockSupergraphSdlRequestSuccess();
-    const fetcher = getDefaultFetcher();
     const result = await loadSupergraphSdlFromStorage({
       graphRef,
       apiKey,
@@ -42,27 +44,29 @@ describe('loadSupergraphSdlFromStorage', () => {
 
   it('Queries alternate Uplink URL if first one fails', async () => {
     mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
-    mockSupergraphSdlRequestIfAfter('originalId-1234', mockCloudConfigUrl2).reply(
+    mockSupergraphSdlRequestIfAfter(
+      'originalId-1234',
+      mockCloudConfigUrl2,
+    ).reply(
       200,
       JSON.stringify({
         data: {
           routerConfig: {
             __typename: 'RouterConfigResult',
             id: 'originalId-1234',
-            supergraphSdl: getTestingSupergraphSdl()
+            supergraphSdl: getTestingSupergraphSdl(),
           },
         },
       }),
     );
 
-    const fetcher = getDefaultFetcher();
     const result = await loadSupergraphSdlFromUplinks({
       graphRef,
       apiKey,
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
       fetcher,
-      compositionId: "originalId-1234",
+      compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
       earliestFetchTime: null,
@@ -75,10 +79,12 @@ describe('loadSupergraphSdlFromStorage', () => {
   });
 
   it('Throws error if all Uplink URLs fail', async () => {
-    mockSupergraphSdlRequest("originalId-1234", mockCloudConfigUrl1).reply(500);
-    mockSupergraphSdlRequestIfAfter("originalId-1234", mockCloudConfigUrl2).reply(500);
+    mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
+    mockSupergraphSdlRequestIfAfter(
+      'originalId-1234',
+      mockCloudConfigUrl2,
+    ).reply(500);
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromUplinks({
         graphRef,
@@ -86,23 +92,22 @@ describe('loadSupergraphSdlFromStorage', () => {
         endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
         errorReportingEndpoint: undefined,
         fetcher,
-        compositionId: "originalId-1234",
+        compositionId: 'originalId-1234',
         maxRetries: 1,
         roundRobinSeed: 0,
         earliestFetchTime: null,
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 500 Internal Server Error",
-      )
+        'An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
+      ),
     );
-  })
+  });
 
   describe('errors', () => {
     it('throws on a malformed response', async () => {
       mockSupergraphSdlRequest().reply(200, 'Invalid JSON');
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -114,8 +119,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 200 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected token I in JSON at position 0"
-        )
+          'An error occurred while fetching your schema from Apollo: 200 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected token I in JSON at position 0',
+        ),
       );
     });
 
@@ -128,7 +133,6 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       );
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -139,7 +143,9 @@ describe('loadSupergraphSdlFromStorage', () => {
           compositionId: null,
         }),
       ).rejects.toThrowError(
-        new UplinkFetcherError(`An error occurred while fetching your schema from Apollo: \n${message}`)
+        new UplinkFetcherError(
+          `An error occurred while fetching your schema from Apollo: \n${message}`,
+        ),
       );
     });
 
@@ -147,7 +153,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(500);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -159,8 +164,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 500 Internal Server Error"
-        )
+          'An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
+        ),
       );
     });
 
@@ -169,7 +174,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     it("Out of band reporting doesn't submit reports when endpoint is not configured", async () => {
       mockSupergraphSdlRequest().reply(400);
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -181,16 +185,14 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input",
-        )
+          'An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input',
+        ),
       );
     });
 
     it('throws on 400 status response and does not submit an out of band error', async () => {
-
       mockSupergraphSdlRequest().reply(400);
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -202,8 +204,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input",
-        )
+          'An error occurred while fetching your schema from Apollo: 400 invalid json response body at https://example1.cloud-config-url.com/cloudconfig/ reason: Unexpected end of JSON input',
+        ),
       );
     });
 
@@ -211,7 +213,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(413);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -223,8 +224,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 413 Payload Too Large",
-        )
+          'An error occurred while fetching your schema from Apollo: 413 Payload Too Large',
+        ),
       );
     });
 
@@ -232,7 +233,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(422);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -244,8 +244,8 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity",
-        )
+          'An error occurred while fetching your schema from Apollo: 422 Unprocessable Entity',
+        ),
       );
     });
 
@@ -253,7 +253,6 @@ describe('loadSupergraphSdlFromStorage', () => {
       mockSupergraphSdlRequest().reply(408);
       mockOutOfBandReportRequestSuccess();
 
-      const fetcher = getDefaultFetcher();
       await expect(
         loadSupergraphSdlFromStorage({
           graphRef,
@@ -265,18 +264,16 @@ describe('loadSupergraphSdlFromStorage', () => {
         }),
       ).rejects.toThrowError(
         new UplinkFetcherError(
-          "An error occurred while fetching your schema from Apollo: 408 Request Timeout",
-        )
+          'An error occurred while fetching your schema from Apollo: 408 Request Timeout',
+        ),
       );
     });
   });
 
   it('throws on 504 status response and successfully submits an out of band error', async () => {
-
     mockSupergraphSdlRequest().reply(504);
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -288,8 +285,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 504 Gateway Timeout",
-      )
+        'An error occurred while fetching your schema from Apollo: 504 Gateway Timeout',
+      ),
     );
   });
 
@@ -297,7 +294,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     mockSupergraphSdlRequest().replyWithError('no response');
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -309,8 +305,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: request to https://example1.cloud-config-url.com/cloudconfig/ failed, reason: no response",
-      )
+        'An error occurred while fetching your schema from Apollo: request to https://example1.cloud-config-url.com/cloudconfig/ failed, reason: no response',
+      ),
     );
   });
 
@@ -318,7 +314,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     mockSupergraphSdlRequest().reply(502);
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -330,8 +325,8 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 502 Bad Gateway",
-      )
+        'An error occurred while fetching your schema from Apollo: 502 Bad Gateway',
+      ),
     );
   });
 
@@ -339,7 +334,6 @@ describe('loadSupergraphSdlFromStorage', () => {
     mockSupergraphSdlRequest().reply(503);
     mockOutOfBandReportRequestSuccess();
 
-    const fetcher = getDefaultFetcher();
     await expect(
       loadSupergraphSdlFromStorage({
         graphRef,
@@ -351,69 +345,72 @@ describe('loadSupergraphSdlFromStorage', () => {
       }),
     ).rejects.toThrowError(
       new UplinkFetcherError(
-        "An error occurred while fetching your schema from Apollo: 503 Service Unavailable",
-      )
+        'An error occurred while fetching your schema from Apollo: 503 Service Unavailable',
+      ),
     );
   });
 
   it('successfully responds to SDL unchanged by returning null', async () => {
-    mockSupergraphSdlRequestIfAfterUnchanged("id-1234");
+    mockSupergraphSdlRequestIfAfterUnchanged('id-1234');
 
-    const fetcher = getDefaultFetcher();
     const result = await loadSupergraphSdlFromStorage({
-        graphRef,
-        apiKey,
-        endpoint: mockCloudConfigUrl1,
-        errorReportingEndpoint: mockOutOfBandReporterUrl,
-        fetcher,
-        compositionId: "id-1234",
+      graphRef,
+      apiKey,
+      endpoint: mockCloudConfigUrl1,
+      errorReportingEndpoint: mockOutOfBandReporterUrl,
+      fetcher,
+      compositionId: 'id-1234',
     });
     expect(result).toBeNull();
   });
 });
 
-
-describe("loadSupergraphSdlFromUplinks", () => {
+describe('loadSupergraphSdlFromUplinks', () => {
   beforeEach(nockBeforeEach);
   afterEach(nockAfterEach);
 
   it("doesn't retry in the unchanged / null case", async () => {
-    mockSupergraphSdlRequestIfAfterUnchanged("id-1234", mockCloudConfigUrl1);
+    mockSupergraphSdlRequestIfAfterUnchanged('id-1234', mockCloudConfigUrl1);
 
-    const fetcher = jest.fn(getDefaultFetcher());
+    let calls = 0;
     const result = await loadSupergraphSdlFromUplinks({
       graphRef,
       apiKey,
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: mockOutOfBandReporterUrl,
-      fetcher: fetcher as any,
-      compositionId: "id-1234",
+      fetcher: (...args) => {
+        calls++;
+        return fetcher(...args);
+      },
+      compositionId: 'id-1234',
       maxRetries: 5,
       roundRobinSeed: 0,
       earliestFetchTime: null,
     });
 
     expect(result).toBeNull();
-    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(calls).toBe(1);
   });
 
-  it("Waits the correct time before retrying", async () => {
+  it('Waits the correct time before retrying', async () => {
     const timeoutSpy = jest.spyOn(global, 'setTimeout');
 
     mockSupergraphSdlRequest('originalId-1234', mockCloudConfigUrl1).reply(500);
-    mockSupergraphSdlRequestIfAfter('originalId-1234', mockCloudConfigUrl2).reply(
+    mockSupergraphSdlRequestIfAfter(
+      'originalId-1234',
+      mockCloudConfigUrl2,
+    ).reply(
       200,
       JSON.stringify({
         data: {
           routerConfig: {
             __typename: 'RouterConfigResult',
             id: 'originalId-1234',
-            supergraphSdl: getTestingSupergraphSdl()
+            supergraphSdl: getTestingSupergraphSdl(),
           },
         },
       }),
     );
-    const fetcher = getDefaultFetcher();
 
     await loadSupergraphSdlFromUplinks({
       graphRef,
@@ -421,7 +418,7 @@ describe("loadSupergraphSdlFromUplinks", () => {
       endpoints: [mockCloudConfigUrl1, mockCloudConfigUrl2],
       errorReportingEndpoint: undefined,
       fetcher: fetcher,
-      compositionId: "originalId-1234",
+      compositionId: 'originalId-1234',
       maxRetries: 1,
       roundRobinSeed: 0,
       earliestFetchTime: new Date(Date.now() + 1000),
@@ -435,4 +432,3 @@ describe("loadSupergraphSdlFromUplinks", () => {
     timeoutSpy.mockRestore();
   });
 });
-

package/src/supergraphManagers/UplinkFetcher/index.ts

@@ -1,16 +1,16 @@
-import { fetch } from 'apollo-server-env';
 import type { Logger } from '@apollo/utils.logger';
 import resolvable from '@josephg/resolvable';
 import { SupergraphManager, SupergraphSdlHookOptions } from '../../config';
 import { SubgraphHealthCheckFunction, SupergraphSdlUpdateFunction } from '../..';
 import { loadSupergraphSdlFromUplinks } from './loadSupergraphSdlFromStorage';
+import { Fetcher } from '@apollo/utils.fetcher';
 
 export interface UplinkFetcherOptions {
   fallbackPollIntervalInMs: number;
   subgraphHealthCheck?: boolean;
   graphRef: string;
   apiKey: string;
-  fetcher: typeof fetch;
+  fetcher: Fetcher;
   maxRetries: number;
   uplinkEndpoints: string[];
   logger?: Logger;

package/src/supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage.ts

@@ -1,9 +1,13 @@
-import { fetch, Response, Request } from 'apollo-server-env';
 import { GraphQLError } from 'graphql';
 import retry from 'async-retry';
 import { SupergraphSdlUpdate } from '../../config';
 import { submitOutOfBandReportIfConfigured } from './outOfBandReporter';
 import { SupergraphSdlQuery } from '../../__generated__/graphqlTypes';
+import type {
+  Fetcher,
+  FetcherResponse,
+  FetcherRequestInit,
+} from '@apollo/utils.fetcher';
 
 // Magic /* GraphQL */ comment below is for codegen, do not remove
 export const SUPERGRAPH_SDL_QUERY = /* GraphQL */`#graphql
@@ -63,7 +67,7 @@ export async function loadSupergraphSdlFromUplinks({
   apiKey: string;
   endpoints: string[];
   errorReportingEndpoint: string | undefined,
-  fetcher: typeof fetch;
+  fetcher: Fetcher;
   compositionId: string | null;
   maxRetries: number,
   roundRobinSeed: number,
@@ -105,20 +109,21 @@ export async function loadSupergraphSdlFromStorage({
   apiKey: string;
   endpoint: string;
   errorReportingEndpoint?: string;
-  fetcher: typeof fetch;
+  fetcher: Fetcher;
   compositionId: string | null;
 }) : Promise<SupergraphSdlUpdate | null> {
-  let result: Response;
-  const requestDetails = {
+  const requestBody = JSON.stringify({
+    query: SUPERGRAPH_SDL_QUERY,
+    variables: {
+      ref: graphRef,
+      apiKey,
+      ifAfterId: compositionId,
+    },
+  })
+
+  const requestDetails: FetcherRequestInit = {
     method: 'POST',
-    body: JSON.stringify({
-      query: SUPERGRAPH_SDL_QUERY,
-      variables: {
-        ref: graphRef,
-        apiKey,
-        ifAfterId: compositionId,
-      },
-    }),
+    body: requestBody,
     headers: {
       'apollographql-client-name': name,
       'apollographql-client-version': version,
@@ -127,9 +132,8 @@ export async function loadSupergraphSdlFromStorage({
     },
   };
 
-  const request: Request = new Request(endpoint, requestDetails);
-
   const startTime = new Date();
+  let result: FetcherResponse;
   try {
     result = await fetcher(endpoint, requestDetails);
   } catch (e) {
@@ -137,7 +141,8 @@ export async function loadSupergraphSdlFromStorage({
 
     await submitOutOfBandReportIfConfigured({
       error: e,
-      request,
+      requestEndpoint: endpoint,
+      requestBody,
       endpoint: errorReportingEndpoint,
       startedAt: startTime,
       endedAt: endTime,
@@ -168,7 +173,8 @@ export async function loadSupergraphSdlFromStorage({
   } else {
     await submitOutOfBandReportIfConfigured({
       error: new UplinkFetcherError(fetchErrorMsg + result.status + ' ' + result.statusText),
-      request,
+      requestEndpoint: endpoint,
+      requestBody,
       endpoint: errorReportingEndpoint,
       response: result,
       startedAt: startTime,

package/src/supergraphManagers/UplinkFetcher/outOfBandReporter.ts

@@ -1,4 +1,4 @@
-import { fetch, Response, Request } from 'apollo-server-env';
+import { Fetcher, FetcherResponse } from '@apollo/utils.fetcher';
 import { GraphQLError } from 'graphql';
 import {
   ErrorCode,
@@ -30,7 +30,8 @@ interface OobReportMutationFailure {
 
 export async function submitOutOfBandReportIfConfigured({
   error,
-  request,
+  requestEndpoint,
+  requestBody,
   endpoint,
   response,
   startedAt,
@@ -39,13 +40,14 @@ export async function submitOutOfBandReportIfConfigured({
   fetcher,
 }: {
   error: Error;
-  request: Request;
+  requestEndpoint: string;
+  requestBody: string;
   endpoint: string | undefined;
-  response?: Response;
+  response?: FetcherResponse;
   startedAt: Date;
   endedAt: Date;
   tags?: string[];
-  fetcher: typeof fetch;
+  fetcher: Fetcher;
 }) {
   // don't send report if the endpoint url is not configured
   if (!endpoint) {
@@ -85,8 +87,8 @@ export async function submitOutOfBandReportIfConfigured({
         message: error.message,
       },
       request: {
-        url: request.url,
-        body: await request.text(),
+        url: requestEndpoint,
+        body: requestBody,
       },
       response: response
         ? {

package/src/__mocks__/apollo-server-env.ts

@@ -1,56 +0,0 @@
-import {
-  fetch,
-  Request,
-  Response,
-  Body,
-  BodyInit,
-  Headers,
-  HeadersInit,
-  URL,
-  URLSearchParams,
-} from 'apollo-server-env';
-interface FetchMock extends jest.MockedFunction<typeof fetch> {
-  mockResponseOnce(data?: any, headers?: HeadersInit, status?: number): this;
-  mockJSONResponseOnce(data?: object, headers?: HeadersInit): this;
-}
-
-const mockFetch = jest.fn(fetch) as unknown as FetchMock;
-
-mockFetch.mockResponseOnce = (
-  data?: BodyInit,
-  headers?: Headers,
-  status: number = 200,
-) => {
-  return mockFetch.mockImplementationOnce(async () => {
-    return new Response(data, {
-      status,
-      headers,
-    });
-  });
-};
-
-mockFetch.mockJSONResponseOnce = (
-  data = {},
-  headers?: Headers,
-  status?: number,
-) => {
-  return mockFetch.mockResponseOnce(
-    JSON.stringify(data),
-    Object.assign({ 'Content-Type': 'application/json' }, headers),
-    status,
-  );
-};
-
-const env = {
-  fetch: mockFetch,
-  Request,
-  Response,
-  Body,
-  Headers,
-  URL,
-  URLSearchParams,
-};
-
-jest.doMock('apollo-server-env', () => env);
-
-export = env;

package/src/__mocks__/make-fetch-happen-fetcher.ts

@@ -1,57 +0,0 @@
-/// <reference path="../make-fetch-happen.d.ts" />
-// This explicit reference shouldn't be needed because the project references
-// the main project, which includes these type declarations. For some reason,
-// VS Code doesn't pick that up though.
-// (This may be related to https://github.com/microsoft/TypeScript/issues/36708.)
-
-import {
-  fetch,
-  Response,
-  BodyInit,
-  Headers,
-  HeadersInit
-} from 'apollo-server-env';
-
-import fetcher from 'make-fetch-happen';
-
-interface MakeFetchHappenMock extends jest.MockedFunction<typeof fetch> {
-  mockResponseOnce(data?: any, headers?: HeadersInit, status?: number): this;
-  mockJSONResponseOnce(data?: object, headers?: HeadersInit): this;
-}
-
-const mockMakeFetchHappen = jest.fn(fetcher) as unknown as MakeFetchHappenMock;
-const defaults = () => mockMakeFetchHappen;
-
-mockMakeFetchHappen.mockResponseOnce = (
-  data?: BodyInit,
-  headers?: Headers,
-  status: number = 200,
-) => {
-  return mockMakeFetchHappen.mockImplementationOnce(async () => {
-    return new Response(data, {
-      status,
-      headers,
-    });
-  });
-};
-
-mockMakeFetchHappen.mockJSONResponseOnce = (
-  data = {},
-  headers?: Headers,
-  status?: number,
-) => {
-  return mockMakeFetchHappen.mockResponseOnce(
-    JSON.stringify(data),
-    Object.assign({ 'Content-Type': 'application/json' }, headers),
-    status,
-  );
-};
-
-const makeFetchMock = {
-  fetch: mockMakeFetchHappen,
-  defaults,
-};
-
-jest.doMock('make-fetch-happen', () => makeFetchMock);
-
-export = makeFetchMock;