test(webapp): remove obsolete Postgres empty-state probe tests

The empty-state probe now runs against ClickHouse, so the old dual-DB findFirst probe tests no longer apply. Keeps the list-hydrate routing test, which is unchanged.

Author: ericallam

apps/webapp/test/nextRunListPresenter.readthrough.test.ts

@@ -144,220 +144,12 @@ async function createRun(
   });
 }
 
-/**
- * Wraps a real prisma handle in a Proxy whose `taskRun.findFirst` throws if invoked. Used to
- * prove the empty-state probe never touches the legacy replica when the new DB already answers.
- * All other access forwards to the real client (so FK parents etc. still resolve).
- */
-function throwingFindFirst(prisma: PrismaClient, label: string): PrismaClient {
-  return new Proxy(prisma, {
-    get(target, prop) {
-      if (prop === "taskRun") {
-        return new Proxy((target as any).taskRun, {
-          get(trTarget, trProp) {
-            if (trProp === "findFirst") {
-              return async () => {
-                throw new Error(`${label}.taskRun.findFirst must not be invoked`);
-              };
-            }
-            return (trTarget as any)[trProp];
-          },
-        });
-      }
-      return (target as any)[prop];
-    },
-  }) as unknown as PrismaClient;
-}
-
-const callOptions = (ctx: SeedContext, overrides?: { to?: number }) => ({
+const callOptions = (ctx: SeedContext) => ({
   projectId: ctx.projectId,
   pageSize: 10,
-  ...overrides,
 });
 
-// `to` one hour in the past. The CH page filters `created_at <= to`, so a just-created run is
-// deterministically excluded regardless of replication timing — the empty-state tests otherwise
-// raced on the run not having replicated yet (held locally, failed on CI). The PG existence probe
-// has no time filter, so it still finds the row and `hasAnyRuns` stays true.
-const emptyPageWindow = (): { to: number } => ({ to: Date.now() - 60 * 60 * 1000 });
-
-describe("NextRunListPresenter dual-DB empty-state probe + routed hydrate (legacy + new Postgres)", () => {
-  // no-false-empty. Runs ONLY on legacy, none on new. Empty CH page -> listRuns returns [].
-  // splitEnabled true. The probe misses NEW, falls through to the legacy replica and finds the
-  // row, so the dashboard must NOT show "no runs".
-  replicationContainerTest(
-    "no-false-empty: runs only on the legacy replica still report hasAnyRuns true",
-    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma, network }) => {
-      const { clickhouse } = await setupClickhouseReplication({
-        prisma,
-        databaseUrl: postgresContainer.getConnectionUri(),
-        clickhouseUrl: clickhouseContainer.getConnectionUrl(),
-        redisOptions,
-      });
-
-      const { url: newUrl } = await createPostgresContainer(network, {
-        imageTag: "docker.io/postgres:17",
-      });
-      const prismaNew = new PrismaClient({ datasources: { db: { url: newUrl } } });
-      legacyReplicaHolder.client = prisma;
-
-      try {
-        const ctx = await seedParents(prisma, "nofalseempty");
-        await mirrorParents(prismaNew, ctx, "nofalseempty");
-
-        // Run lives ONLY on the legacy DB. We seed it to legacy and never wait for CH replication,
-        // so within the page window the CH id-set page is empty and listRuns returns []. The
-        // empty-state probe (NEW miss -> legacy hit) is what proves hasAnyRuns stays true.
-        await createRun(prisma, ctx, { friendlyId: "run_legacyOnly" });
-
-        const presenter = new NextRunListPresenter(prisma, clickhouse, {
-          newClient: prismaNew,
-          legacyReplica: prisma,
-          splitEnabled: true,
-        });
-
-        const result = await presenter.call(
-          ctx.organizationId,
-          ctx.environmentId,
-          callOptions(ctx, emptyPageWindow())
-        );
-
-        // CH id-set is empty within the page window, but the legacy probe finds the row.
-        expect(result.runs).toHaveLength(0);
-        expect(result.hasAnyRuns).toBe(true);
-      } finally {
-        await prismaNew.$disconnect();
-      }
-    }
-  );
-
-  // new-DB short-circuit. A run on NEW, legacy replica wrapped so its taskRun.findFirst
-  // throws. Empty CH page. The probe answers from NEW and must NEVER fall through to legacy. The
-  // post-migration straggler is the same shape: present on NEW, absent from LEGACY, legacy never
-  // invoked.
-  replicationContainerTest(
-    "new-DB short-circuit: hasAnyRuns answered from the new DB without touching the legacy replica",
-    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma, network }) => {
-      const { clickhouse } = await setupClickhouseReplication({
-        prisma,
-        databaseUrl: postgresContainer.getConnectionUri(),
-        clickhouseUrl: clickhouseContainer.getConnectionUrl(),
-        redisOptions,
-      });
-
-      const { url: newUrl } = await createPostgresContainer(network, {
-        imageTag: "docker.io/postgres:17",
-      });
-      const prismaNew = new PrismaClient({ datasources: { db: { url: newUrl } } });
-      legacyReplicaHolder.client = prisma;
-
-      try {
-        const ctx = await seedParents(prisma, "newshortcircuit");
-        await mirrorParents(prismaNew, ctx, "newshortcircuit");
-
-        // The (migrated/straggler) run lives ONLY on NEW.
-        await createRun(prismaNew, ctx, { friendlyId: "run_newOnly" });
-
-        const legacySpy = throwingFindFirst(prisma, "legacyReplica");
-
-        const presenter = new NextRunListPresenter(prisma, clickhouse, {
-          newClient: prismaNew,
-          legacyReplica: legacySpy,
-          splitEnabled: true,
-        });
-
-        // If the legacy spy were invoked, this would throw — the test passing IS the proof.
-        const result = await presenter.call(
-          ctx.organizationId,
-          ctx.environmentId,
-          callOptions(ctx)
-        );
-
-        expect(result.runs).toHaveLength(0);
-        expect(result.hasAnyRuns).toBe(true);
-      } finally {
-        await prismaNew.$disconnect();
-      }
-    }
-  );
-
-  // genuinely empty. Nothing on either DB. Empty CH page. splitEnabled true. Both
-  // probes run and return null -> the true empty state is preserved.
-  replicationContainerTest(
-    "genuinely empty: both DBs empty reports hasAnyRuns false",
-    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma, network }) => {
-      const { clickhouse } = await setupClickhouseReplication({
-        prisma,
-        databaseUrl: postgresContainer.getConnectionUri(),
-        clickhouseUrl: clickhouseContainer.getConnectionUrl(),
-        redisOptions,
-      });
-
-      const { url: newUrl } = await createPostgresContainer(network, {
-        imageTag: "docker.io/postgres:17",
-      });
-      const prismaNew = new PrismaClient({ datasources: { db: { url: newUrl } } });
-      legacyReplicaHolder.client = prisma;
-
-      try {
-        const ctx = await seedParents(prisma, "trulyempty");
-        await mirrorParents(prismaNew, ctx, "trulyempty");
-
-        const presenter = new NextRunListPresenter(prisma, clickhouse, {
-          newClient: prismaNew,
-          legacyReplica: prisma,
-          splitEnabled: true,
-        });
-
-        const result = await presenter.call(
-          ctx.organizationId,
-          ctx.environmentId,
-          callOptions(ctx)
-        );
-
-        expect(result.runs).toHaveLength(0);
-        expect(result.hasAnyRuns).toBe(false);
-      } finally {
-        await prismaNew.$disconnect();
-      }
-    }
-  );
-
-  // passthrough single-DB (two-arg ctor). One `prisma`, seed a run, empty CH page.
-  // splitEnabled defaults false -> exactly one plain findFirst against the single handle; the
-  // split branch (new/legacy) is structurally never entered (no second handle is injected).
-  // Also covers "served from the replica only" — the ctor exposes no legacy-writer field, so a
-  // no-primary-read guarantee is structural.
-  replicationContainerTest(
-    "passthrough single-DB: two-arg ctor finds the run via the single handle",
-    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
-      const { clickhouse } = await setupClickhouseReplication({
-        prisma,
-        databaseUrl: postgresContainer.getConnectionUri(),
-        clickhouseUrl: clickhouseContainer.getConnectionUrl(),
-        redisOptions,
-      });
-
-      legacyReplicaHolder.client = prisma;
-
-      const ctx = await seedParents(prisma, "passthrough");
-      await createRun(prisma, ctx, { friendlyId: "run_passthrough" });
-
-      // Two-arg ctor: no readThroughDeps -> RunsRepository.readThrough is undefined
-      // (passthrough) and the probe is one plain `this.replica.taskRun.findFirst`.
-      const presenter = new NextRunListPresenter(prisma, clickhouse);
-
-      const result = await presenter.call(
-        ctx.organizationId,
-        ctx.environmentId,
-        callOptions(ctx, emptyPageWindow())
-      );
-
-      expect(result.runs).toHaveLength(0);
-      expect(result.hasAnyRuns).toBe(true);
-    }
-  );
-
+describe("NextRunListPresenter routed hydrate (legacy + new Postgres)", () => {
   // list hydrate flows through the routed store: split, non-empty CH id-set whose rows are
   // split across NEW + the legacy replica. result.runs must be the union, id-desc ordered. This
   // proves the deps are threaded so the routed store is actually used.