@apollo/gateway 2.0.0-alpha.2 → 2.0.0-alpha.6

package/src/__tests__/integration/networkRequests.test.ts

@@ -1,6 +1,5 @@
-import nock from 'nock';
 import gql from 'graphql-tag';
-import { DocumentNode, GraphQLObjectType, GraphQLSchema } from 'graphql';
+import { GraphQLObjectType, GraphQLSchema } from 'graphql';
 import mockedEnv from 'mocked-env';
 import { Logger } from 'apollo-server-types';
 import { ApolloGateway } from '../..';
@@ -12,7 +11,7 @@ import {
   mockSupergraphSdlRequestSuccess,
   mockSupergraphSdlRequest,
   mockApolloConfig,
-  mockCloudConfigUrl,
+  mockCloudConfigUrl1,
   mockSupergraphSdlRequestIfAfter,
   mockSupergraphSdlRequestSuccessIfAfter,
 } from './nockMocks';
@@ -20,21 +19,17 @@ import {
   accounts,
   books,
   documents,
+  Fixture,
   fixturesWithUpdate,
   inventory,
   product,
   reviews,
 } from 'apollo-federation-integration-testsuite';
 import { getTestingSupergraphSdl } from '../execution-utils';
+import { nockAfterEach, nockBeforeEach } from '../nockAssertions';
+import resolvable from '@josephg/resolvable';
 
-type GenericFunction = (...args: unknown[]) => unknown;
-export interface MockService {
-  name: string;
-  url: string;
-  typeDefs: DocumentNode;
-}
-
-const simpleService: MockService = {
+const simpleService: Fixture = {
   name: 'accounts',
   url: 'http://localhost:4001',
   typeDefs: gql`
@@ -63,7 +58,7 @@ let gateway: ApolloGateway | null = null;
 let cleanUp: (() => void) | null = null;
 
 beforeEach(() => {
-  if (!nock.isActive()) nock.activate();
+  nockBeforeEach();
 
   const warn = jest.fn();
   const debug = jest.fn();
@@ -79,9 +74,8 @@ beforeEach(() => {
 });
 
 afterEach(async () => {
-  expect(nock.isDone()).toBeTruthy();
-  nock.cleanAll();
-  nock.restore();
+  nockAfterEach();
+
   if (gateway) {
     await gateway.stop();
     gateway = null;
@@ -106,7 +100,7 @@ it('Fetches Supergraph SDL from remote storage', async () => {
 
   gateway = new ApolloGateway({
     logger,
-    schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+    uplinkEndpoints: [mockCloudConfigUrl1],
   });
 
   await gateway.load(mockApolloConfig);
@@ -116,7 +110,7 @@ it('Fetches Supergraph SDL from remote storage', async () => {
 
 it('Fetches Supergraph SDL from remote storage using a configured env variable', async () => {
   cleanUp = mockedEnv({
-    APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: mockCloudConfigUrl,
+    APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT: mockCloudConfigUrl1,
   });
   mockSupergraphSdlRequestSuccess();
 
@@ -139,29 +133,39 @@ it('Updates Supergraph SDL from remote storage', async () => {
 
   // This test is only interested in the second time the gateway notifies of an
   // update, since the first happens on load.
-  let secondUpdateResolve: GenericFunction;
-  const secondUpdate = new Promise((res) => (secondUpdateResolve = res));
-  const schemaChangeCallback = jest
-    .fn()
-    .mockImplementationOnce(() => undefined)
-    .mockImplementationOnce(() => {
-      secondUpdateResolve();
-    });
+  const secondUpdate = resolvable();
 
   gateway = new ApolloGateway({
     logger,
-    schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+    uplinkEndpoints: [mockCloudConfigUrl1],
   });
-  // eslint-disable-next-line
-  // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-  gateway.experimental_pollInterval = 100;
-  gateway.onSchemaLoadOrUpdate(schemaChangeCallback);
+  // for testing purposes, a short pollInterval is ideal so we'll override here
+  gateway['pollIntervalInMs'] = 100;
+
+  const schemas: GraphQLSchema[] = [];
+  gateway.onSchemaLoadOrUpdate(({ apiSchema }) => {
+    schemas.push(apiSchema);
+  });
+  gateway.onSchemaLoadOrUpdate(
+    jest
+      .fn()
+      .mockImplementationOnce(() => {})
+      .mockImplementationOnce(() => secondUpdate.resolve()),
+  );
 
   await gateway.load(mockApolloConfig);
-  expect(gateway['compositionId']).toMatchInlineSnapshot(`"originalId-1234"`);
 
   await secondUpdate;
-  expect(gateway['compositionId']).toMatchInlineSnapshot(`"updatedId-5678"`);
+
+  // First schema has no 'review' field on the 'Query' type
+  expect(
+    (schemas[0].getType('Query') as GraphQLObjectType).getFields()['review'],
+  ).toBeFalsy();
+
+  // Updated schema adds 'review' field on the 'Query' type
+  expect(
+    (schemas[1].getType('Query') as GraphQLObjectType).getFields()['review'],
+  ).toBeTruthy();
 });
 
 describe('Supergraph SDL update failures', () => {
@@ -170,7 +174,8 @@ describe('Supergraph SDL update failures', () => {
 
     gateway = new ApolloGateway({
       logger,
-      schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+      uplinkEndpoints: [mockCloudConfigUrl1],
+      uplinkMaxRetries: 0,
     });
 
     await expect(
@@ -192,24 +197,23 @@ describe('Supergraph SDL update failures', () => {
     mockSupergraphSdlRequestIfAfter('originalId-1234').reply(500);
 
     // Spy on logger.error so we can just await once it's been called
-    let errorLogged: GenericFunction;
-    const errorLoggedPromise = new Promise((r) => (errorLogged = r));
-    logger.error = jest.fn(() => errorLogged());
+    const errorLoggedPromise = resolvable();
+    logger.error = jest.fn(() => errorLoggedPromise.resolve());
 
     gateway = new ApolloGateway({
       logger,
-      schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+      uplinkEndpoints: [mockCloudConfigUrl1],
+      uplinkMaxRetries: 0,
     });
 
-    // eslint-disable-next-line
-    // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway.experimental_pollInterval = 100;
+    // for testing purposes, a short pollInterval is ideal so we'll override here
+    gateway['pollIntervalInMs'] = 100;
 
     await gateway.load(mockApolloConfig);
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
+      'UplinkFetcher failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: 500 Internal Server Error',
     );
   });
 
@@ -226,25 +230,22 @@ describe('Supergraph SDL update failures', () => {
     });
 
     // Spy on logger.error so we can just await once it's been called
-    let errorLogged: GenericFunction;
-    const errorLoggedPromise = new Promise((r) => (errorLogged = r));
-    logger.error = jest.fn(() => errorLogged());
+    const errorLoggedPromise = resolvable();
+    logger.error = jest.fn(() => errorLoggedPromise.resolve());
 
     gateway = new ApolloGateway({
       logger,
-      schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+      uplinkEndpoints: [mockCloudConfigUrl1],
+      uplinkMaxRetries: 0,
     });
-    // eslint-disable-next-line
-    // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway.experimental_pollInterval = 100;
+    // for testing purposes, a short pollInterval is ideal so we'll override here
+    gateway['pollIntervalInMs'] = 100;
 
     await gateway.load(mockApolloConfig);
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'An error occurred while fetching your schema from Apollo: ' +
-        '\n' +
-        'Cannot query field "fail" on type "Query".',
+      `UplinkFetcher failed to update supergraph with the following error: An error occurred while fetching your schema from Apollo: \nCannot query field "fail" on type "Query".`,
     );
   });
 
@@ -264,23 +265,21 @@ describe('Supergraph SDL update failures', () => {
     );
 
     // Spy on logger.error so we can just await once it's been called
-    let errorLogged: GenericFunction;
-    const errorLoggedPromise = new Promise((r) => (errorLogged = r));
-    logger.error = jest.fn(() => errorLogged());
+    const errorLoggedPromise = resolvable();
+    logger.error = jest.fn(() => errorLoggedPromise.resolve());
 
     gateway = new ApolloGateway({
       logger,
-      schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+      uplinkEndpoints: [mockCloudConfigUrl1],
     });
-    // eslint-disable-next-line
-    // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway.experimental_pollInterval = 100;
+    // for testing purposes, a short pollInterval is ideal so we'll override here
+    gateway['pollIntervalInMs'] = 100;
 
     await gateway.load(mockApolloConfig);
     await errorLoggedPromise;
 
     expect(logger.error).toHaveBeenCalledWith(
-      'Syntax Error: Unexpected Name "Syntax".',
+      'UplinkFetcher failed to update supergraph with the following error: Syntax Error: Unexpected Name "Syntax".',
     );
     expect(gateway.schema).toBeTruthy();
   });
@@ -301,11 +300,10 @@ describe('Supergraph SDL update failures', () => {
 
     gateway = new ApolloGateway({
       logger,
-      schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+      uplinkEndpoints: [mockCloudConfigUrl1],
     });
-    // eslint-disable-next-line
-    // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway.experimental_pollInterval = 100;
+    // for testing purposes, a short pollInterval is ideal so we'll override here
+    gateway['pollIntervalInMs'] = 100;
 
     await expect(
       gateway.load(mockApolloConfig),
@@ -331,26 +329,22 @@ it('Rollsback to a previous schema when triggered', async () => {
   );
   mockSupergraphSdlRequestSuccessIfAfter('updatedId-5678');
 
-  let firstResolve: GenericFunction;
-  let secondResolve: GenericFunction;
-  let thirdResolve: GenericFunction;
-  const firstSchemaChangeBlocker = new Promise((res) => (firstResolve = res));
-  const secondSchemaChangeBlocker = new Promise((res) => (secondResolve = res));
-  const thirdSchemaChangeBlocker = new Promise((res) => (thirdResolve = res));
+  const firstSchemaChangeBlocker = resolvable();
+  const secondSchemaChangeBlocker = resolvable();
+  const thirdSchemaChangeBlocker = resolvable();
 
   const onChange = jest
     .fn()
-    .mockImplementationOnce(() => firstResolve())
-    .mockImplementationOnce(() => secondResolve())
-    .mockImplementationOnce(() => thirdResolve());
+    .mockImplementationOnce(() => firstSchemaChangeBlocker.resolve())
+    .mockImplementationOnce(() => secondSchemaChangeBlocker.resolve())
+    .mockImplementationOnce(() => thirdSchemaChangeBlocker.resolve());
 
   gateway = new ApolloGateway({
     logger,
-    schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+    uplinkEndpoints: [mockCloudConfigUrl1],
   });
-  // eslint-disable-next-line
-  // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-  gateway.experimental_pollInterval = 100;
+  // for testing purposes, a short pollInterval is ideal so we'll override here
+  gateway['pollIntervalInMs'] = 100;
 
   gateway.onSchemaChange(onChange);
   await gateway.load(mockApolloConfig);
@@ -408,9 +402,8 @@ describe('Downstream service health checks', () => {
         err = e;
       }
 
-      // TODO: smell that we should be awaiting something else
       expect(err.message).toMatchInlineSnapshot(`
-        "The gateway did not update its schema due to failed service health checks. The gateway will continue to operate with the previous schema and reattempt updates. The following error occurred during the health check:
+        "The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:
         [accounts]: 500: Internal Server Error"
       `);
 
@@ -432,11 +425,10 @@ describe('Downstream service health checks', () => {
       gateway = new ApolloGateway({
         serviceHealthCheck: true,
         logger,
-        schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+        uplinkEndpoints: [mockCloudConfigUrl1],
       });
-      // eslint-disable-next-line
-      // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-      gateway.experimental_pollInterval = 100;
+      // for testing purposes, a short pollInterval is ideal so we'll override here
+      gateway['pollIntervalInMs'] = 100;
 
       await gateway.load(mockApolloConfig);
       await gateway.stop();
@@ -456,7 +448,7 @@ describe('Downstream service health checks', () => {
       gateway = new ApolloGateway({
         serviceHealthCheck: true,
         logger,
-        schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+        uplinkEndpoints: [mockCloudConfigUrl1],
       });
 
       // This is the ideal, but our version of Jest has a bug with printing error snapshots.
@@ -476,7 +468,7 @@ describe('Downstream service health checks', () => {
 
       // TODO: smell that we should be awaiting something else
       expect(err.message).toMatchInlineSnapshot(`
-        "The gateway did not update its schema due to failed service health checks. The gateway will continue to operate with the previous schema and reattempt updates. The following error occurred during the health check:
+        "The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:
         [accounts]: 500: Internal Server Error"
       `);
 
@@ -505,23 +497,20 @@ describe('Downstream service health checks', () => {
       );
       mockAllServicesHealthCheckSuccess();
 
-      let resolve1: GenericFunction;
-      let resolve2: GenericFunction;
-      const schemaChangeBlocker1 = new Promise((res) => (resolve1 = res));
-      const schemaChangeBlocker2 = new Promise((res) => (resolve2 = res));
+      const schemaChangeBlocker1 = resolvable();
+      const schemaChangeBlocker2 = resolvable();
       const onChange = jest
         .fn()
-        .mockImplementationOnce(() => resolve1())
-        .mockImplementationOnce(() => resolve2());
+        .mockImplementationOnce(() => schemaChangeBlocker1.resolve())
+        .mockImplementationOnce(() => schemaChangeBlocker2.resolve());
 
       gateway = new ApolloGateway({
         serviceHealthCheck: true,
         logger,
-        schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+        uplinkEndpoints: [mockCloudConfigUrl1],
       });
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-      gateway.experimental_pollInterval = 100;
+      // for testing purposes, a short pollInterval is ideal so we'll override here
+      gateway['pollIntervalInMs'] = 100;
 
       gateway.onSchemaChange(onChange);
       await gateway.load(mockApolloConfig);
@@ -539,6 +528,10 @@ describe('Downstream service health checks', () => {
     });
 
     it('Preserves original schema when health check fails', async () => {
+      const errorLoggedPromise = resolvable();
+      const errorSpy = jest.fn(() => errorLoggedPromise.resolve());
+      logger.error = errorSpy;
+
       mockSupergraphSdlRequestSuccess();
       mockAllServicesHealthCheckSuccess();
 
@@ -555,61 +548,16 @@ describe('Downstream service health checks', () => {
       mockServiceHealthCheckSuccess(reviews);
       mockServiceHealthCheckSuccess(documents);
 
-      let resolve: GenericFunction;
-      const schemaChangeBlocker = new Promise((res) => (resolve = res));
-
       gateway = new ApolloGateway({
         serviceHealthCheck: true,
         logger,
-        schemaConfigDeliveryEndpoint: mockCloudConfigUrl,
+        uplinkEndpoints: [mockCloudConfigUrl1],
       });
-      // eslint-disable-next-line
-      // @ts-ignore for testing purposes, a short pollInterval is ideal so we'll override here
-      gateway.experimental_pollInterval = 100;
-
-      // eslint-disable-next-line
-      // @ts-ignore for testing purposes, we'll call the original `updateSchema`
-      // function from our mock. The first call should mimic original behavior,
-      // but the second call needs to handle the PromiseRejection. Typically for tests
-      // like these we would leverage the `gateway.onSchemaChange` callback to drive
-      // the test, but in this case, that callback isn't triggered when the update
-      // fails (as expected) so we get creative with the second mock as seen below.
-      const original = gateway.updateSchema;
-      const mockUpdateSchema = jest
-        .fn()
-        .mockImplementationOnce(async () => {
-          await original.apply(gateway);
-        })
-        .mockImplementationOnce(async () => {
-          // mock the first poll and handle the error which would otherwise be caught
-          // and logged from within the `pollServices` class method
-
-          // This is the ideal, but our version of Jest has a bug with printing error snapshots.
-          // See: https://github.com/facebook/jest/pull/10217 (fixed in v26.2.0)
-          //     expect(original.apply(gateway)).rejects.toThrowErrorMatchingInlineSnapshot(`
-          //       The gateway did not update its schema due to failed service health checks. The gateway will continue to operate with the previous schema and reattempt updates. The following error occurred during the health check:
-          //         [accounts]: 500: Internal Server Error"
-          //     `);
-          // Instead we'll just use the regular snapshot matcher...
-          let err;
-          try {
-            await original.apply(gateway);
-          } catch (e) {
-            err = e;
-          }
-
-          expect(err.message).toMatchInlineSnapshot(`
-            "The gateway did not update its schema due to failed service health checks. The gateway will continue to operate with the previous schema and reattempt updates. The following error occurred during the health check:
-            [accounts]: 500: Internal Server Error"
-          `);
-          // finally resolve the promise which drives this test
-          resolve();
-        });
-
-      // eslint-disable-next-line
-      // @ts-ignore for testing purposes, replace the `updateSchema`
-      // function on the gateway with our mock
-      gateway.updateSchema = mockUpdateSchema;
+      // for testing purposes, a short pollInterval is ideal so we'll override here
+      gateway['pollIntervalInMs'] = 100;
+
+      const updateSpy = jest.fn();
+      gateway.onSchemaLoadOrUpdate(() => updateSpy());
 
       // load the gateway as usual
       await gateway.load(mockApolloConfig);
@@ -618,11 +566,15 @@ describe('Downstream service health checks', () => {
       expect(getRootQueryFields(gateway.schema)).toContain('topReviews');
       expect(getRootQueryFields(gateway.schema)).not.toContain('review');
 
-      await schemaChangeBlocker;
+      await errorLoggedPromise;
+      expect(logger.error).toHaveBeenCalledWith(
+        `UplinkFetcher failed to update supergraph with the following error: The gateway subgraphs health check failed. Updating to the provided \`supergraphSdl\` will likely result in future request failures to subgraphs. The following error occurred during the health check:\n[accounts]: 500: Internal Server Error`,
+      );
 
       // At this point, the mock update should have been called but the schema
       // should still be the original.
-      expect(mockUpdateSchema).toHaveBeenCalledTimes(2);
+      expect(updateSpy).toHaveBeenCalledTimes(1);
+
       expect(getRootQueryFields(gateway.schema)).toContain('topReviews');
       expect(getRootQueryFields(gateway.schema)).not.toContain('review');
     });

package/src/__tests__/integration/nockMocks.ts

@@ -1,10 +1,9 @@
 import nock from 'nock';
-import { MockService } from './networkRequests.test';
 import { HEALTH_CHECK_QUERY, SERVICE_DEFINITION_QUERY } from '../..';
-import { SUPERGRAPH_SDL_QUERY } from '../../loadSupergraphSdlFromStorage';
+import { SUPERGRAPH_SDL_QUERY } from '../../supergraphManagers/UplinkFetcher/loadSupergraphSdlFromStorage';
 import { getTestingSupergraphSdl } from '../../__tests__/execution-utils';
 import { print } from 'graphql';
-import { fixtures } from 'apollo-federation-integration-testsuite';
+import { Fixture, fixtures as testingFixtures } from 'apollo-federation-integration-testsuite';
 
 export const graphRef = 'federated-service@current';
 export const apiKey = 'service:federated-service:DD71EBbGmsuh-6suUVDwnA';
@@ -19,31 +18,39 @@ export const mockApolloConfig = {
 };
 
 // Service mocks
-function mockSdlQuery({ url }: MockService) {
+function mockSdlQuery({ url }: Fixture) {
   return nock(url).post('/', {
     query: SERVICE_DEFINITION_QUERY,
   });
 }
 
-export function mockSdlQuerySuccess(service: MockService) {
+export function mockSdlQuerySuccess(service: Fixture) {
   return mockSdlQuery(service).reply(200, {
     data: { _service: { sdl: print(service.typeDefs) } },
   });
 }
 
-export function mockServiceHealthCheck({ url }: MockService) {
+export function mockAllServicesSdlQuerySuccess(
+  fixtures: Fixture[] = testingFixtures,
+) {
+  return fixtures.map((fixture) => mockSdlQuerySuccess(fixture));
+}
+
+export function mockServiceHealthCheck({ url }: Fixture) {
   return nock(url).post('/', {
     query: HEALTH_CHECK_QUERY,
   });
 }
 
-export function mockServiceHealthCheckSuccess(service: MockService) {
+export function mockServiceHealthCheckSuccess(service: Fixture) {
   return mockServiceHealthCheck(service).reply(200, {
     data: { __typename: 'Query' },
   });
 }
 
-export function mockAllServicesHealthCheckSuccess() {
+export function mockAllServicesHealthCheckSuccess(
+  fixtures: Fixture[] = testingFixtures,
+) {
   return fixtures.map((fixture) =>
     mockServiceHealthCheck(fixture).reply(200, {
       data: { __typename: 'Query' },
@@ -64,14 +71,20 @@ function gatewayNock(url: Parameters<typeof nock>[0]): nock.Scope {
   });
 }
 
-export const mockCloudConfigUrl =
-  'https://example.cloud-config-url.com/cloudconfig/';
+export const mockCloudConfigUrl1 =
+  'https://example1.cloud-config-url.com/cloudconfig/';
+
+export const mockCloudConfigUrl2 =
+  'https://example2.cloud-config-url.com/cloudconfig/';
+
+export const mockCloudConfigUrl3 =
+  'https://example3.cloud-config-url.com/cloudconfig/';
 
 export const mockOutOfBandReporterUrl =
   'https://example.outofbandreporter.com/monitoring/';
 
-export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null) {
-  return gatewayNock(mockCloudConfigUrl).post('/', {
+export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null, url: string = mockCloudConfigUrl1) {
+  return gatewayNock(url).post('/', {
     query: SUPERGRAPH_SDL_QUERY,
     variables: {
       ref: graphRef,
@@ -81,8 +94,8 @@ export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null) {
   });
 }
 
-export function mockSupergraphSdlRequest(ifAfter: string | null = null) {
-  return mockSupergraphSdlRequestIfAfter(ifAfter);
+export function mockSupergraphSdlRequest(ifAfter: string | null = null, url: string = mockCloudConfigUrl1) {
+  return mockSupergraphSdlRequestIfAfter(ifAfter, url);
 }
 
 export function mockSupergraphSdlRequestSuccessIfAfter(
@@ -108,9 +121,10 @@ export function mockSupergraphSdlRequestSuccessIfAfter(
 }
 
 export function mockSupergraphSdlRequestIfAfterUnchanged(
-    ifAfter: string | null = null,
+  ifAfter: string | null = null,
+  url: string = mockCloudConfigUrl1,
 ) {
-  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+  return mockSupergraphSdlRequestIfAfter(ifAfter, url).reply(
       200,
       JSON.stringify({
         data: {

package/src/__tests__/nockAssertions.ts

@@ -0,0 +1,20 @@
+import nock from 'nock';
+
+// Ensures an active and clean nock before every test
+export function nockBeforeEach() {
+  if (!nock.isActive()) {
+    nock.activate();
+  }
+  // Cleaning _before_ each test ensures that any mocks from a previous test
+  // which failed don't affect the current test.
+  nock.cleanAll();
+}
+
+// Ensures a test is complete (all expected requests were run) and a clean
+// global state after each test.
+export function nockAfterEach() {
+  // unmock HTTP interceptor
+  nock.restore();
+  // effectively nock.isDone() but with more helpful messages in test failures
+  expect(nock.activeMocks()).toEqual([]);
+};