test(webapp): strengthen split suite assertions

Author: carderne

apps/webapp/test/apiRunListPresenter.readthrough.test.ts

@@ -47,7 +47,7 @@ vi.mock("~/db.server", async () => {
 
 import { createPostgresContainer, replicationContainerTest } from "@internal/testcontainers";
 import { PrismaClient } from "@trigger.dev/database";
-import { setTimeout } from "node:timers/promises";
+import { z } from "zod";
 import { CURRENT_API_VERSION } from "~/api/versions";
 import { ApiRunListPresenter } from "~/presenters/v3/ApiRunListPresenter.server";
 import { createRun, mirrorParents, seedParents } from "./helpers/apiRunListPresenterTestHelpers";
@@ -102,7 +102,23 @@ describe("ApiRunListPresenter public /runs routed read-through", () => {
           data: { id: migratedB.id },
         });
 
-        await setTimeout(1500);
+        const replicatedRunsQuery = clickhouse.reader.query({
+          name: "waitForApiRunListPresenterTaskRuns",
+          query:
+            "SELECT countDistinct(run_id) AS count FROM trigger_dev.task_runs_v2 WHERE run_id IN {run_ids:Array(String)}",
+          schema: z.object({ count: z.number() }),
+          params: z.object({ run_ids: z.array(z.string()) }),
+        });
+        await vi.waitFor(
+          async () => {
+            const [error, rows] = await replicatedRunsQuery({
+              run_ids: [legacyOnlyA.id, legacyOnlyB.id, migratedA.id, migratedB.id],
+            });
+            if (error) throw error;
+            expect(rows?.[0]?.count).toBe(4);
+          },
+          { timeout: 15_000, interval: 100 }
+        );
 
         const presenter = new ApiRunListPresenter(prisma, prisma, {
           newClient: prismaNew,

apps/webapp/test/dashboardAgentWatches.delivery.test.ts

@@ -895,11 +895,13 @@ describe("the watch card submit", () => {
 
       // The crash state: the request record is written and the watch is live, but the
       // process died before the confirmation was appended.
-      await appendChatMessageOnce(ctx.agentDb, {
+      const requestAppended = await appendChatMessageOnce(ctx.agentDb, {
         chatId: "chat_1",
         userId: seeded.user.id,
+        organizationId: seeded.organization.id,
         message: { id: "watch-request:wreq_1", role: "user", parts: [] } as never,
       });
+      expect(requestAppended).toBe(true);
       const created = await create({ seeded, chatId: "chat_1" });
       expect(created.ok).toBe(true);
       if (!created.ok || !created.watching) return;

apps/webapp/test/dashboardAgentWatches.lifecycle.test.ts

@@ -862,6 +862,7 @@ describe("the check endpoint", () => {
   async function activeWatch(seeded: Seeded, spec?: WatchSpec) {
     const result = await create({ seeded, spec });
     if (!result.ok) throw new Error(`watch not created: ${result.code}`);
+    if (!result.watching) throw new Error("expected an active watch");
     return result;
   }
 

apps/webapp/test/engine/triggerTask.externalDeploymentId.helpers.ts

@@ -17,35 +17,53 @@ import {
 
 export class RecordingExternalDeploymentCache implements ExternalDeploymentCache {
   readonly gets: Array<{ environmentId: string; externalId: string }> = [];
-  readonly writes: Array<{ externalId: string; entry: ExternalDeploymentCacheEntry }> = [];
+  readonly writes: Array<{
+    environmentId: string;
+    externalId: string;
+    entry: ExternalDeploymentCacheEntry;
+  }> = [];
+  readonly missing: Array<{ environmentId: string; externalId: string }> = [];
+  private readonly entries = new Map<string, ExternalDeploymentCacheEntry>();
 
-  constructor(private readonly entries = new Map<string, ExternalDeploymentCacheEntry>()) {}
-
-  readonly missing: string[] = [];
+  constructor(
+    entries: Array<{
+      environmentId: string;
+      externalId: string;
+      entry: ExternalDeploymentCacheEntry;
+    }> = []
+  ) {
+    for (const { environmentId, externalId, entry } of entries) {
+      this.entries.set(this.key(environmentId, externalId), entry);
+    }
+  }
 
   async get(environmentId: string, externalId: string) {
     this.gets.push({ environmentId, externalId });
 
-    const entry = this.entries.get(externalId);
+    const entry = this.entries.get(this.key(environmentId, externalId));
 
     if (entry) {
       return { outcome: "deployed" as const, entry };
     }
 
-    return this.missing.includes(externalId) ? { outcome: "missing" as const } : null;
+    return this.missing.some(
+      (missing) => missing.environmentId === environmentId && missing.externalId === externalId
+    )
+      ? { outcome: "missing" as const }
+      : null;
   }
 
-  async setIfNewer(
-    _environmentId: string,
-    externalId: string,
-    entry: ExternalDeploymentCacheEntry
-  ) {
-    this.writes.push({ externalId, entry });
-    this.entries.set(externalId, entry);
+  async setIfNewer(environmentId: string, externalId: string, entry: ExternalDeploymentCacheEntry) {
+    this.writes.push({ environmentId, externalId, entry });
+    this.entries.set(this.key(environmentId, externalId), entry);
+  }
+
+  async setMissing(environmentId: string, externalId: string) {
+    this.missing.push({ environmentId, externalId });
   }
 
-  async setMissing(_environmentId: string, externalId: string) {
-    this.missing.push(externalId);
+  private key(environmentId: string, externalId: string) {
+    return JSON.stringify([environmentId, externalId]);
   }
 }
 

apps/webapp/test/engine/triggerTask.externalDeploymentId.resolution.test.ts

@@ -40,19 +40,18 @@ describe("triggerTask external deployment id", () => {
 
       const worker = await setupBackgroundWorker(engine, environment, taskIdentifier);
 
-      const cache = new RecordingExternalDeploymentCache(
-        new Map([
-          [
-            "commit-cached",
-            {
-              workerId: worker.worker.id,
-              version: worker.worker.version,
-              sdkVersion: "",
-              cliVersion: "",
-            },
-          ],
-        ])
-      );
+      const cache = new RecordingExternalDeploymentCache([
+        {
+          environmentId: environment.id,
+          externalId: "commit-cached",
+          entry: {
+            workerId: worker.worker.id,
+            version: worker.worker.version,
+            sdkVersion: "",
+            cliVersion: "",
+          },
+        },
+      ]);
 
       const service = createService(prisma, engine, cache);
 
@@ -163,7 +162,19 @@ describe("triggerTask external deployment id", () => {
         },
       });
 
-      const service = createService(prisma, engine, new NoopExternalDeploymentCache());
+      const cache = new RecordingExternalDeploymentCache([
+        {
+          environmentId: otherEnvironment.id,
+          externalId: "commit-elsewhere",
+          entry: {
+            workerId: worker.worker.id,
+            version: worker.worker.version,
+            sdkVersion: "",
+            cliVersion: "",
+          },
+        },
+      ]);
+      const service = createService(prisma, engine, cache);
 
       const result = await service.call({
         taskId: taskIdentifier,
@@ -177,6 +188,12 @@ describe("triggerTask external deployment id", () => {
 
       expect(run.status).toBe("PENDING_VERSION");
       expect(run.lockedToVersionId).toBeNull();
+      expect(cache.gets).toEqual([
+        { environmentId: environment.id, externalId: "commit-elsewhere" },
+      ]);
+      expect(cache.missing).toEqual([
+        { environmentId: environment.id, externalId: "commit-elsewhere" },
+      ]);
     }
   );
 });