Remove itAsync from remaining relevant tests

src/__tests__/graphqlSubscriptions.ts

@@ -4,9 +4,9 @@ import { ApolloClient, FetchResult } from "../core";
 import { InMemoryCache } from "../cache";
 import { ApolloError, PROTOCOL_ERRORS_SYMBOL } from "../errors";
 import { QueryManager } from "../core/QueryManager";
-import { itAsync, mockObservableLink } from "../testing";
+import { mockObservableLink } from "../testing";
 import { GraphQLError } from "graphql";
-import { spyOnConsole } from "../testing/internal";
+import { ObservableStream, spyOnConsole } from "../testing/internal";
 import { getDefaultOptionsForQueryManagerTests } from "../testing/core/mocking/mockQueryManager";
 
 describe("GraphQL Subscriptions", () => {
@@ -47,62 +47,44 @@ describe("GraphQL Subscriptions", () => {
     };
   });
 
-  itAsync(
-    "should start a subscription on network interface and unsubscribe",
-    (resolve, reject) => {
-      const link = mockObservableLink();
-      // This test calls directly through Apollo Client
-      const client = new ApolloClient({
-        link,
-        cache: new InMemoryCache({ addTypename: false }),
-      });
+  it("should start a subscription on network interface and unsubscribe", async () => {
+    const link = mockObservableLink();
+    // This test calls directly through Apollo Client
+    const client = new ApolloClient({
+      link,
+      cache: new InMemoryCache({ addTypename: false }),
+    });
 
-      let count = 0;
-      const sub = client.subscribe(defaultOptions).subscribe({
-        next(result) {
-          count++;
-          expect(result).toEqual(results[0].result);
+    const stream = new ObservableStream(client.subscribe(defaultOptions));
+    link.simulateResult(results[0]);
 
-          // Test unsubscribing
-          if (count > 1) {
-            throw new Error("next fired after unsubscribing");
-          }
-          sub.unsubscribe();
-          resolve();
-        },
-      });
+    await expect(stream).toEmitValue(results[0].result);
 
-      link.simulateResult(results[0]);
-    }
-  );
+    stream.unsubscribe();
+
+    await expect(stream).not.toEmitAnything();
+  });
 
-  itAsync("should subscribe with default values", (resolve, reject) => {
+  it("should subscribe with default values", async () => {
     const link = mockObservableLink();
     // This test calls directly through Apollo Client
     const client = new ApolloClient({
       link,
       cache: new InMemoryCache({ addTypename: false }),
     });
 
-    let count = 0;
-    const sub = client.subscribe(options).subscribe({
-      next(result) {
-        expect(result).toEqual(results[0].result);
+    const stream = new ObservableStream(client.subscribe(options));
 
-        // Test unsubscribing
-        if (count > 1) {
-          throw new Error("next fired after unsubscribing");
-        }
-        sub.unsubscribe();
+    link.simulateResult(results[0]);
 
-        resolve();
-      },
-    });
+    await expect(stream).toEmitValue(results[0].result);
 
-    link.simulateResult(results[0]);
+    stream.unsubscribe();
+
+    await expect(stream).not.toEmitAnything();
   });
 
-  itAsync("should multiplex subscriptions", (resolve, reject) => {
+  it("should multiplex subscriptions", async () => {
     const link = mockObservableLink();
     const queryManager = new QueryManager(
       getDefaultOptionsForQueryManagerTests({
@@ -112,88 +94,57 @@ describe("GraphQL Subscriptions", () => {
     );
 
     const obs = queryManager.startGraphQLSubscription(options);
-
-    let counter = 0;
-
-    // tslint:disable-next-line
-    obs.subscribe({
-      next(result) {
-        expect(result).toEqual(results[0].result);
-        counter++;
-        if (counter === 2) {
-          resolve();
-        }
-      },
-    }) as any;
-
-    // Subscribe again. Should also receive the same result.
-    // tslint:disable-next-line
-    obs.subscribe({
-      next(result) {
-        expect(result).toEqual(results[0].result);
-        counter++;
-        if (counter === 2) {
-          resolve();
-        }
-      },
-    }) as any;
+    const stream1 = new ObservableStream(obs);
+    const stream2 = new ObservableStream(obs);
 
     link.simulateResult(results[0]);
+
+    await expect(stream1).toEmitValue(results[0].result);
+    await expect(stream2).toEmitValue(results[0].result);
   });
 
-  itAsync(
-    "should receive multiple results for a subscription",
-    (resolve, reject) => {
-      const link = mockObservableLink();
-      let numResults = 0;
-      const queryManager = new QueryManager(
-        getDefaultOptionsForQueryManagerTests({
-          link,
-          cache: new InMemoryCache({ addTypename: false }),
-        })
-      );
-
-      // tslint:disable-next-line
-      queryManager.startGraphQLSubscription(options).subscribe({
-        next(result) {
-          expect(result).toEqual(results[numResults].result);
-          numResults++;
-          if (numResults === 4) {
-            resolve();
-          }
-        },
-      }) as any;
+  it("should receive multiple results for a subscription", async () => {
+    const link = mockObservableLink();
+    const queryManager = new QueryManager(
+      getDefaultOptionsForQueryManagerTests({
+        link,
+        cache: new InMemoryCache({ addTypename: false }),
+      })
+    );
 
-      for (let i = 0; i < 4; i++) {
-        link.simulateResult(results[i]);
-      }
+    const stream = new ObservableStream(
+      queryManager.startGraphQLSubscription(options)
+    );
+
+    for (let i = 0; i < 4; i++) {
+      link.simulateResult(results[i]);
     }
-  );
-
-  itAsync(
-    "should not cache subscription data if a `no-cache` fetch policy is used",
-    (resolve, reject) => {
-      const link = mockObservableLink();
-      const cache = new InMemoryCache({ addTypename: false });
-      const client = new ApolloClient({
-        link,
-        cache,
-      });
 
-      expect(cache.extract()).toEqual({});
+    await expect(stream).toEmitValue(results[0].result);
+    await expect(stream).toEmitValue(results[1].result);
+    await expect(stream).toEmitValue(results[2].result);
+    await expect(stream).toEmitValue(results[3].result);
+    await expect(stream).not.toEmitAnything();
+  });
 
-      options.fetchPolicy = "no-cache";
-      const sub = client.subscribe(options).subscribe({
-        next() {
-          expect(cache.extract()).toEqual({});
-          sub.unsubscribe();
-          resolve();
-        },
-      });
+  it("should not cache subscription data if a `no-cache` fetch policy is used", async () => {
+    const link = mockObservableLink();
+    const cache = new InMemoryCache({ addTypename: false });
+    const client = new ApolloClient({
+      link,
+      cache,
+    });
 
-      link.simulateResult(results[0]);
-    }
-  );
+    expect(cache.extract()).toEqual({});
+
+    options.fetchPolicy = "no-cache";
+    const stream = new ObservableStream(client.subscribe(options));
+
+    link.simulateResult(results[0]);
+
+    await expect(stream).toEmitNext();
+    expect(cache.extract()).toEqual({});
+  });
 
   it("should throw an error if the result has errors on it", () => {
     const link = mockObservableLink();
@@ -492,27 +443,22 @@ describe("GraphQL Subscriptions", () => {
     });
   });
 
-  itAsync(
-    "should pass a context object through the link execution chain",
-    (resolve, reject) => {
-      const link = mockObservableLink();
-      const client = new ApolloClient({
-        cache: new InMemoryCache(),
-        link,
-      });
+  it("should pass a context object through the link execution chain", async () => {
+    const link = mockObservableLink();
+    const client = new ApolloClient({
+      cache: new InMemoryCache(),
+      link,
+    });
 
-      client.subscribe(options).subscribe({
-        next() {
-          expect(link.operation?.getContext().someVar).toEqual(
-            options.context.someVar
-          );
-          resolve();
-        },
-      });
+    const stream = new ObservableStream(client.subscribe(options));
 
-      link.simulateResult(results[0]);
-    }
-  );
+    link.simulateResult(results[0]);
+
+    await expect(stream).toEmitNext();
+    expect(link.operation?.getContext().someVar).toEqual(
+      options.context.someVar
+    );
+  });
 
   it("should throw an error if the result has protocolErrors on it", async () => {
     const link = mockObservableLink();