@apollo/gateway 2.4.4 → 2.4.6

package/src/__tests__/gateway/lifecycle-hooks.test.ts

@@ -1,239 +0,0 @@
-import gql from 'graphql-tag';
-import { ApolloGateway } from '../..';
-import {
-  DynamicGatewayConfig,
-  Experimental_DidResolveQueryPlanCallback,
-  Experimental_UpdateServiceDefinitions,
-  ServiceDefinitionUpdate,
-} from '../../config';
-import {
-  product,
-  reviews,
-  inventory,
-  accounts,
-  books,
-  documents,
-  fixtures,
-  fixturesWithUpdate,
-} from 'apollo-federation-integration-testsuite';
-import { createHash } from '@apollo/utils.createhash';
-import type { Logger } from '@apollo/utils.logger';
-import resolvable from '@josephg/resolvable';
-import { getTestingSupergraphSdl } from '../execution-utils';
-
-// The order of this was specified to preserve existing test coverage. Typically
-// we would just import and use the `fixtures` array.
-const serviceDefinitions = [
-  product,
-  reviews,
-  inventory,
-  accounts,
-  books,
-  documents,
-].map((s, i) => ({
-  name: s.name,
-  typeDefs: s.typeDefs,
-  url: `http://localhost:${i}`,
-}));
-
-let logger: Logger;
-
-beforeEach(() => {
-  const warn = jest.fn();
-  const debug = jest.fn();
-  const error = jest.fn();
-  const info = jest.fn();
-
-  logger = {
-    warn,
-    debug,
-    error,
-    info,
-  };
-});
-
-describe('lifecycle hooks', () => {
-  it('uses updateServiceDefinitions override', async () => {
-    const experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions =
-      jest.fn(async () => {
-        return { serviceDefinitions, isNewSchema: true };
-      });
-
-    const gateway = new ApolloGateway({
-      serviceList: serviceDefinitions,
-      experimental_updateServiceDefinitions,
-      logger,
-    });
-
-    await gateway.load();
-
-    expect(experimental_updateServiceDefinitions).toBeCalled();
-    expect(gateway.schema!.getType('Furniture')).toBeDefined();
-    await gateway.stop();
-  });
-
-  it('calls experimental_didUpdateSupergraph on schema update', async () => {
-    const compositionMetadata = {
-      formatVersion: 1,
-      id: 'abc',
-      implementingServiceLocations: [],
-      schemaHash: 'hash1',
-    };
-
-    const mockUpdate = jest
-      .fn<Promise<ServiceDefinitionUpdate>, [config: DynamicGatewayConfig]>()
-      .mockImplementationOnce(async () => {
-        return {
-          serviceDefinitions: fixtures,
-          isNewSchema: true,
-          compositionMetadata: {
-            ...compositionMetadata,
-            id: '123',
-            schemaHash: 'hash2',
-          },
-        };
-      })
-      // We want to return a different composition across two ticks, so we mock it
-      // slightly differently
-      .mockImplementationOnce(async () => {
-        return {
-          serviceDefinitions: fixturesWithUpdate,
-          isNewSchema: true,
-          compositionMetadata,
-        };
-      });
-
-    const mockDidUpdate = jest.fn();
-
-    const gateway = new ApolloGateway({
-      experimental_updateServiceDefinitions: mockUpdate,
-      experimental_didUpdateSupergraph: mockDidUpdate,
-      logger,
-    });
-    // for testing purposes, a short pollInterval is ideal so we'll override here
-    gateway['pollIntervalInMs'] = 100;
-
-    const schemaChangeBlocker1 = resolvable();
-    const schemaChangeBlocker2 = resolvable();
-
-    gateway.onSchemaLoadOrUpdate(
-      jest
-        .fn()
-        .mockImplementationOnce(() => schemaChangeBlocker1.resolve())
-        .mockImplementationOnce(() => schemaChangeBlocker2.resolve()),
-    );
-
-    await gateway.load();
-
-    await schemaChangeBlocker1;
-
-    expect(mockUpdate).toBeCalledTimes(1);
-    expect(mockDidUpdate).toBeCalledTimes(1);
-
-    await schemaChangeBlocker2;
-
-    expect(mockUpdate).toBeCalledTimes(2);
-    expect(mockDidUpdate).toBeCalledTimes(2);
-
-    const [firstCall, secondCall] = mockDidUpdate.mock.calls;
-
-    // Note that we've composing our usual test fixtures here
-    const expectedFirstId = createHash('sha256').update(getTestingSupergraphSdl()).digest('hex');
-    expect(firstCall[0]!.compositionId).toEqual(expectedFirstId);
-    // first call should have no second "previous" argument
-    expect(firstCall[1]).toBeUndefined();
-
-    // Note that this assertion is a tad fragile in that every time we modify
-    // the supergraph (even just formatting differences), this ID will change
-    // and this test will have to updated.
-    expect(secondCall[0]!.compositionId).toEqual(
-      '4644102bb30ec7e254fac2577f78137bbab156cb965973ae481f309120738ff6',
-    );
-    // second call should have previous info in the second arg
-    expect(secondCall[1]!.compositionId).toEqual(expectedFirstId);
-
-    await gateway.stop();
-  });
-
-  it('uses default service definition updater', async () => {
-    const gateway = new ApolloGateway({
-      localServiceList: serviceDefinitions,
-      logger,
-    });
-
-    const { schema } = await gateway.load();
-
-    // spying on gateway.loadServiceDefinitions wasn't working, so this also
-    // should test functionality. If there's no overwriting service definition
-    // updater, it has to use the default. If there's a valid schema, then
-    // the loader had to have been called.
-    expect(schema.getType('User')).toBeDefined();
-
-    await gateway.stop();
-  });
-
-  it('warns when polling on the default fetcher', async () => {
-    new ApolloGateway({
-      serviceList: serviceDefinitions,
-      pollIntervalInMs: 10,
-      logger,
-    });
-    expect(logger.warn).toHaveBeenCalledWith(
-      'Polling running services is dangerous and not recommended in production. Polling should only be used against a registry. If you are polling running services, use with caution.',
-    );
-  });
-
-  it('registers schema change callbacks when pollIntervalInMs is set for unmanaged configs', async () => {
-    const experimental_updateServiceDefinitions: Experimental_UpdateServiceDefinitions =
-      jest.fn(async (_config) => {
-        return { serviceDefinitions, isNewSchema: true };
-      });
-
-    const gateway = new ApolloGateway({
-      serviceList: [{ name: 'book', url: 'http://localhost:32542' }],
-      experimental_updateServiceDefinitions,
-      pollIntervalInMs: 100,
-      logger,
-    });
-
-    const schemaChangeBlocker = resolvable();
-    const schemaChangeCallback = jest.fn(() => schemaChangeBlocker.resolve());
-
-    gateway.onSchemaLoadOrUpdate(schemaChangeCallback);
-    await gateway.load();
-
-    await schemaChangeBlocker;
-
-    expect(schemaChangeCallback).toBeCalledTimes(1);
-    await gateway.stop();
-  });
-
-  it('calls experimental_didResolveQueryPlan when executor is called', async () => {
-    const experimental_didResolveQueryPlan: Experimental_DidResolveQueryPlanCallback =
-      jest.fn();
-
-    const gateway = new ApolloGateway({
-      localServiceList: [books],
-      experimental_didResolveQueryPlan,
-    });
-
-    const { executor } = await gateway.load();
-
-    const source = `#graphql
-      { book(isbn: "0262510871") { year } }
-    `;
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    await executor({
-      source,
-      document: gql(source),
-      request: {},
-      queryHash: 'hashed',
-      context: {},
-    });
-
-    expect(experimental_didResolveQueryPlan).toBeCalled();
-    await gateway.stop();
-  });
-});

package/src/__tests__/gateway/opentelemetry.test.ts

@@ -1,123 +0,0 @@
-import gql from 'graphql-tag';
-import {ApolloGateway, LocalGraphQLDataSource} from '../../';
-import {fixtures, spanSerializer} from 'apollo-federation-integration-testsuite';
-import {InMemorySpanExporter, SimpleSpanProcessor} from '@opentelemetry/tracing'
-import {NodeTracerProvider} from '@opentelemetry/node';
-import { buildSubgraphSchema } from '@apollo/subgraph';
-
-expect.addSnapshotSerializer(spanSerializer);
-
-const inMemorySpans = new InMemorySpanExporter();
-const tracerProvider = new NodeTracerProvider();
-tracerProvider.addSpanProcessor(new SimpleSpanProcessor(inMemorySpans));
-tracerProvider.register();
-
-beforeEach(() => {
-  inMemorySpans.reset();
-});
-
-describe('opentelemetry', () => {
-  async function execute(executor: any, source: string, variables: any, operationName: string) {
-    await executor({
-      source,
-      document: gql(source),
-      request: {
-        variables,
-      },
-      operationName,
-      queryHash: 'hashed',
-      context: null,
-      cache: {} as any,
-    });
-  }
-
-  describe('with local data', () =>
-  {
-    async function gateway() {
-      const localDataSources = Object.fromEntries(
-        fixtures.map((f) => [
-          f.name,
-          new LocalGraphQLDataSource(buildSubgraphSchema(f)),
-        ]),
-      );
-      const gateway = new ApolloGateway({
-        localServiceList: fixtures,
-        buildService(service) {
-          return localDataSources[service.name];
-        },
-      });
-
-      const {executor} = await gateway.load();
-      return executor;
-    }
-
-    it('receives spans on success', async () => {
-      const executor = await gateway();
-
-      const source = `#graphql
-      query GetProduct($upc: String!) {
-        product(upc: $upc) {
-          name
-        }
-      }
-    `;
-
-      await execute(executor, source, {upc: '1'}, 'GetProduct');
-      expect(inMemorySpans.getFinishedSpans()).toMatchSnapshot();
-    });
-
-    it('receives spans on validation failure', async () => {
-      const executor = await gateway();
-      const source = `#graphql
-      query InvalidVariables($first: Int!) {
-        topReviews(first: $first) {
-          body
-        }
-      }
-    `;
-
-      await execute(executor, source, { upc: '1' }, 'InvalidVariables');
-      expect(inMemorySpans.getFinishedSpans()).toMatchSnapshot();
-    });
-
-    it('receives spans on plan failure', async () => {
-      const executor = await gateway();
-      const source = `#graphql
-      subscription GetProduct($upc: String!) {
-        product(upc: $upc) {
-          name
-        }
-      }
-    `;
-
-      try {
-        await execute(executor, source, {upc: '1'}, 'GetProduct');
-      }
-      catch(err) {}
-      expect(inMemorySpans.getFinishedSpans()).toMatchSnapshot();
-    });
-  });
-
-
-  it('receives spans on fetch failure', async () => {
-    const gateway = new ApolloGateway({
-      localServiceList: fixtures,
-      fetcher: () => {
-        throw Error('Nooo');
-      },
-    });
-
-    const { executor } = await gateway.load();
-
-    const source = `#graphql
-    query GetProduct($upc: String!) {
-      product(upc: $upc) {
-        name
-      }
-    }
-    `;
-
-    await execute(executor, source, {upc: '1'}, 'GetProduct');
-    expect(inMemorySpans.getFinishedSpans()).toMatchSnapshot();
-  });
-});

package/src/__tests__/gateway/queryPlanCache.test.ts

@@ -1,231 +0,0 @@
-import gql from 'graphql-tag';
-import { ApolloServer } from '@apollo/server';
-import { buildSubgraphSchema } from '@apollo/subgraph';
-
-import { LocalGraphQLDataSource } from '../../datasources/LocalGraphQLDataSource';
-import { ApolloGateway } from '../../';
-import { fixtures } from 'apollo-federation-integration-testsuite';
-import { QueryPlanner } from '@apollo/query-planner';
-import { unwrapSingleResultKind } from '../gateway/testUtils';
-
-it('caches the query plan for a request', async () => {
-  const buildQueryPlanSpy = jest.spyOn(QueryPlanner.prototype, 'buildQueryPlan');
-
-  const localDataSources = Object.fromEntries(
-    fixtures.map((f) => [
-      f.name,
-      new LocalGraphQLDataSource(buildSubgraphSchema(f)),
-    ]),
-  );
-  const gateway = new ApolloGateway({
-    localServiceList: fixtures,
-    buildService(service) {
-      return localDataSources[service.name];
-    },
-  });
-
-  const server = new ApolloServer({ gateway });
-  await server.start();
-
-  const upc = '1';
-
-  const query = `#graphql
-    query GetProduct($upc: String!) {
-      product(upc: $upc) {
-        name
-      }
-    }
-  `;
-
-  const result = await server.executeOperation({
-    query,
-    variables: { upc },
-  });
-
-  const { data: result1Data } = unwrapSingleResultKind(result);
-  expect(result1Data).toEqual({
-    product: {
-      name: 'Table',
-    },
-  });
-
-  const secondResult = await server.executeOperation({
-    query,
-    variables: { upc },
-  });
-
-  expect(unwrapSingleResultKind(secondResult).data).toEqual(result1Data);
-  expect(buildQueryPlanSpy).toHaveBeenCalledTimes(1);
-});
-
-it('supports multiple operations and operationName', async () => {
-  const query = `#graphql
-    query GetUser {
-      me {
-        username
-      }
-    }
-    query GetReviews {
-      topReviews {
-        body
-      }
-    }
-  `;
-
-  const localDataSources = Object.fromEntries(
-    fixtures.map((f) => [
-      f.name,
-      new LocalGraphQLDataSource(buildSubgraphSchema(f)),
-    ]),
-  );
-
-  const gateway = new ApolloGateway({
-    localServiceList: fixtures,
-    buildService(service) {
-      return localDataSources[service.name];
-    },
-  });
-
-  const server = new ApolloServer({ gateway });
-  await server.start();
-
-  const userResult = await server.executeOperation({
-    query,
-    operationName: 'GetUser',
-  });
-
-  const reviewsResult = await server.executeOperation({
-    query,
-    operationName: 'GetReviews',
-  });
-
-  expect(unwrapSingleResultKind(userResult).data).toEqual({
-    me: { username: '@ada' },
-  });
-  expect(unwrapSingleResultKind(reviewsResult).data).toEqual({
-    topReviews: [
-      { body: 'Love it!' },
-      { body: 'Too expensive.' },
-      { body: 'Could be better.' },
-      { body: 'Prefer something else.' },
-      { body: 'Wish I had read this before.' },
-    ],
-  });
-});
-
-it('does not corrupt cached queryplan data across requests', async () => {
-  const serviceA = {
-    name: 'a',
-    typeDefs: gql`
-      type Query {
-        user: User
-      }
-
-      type User @key(fields: "id") {
-        id: ID!
-        preferences: Preferences
-      }
-
-      type Preferences {
-        favorites: Things
-      }
-
-      type Things {
-        color: String
-        animal: String
-      }
-    `,
-    resolvers: {
-      Query: {
-        user() {
-          return {
-            id: '1',
-            preferences: {
-              favorites: { color: 'limegreen', animal: 'platypus' },
-            },
-          };
-        },
-      },
-    },
-  };
-
-  const serviceB = {
-    name: 'b',
-    typeDefs: gql`
-      extend type User @key(fields: "id") {
-        id: ID! @external
-        preferences: Preferences @external
-        favoriteColor: String
-          @requires(fields: "preferences { favorites { color } }")
-        favoriteAnimal: String
-          @requires(fields: "preferences { favorites { animal } }")
-      }
-
-      extend type Preferences {
-        favorites: Things @external
-      }
-
-      extend type Things {
-        color: String @external
-        animal: String @external
-      }
-    `,
-    resolvers: {
-      User: {
-        favoriteColor(user: any) {
-          return user.preferences.favorites.color;
-        },
-        favoriteAnimal(user: any) {
-          return user.preferences.favorites.animal;
-        },
-      },
-    },
-  };
-
-  const dataSources: Record<string, LocalGraphQLDataSource> = {
-    a: new LocalGraphQLDataSource(buildSubgraphSchema(serviceA)),
-    b: new LocalGraphQLDataSource(buildSubgraphSchema(serviceB)),
-  };
-
-  const gateway = new ApolloGateway({
-    localServiceList: [serviceA, serviceB],
-    buildService(service) {
-      return dataSources[service.name];
-    },
-  });
-
-  const server = new ApolloServer({ gateway });
-  await server.start();
-
-  const query1 = `#graphql
-    query UserFavoriteColor {
-      user {
-        favoriteColor
-      }
-    }
-  `;
-
-  const query2 = `#graphql
-    query UserFavorites {
-      user {
-        favoriteColor
-        favoriteAnimal
-      }
-    }
-  `;
-
-  const result1 = await server.executeOperation({
-    query: query1,
-  });
-  const result2 = await server.executeOperation({
-    query: query2,
-  });
-  const result3 = await server.executeOperation({
-    query: query1,
-  });
-
-  expect(unwrapSingleResultKind(result1).errors).toEqual(undefined);
-  expect(unwrapSingleResultKind(result2).errors).toEqual(undefined);
-  expect(unwrapSingleResultKind(result3).errors).toEqual(undefined);
-  expect(result1).toEqual(result3);
-});

package/src/__tests__/gateway/queryPlannerConfig.test.ts

@@ -1,101 +0,0 @@
-import gql from 'graphql-tag';
-import { startSubgraphsAndGateway, Services } from './testUtils'
-
-let services: Services;
-
-afterEach(async () => {
-  if (services) {
-    await services.stop();
-  }
-});
-
-describe('`debug.bypassPlannerForSingleSubgraph` config', () => {
-  const subgraph = {
-    name: 'A',
-    url: 'https://A',
-    typeDefs: gql`
-      type Query {
-        a: A
-      }
-
-      type A {
-        b: B
-      }
-
-      type B {
-        x: Int
-        y: String
-      }
-    `,
-    resolvers: {
-      Query: {
-        a: () => ({
-          b: {
-            x: 1,
-            y: 'foo',
-          }
-        }),
-      }
-    }
-  };
-
-  const query = `
-    {
-      a {
-        b {
-          x
-          y
-        }
-      }
-    }
-  `;
-
-  const expectedResult = `
-    Object {
-      "data": Object {
-        "a": Object {
-          "b": Object {
-            "x": 1,
-            "y": "foo",
-          },
-        },
-      },
-    }
-  `;
-
-  it('is disabled by default', async () => {
-    services = await startSubgraphsAndGateway([subgraph]);
-
-    const response = await services.queryGateway(query);
-    const result = await response.json();
-    expect(result).toMatchInlineSnapshot(expectedResult);
-
-    const queryPlanner = services.gateway.__testing().queryPlanner!;
-    // If the query planner is genuinely used, we shoud have evaluated 1 plan.
-    expect(queryPlanner.lastGeneratedPlanStatistics()?.evaluatedPlanCount).toBe(1);
-  });
-
-  it('works when enabled', async () => {
-    services = await startSubgraphsAndGateway(
-      [subgraph],
-      {
-        gatewayConfig: {
-          queryPlannerConfig: {
-            debug: {
-              bypassPlannerForSingleSubgraph: true,
-            }
-          }
-        }
-      }
-    );
-
-    const response = await services.queryGateway(query);
-    const result = await response.json();
-    expect(result).toMatchInlineSnapshot(expectedResult);
-
-    const queryPlanner = services.gateway.__testing().queryPlanner!;
-    // The `bypassPlannerForSingleSubgraph` doesn't evaluate anything. It's use is the only case where `evaluatedPlanCount` can be 0.
-    expect(queryPlanner.lastGeneratedPlanStatistics()?.evaluatedPlanCount).toBe(0);
-  });
-});
-