fix(tests): stabilize read deadlines and connector deletion races

Author: waleedlatif1

apps/sim/lib/billing/core/usage-log.test.ts

@@ -456,6 +456,7 @@ describe('ledger aggregates', () => {
 
   beforeEach(() => {
     installSharedDbMocks()
+    vi.spyOn(Date, 'now').mockReturnValue(billingPeriod.start.getTime())
   })
 
   for (const aggregate of aggregates) {

apps/sim/lib/billing/organizations/member-limits.test.ts

@@ -34,6 +34,7 @@ describe('getOrgMemberUsageForBillingPeriod', () => {
       start: new Date('2026-06-01T00:00:00.000Z'),
       end: new Date('2026-07-01T00:00:00.000Z'),
     }
+    vi.spyOn(Date, 'now').mockReturnValue(billingPeriod.start.getTime())
     queueTableRows(usageLog, [{ cost: '4.5' }])
     mockGetOrganizationSubscription.mockResolvedValue({
       periodStart: new Date('2026-07-01T00:00:00.000Z'),

apps/sim/lib/knowledge/__integration__/connector-lifecycle-locks.integration.ts

@@ -9,6 +9,7 @@ import {
   user,
   workspace,
 } from '@sim/db/schema'
+import { createDeferred } from '@sim/testing/helpers/deferred'
 import { generateId } from '@sim/utils/id'
 import { and, eq, inArray, isNotNull, sql } from 'drizzle-orm'
 import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -30,7 +31,7 @@ import {
 } from '@/lib/knowledge/__integration__/seed-source-access-fixture'
 import { deferConnectorSync } from '@/lib/knowledge/connectors/sync-deferral'
 import { completeSuccessfulSync } from '@/lib/knowledge/connectors/sync-engine'
-import { createContentSyncLease } from '@/lib/knowledge/connectors/sync-lock'
+import { createContentSyncLease, SyncLockLostException } from '@/lib/knowledge/connectors/sync-lock'
 import { sweepStuckDocuments } from '@/lib/knowledge/connectors/sync-primitives'
 import { deleteKnowledgeBase } from '@/lib/knowledge/service'
 import { GitHubRequestDeferredError } from '@/connectors/github/request'
@@ -40,14 +41,6 @@ const WAIT_OPTIONS = { interval: 5, timeout: 5000 }
 const ACTIONS = ['complete', 'defer', 'recover'] as const
 type Action = (typeof ACTIONS)[number]
 
-function deferred() {
-  let resolve!: () => void
-  const promise = new Promise<void>((ready) => {
-    resolve = ready
-  })
-  return { promise, resolve }
-}
-
 function emptyResult(): SyncResult {
   return {
     docsAdded: 0,
@@ -156,29 +149,37 @@ describe('source lifecycle KB guards', () => {
   }
 
   function holdCommit(action: Action) {
-    const gate = { pid: undefined as number | undefined, release: deferred() }
+    const gate = {
+      pid: undefined as number | undefined,
+      release: createDeferred<void>(),
+      resumeAfterCommit: createDeferred<void>(),
+    }
     const transaction = db.transaction.bind(db)
-    vi.spyOn(db, 'transaction').mockImplementation((callback, config) =>
-      transaction(async (tx) => {
+    vi.spyOn(db, 'transaction').mockImplementation(async (callback, config) => {
+      let heldCommit = false
+      const result = await transaction(async (tx) => {
         await tx.execute(sql`SET LOCAL statement_timeout = '10s'`)
         await tx.execute(sql`SET LOCAL idle_in_transaction_session_timeout = '15s'`)
         const result = await callback(tx)
         if (gate.pid === undefined && (await wrote(action, tx))) {
           const [backend] = await tx.execute<{ pid: number }>(sql`SELECT pg_backend_pid() AS pid`)
           gate.pid = backend.pid
+          heldCommit = true
           await gate.release.promise
         }
         return result
       }, config)
-    )
+      if (heldCommit && action === 'recover') await gate.resumeAfterCommit.promise
+      return result
+    })
     return gate
   }
 
   it.each(ACTIONS)(
     '%s can commit while an unrelated embedding holds the KB key-share lock',
     async (action) => {
-      const release = deferred()
-      const acquired = deferred()
+      const release = createDeferred<void>()
+      const acquired = createDeferred<void>()
       const holding = db.transaction(async (tx) => {
         await tx.execute(sql`SET LOCAL idle_in_transaction_session_timeout = '15s'`)
         await tx
@@ -228,15 +229,23 @@ describe('source lifecycle KB guards', () => {
         .where(eq(knowledgeBase.id, ids.knowledgeBaseId))
       expect(active.deletedAt).toBeNull()
       gate.release.resolve()
-      expect(await completed).toMatchObject([{ status: 'fulfilled' }])
       expect(await deleted).toMatchObject([{ status: 'fulfilled' }])
+      gate.resumeAfterCommit.resolve()
+      if (action === 'recover') {
+        expect(await completed).toMatchObject([
+          { status: 'rejected', reason: expect.any(SyncLockLostException) },
+        ])
+      } else {
+        expect(await completed).toMatchObject([{ status: 'fulfilled' }])
+      }
       const [archived] = await db
         .select({ id: document.id })
         .from(document)
         .where(and(eq(document.id, retryDocumentId), isNotNull(document.archivedAt)))
       expect(archived?.id).toBe(retryDocumentId)
     } finally {
       gate.release.resolve()
+      gate.resumeAfterCommit.resolve()
       await completed
       await deleted
     }