Test that cache.update{Query,Fragment} are broadcast-batched.

Author: benjamn

src/cache/inmemory/__tests__/cache.ts

@@ -1296,6 +1296,166 @@ describe('Cache', () => {
     );
   });
 
+  describe("cache.updateQuery and cache.updateFragment", () => {
+    it('should be batched', () => {
+      const cache = new InMemoryCache({
+        typePolicies: {
+          Person: {
+            keyFields: ["name"],
+          },
+        },
+      });
+
+      type QueryData = {
+        me: {
+          __typename: string;
+          name: string;
+        },
+      };
+
+      const query: TypedDocumentNode<QueryData> = gql`query { me { name } }`;
+      const results: QueryData[] = [];
+
+      const cancel = cache.watch({
+        query,
+        optimistic: true,
+        callback(diff) {
+          results.push(diff.result!);
+        },
+      });
+
+      cache.updateQuery({ query }, data => {
+        expect(data).toBe(null);
+
+        cache.writeQuery({
+          query,
+          data: {
+            me: {
+              __typename: "Person",
+              name: "Ben",
+            },
+          },
+        });
+
+        return {
+          me: {
+            __typename: "Person",
+            name: "Ben Newman",
+          },
+        };
+      });
+
+      expect(results).toEqual([
+        { me: { __typename: "Person", name: "Ben Newman" }},
+      ]);
+
+      expect(cache.extract()).toEqual({
+        'Person:{"name":"Ben Newman"}': {
+          __typename: "Person",
+          name: "Ben Newman",
+        },
+        'Person:{"name":"Ben"}': {
+          __typename: "Person",
+          name: "Ben",
+        },
+        ROOT_QUERY: {
+          __typename: "Query",
+          me: {
+            __ref: 'Person:{"name":"Ben Newman"}',
+          },
+        },
+      });
+
+      const usernameFragment = gql`
+        fragment UsernameFragment on Person {
+          username
+        }
+      `;
+
+      const bnId = cache.identify({
+        __typename: "Person",
+        name: "Ben Newman",
+      });
+
+      cache.updateFragment({
+        id: bnId,
+        fragment: usernameFragment,
+        returnPartialData: true,
+      }, data => {
+        expect(data).toEqual({
+          __typename: "Person",
+        });
+
+        cache.writeQuery({
+          query,
+          data: {
+            me: {
+              __typename: "Person",
+              name: "Brian Kim",
+            },
+          },
+        });
+
+        cache.writeFragment({
+          id: cache.identify({
+            __typename: "Person",
+            name: "Brian Kim",
+          }),
+          fragment: usernameFragment,
+          data: {
+            username: "brainkim",
+          },
+        });
+
+        expect(results.length).toBe(1);
+
+        return {
+          ...data,
+          name: "Ben Newman",
+          username: "benjamn",
+        };
+      });
+
+      // Still just two results, thanks to cache.update{Query,Fragment} using
+      // cache.batch behind the scenes.
+      expect(results).toEqual([
+        { me: { __typename: "Person", name: "Ben Newman" }},
+        { me: { __typename: "Person", name: "Brian Kim" }},
+      ]);
+
+      expect(cache.extract()).toEqual({
+        'Person:{"name":"Ben"}': {
+          __typename: "Person",
+          name: "Ben",
+        },
+        'Person:{"name":"Ben Newman"}': {
+          __typename: "Person",
+          name: "Ben Newman",
+          username: "benjamn",
+        },
+        'Person:{"name":"Brian Kim"}': {
+          __typename: "Person",
+          name: "Brian Kim",
+          username: "brainkim",
+        },
+        ROOT_QUERY: {
+          __typename: "Query",
+          me: {
+            __ref: 'Person:{"name":"Brian Kim"}',
+          },
+        },
+        __META: {
+          extraRootIds: [
+            'Person:{"name":"Ben Newman"}',
+            'Person:{"name":"Brian Kim"}',
+          ],
+        },
+      });
+
+      cancel();
+    });
+  });
+
   describe('cache.restore', () => {
     it('replaces cache.{store{Reader,Writer},maybeBroadcastWatch}', () => {
       const cache = new InMemoryCache;