test(leader-lock): use fake timers to deterministically test follower polling

The "follower does a final read after timeout" test (and the
"follower returns null after timeout" test) relied on real-clock
`setTimeout` and `Date.now()` with very tight bounds (pollIntervalMs=5,
maxWaitMs=9). Any CI scheduler jitter of >4ms would cause the second
in-loop poll to be skipped, the polls counter to end at 2 instead of 3,
and the assertion `expect(result).toBe('late-leader')` to fail.

Switched both tests to `vi.useFakeTimers()` so the schedule is driven by
mocked time advanced via `vi.advanceTimersByTimeAsync`. The intent is
unchanged — verify that the in-loop deadline triggers exactly one
post-deadline last-chance call to `onFollower` — but the assertions no
longer depend on wall-clock timing.

Verified across 5 sequential runs with zero flakes.

Author: waleedlatif1

apps/sim/lib/concurrency/__tests__/leader-lock.test.ts

@@ -120,39 +120,62 @@ describe('withLeaderLock', () => {
   it('follower does a final read after timeout to catch a just-finished leader', async () => {
     redisConfigMockFns.mockAcquireLock.mockResolvedValueOnce(false)
 
-    // pollInterval=5, maxWait=9 → loop exits after 2 in-loop polls (T+5, T+10);
-    // the third call (polls=3) is the post-deadline last-chance read.
-    let polls = 0
-    const onFollower = vi.fn(async () => {
-      polls += 1
-      if (polls <= 2) return null
-      return 'late-leader'
-    })
+    /**
+     * The intent: after the in-loop poll deadline is reached, the follower
+     * does exactly one more (last-chance) `onFollower` call to catch a leader
+     * that finished between the previous poll and the timeout. Using fake
+     * timers makes the timing deterministic — pollInterval=10 and maxWait=15
+     * cause two in-loop polls (T+10, T+20) and one last-chance read (T+20),
+     * but the schedule is driven by mocked time, not the CI wall clock.
+     */
+    vi.useFakeTimers()
+    try {
+      let polls = 0
+      const onFollower = vi.fn(async () => {
+        polls += 1
+        if (polls <= 2) return null
+        return 'late-leader'
+      })
 
-    const result = await withLeaderLock<string>({
-      key: 'k',
-      pollIntervalMs: 5,
-      maxWaitMs: 9,
-      onLeader: async () => 'should-not-run',
-      onFollower,
-    })
+      const promise = withLeaderLock<string>({
+        key: 'k',
+        pollIntervalMs: 10,
+        maxWaitMs: 15,
+        onLeader: async () => 'should-not-run',
+        onFollower,
+      })
+
+      await vi.advanceTimersByTimeAsync(30)
+      const result = await promise
 
-    expect(result).toBe('late-leader')
-    expect(onFollower).toHaveBeenCalledTimes(3)
+      expect(result).toBe('late-leader')
+      expect(onFollower).toHaveBeenCalledTimes(3)
+    } finally {
+      vi.useRealTimers()
+    }
   })
 
   it('follower returns null after timeout', async () => {
     redisConfigMockFns.mockAcquireLock.mockResolvedValueOnce(false)
 
-    const result = await withLeaderLock<string>({
-      key: 'k',
-      pollIntervalMs: 5,
-      maxWaitMs: 20,
-      onLeader: async () => 'should-not-run',
-      onFollower: async () => null,
-    })
+    vi.useFakeTimers()
+    try {
+      const onFollower = vi.fn(async () => null)
+      const promise = withLeaderLock<string>({
+        key: 'k',
+        pollIntervalMs: 10,
+        maxWaitMs: 25,
+        onLeader: async () => 'should-not-run',
+        onFollower,
+      })
+
+      await vi.advanceTimersByTimeAsync(50)
+      const result = await promise
 
-    expect(result).toBeNull()
+      expect(result).toBeNull()
+    } finally {
+      vi.useRealTimers()
+    }
   })
 
   it('only one of N concurrent callers acquires the lock', async () => {