fix(tests): take a draft's timestamp from before the run loads it

Reading it after the load let an edit landing in between look tested; the snapshot from
before the load can only err toward stale.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: TheodoreSpeaks

apps/sim/lib/workflow-tests/repository.ts

@@ -142,7 +142,7 @@ export interface RanAgainstEntry {
   deploymentVersionId: string | null
   /** A `runWorkflow()` execution of it, whose snapshot is the workflow as it ran; null for a child. */
   executionId: string | null
-  /** For a draft, the workflow's `updatedAt` when the run loaded it; a later edit makes the run stale. */
+  /** For a draft, the workflow's `updatedAt` before the run loaded it; a later edit makes the run stale. */
   draftUpdatedAt: string | null
 }
 
@@ -151,15 +151,13 @@ export type EnteredWorkflow = Omit<RanAgainstEntry, 'executionId'>
 
 type ExecutedWorkflow = Omit<RanAgainstEntry, 'draftUpdatedAt'>
 
-/** When a draft last changed; a test run reads it as it loads the draft. */
-export async function readDraftUpdatedAt(workflowId: string): Promise<string> {
-  const [row] = await db
-    .select({ updatedAt: workflow.updatedAt })
+/** When each of the workspace's drafts last changed; a test run reads them before it loads any. */
+export async function readDraftTimestamps(workspaceId: string): Promise<Map<string, string>> {
+  const rows = await db
+    .select({ id: workflow.id, updatedAt: workflow.updatedAt })
     .from(workflow)
-    .where(eq(workflow.id, workflowId))
-    .limit(1)
-  if (!row) throw new Error(`Workflow ${workflowId} not found`)
-  return row.updatedAt.toISOString()
+    .where(and(eq(workflow.workspaceId, workspaceId), isNull(workflow.archivedAt)))
+  return new Map(rows.map((row) => [row.id, row.updatedAt.toISOString()]))
 }
 
 const enteredKey = (entry: { workflowId: string; deploymentVersionId: string | null }) =>

apps/sim/lib/workflow-tests/run-test-file.ts

@@ -51,7 +51,7 @@ export async function runWorkflowTestFile(
     )
     return {
       report: testReportSchema.parse(JSON.parse(Buffer.from(bytes).toString('utf-8'))),
-      entered: await session.enteredWorkflows(),
+      entered: session.enteredWorkflows(),
     }
   } finally {
     closeWorkflowTestSession(requestId)

apps/sim/lib/workflow-tests/session.ts

@@ -15,7 +15,7 @@ import {
   type ParkedMockCall,
 } from '@/lib/workflow-tests/mock-channel'
 import type { TestCaseStatus, TestEvent, TestTarget } from '@/lib/workflow-tests/protocol'
-import { type EnteredWorkflow, readDraftUpdatedAt } from '@/lib/workflow-tests/repository'
+import { type EnteredWorkflow, readDraftTimestamps } from '@/lib/workflow-tests/repository'
 import {
   runWorkflowForTest,
   type WorkflowTestRunResult,
@@ -251,10 +251,7 @@ class RunMatcher implements MockMatcher {
   constructor(
     targets: TestTarget[],
     private readonly loadChildBlocks: (workflowId: string) => Promise<Record<string, BlockState>>,
-    private readonly onEnter: (
-      workflowId: string,
-      deploymentVersionId: string | null
-    ) => Promise<void>
+    private readonly onEnter: (workflowId: string, deploymentVersionId: string | null) => void
   ) {
     this.targets = [...targets].sort(
       (a, b) => Number(a.workflow === null) - Number(b.workflow === null)
@@ -276,7 +273,7 @@ class RunMatcher implements MockMatcher {
       this.entered = true
       this.outputRegistry = resolvedSecretTraceRegistry
     }
-    await this.onEnter(workflowId, deploymentVersionId)
+    this.onEnter(workflowId, deploymentVersionId)
     const workflowName = await this.workflowName(workflowId)
     for (const block of blocks) this.blocks.set(block.id, block)
     await this.learnWorkflow(
@@ -527,7 +524,7 @@ class TestWorkflowRun {
 export class WorkflowTestSession {
   private readonly runs = new Map<string, TestWorkflowRun>()
   /** Every workflow version this file's runs executed, children included, as each loaded it. */
-  private readonly enteredVersions = new Map<string, Promise<EnteredWorkflow>>()
+  private readonly enteredVersions = new Map<string, EnteredWorkflow>()
   /** Set when the sandbox run ends; a start still awaiting its lookups then starts nothing. */
   private closed = false
   /** Stops `toMatchRubric` model calls still in flight when the sandbox run ends. */
@@ -546,9 +543,10 @@ export class WorkflowTestSession {
     const blocks = await loadWorkflowBlocks(workflowId, workspaceId, version)
     const triggerBlockId = chooseTrigger(args.workflow, blocks, args.trigger)
     const targets = await resolveToolTargets(workspaceId, args.targets)
+    const draftsBeforeLoad = version === 'draft' ? await readDraftTimestamps(workspaceId) : null
     if (this.closed) throw new Error('This workflow test run has ended')
     const matcher = new RunMatcher(targets, loadChildBlockNames, (id, deploymentVersionId) =>
-      this.recordEntered(id, deploymentVersionId)
+      this.recordEntered(id, deploymentVersionId, draftsBeforeLoad)
     )
     const channel = createMockChannel(matcher)
     const abort = new AbortController()
@@ -592,23 +590,28 @@ export class WorkflowTestSession {
     }
   }
 
-  /** The first entry of a draft keeps its timestamp, so an edit between runs leaves the file stale. */
-  private async recordEntered(workflowId: string, deploymentVersionId: string | null) {
+  /**
+   * A draft records its timestamp from before the run loaded it, so any edit after that point,
+   * including one the load may have missed, leaves the run stale. The first run to enter a
+   * workflow keeps its entry, the earliest timestamp.
+   */
+  private recordEntered(
+    workflowId: string,
+    deploymentVersionId: string | null,
+    draftsBeforeLoad: Map<string, string> | null
+  ): void {
     const key = `${workflowId}:${deploymentVersionId ?? 'draft'}`
-    let entry = this.enteredVersions.get(key)
-    if (!entry) {
-      entry = (async () => ({
-        workflowId,
-        deploymentVersionId,
-        draftUpdatedAt: deploymentVersionId === null ? await readDraftUpdatedAt(workflowId) : null,
-      }))()
-      this.enteredVersions.set(key, entry)
-    }
-    await entry
+    if (this.enteredVersions.has(key)) return
+    this.enteredVersions.set(key, {
+      workflowId,
+      deploymentVersionId,
+      draftUpdatedAt:
+        deploymentVersionId === null ? (draftsBeforeLoad?.get(workflowId) ?? null) : null,
+    })
   }
 
-  enteredWorkflows(): Promise<EnteredWorkflow[]> {
-    return Promise.all(this.enteredVersions.values())
+  enteredWorkflows(): EnteredWorkflow[] {
+    return [...this.enteredVersions.values()]
   }
 
   close(): void {