run lint

gax/test/unit/apiCallable.ts

@@ -136,13 +136,13 @@ describe('createApiCall', () => {
       assert(Number(resp) - start <= 30100);
     });
   });
-  it('override just custom retry.retryCodes with retry codes', async () => {
+  it('override just custom retry.retryCodes with retry codes', () => {
     const initialRetryCodes = [1];
     const overrideRetryCodes = [1, 2, 3];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     sinon.stub(retries, 'retryable').callsFake((func, retry): any => {
-        assert.strictEqual(retry.retryCodes, overrideRetryCodes);
-        return func;
+      assert.strictEqual(retry.retryCodes, overrideRetryCodes);
+      return func;
     });
 
     function func() {
@@ -161,14 +161,14 @@ describe('createApiCall', () => {
       },
     });
 
-    await apiCall(
+    apiCall(
       {},
       {
         retry: {
           retryCodes: overrideRetryCodes,
         },
       },
-    );
+    ).catch(console.error);
   });
   it('errors when you override custom retry.shouldRetryFn with a function on a non streaming call', async () => {
     function neverRetry() {
@@ -211,7 +211,7 @@ describe('createApiCall', () => {
     }
   });
 
-  it('override just custom retry.backoffSettings', async () => {
+  it('override just custom retry.backoffSettings', () => {
     const initialBackoffSettings = gax.createDefaultBackoffSettings();
     const overriBackoffSettings = gax.createBackoffSettings(
       100,
@@ -238,14 +238,14 @@ describe('createApiCall', () => {
       },
     });
 
-    await apiCall(
+    apiCall(
       {},
       {
         retry: {
           backoffSettings: overriBackoffSettings,
         },
       },
-    );
+    ).catch(console.error);
   });
 
   it('errors when a resumption strategy is passed for a non streaming call', async () => {
@@ -265,7 +265,7 @@ describe('createApiCall', () => {
     };
 
     function func() {
-      Promise.resolve();
+      Promise.resolve().catch(console.error);
     }
     const apiCall = createApiCall(func, {
       settings: {
@@ -443,7 +443,7 @@ describe('retryable', () => {
       assert.strictEqual(toAttempt, 0);
       assert(deadlineArg);
       done();
-    });
+    }).catch(console.error);
   });
 
   it('retries the API call with promise', async () => {
@@ -464,13 +464,12 @@ describe('retryable', () => {
       callback(null, 1729);
     }
     const apiCall = createApiCall(func, settings);
-    await apiCall({}, undefined)
-      .then(resp => {
-        assert.ok(Array.isArray(resp));
-        assert.strictEqual(resp[0], 1729);
-        assert.strictEqual(toAttempt, 0);
-        assert.ok(deadlineArg);
-      });
+    await apiCall({}, undefined).then(resp => {
+      assert.ok(Array.isArray(resp));
+      assert.strictEqual(resp[0], 1729);
+      assert.strictEqual(toAttempt, 0);
+      assert.ok(deadlineArg);
+    });
   });
 
   it('cancels in the middle of retries', done => {
@@ -515,7 +514,7 @@ describe('retryable', () => {
       assert.strictEqual(err!.note, undefined);
       assert.strictEqual(spy.callCount, 1);
       done();
-    });
+    }).catch(console.error);
   });
 
   it('aborts retries', async () => {
@@ -536,7 +535,7 @@ describe('retryable', () => {
       assert(err!.note);
       assert.strictEqual(spy.callCount, toAttempt);
       done();
-    });
+    }).catch(console.error);
   });
 
   it('errors on maxRetries and surfaces original error', async () => {
@@ -661,7 +660,7 @@ describe('retryable', () => {
       assert(spy.callCount > callsLowerBound);
       assert(spy.callCount < callsUpperBound);
       done();
-    });
+    }).catch(console.error);
   });
 
   it.skip('reports A/B testing', () => {

gax/test/unit/bundling.ts

@@ -881,13 +881,12 @@ describe('bundleable', () => {
     const apiCall = createApiCall(spy, settings);
     await apiCall({field1: [1, 2, 3], field2: 'id'}, undefined, (err, obj) => {
       if (err) {
-         return err;
+        throw err;
       } else {
         callback([obj]);
       }
     });
-    await apiCall({field1: [1, 2, 3], field2: 'id'}, undefined)
-      .then(callback)
+    await apiCall({field1: [1, 2, 3], field2: 'id'}, undefined).then(callback);
   });
 
   it('does not fail if bundle field is not set', done => {
@@ -1001,27 +1000,27 @@ describe('bundleable', () => {
       } else {
         callback();
       }
-    });
+    }).catch(console.error);
     apiCall({data: ['data1'], logName: 'log2'}, undefined, err => {
       if (err) {
         done(err);
       } else {
         callback();
       }
-    });
+    }).catch(console.error);
     apiCall({data: ['data2'], logName: 'log1'}, undefined, err => {
       if (err) {
         done(err);
       } else {
         callback();
       }
-    });
+    }).catch(console.error);
     apiCall({data: ['data2'], logName: 'log2'}, undefined, err => {
       if (err) {
         done(err);
       } else {
         callback();
       }
-    });
+    }).catch(console.error);
   });
 });

gax/test/unit/grpc-fallback.ts

@@ -138,18 +138,22 @@ describe('createStub', () => {
 
   it('validates universe domain if set', async () => {
     const opts = {...stubOptions, universeDomain: 'example.com'};
-    assert.rejects(
-      gaxGrpc.createStub(echoService, opts),
-      /configured universe domain/,
-    );
+    assert
+      .rejects(
+        gaxGrpc.createStub(echoService, opts),
+        /configured universe domain/,
+      )
+      .catch(console.error);
   });
 
   it('validates universe domain if unset', async () => {
     authClient.universeDomain = 'example.com';
-    assert.rejects(
-      gaxGrpc.createStub(echoService, stubOptions),
-      /configured universe domain/,
-    );
+    assert
+      .rejects(
+        gaxGrpc.createStub(echoService, stubOptions),
+        /configured universe domain/,
+      )
+      .catch(console.error);
     // reset to default value
     authClient.universeDomain = 'googleapis.com';
   });

gax/test/unit/grpc.ts

@@ -184,22 +184,26 @@ describe('grpc', () => {
         port: 443,
         universeDomain: 'example.com',
       };
-      assert.rejects(
-        // @ts-ignore
-        grpcClient.createStub(DummyStub, opts),
-        /configured universe domain/,
-      );
+      assert
+        .rejects(
+          // @ts-ignore
+          grpcClient.createStub(DummyStub, opts),
+          /configured universe domain/,
+        )
+        .catch(console.error);
     });
 
     it('validates universe domain if unset', async () => {
       const opts = {servicePath: 'foo.example.com', port: 443};
       stubAuth.getUniverseDomain.reset();
       stubAuth.getUniverseDomain.resolves('example.com');
-      assert.rejects(
-        // @ts-ignore
-        grpcClient.createStub(DummyStub, opts),
-        /configured universe domain/,
-      );
+      assert
+        .rejects(
+          // @ts-ignore
+          grpcClient.createStub(DummyStub, opts),
+          /configured universe domain/,
+        )
+        .catch(console.error);
     });
 
     it('supports optional parameters', () => {
@@ -711,10 +715,12 @@ dvorak
       // Create a client and test the certificate detection flow:
       process.env.GOOGLE_API_USE_CLIENT_CERTIFICATE = 'true';
       const clientMock = new GrpcClient();
-      assert.rejects(
-        clientMock.createStub(DummyStub, {universeDomain: 'example.com'}),
-        /configured universe domain/,
-      );
+      assert
+        .rejects(
+          clientMock.createStub(DummyStub, {universeDomain: 'example.com'}),
+          /configured universe domain/,
+        )
+        .catch(console.error);
       await fsp.rm(tmpFolder, {recursive: true, force: true}); // Cleanup.
     });
   });