diff --git a/test/index.ts b/test/index.ts
index a9aeaa2b3..570c3c411 100644
--- a/test/index.ts
+++ b/test/index.ts
@@ -111,7 +111,7 @@ class FakeInstance {
   constructor() {
     this.calledWith_ = arguments;
   }
-  static formatName_(name: string) {
+  static formatName_(projectId: string, name: string) {
     return name;
   }
 }
@@ -357,13 +357,13 @@ describe('Spanner', () => {
     });
 
     it('should set the correct defaults on the request', done => {
-      sandbox.stub(FakeInstance, 'formatName_').callsFake((projectId, name) => {
+      const stub = sandbox.stub(FakeInstance, 'formatName_').returns(PATH);
+
+      spanner.request = (config) => {
+        const [projectId, name] = stub.lastCall.args;
         assert.strictEqual(projectId, spanner.projectId);
         assert.strictEqual(name, NAME);
-        return PATH;
-      });
 
-      spanner.request = (config) => {
         assert.deepStrictEqual(CONFIG, ORIGINAL_CONFIG);
         assert.strictEqual(config.client, 'InstanceAdminClient');
         assert.strictEqual(config.method, 'createInstance');
@@ -384,25 +384,24 @@ describe('Spanner', () => {
       spanner.createInstance(NAME, CONFIG, assert.ifError);
     });
 
-    it('should accept a path', done => {
-      sandbox.stub(FakeInstance, 'formatName_').callsFake((projectId, name) => {
-        assert.strictEqual(name, PATH);
-        setImmediate(done);
-        return name;
-      });
+    it('should accept a path', () => {
+      const stub = sandbox.stub(FakeInstance, 'formatName_').callThrough();
       spanner.createInstance(PATH, CONFIG, assert.ifError);
+
+      const [projectId, name] = stub.lastCall.args;
+      assert.strictEqual(name, PATH);
     });
 
     describe('config.nodes', () => {
-      it('should rename to nodeCount', done => {
+      it('should rename to nodeCount', () => {
         const config = extend({}, CONFIG, {nodes: 10});
-        sandbox.stub(spanner, 'request').callsFake(config_ => {
-          const reqOpts = config_.reqOpts;
-          assert.strictEqual(reqOpts.instance.nodeCount, config.nodes);
-          assert.strictEqual(reqOpts.instance.nodes, undefined);
-          done();
-        });
+        const stub = sandbox.stub(spanner, 'request');
         spanner.createInstance(NAME, config, assert.ifError);
+
+        const [config_] = stub.lastCall.args;
+        const reqOpts = config_.reqOpts;
+        assert.strictEqual(reqOpts.instance.nodeCount, config.nodes);
+        assert.strictEqual(reqOpts.instance.nodes, undefined);
       });
     });
 
@@ -458,13 +457,13 @@ describe('Spanner', () => {
         const formattedName = 'formatted-name';
         sandbox.stub(FakeInstance, 'formatName_').returns(formattedName);
         const fakeInstanceInstance = {};
-        sandbox.stub(spanner, 'instance').callsFake(name => {
-          assert.strictEqual(name, formattedName);
-          return fakeInstanceInstance;
-        });
+        const instanceStub =
+            sandbox.stub(spanner, 'instance').returns(fakeInstanceInstance);
 
         spanner.createInstance(NAME, CONFIG, (err, instance, op, resp) => {
           assert.ifError(err);
+          const [instanceName] = instanceStub.lastCall.args;
+          assert.strictEqual(instanceName, formattedName);
           assert.strictEqual(instance, fakeInstanceInstance);
           assert.strictEqual(op, OPERATION);
           assert.strictEqual(resp, API_RESPONSE);
diff --git a/test/session-pool.ts b/test/session-pool.ts
index 2af0de26f..9a589a237 100644
--- a/test/session-pool.ts
+++ b/test/session-pool.ts
@@ -1451,66 +1451,25 @@ describe('SessionPool', () => {
 
   describe('_startHouseKeeping', () => {
     it('should set an interval to evict idle sessions', done => {
-      const callIndex = 0;
       const expectedInterval = sessionPool.options.idlesAfter * 60000;
+      const clock = sandbox.useFakeTimers();
 
-      let intervalCalls = 0;
-      let unreffed = false;
-
-      const fakeHandle = {
-        unref() {
-          unreffed = true;
-        },
-      };
-
-      sandbox.stub(global, 'setInterval').callsFake((fn, interval) => {
-        if (intervalCalls++ !== callIndex) {
-          return {unref: noop};
-        }
-        assert.strictEqual(interval, expectedInterval);
-        setImmediate(fn);
-        return fakeHandle;
-      });
-
-      sessionPool._evictIdleSessions = () => {
-        assert.strictEqual(sessionPool._evictHandle, fakeHandle);
-        assert.strictEqual(unreffed, true);
-        done();
-      };
-
+      sessionPool._evictIdleSessions = done;
       sessionPool._startHouseKeeping();
+      clock.tick(expectedInterval);
     });
 
     it('should set an interval to ping sessions', done => {
-      const callIndex = 1;
       const expectedInterval = sessionPool.options.keepAlive * 60000;
-
-      let intervalCalls = 0;
-      let unreffed = false;
-
-      const fakeHandle = {
-        unref() {
-          unreffed = true;
-        },
-      };
-
-      sandbox.stub(global, 'setInterval').callsFake((fn, interval) => {
-        if (intervalCalls++ !== callIndex) {
-          return {unref: noop};
-        }
-        assert.strictEqual(interval, expectedInterval);
-        setImmediate(fn);
-        return fakeHandle;
-      });
+      const clock = sandbox.useFakeTimers();
 
       sessionPool._pingIdleSessions = () => {
-        assert.strictEqual(sessionPool._pingHandle, fakeHandle);
-        assert.strictEqual(unreffed, true);
         done();
         return Promise.resolve([]);
       };
 
       sessionPool._startHouseKeeping();
+      clock.tick(expectedInterval);
     });
   });
 
@@ -1520,15 +1479,14 @@ describe('SessionPool', () => {
       sessionPool._evictHandle = 'b';
 
       const fakeHandles = [sessionPool._pingHandle, sessionPool._evictHandle];
+      const stub = sandbox.stub(global, 'clearInterval');
 
-      let clearCalls = 0;
+      sessionPool._stopHouseKeeping();
 
-      sandbox.stub(global, 'clearInterval').callsFake(handle => {
-        assert.strictEqual(handle, fakeHandles[clearCalls++]);
+      fakeHandles.forEach((fakeHandle, i) => {
+        const [handle] = stub.getCall(i).args;
+        assert.strictEqual(handle, fakeHandle);
       });
-
-      sessionPool._stopHouseKeeping();
-      assert.strictEqual(clearCalls, 2);
     });
   });
 });