Remove itAsync part 2

src/__tests__/local-state/subscriptions.ts

@@ -4,10 +4,10 @@ import { Observable } from "../../utilities";
 import { ApolloLink } from "../../link/core";
 import { ApolloClient } from "../../core";
 import { InMemoryCache } from "../../cache";
-import { itAsync } from "../../testing";
+import { ObservableStream } from "../../testing/internal";
 
 describe("Basic functionality", () => {
-  itAsync("should not break subscriptions", (resolve, reject) => {
+  it("should not break subscriptions", async () => {
     const query = gql`
       subscription {
         field
@@ -28,65 +28,43 @@ describe("Basic functionality", () => {
       },
     });
 
-    let counter = 0;
-    expect.assertions(2);
-    client.subscribe({ query }).forEach((item) => {
-      expect(item).toMatchObject({ data: { field: ++counter } });
-      if (counter === 2) {
-        resolve();
-      }
-    });
+    const stream = new ObservableStream(client.subscribe({ query }));
+
+    await expect(stream).toEmitValue({ data: { field: 1 } });
+    await expect(stream).toEmitValue({ data: { field: 2 } });
+    await expect(stream).toComplete();
   });
 
-  itAsync(
-    "should be able to mix @client fields with subscription results",
-    (resolve, reject) => {
-      const query = gql`
-        subscription {
-          field
-          count @client
-        }
-      `;
+  it("should be able to mix @client fields with subscription results", async () => {
+    const query = gql`
+      subscription {
+        field
+        count @client
+      }
+    `;
 
-      const link = new ApolloLink(() =>
-        Observable.of({ data: { field: 1 } }, { data: { field: 2 } })
-      );
+    const link = new ApolloLink(() =>
+      Observable.of({ data: { field: 1 } }, { data: { field: 2 } })
+    );
 
-      let subCounter = 0;
-      const client = new ApolloClient({
-        cache: new InMemoryCache(),
-        link,
-        resolvers: {
-          Subscription: {
-            count: () => {
-              subCounter += 1;
-              return subCounter;
-            },
+    let subCounter = 0;
+    const client = new ApolloClient({
+      cache: new InMemoryCache(),
+      link,
+      resolvers: {
+        Subscription: {
+          count: () => {
+            subCounter += 1;
+            return subCounter;
           },
         },
-      });
+      },
+    });
 
-      expect.assertions(2);
-      const obs = client.subscribe({ query });
-      let resultCounter = 1;
-      obs.subscribe({
-        next(result) {
-          try {
-            expect(result).toMatchObject({
-              data: {
-                field: resultCounter,
-                count: resultCounter,
-              },
-            });
-          } catch (error) {
-            reject(error);
-          }
-          resultCounter += 1;
-        },
-        complete() {
-          resolve();
-        },
-      });
-    }
-  );
+    const stream = new ObservableStream(client.subscribe({ query }));
+
+    await expect(stream).toEmitValue({ data: { field: 1, count: 1 } });
+    await expect(stream).toEmitValue({ data: { field: 2, count: 2 } });
+    await expect(stream).toComplete();
+  });
 });