tests: fix various test issues caused by version upgrades

Author: feywind

test/exponential-retry.ts

@@ -18,6 +18,7 @@ import * as sinon from 'sinon';
 
 import {ExponentialRetry} from '../src/exponential-retry';
 import {Duration} from '../src/temporal';
+import {TestUtils} from './test-utils';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function introspect(obj: unknown): any {
@@ -52,27 +53,30 @@ describe('exponential retry class', () => {
   });
 
   it('makes the first callback', () => {
-    const clock = sandbox.useFakeTimers();
+    const clock = TestUtils.useFakeTimers(sandbox);
     const er = new ExponentialRetry<TestItem>(
       Duration.from({millis: 100}),
       Duration.from({millis: 1000}),
     );
     sandbox.stub(global.Math, 'random').returns(0.75);
 
     const item = makeItem();
+    let retried = false;
     er.retryLater(item, (s: typeof item, t: Duration) => {
       assert.strictEqual(s, item);
       assert.strictEqual(t.totalOf('millisecond'), 125);
+      retried = true;
     });
 
     clock.tick(125);
 
     const leftovers = er.close();
+    assert.strictEqual(retried, true);
     assert.strictEqual(leftovers.length, 0);
   });
 
   it('closes gracefully', () => {
-    const clock = sandbox.useFakeTimers();
+    const clock = TestUtils.useFakeTimers(sandbox);
     const er = new ExponentialRetry<TestItem>(
       Duration.from({millis: 100}),
       Duration.from({millis: 1000}),
@@ -102,7 +106,7 @@ describe('exponential retry class', () => {
   });
 
   it('backs off exponentially', () => {
-    const clock = sandbox.useFakeTimers();
+    const clock = TestUtils.useFakeTimers(sandbox);
     const er = new ExponentialRetry<TestItem>(
       Duration.from({millis: 100}),
       Duration.from({millis: 1000}),
@@ -136,7 +140,7 @@ describe('exponential retry class', () => {
   });
 
   it('backs off exponentially until the max backoff', () => {
-    const clock = sandbox.useFakeTimers();
+    const clock = TestUtils.useFakeTimers(sandbox);
     const item = makeItem();
     const er = new ExponentialRetry<TestItem>(
       Duration.from({millis: 100}),
@@ -170,7 +174,7 @@ describe('exponential retry class', () => {
   });
 
   it('calls retries in the right order', () => {
-    const clock = sandbox.useFakeTimers();
+    const clock = TestUtils.useFakeTimers(sandbox);
     const items = [makeItem(), makeItem()];
 
     const er = new ExponentialRetry<TestItem>(

test/lease-manager.ts

@@ -30,6 +30,7 @@ import {
   Subscriber,
 } from '../src/subscriber';
 import {defaultOptions} from '../src/default-options';
+import {TestUtils} from './test-utils';
 
 const FREE_MEM = 9376387072;
 const fakeos = {
@@ -237,7 +238,7 @@ describe('LeaseManager', () => {
         // This random number was generated once to keep the test results stable.
         random = 0.5756015072052962;
         sandbox.stub(global.Math, 'random').returns(random);
-        clock = sandbox.useFakeTimers();
+        clock = TestUtils.useFakeTimers(sandbox);
         expectedTimeout =
           (subscriber.ackDeadline * 1000 * 0.9 - subscriber.modAckLatency) *
           random;
@@ -397,7 +398,7 @@ describe('LeaseManager', () => {
     });
 
     it('should cancel any lease extensions', () => {
-      const clock = sandbox.useFakeTimers();
+      const clock = TestUtils.useFakeTimers(sandbox);
       const stub = sandbox.stub(subscriber, 'modAck').resolves();
 
       leaseManager.add(new FakeMessage() as {} as Message);
@@ -518,7 +519,7 @@ describe('LeaseManager', () => {
     });
 
     it('should cancel any extensions if no messages are left', () => {
-      const clock = sandbox.useFakeTimers();
+      const clock = TestUtils.useFakeTimers(sandbox);
       const message = new FakeMessage() as {} as Message;
       const stub = sandbox.stub(subscriber, 'modAck').resolves();
 
@@ -563,7 +564,7 @@ describe('LeaseManager', () => {
 
   describe('deadline extension', () => {
     beforeEach(() => {
-      sandbox.useFakeTimers();
+      TestUtils.useFakeTimers(sandbox);
     });
     afterEach(() => {
       sandbox.clock.restore();

test/message-queues.ts

@@ -26,6 +26,7 @@ import * as messageTypes from '../src/message-queues';
 import {BatchError} from '../src/message-queues';
 import {Message, Subscriber} from '../src/subscriber';
 import {DebugMessage} from '../src/debug';
+import {TestUtils} from './test-utils';
 
 class FakeClient {
   async acknowledge(
@@ -170,7 +171,7 @@ describe('MessageQueues', () => {
       });
 
       it('should schedule a flush if needed', () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const stub = sandbox.stub(messageQueue, 'flush');
         const delay = 1000;
 
@@ -183,7 +184,7 @@ describe('MessageQueues', () => {
       });
 
       it('should return a Promise that resolves when the ack is sent', async () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const delay = 1000;
         messageQueue.setOptions({maxMilliseconds: delay});
 
@@ -204,7 +205,7 @@ describe('MessageQueues', () => {
 
     describe('flush', () => {
       it('should cancel scheduled flushes', () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const spy = sandbox.spy(messageQueue, 'flush');
         const delay = 1000;
 
@@ -350,7 +351,7 @@ describe('MessageQueues', () => {
       });
 
       it('should default maxMilliseconds to 100', () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const stub = sandbox.stub(messageQueue, 'flush');
 
         void messageQueue.add(fakeMessage());
@@ -360,7 +361,7 @@ describe('MessageQueues', () => {
       });
 
       it('should respect user supplied maxMilliseconds', () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const stub = sandbox.stub(messageQueue, 'flush');
         const maxMilliseconds = 10000;
 
@@ -557,7 +558,7 @@ describe('MessageQueues', () => {
       // This doesn't need to be duplicated down to modAck because it's just
       // testing common code.
       it('should retry transient failures', async () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         sandbox.stub(global.Math, 'random').returns(0.5);
 
         const message = fakeMessage();

test/message-stream.ts

@@ -22,12 +22,13 @@ import * as sinon from 'sinon';
 import {Duplex, PassThrough} from 'stream';
 import * as uuid from 'uuid';
 import * as defer from 'p-defer';
+import {promisify} from 'util';
 
 import * as messageTypes from '../src/message-stream';
 import {Subscriber} from '../src/subscriber';
 import {defaultOptions} from '../src/default-options';
 import {Duration} from '../src/temporal';
-import {promisify} from 'util';
+import {TestUtils} from './test-utils';
 
 const FAKE_STREAMING_PULL_TIMEOUT = 123456789;
 const FAKE_CLIENT_CONFIG = {
@@ -63,13 +64,21 @@ class FakePassThrough extends PassThrough {
   }
 }
 
+interface AccessReadableState {
+  _readableState: StreamState;
+}
+
 class FakeGrpcStream extends Duplex {
   options: StreamingPullOptions;
-  _readableState!: StreamState;
   constructor(options: StreamingPullOptions) {
     super({objectMode: true});
     this.options = options;
   }
+
+  get readableState(): StreamState {
+    return (this as unknown as AccessReadableState)._readableState;
+  }
+
   cancel(): void {
     const status = {
       code: 1,
@@ -156,8 +165,8 @@ describe('MessageStream', () => {
   });
 
   beforeEach(async () => {
-    sandbox.useFakeTimers();
     now = Date.now();
+    TestUtils.useFakeTimers(sandbox, now);
 
     const gaxClient = new FakeGaxClient();
     client = gaxClient.client; // we hit the grpc client directly
@@ -207,7 +216,7 @@ describe('MessageStream', () => {
       describe('defaults', () => {
         it('should default highWaterMark to 0', () => {
           client.streams.forEach(stream => {
-            assert.strictEqual(stream._readableState.highWaterMark, 0);
+            assert.strictEqual(stream.readableState.highWaterMark, 0);
           });
         });
 
@@ -229,7 +238,10 @@ describe('MessageStream', () => {
 
         it('should default timeout to 5 minutes', () => {
           const expectedTimeout = now + 60000 * 5;
-          assert.strictEqual(client.deadline, expectedTimeout);
+
+          // Floating point calcuations in Duration might make this a few
+          // microseconds off.
+          assert.ok(Math.abs(client.deadline! - expectedTimeout) < 10);
         });
       });
 
@@ -252,9 +264,10 @@ describe('MessageStream', () => {
             client.streams.length,
             defaultOptions.subscription.maxStreams,
           );
+
           client.streams.forEach(stream => {
             assert.strictEqual(
-              stream._readableState.highWaterMark,
+              stream.readableState.highWaterMark,
               highWaterMark,
             );
           });

test/publisher/message-queues.ts

@@ -26,6 +26,7 @@ import * as p from '../../src/publisher';
 import * as b from '../../src/publisher/message-batch';
 import * as q from '../../src/publisher/message-queues';
 import {PublishError} from '../../src/publisher/publish-error';
+import {TestUtils} from '../test-utils';
 
 class FakeTopic {
   name = 'projects/foo/topics/fake-topic';
@@ -279,7 +280,7 @@ describe('Message Queues', () => {
       });
 
       it('should set a timeout to publish if need be', () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const stub = sandbox.stub(queue, 'publish').resolves();
         const maxMilliseconds = 1234;
 
@@ -293,7 +294,7 @@ describe('Message Queues', () => {
       });
 
       it('should noop if a timeout is already set', () => {
-        const clock = sandbox.useFakeTimers();
+        const clock = TestUtils.useFakeTimers(sandbox);
         const stub = sandbox.stub(queue, 'publish').resolves();
         const maxMilliseconds = 1234;
 
@@ -582,7 +583,7 @@ describe('Message Queues', () => {
 
       beforeEach(() => {
         queue.batchOptions = {maxMilliseconds};
-        clock = sinon.useFakeTimers();
+        clock = TestUtils.useFakeTimers(sandbox);
       });
 
       afterEach(() => {

test/test-utils.ts

@@ -0,0 +1,47 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {SinonSandbox, SinonFakeTimers} from 'sinon';
+
+type FakeTimersParam = Parameters<SinonSandbox['useFakeTimers']>[0];
+interface FakeTimerConfig {
+  now?: number,
+  toFake?: string[];
+}
+
+/**
+ * Utilities for unit test code.
+ *
+ * @private
+ */
+export class TestUtils {
+  /**
+   * This helper should be used to enable fake timers for Sinon sandbox.
+   *
+   * @param sandbox The sandbox
+   * @param now An optional date to set for "now"
+   * @returns The clock object from useFakeTimers()
+   */
+  static useFakeTimers(sandbox: SinonSandbox, now?: number): SinonFakeTimers {
+    const config: FakeTimerConfig = {
+      toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date'],
+    };
+    if (now) {
+      config.now = now;
+    }
+
+    // The types are screwy in useFakeTimers(). I'm just going to pick one.
+    return sandbox.useFakeTimers(config as FakeTimersParam);
+  }
+}