@apollo/gateway 2.4.4 → 2.4.6

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

@@ -1,237 +0,0 @@
-import { disableFragmentWarnings } from 'graphql-tag';
-import { execute } from '../execution-utils';
-
-beforeAll(() => {
-  disableFragmentWarnings();
-});
-it('supports inline fragments (one level)', async () => {
-  const query = `#graphql
-    query GetUser {
-      me {
-        ... on User {
-          username
-        }
-      }
-    }
-  `;
-
-  const { data, queryPlan } = await execute({
-    query,
-  });
-
-  expect(data).toEqual({
-    me: {
-      username: '@ada',
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-});
-
-it('supports inline fragments (multi level)', async () => {
-  const query = `#graphql
-    query GetUser {
-      me {
-        ... on User {
-          username
-          reviews {
-            ... on Review {
-              body
-              product {
-                ... on Product {
-                  ... on Book {
-                    title
-                  }
-                  ... on Furniture {
-                    name
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  `;
-
-  const { data, queryPlan } = await execute({
-    query,
-  });
-
-  expect(data).toEqual({
-    me: {
-      username: '@ada',
-      reviews: [
-        { body: 'Love it!', product: { name: 'Table' } },
-        { body: 'Too expensive.', product: { name: 'Couch' } },
-        { body: 'A classic.', product: { title: 'Design Patterns' } },
-      ],
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-  expect(queryPlan).toCallService('reviews');
-  expect(queryPlan).toCallService('product');
-  expect(queryPlan).toCallService('books');
-});
-
-it('supports named fragments (one level)', async () => {
-  const query = `#graphql
-    query GetUser {
-      me {
-        ...userDetails
-      }
-    }
-
-    fragment userDetails on User {
-      username
-    }
-  `;
-
-  const { data, queryPlan } = await execute({
-    query,
-  });
-
-  expect(data).toEqual({
-    me: {
-      username: '@ada',
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-});
-
-it('supports multiple named fragments (one level, mixed ordering)', async () => {
-  const query = `#graphql
-    fragment userInfo on User {
-      name {
-        first
-        last
-      }
-    }
-    query GetUser {
-      me {
-        ...userDetails
-        ...userInfo
-      }
-    }
-
-    fragment userDetails on User {
-      username
-    }
-  `;
-
-  const { data, queryPlan } = await execute({
-    query,
-  });
-
-  expect(data).toEqual({
-    me: {
-      username: '@ada',
-      name: {
-        first: 'Ada',
-        last: 'Lovelace',
-      }
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-});
-
-it('supports multiple named fragments (multi level, mixed ordering)', async () => {
-  const query = `#graphql
-    fragment reviewDetails on Review {
-      body
-    }
-    query GetUser {
-      me {
-        ...userDetails
-      }
-    }
-
-    fragment userDetails on User {
-      username
-      reviews {
-        ...reviewDetails
-      }
-    }
-  `;
-
-  const { data, queryPlan } = await execute({
-    query,
-  });
-
-  expect(data).toEqual({
-    me: {
-      reviews: [
-        { body: 'Love it!' },
-        { body: 'Too expensive.' },
-        { body: 'A classic.' },
-      ],
-      username: '@ada',
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-});
-
-it('supports variables within fragments', async () => {
-  const query = `#graphql
-    query GetUser($format: Boolean) {
-      me {
-        ...userDetails
-      }
-    }
-
-    fragment userDetails on User {
-      username
-      reviews {
-        body(format: $format)
-      }
-    }
-  `;
-
-  const format = true;
-  const { data, queryPlan } = await execute({
-    query,
-    variables: { format },
-  });
-
-  expect(data).toEqual({
-    me: {
-      username: '@ada',
-      reviews: [
-        { body: 'Love it!' },
-        { body: 'Too expensive.' },
-        { body: 'A classic.' },
-      ],
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-  expect(queryPlan).toCallService('reviews');
-});
-
-it('supports root fragments', async () => {
-  const query = `#graphql
-    query GetUser {
-      ... on Query {
-        me {
-          username
-        }
-      }
-    }
-  `;
-
-  const { data, queryPlan } = await execute({
-    query,
-  });
-
-  expect(data).toEqual({
-    me: {
-      username: '@ada',
-    },
-  });
-
-  expect(queryPlan).toCallService('accounts');
-});

package/src/__tests__/integration/list-key.test.ts

@@ -1,128 +0,0 @@
-import gql from 'graphql-tag';
-import { execute, ServiceDefinitionModule } from '../execution-utils';
-import { astSerializer, queryPlanSerializer } from 'apollo-federation-integration-testsuite';
-
-expect.addSnapshotSerializer(astSerializer);
-expect.addSnapshotSerializer(queryPlanSerializer);
-
-const users = [
-  { id: ['1', '1'], name: 'Trevor', __typename: 'User' },
-  { id: ['2', '2'], name: 'James Baxley', __typename: 'User' },
-];
-
-const reviews = [
-  { id: '1', authorId: ['1', '1'], body: 'Good', __typename: 'Review' },
-  { id: '2', authorId: ['2', '2'], body: 'Bad', __typename: 'Review' },
-];
-
-const reviewService: ServiceDefinitionModule = {
-  name: 'review',
-  typeDefs: gql`
-    type Query {
-      reviews: [Review!]!
-    }
-
-    type Review {
-      id: ID!
-      author: User!
-      body: String!
-    }
-
-    extend type User @key(fields: "id") {
-      id: [ID!]! @external
-    }
-  `,
-  resolvers: {
-    Query: {
-      reviews() {
-        return reviews;
-      },
-    },
-    Review: {
-      author(review) {
-        return {
-          id: review.authorId,
-        };
-      },
-    },
-  },
-};
-
-const listsAreEqual = <T>(as: T[], bs: T[]) =>
-  as.length === bs.length && as.every((_, i) => bs[i] === as[i]);
-
-const userService: ServiceDefinitionModule = {
-  name: 'user',
-  typeDefs: gql`
-    type User @key(fields: "id") {
-      id: [ID!]!
-      name: String!
-    }
-  `,
-  resolvers: {
-    User: {
-      __resolveReference(reference) {
-        return users.find(user => listsAreEqual(user.id, reference.id));
-      },
-    },
-  },
-};
-
-it('fetches data correctly list type @key fields', async () => {
-  const query = `#graphql
-    query Reviews {
-      reviews {
-        body
-        author {
-          name
-        }
-      }
-    }
-  `;
-
-  const { data, queryPlan } = await execute(
-    {
-      query,
-    },
-    [userService, reviewService],
-  );
-
-  expect(data).toEqual({
-    reviews: [
-      { body: 'Good', author: { name: 'Trevor' } },
-      { body: 'Bad', author: { name: 'James Baxley' } },
-    ],
-  });
-  expect(queryPlan).toMatchInlineSnapshot(`
-    QueryPlan {
-      Sequence {
-        Fetch(service: "review") {
-          {
-            reviews {
-              body
-              author {
-                __typename
-                id
-              }
-            }
-          }
-        },
-        Flatten(path: "reviews.@.author") {
-          Fetch(service: "user") {
-            {
-              ... on User {
-                __typename
-                id
-              }
-            } =>
-            {
-              ... on User {
-                name
-              }
-            }
-          },
-        },
-      },
-    }
-  `);
-});

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

@@ -1,122 +0,0 @@
-import { ApolloGateway } from '../..';
-import type { Logger } from '@apollo/utils.logger';
-import { PassThrough } from "stream";
-
-import * as winston from "winston";
-import WinstonTransport from 'winston-transport';
-import * as bunyan from "bunyan";
-import * as loglevel from "loglevel";
-import * as log4js from "log4js";
-
-const LOWEST_LOG_LEVEL = "debug";
-
-const KNOWN_DEBUG_MESSAGE = "Gateway successfully initialized (but not yet loaded)";
-
-async function triggerKnownDebugMessage(logger: Logger) {
-  // Trigger a known error.
-  // This is a bit brittle since it merely leverages a known debug log
-  // message outside of the constructor, but it seemed worth testing
-  // the compatibility with `ApolloGateway` itself rather than generically.
-  // The error does not matter, so it is caught and ignored.
-  await new ApolloGateway({ logger }).load().catch(_e => undefined);
-}
-
-describe("logger", () => {
-  it("works with 'winston'", async () => {
-    const sink = jest.fn();
-    const transport = new class extends WinstonTransport {
-      constructor() {
-        super({
-          format: winston.format.json(),
-        });
-      }
-
-      log(info: any) {
-        sink(info);
-      }
-    };
-
-    const logger = winston.createLogger({ level: 'debug' }).add(transport);
-
-    await triggerKnownDebugMessage(logger);
-
-    expect(sink).toHaveBeenCalledWith(expect.objectContaining({
-      level: LOWEST_LOG_LEVEL,
-      message: KNOWN_DEBUG_MESSAGE,
-    }));
-  });
-
-  it("works with 'bunyan'", async () => {
-    const sink = jest.fn();
-
-    // Bunyan uses streams for its logging implementations.
-    const writable = new PassThrough();
-    writable.on("data", data => sink(JSON.parse(data.toString())));
-
-    const logger = bunyan.createLogger({
-      name: "test-logger-bunyan",
-      streams: [{
-        level: LOWEST_LOG_LEVEL,
-        stream: writable,
-      }]
-    });
-
-    await triggerKnownDebugMessage(logger);
-
-    expect(sink).toHaveBeenCalledWith(expect.objectContaining({
-      level: bunyan.DEBUG,
-      msg: KNOWN_DEBUG_MESSAGE,
-    }));
-  });
-
-  it("works with 'loglevel'", async () => {
-    const sink = jest.fn();
-
-    const logger = loglevel.getLogger("test-logger-loglevel")
-    logger.methodFactory = (_methodName, level): loglevel.LoggingMethod =>
-      (message) => sink({ level, message });
-
-    // The `setLevel` method must be called after overwriting `methodFactory`.
-    // This is an intentional API design pattern of the loglevel package:
-    // https://www.npmjs.com/package/loglevel#writing-plugins
-    logger.setLevel(loglevel.levels.DEBUG);
-
-    await triggerKnownDebugMessage(logger);
-
-    expect(sink).toHaveBeenCalledWith({
-      level: loglevel.levels.DEBUG,
-      message: KNOWN_DEBUG_MESSAGE,
-    });
-  });
-
-  it("works with 'log4js'", async () => {
-    const sink = jest.fn();
-
-    log4js.configure({
-      appenders: {
-        custom: {
-          type: {
-            configure: () =>
-              (loggingEvent: log4js.LoggingEvent) => sink(loggingEvent)
-          }
-        }
-      },
-      categories: {
-        default: {
-          appenders: ['custom'],
-          level: LOWEST_LOG_LEVEL,
-        }
-      }
-    });
-
-    const logger = log4js.getLogger();
-    logger.level = LOWEST_LOG_LEVEL;
-
-    await triggerKnownDebugMessage(logger);
-
-    expect(sink).toHaveBeenCalledWith(expect.objectContaining({
-      level: log4js.levels.DEBUG,
-      data: [KNOWN_DEBUG_MESSAGE],
-    }));
-  });
-});