vscode-apollo 1.19.3 → 1.20.1

package/src/tools/__tests__/buildServiceDefinition.test.ts

@@ -0,0 +1,491 @@
+import gql from "graphql-tag";
+import { buildServiceDefinition } from "../buildServiceDefinition";
+import { GraphQLNamedType, GraphQLObjectType, printType } from "graphql";
+
+describe("buildServiceDefinition", () => {
+  describe(`type definitions`, () => {
+    it(`should include types from different modules`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            type Post {
+              title: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(printType(schema.getType("User")!)).toMatchInlineSnapshot(`
+"type User {
+  name: String
+}"
+`);
+
+      expect(printType(schema.getType("Post")!)).toMatchInlineSnapshot(`
+"type Post {
+  title: String
+}"
+`);
+    });
+
+    it(`should not allow two types with the same name in the same module`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            type User {
+              title: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Type "User" was defined more than once.],
+]
+`);
+    });
+
+    it(`should not allow two types with the same name in different modules`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            type User {
+              title: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Type "User" was defined more than once.],
+]
+`);
+    });
+
+    it(`should report multiple type duplication errors`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            type User {
+              title: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            type Post {
+              title: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            type Post {
+              name: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Type "User" was defined more than once.],
+  [GraphQLError: Type "Post" was defined more than once.],
+]
+`);
+    });
+  });
+
+  describe(`directive definitions`, () => {
+    it(`should include directive`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+      const directive = schema.getDirective("something");
+      expect(directive).toBeDefined();
+    });
+
+    it(`should include directives from different modules`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+        {
+          typeDefs: gql`
+            directive @another on FIELD_DEFINITION
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(schema.getDirective("something")).toMatchInlineSnapshot(
+        `"@something"`
+      );
+
+      expect(schema.getDirective("another")).toMatchInlineSnapshot(
+        `"@another"`
+      );
+    });
+
+    it(`should not allow two types with the same name in the same module`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Directive "something" was defined more than once.],
+]
+`);
+    });
+
+    it(`should not allow two types with the same name in different modules`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Directive "something" was defined more than once.],
+]
+`);
+    });
+
+    it(`should report multiple type duplication errors`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+        {
+          typeDefs: gql`
+            directive @something on FIELD_DEFINITION
+          `,
+        },
+        {
+          typeDefs: gql`
+            directive @another on FIELD_DEFINITION
+          `,
+        },
+        {
+          typeDefs: gql`
+            directive @another on FIELD_DEFINITION
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Directive "something" was defined more than once.],
+  [GraphQLError: Directive "another" was defined more than once.],
+]
+`);
+    });
+  });
+
+  describe(`type extension`, () => {
+    it(`should allow extending a type from the same module`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+
+            extend type User {
+              email: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(printType(schema.getType("User")!)).toMatchInlineSnapshot(`
+"type User {
+  name: String
+  email: String
+}"
+`);
+    });
+
+    it(`should allow extending a type from a different module`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            extend type User {
+              email: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(printType(schema.getType("User")!)).toMatchInlineSnapshot(`
+"type User {
+  name: String
+  email: String
+}"
+`);
+    });
+
+    it(`should report an error when extending a non-existent type`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            extend type User {
+              email: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toMatchInlineSnapshot(`
+Array [
+  [GraphQLError: Cannot extend type "User" because it does not exist in the existing schema.],
+]
+`);
+    });
+  });
+
+  describe(`extending root operation types that aren't defined elsewhere`, () => {
+    it(`should be allowed`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            extend type Query {
+              rootField: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(printType(schema.getType("Query")!)).toMatchInlineSnapshot(`
+"type Query {
+  rootField: String
+}"
+`);
+    });
+
+    it(`should be allowed with non default type names`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            schema {
+              query: QueryRoot
+            }
+            extend type QueryRoot {
+              rootField: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(printType(schema.getType("QueryRoot")!)).toMatchInlineSnapshot(`
+"type QueryRoot {
+  rootField: String
+}"
+`);
+    });
+
+    it(`should be allowed with non default nanmes specified in schema extensions`, () => {
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            schema {
+              query: QueryRoot
+            }
+            type QueryRoot {
+              rootField: String
+            }
+          `,
+        },
+        {
+          typeDefs: gql`
+            extend schema {
+              mutation: MutationRoot
+            }
+            extend type MutationRoot {
+              rootField: String
+            }
+          `,
+        },
+      ]);
+
+      expect(service.errors).toBeUndefined();
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      expect(printType(schema.getType("MutationRoot")!)).toMatchInlineSnapshot(`
+"type MutationRoot {
+  rootField: String
+}"
+`);
+    });
+  });
+
+  describe(`resolvers`, () => {
+    it(`should add a resolver for a field`, () => {
+      const name = () => {};
+
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type User {
+              name: String
+            }
+          `,
+          resolvers: {
+            User: {
+              name,
+            },
+          },
+        },
+      ]);
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      const userType = schema.getType("User");
+      expect(userType).toBeDefined();
+
+      const nameField = (userType! as GraphQLObjectType).getFields()["name"];
+      expect(nameField).toBeDefined();
+
+      expect(nameField.resolve).toEqual(name);
+    });
+
+    it(`should handle subscriptions`, () => {
+      const commentAddedSubscription = () =>
+        async function* () {
+          yield "111";
+          yield "222";
+          yield "333";
+        };
+
+      const service = buildServiceDefinition([
+        {
+          typeDefs: gql`
+            type Subscription {
+              commentAdded: String
+            }
+          `,
+          resolvers: {
+            Subscription: {
+              commentAdded: {
+                subscribe: commentAddedSubscription,
+              },
+            },
+          },
+        },
+      ]);
+
+      expect(service.schema).toBeDefined();
+      const schema = service.schema!;
+
+      const subscriptionType = schema.getType("Subscription");
+      expect(subscriptionType).toBeDefined();
+
+      const commentAdded = (subscriptionType! as GraphQLObjectType).getFields()[
+        "commentAdded"
+      ];
+      expect(commentAdded).toBeDefined();
+
+      expect(commentAdded.subscribe).toEqual(commentAddedSubscription);
+    });
+  });
+});

package/src/tools/__tests__/snapshotSerializers/astSerializer.ts

@@ -0,0 +1,19 @@
+import { ASTNode, print } from "graphql";
+import { Plugin } from "pretty-format";
+
+const plugin: Plugin = {
+  test(value) {
+    return value && typeof value.kind === "string";
+  },
+
+  serialize(value: ASTNode, _config, indentation): string {
+    return (
+      indentation +
+      print(value)
+        .trim()
+        .replace(/\n/g, "\n" + indentation)
+    );
+  },
+};
+
+export default plugin;

package/src/tools/__tests__/snapshotSerializers/graphQLTypeSerializer.ts

@@ -0,0 +1,14 @@
+import { isNamedType, GraphQLNamedType, printType } from "graphql";
+import { Plugin } from "pretty-format";
+
+const plugin: Plugin = {
+  test(value) {
+    return value && isNamedType(value);
+  },
+
+  serialize(value: GraphQLNamedType): string {
+    return printType(value);
+  },
+};
+
+export default plugin;