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

package/src/__tests__/integration/nockMocks.ts

@@ -1,22 +1,33 @@
 import nock from 'nock';
-import { HEALTH_CHECK_QUERY, SERVICE_DEFINITION_QUERY } from '../..';
 import { MockService } from './networkRequests.test';
-
-export const graphId = 'federated-service';
-export const apiKeyHash = 'dd55a79d467976346d229a7b12b673ce';
-const storageSecret = 'my-storage-secret';
-const accountsService = 'accounts';
+import { HEALTH_CHECK_QUERY, SERVICE_DEFINITION_QUERY } from '../..';
+import { SUPERGRAPH_SDL_QUERY } from '../../loadSupergraphSdlFromStorage';
+import { getTestingSupergraphSdl } from '../../__tests__/execution-utils';
+import { print } from 'graphql';
+import { fixtures } from 'apollo-federation-integration-testsuite';
+
+export const graphRef = 'federated-service@current';
+export const apiKey = 'service:federated-service:DD71EBbGmsuh-6suUVDwnA';
+const apiKeyHash = 'dd55a79d467976346d229a7b12b673ce';
+
+export const mockApolloConfig = {
+  apollo: {
+    key: apiKey,
+    keyHash: apiKeyHash,
+    graphRef,
+  },
+};
 
 // Service mocks
-function mockSDLQuery({ url }: MockService) {
+function mockSdlQuery({ url }: MockService) {
   return nock(url).post('/', {
     query: SERVICE_DEFINITION_QUERY,
   });
 }
 
-export function mockSDLQuerySuccess(service: MockService) {
-  mockSDLQuery(service).reply(200, {
-    data: { _service: { sdl: service.sdl } },
+export function mockSdlQuerySuccess(service: MockService) {
+  return mockSdlQuery(service).reply(200, {
+    data: { _service: { sdl: print(service.typeDefs) } },
   });
 }
 
@@ -32,82 +43,100 @@ export function mockServiceHealthCheckSuccess(service: MockService) {
   });
 }
 
-// GCS mocks
-function gcsNock(url: Parameters<typeof nock>[0]): nock.Scope {
+export function mockAllServicesHealthCheckSuccess() {
+  return fixtures.map((fixture) =>
+    mockServiceHealthCheck(fixture).reply(200, {
+      data: { __typename: 'Query' },
+    }),
+  );
+}
+
+// Supergraph SDL fetching mocks
+function gatewayNock(url: Parameters<typeof nock>[0]): nock.Scope {
+  const { name, version } = require('../../../package.json');
   return nock(url, {
     reqheaders: {
-      'user-agent': `apollo-gateway/${
-        require('../../../package.json').version
-      }`,
+      'apollographql-client-name': name,
+      'apollographql-client-version': version,
+      'user-agent': `${name}/${version}`,
+      'content-type': 'application/json',
     },
   });
 }
 
-export function mockStorageSecret() {
-  return gcsNock('https://storage-secrets.api.apollographql.com:443').get(
-    `/${graphId}/storage-secret/${apiKeyHash}.json`,
-  );
-}
+export const mockCloudConfigUrl =
+  'https://example.cloud-config-url.com/cloudconfig/';
 
-export function mockStorageSecretSuccess() {
-  return gcsNock('https://storage-secrets.api.apollographql.com:443')
-    .get(
-      `/${graphId}/storage-secret/${apiKeyHash}.json`,
-    )
-    .reply(200, `"${storageSecret}"`);
-}
+export const mockOutOfBandReporterUrl =
+  'https://example.outofbandreporter.com/monitoring/';
 
-// get composition config link, using received storage secret
-export function mockCompositionConfigLink() {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/v1/composition-config-link`,
-  );
-}
-
-export function mockCompositionConfigLinkSuccess() {
-  return mockCompositionConfigLink().reply(200, {
-    configPath: `${storageSecret}/current/v1/composition-configs/composition-config-path.json`,
+export function mockSupergraphSdlRequestIfAfter(ifAfter: string | null) {
+  return gatewayNock(mockCloudConfigUrl).post('/', {
+    query: SUPERGRAPH_SDL_QUERY,
+    variables: {
+      ref: graphRef,
+      apiKey: apiKey,
+      ifAfterId: ifAfter,
+    },
   });
 }
 
-// get composition configs, using received composition config link
-export function mockCompositionConfigs() {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/v1/composition-configs/composition-config-path.json`,
-  );
+export function mockSupergraphSdlRequest(ifAfter: string | null = null) {
+  return mockSupergraphSdlRequestIfAfter(ifAfter);
 }
 
-export function mockCompositionConfigsSuccess(services: MockService[]) {
-  return mockCompositionConfigs().reply(200, {
-    implementingServiceLocations: services.map(service => ({
-      name: accountsService,
-      path: `${storageSecret}/current/v1/implementing-services/${accountsService}/${service.gcsDefinitionPath}`,
-    })),
-  });
+export function mockSupergraphSdlRequestSuccessIfAfter(
+  ifAfter: string | null = null,
+  id: string = 'originalId-1234',
+  supergraphSdl: string = getTestingSupergraphSdl(),
+) {
+  if (supergraphSdl == null) {
+    supergraphSdl = getTestingSupergraphSdl();
+  }
+  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+    200,
+    JSON.stringify({
+      data: {
+        routerConfig: {
+          __typename: 'RouterConfigResult',
+          id,
+          supergraphSdl,
+        },
+      },
+    }),
+  );
 }
 
-// get implementing service reference, using received composition-config
-export function mockImplementingServices({ gcsDefinitionPath }: MockService) {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/v1/implementing-services/${accountsService}/${gcsDefinitionPath}`,
+export function mockSupergraphSdlRequestIfAfterUnchanged(
+    ifAfter: string | null = null,
+) {
+  return mockSupergraphSdlRequestIfAfter(ifAfter).reply(
+      200,
+      JSON.stringify({
+        data: {
+          routerConfig: {
+            __typename: 'Unchanged',
+          },
+        },
+      }),
   );
 }
 
-export function mockImplementingServicesSuccess(service: MockService) {
-  return mockImplementingServices(service).reply(200, {
-    name: accountsService,
-    partialSchemaPath: `${storageSecret}/current/raw-partial-schemas/${service.partialSchemaPath}`,
-    url: service.url,
-  });
+export function mockSupergraphSdlRequestSuccess() {
+  return mockSupergraphSdlRequestSuccessIfAfter(null);
 }
 
-// get raw-partial-schema, using received composition-config
-export function mockRawPartialSchema({ partialSchemaPath }: MockService) {
-  return gcsNock('https://federation.api.apollographql.com:443').get(
-    `/${storageSecret}/current/raw-partial-schemas/${partialSchemaPath}`,
-  );
+export function mockOutOfBandReportRequest() {
+  return gatewayNock(mockOutOfBandReporterUrl).post('/', () => true);
 }
 
-export function mockRawPartialSchemaSuccess(service: MockService) {
-  return mockRawPartialSchema(service).reply(200, service.sdl);
+export function mockOutOfBandReportRequestSuccess() {
+  return mockOutOfBandReportRequest().reply(
+    200,
+    JSON.stringify({
+      data: {
+        reportError: true
+      },
+    }),
+  );
 }

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

@@ -45,7 +45,10 @@ it('does not load fields provided even when going to other service', async () =>
       topReviews {
         author {
           username
-          name
+          name {
+            first
+            last
+          }
         }
       }
     }
@@ -60,11 +63,11 @@ it('does not load fields provided even when going to other service', async () =>
 
   expect(data).toEqual({
     topReviews: [
-      { author: { username: '@ada', name: 'Ada Lovelace' } },
-      { author: { username: '@ada', name: 'Ada Lovelace' } },
-      { author: { username: '@complete', name: 'Alan Turing' } },
-      { author: { username: '@complete', name: 'Alan Turing' } },
-      { author: { username: '@complete', name: 'Alan Turing' } },
+      { author: { username: '@ada', name: { first: 'Ada', last: 'Lovelace' } } },
+      { author: { username: '@ada', name: { first: 'Ada', last: 'Lovelace' } } },
+      { author: { username: '@complete', name: { first: 'Alan', last: 'Turing' } } },
+      { author: { username: '@complete', name: { first: 'Alan', last: 'Turing' } } },
+      { author: { username: '@complete', name: { first: 'Alan', last: 'Turing' } } },
     ],
   });
 

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

@@ -1,7 +1,9 @@
 import gql from 'graphql-tag';
 import { execute } from '../execution-utils';
-import { serializeQueryPlan } from '../..';
+import { astSerializer, queryPlanSerializer } from 'apollo-federation-integration-testsuite';
 
+expect.addSnapshotSerializer(astSerializer);
+expect.addSnapshotSerializer(queryPlanSerializer);
 it('supports passing additional fields defined by a requires', async () => {
   const query = `#graphql
     query GetReviwedBookNames {
@@ -128,33 +130,33 @@ it('collapses nested requires', async () => {
 
   expect(errors).toEqual(undefined);
 
-  expect(serializeQueryPlan(queryPlan)).toMatchInlineSnapshot(`
-    "QueryPlan {
+  expect(queryPlan).toMatchInlineSnapshot(`
+    QueryPlan {
       Sequence {
-        Fetch(service: \\"a\\") {
+        Fetch(service: "a") {
           {
             user {
               __typename
               id
               preferences {
                 favorites {
-                  color
                   animal
+                  color
                 }
               }
             }
           }
         },
-        Flatten(path: \\"user\\") {
-          Fetch(service: \\"b\\") {
+        Flatten(path: "user") {
+          Fetch(service: "b") {
             {
               ... on User {
                 __typename
                 id
                 preferences {
                   favorites {
-                    color
                     animal
+                    color
                   }
                 }
               }
@@ -168,7 +170,7 @@ it('collapses nested requires', async () => {
           },
         },
       },
-    }"
+    }
   `);
 
   expect(data).toEqual({
@@ -209,10 +211,10 @@ it('collapses nested requires with user-defined fragments', async () => {
 
   expect(errors).toEqual(undefined);
 
-  expect(serializeQueryPlan(queryPlan)).toMatchInlineSnapshot(`
-    "QueryPlan {
+  expect(queryPlan).toMatchInlineSnapshot(`
+    QueryPlan {
       Sequence {
-        Fetch(service: \\"a\\") {
+        Fetch(service: "a") {
           {
             user {
               __typename
@@ -226,8 +228,8 @@ it('collapses nested requires with user-defined fragments', async () => {
             }
           }
         },
-        Flatten(path: \\"user\\") {
-          Fetch(service: \\"b\\") {
+        Flatten(path: "user") {
+          Fetch(service: "b") {
             {
               ... on User {
                 __typename
@@ -247,7 +249,7 @@ it('collapses nested requires with user-defined fragments', async () => {
           },
         },
       },
-    }"
+    }
   `);
 
   expect(data).toEqual({