Call createMockSchema inside createTestSchema

.api-reports/api-report-testing.md

@@ -449,11 +449,6 @@ type ConcastSourcesIterable<T> = Iterable<Source<T>>;
 // @public (undocumented)
 export function createMockClient<TData>(data: TData, query: DocumentNode, variables?: {}): ApolloClient<NormalizedCacheObject>;
 
-// @alpha
-export const createMockSchema: (staticSchema: GraphQLSchema, mocks: {
-    [key: string]: any;
-}) => GraphQLSchema;
-
 // @alpha
 export const createSchemaFetch: (schema: GraphQLSchema, mockFetchOpts?: {
     validate: boolean;
@@ -462,10 +457,11 @@ export const createSchemaFetch: (schema: GraphQLSchema, mockFetchOpts?: {
     restore: () => void;
 } & Disposable;
 
+// Warning: (ae-forgotten-export) The symbol "TestSchemaOptions" needs to be exported by the entry point index.d.ts
 // Warning: (ae-forgotten-export) The symbol "ProxiedSchema" needs to be exported by the entry point index.d.ts
 //
 // @alpha
-export const createTestSchema: (schemaWithMocks: GraphQLSchema, resolvers: Resolvers) => ProxiedSchema;
+export const createTestSchema: (schemaWithTypeDefs: GraphQLSchema, options: TestSchemaOptions) => ProxiedSchema;
 
 // @public (undocumented)
 namespace DataProxy {
@@ -1286,24 +1282,10 @@ type Path = ReadonlyArray<string | number>;
 // @public (undocumented)
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 
-// Warning: (ae-forgotten-export) The symbol "ProxiedSchemaFns" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "TestSchemaFns" needs to be exported by the entry point index.d.ts
 //
 // @public (undocumented)
-type ProxiedSchema = GraphQLSchema & ProxiedSchemaFns;
-
-// @public (undocumented)
-interface ProxiedSchemaFns {
-    // (undocumented)
-    add: (addOptions: {
-        resolvers: Resolvers;
-    }) => ProxiedSchema;
-    // (undocumented)
-    fork: (forkOptions?: {
-        resolvers?: Resolvers;
-    }) => ProxiedSchema;
-    // (undocumented)
-    reset: () => void;
-}
+type ProxiedSchema = GraphQLSchema & TestSchemaFns;
 
 // @public (undocumented)
 class QueryInfo {
@@ -1681,6 +1663,30 @@ interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
     variables?: TVariables;
 }
 
+// @public (undocumented)
+interface TestSchemaFns {
+    // (undocumented)
+    add: (addOptions: {
+        resolvers: Resolvers;
+    }) => ProxiedSchema;
+    // (undocumented)
+    fork: (forkOptions?: {
+        resolvers?: Resolvers;
+    }) => ProxiedSchema;
+    // (undocumented)
+    reset: () => void;
+}
+
+// @public (undocumented)
+interface TestSchemaOptions {
+    // (undocumented)
+    mocks?: {
+        [key: string]: any;
+    };
+    // (undocumented)
+    resolvers: Resolvers;
+}
+
 // @public (undocumented)
 export function tick(): Promise<void>;
 

.api-reports/api-report-testing_core.md

@@ -456,10 +456,11 @@ export const createSchemaFetch: (schema: GraphQLSchema, mockFetchOpts?: {
     restore: () => void;
 } & Disposable;
 
+// Warning: (ae-forgotten-export) The symbol "TestSchemaOptions" needs to be exported by the entry point index.d.ts
 // Warning: (ae-forgotten-export) The symbol "ProxiedSchema" needs to be exported by the entry point index.d.ts
 //
 // @alpha
-export const createTestSchema: (schemaWithMocks: GraphQLSchema, resolvers: Resolvers) => ProxiedSchema;
+export const createTestSchema: (schemaWithTypeDefs: GraphQLSchema, options: TestSchemaOptions) => ProxiedSchema;
 
 // @public (undocumented)
 namespace DataProxy {
@@ -1236,24 +1237,10 @@ type Path = ReadonlyArray<string | number>;
 // @public (undocumented)
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 
-// Warning: (ae-forgotten-export) The symbol "ProxiedSchemaFns" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "TestSchemaFns" needs to be exported by the entry point index.d.ts
 //
 // @public (undocumented)
-type ProxiedSchema = GraphQLSchema & ProxiedSchemaFns;
-
-// @public (undocumented)
-interface ProxiedSchemaFns {
-    // (undocumented)
-    add: (addOptions: {
-        resolvers: Resolvers;
-    }) => ProxiedSchema;
-    // (undocumented)
-    fork: (forkOptions?: {
-        resolvers?: Resolvers;
-    }) => ProxiedSchema;
-    // (undocumented)
-    reset: () => void;
-}
+type ProxiedSchema = GraphQLSchema & TestSchemaFns;
 
 // @public (undocumented)
 class QueryInfo {
@@ -1633,6 +1620,30 @@ interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {
     variables?: TVariables;
 }
 
+// @public (undocumented)
+interface TestSchemaFns {
+    // (undocumented)
+    add: (addOptions: {
+        resolvers: Resolvers;
+    }) => ProxiedSchema;
+    // (undocumented)
+    fork: (forkOptions?: {
+        resolvers?: Resolvers;
+    }) => ProxiedSchema;
+    // (undocumented)
+    reset: () => void;
+}
+
+// @public (undocumented)
+interface TestSchemaOptions {
+    // (undocumented)
+    mocks?: {
+        [key: string]: any;
+    };
+    // (undocumented)
+    resolvers: Resolvers;
+}
+
 // @public (undocumented)
 export function tick(): Promise<void>;
 

.changeset/spotty-garlics-knock.md

@@ -0,0 +1,5 @@
+---
+"@apollo/client": minor
+---
+
+Call `createMockSchema` inside `createTestSchema`.

src/__tests__/__snapshots__/exports.ts.snap

@@ -369,7 +369,6 @@ Array [
   "MockSubscriptionLink",
   "MockedProvider",
   "createMockClient",
-  "createMockSchema",
   "createSchemaFetch",
   "createTestSchema",
   "itAsync",

src/testing/core/__tests__/createTestSchema.test.tsx

@@ -17,7 +17,6 @@ import { createTestSchema } from "../createTestSchema.js";
 import { GraphQLError, buildSchema } from "graphql";
 import type { UseSuspenseQueryResult } from "../../../react/index.js";
 import { useMutation, useSuspenseQuery } from "../../../react/index.js";
-import { createMockSchema } from "../../graphql-tools/utils.js";
 import userEvent from "@testing-library/user-event";
 import { act, screen } from "@testing-library/react";
 import { createSchemaFetch } from "../createSchemaFetch.js";
@@ -140,34 +139,35 @@ interface ViewerQueryData {
 }
 
 describe("schema proxy", () => {
-  const schemaWithMocks = createMockSchema(schemaWithTypeDefs, {
-    ID: () => "1",
-    Int: () => 42,
-    String: () => "String",
-    Date: () => new Date("January 1, 2024 01:00:00").toJSON().split("T")[0],
-  });
-
-  const schema = createTestSchema(schemaWithMocks, {
-    Query: {
-      viewer: () => ({
-        name: "Jane Doe",
-        book: {
-          text: "Hello World",
-          title: "The Book",
+  const schema = createTestSchema(schemaWithTypeDefs, {
+    resolvers: {
+      Query: {
+        viewer: () => ({
+          name: "Jane Doe",
+          book: {
+            text: "Hello World",
+            title: "The Book",
+          },
+        }),
+      },
+      Book: {
+        __resolveType: (obj) => {
+          if ("text" in obj) {
+            return "TextBook";
+          }
+          if ("colors" in obj) {
+            return "ColoringBook";
+          }
+          throw new Error("Could not resolve type");
         },
-      }),
-    },
-    Book: {
-      __resolveType: (obj) => {
-        if ("text" in obj) {
-          return "TextBook";
-        }
-        if ("colors" in obj) {
-          return "ColoringBook";
-        }
-        throw new Error("Could not resolve type");
       },
     },
+    mocks: {
+      ID: () => "1",
+      Int: () => 42,
+      String: () => "String",
+      Date: () => new Date("January 1, 2024 01:00:00").toJSON().split("T")[0],
+    },
   });
 
   it("mocks scalars and resolvers", async () => {
@@ -849,27 +849,35 @@ describe("schema proxy", () => {
   it("preserves resolvers from previous calls to .add on subsequent calls to .fork", async () => {
     let name = "Virginia";
 
-    const schema = createTestSchema(schemaWithMocks, {
-      Query: {
-        viewer: () => ({
-          name,
-          book: {
-            text: "Hello World",
-            title: "The Book",
+    const schema = createTestSchema(schemaWithTypeDefs, {
+      resolvers: {
+        Query: {
+          viewer: () => ({
+            name,
+            book: {
+              text: "Hello World",
+              title: "The Book",
+            },
+          }),
+        },
+        Book: {
+          __resolveType: (obj) => {
+            if ("text" in obj) {
+              return "TextBook";
+            }
+            if ("colors" in obj) {
+              return "ColoringBook";
+            }
+            throw new Error("Could not resolve type");
           },
-        }),
-      },
-      Book: {
-        __resolveType: (obj) => {
-          if ("text" in obj) {
-            return "TextBook";
-          }
-          if ("colors" in obj) {
-            return "ColoringBook";
-          }
-          throw new Error("Could not resolve type");
         },
       },
+      mocks: {
+        ID: () => "1",
+        Int: () => 42,
+        String: () => "String",
+        Date: () => new Date("January 1, 2024 01:00:00").toJSON().split("T")[0],
+      },
     });
 
     schema.add({

src/testing/core/createTestSchema.ts

@@ -1,16 +1,22 @@
 import { addResolversToSchema } from "@graphql-tools/schema";
 import type { GraphQLSchema } from "graphql";
 
+import { createMockSchema } from "../graphql-tools/utils.js";
 import type { Resolvers } from "../../core/types.js";
 
-type ProxiedSchema = GraphQLSchema & ProxiedSchemaFns;
+type ProxiedSchema = GraphQLSchema & TestSchemaFns;
 
-interface ProxiedSchemaFns {
+interface TestSchemaFns {
   add: (addOptions: { resolvers: Resolvers }) => ProxiedSchema;
   fork: (forkOptions?: { resolvers?: Resolvers }) => ProxiedSchema;
   reset: () => void;
 }
 
+interface TestSchemaOptions {
+  resolvers: Resolvers;
+  mocks?: { [key: string]: any };
+}
+
 /**
  * A function that creates a [Proxy object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy)
  * around a given `schema` with `resolvers`. This proxied schema can be used to
@@ -19,41 +25,43 @@ interface ProxiedSchemaFns {
  * can be modified independently of the original schema. `reset` will restore
  * resolvers to the original proxied schema.
  *
- * @param schemaWithMocks - A `GraphQLSchema`.
- * @param resolvers - `Resolvers` object.
+ * @param schema - A `GraphQLSchema`.
+ * @param options - An `options` object that accepts `mocks` and `resolvers` objects.
  * @returns A `ProxiedSchema` with `add`, `fork` and `reset` methods.
  *
  * @example
  * ```js
- * const schemaWithMocks = createMockSchema(schemaWithTypeDefs, {
-     ID: () => "1",
-     Int: () => 36,
-     String: () => "String",
-     Date: () => new Date("December 10, 1815 01:00:00").toJSON().split("T")[0],
-   });
  *
- * const schema = createTestSchema(schemaWithMocks, {
-     Query: {
-       writer: () => ({
-         name: "Ada Lovelace",
-       }),
+ * const schema = createTestSchema(schemaWithTypeDefs, {
+ *   resolvers: {
+       Query: {
+         writer: () => ({
+           name: "Ada Lovelace",
+         }),
+       }
+     },
+     mocks: {
+       ID: () => "1",
+       Int: () => 36,
+       String: () => "String",
+       Date: () => new Date("December 10, 1815 01:00:00").toJSON().split("T")[0],
      }
    });
  * ```
  * @since 3.9.0
  * @alpha
  */
 const createTestSchema = (
-  schemaWithMocks: GraphQLSchema,
-  resolvers: Resolvers
+  schemaWithTypeDefs: GraphQLSchema,
+  options: TestSchemaOptions
 ): ProxiedSchema => {
-  let targetResolvers = { ...resolvers };
+  let targetResolvers = { ...options.resolvers };
   let targetSchema = addResolversToSchema({
-    schema: schemaWithMocks,
+    schema: createMockSchema(schemaWithTypeDefs, options.mocks ?? {}),
     resolvers: targetResolvers,
   });
 
-  const fns: ProxiedSchemaFns = {
+  const fns: TestSchemaFns = {
     add: ({ resolvers: newResolvers }) => {
       targetResolvers = { ...targetResolvers, ...newResolvers };
       targetSchema = addResolversToSchema({
@@ -65,13 +73,16 @@ const createTestSchema = (
     },
 
     fork: ({ resolvers: newResolvers } = {}) => {
-      return createTestSchema(targetSchema, newResolvers ?? targetResolvers);
+      return createTestSchema(targetSchema, {
+        resolvers: newResolvers ?? targetResolvers,
+        mocks: options.mocks,
+      });
     },
 
     reset: () => {
       targetSchema = addResolversToSchema({
-        schema: schemaWithMocks,
-        resolvers,
+        schema: schemaWithTypeDefs,
+        resolvers: options.resolvers,
       });
     },
   };