test(webapp): stop unit tests reaching env-configured Redis/Postgres in CI

CI runners have no .env, no REDIS_HOST/REDIS_PORT, and no Postgres at
localhost:5432, which surfaced two failure layers that local runs mask
(the dev stack answers on both):

- suites transitively importing triggerTaskV1.server failed to collect
  because autoIncrementCounter.server.ts throws at import when
  REDIS_HOST/REDIS_PORT are unset (shards 2/5/6). Default the pair in
  test/setup.ts — the global ioredis lazyConnect mock means nothing dials.
- TriggerFailedTaskService.call() resolved its event repository via
  getEventRepository → global prisma (feature-flag read + Prisma event
  repo), so in CI the swallowed connect error returned null friendlyIds
  (shard 8). Allow injecting the repository/store pair and bind the test
  to an EventRepository over the testcontainer DB.
- once the cancelDevSessionRuns suite could collect, findLatestSession's
  hardwired global $replica was the next masked layer; give it an
  injectable client (defaulting to $replica) and pass the service's
  _replica through.

Verified by replaying the exact CI env locally (.env hidden, workflow env
vars, dead localhost DB, GITHUB_ACTIONS set): all four failing suites and
full shards 2/5/6/8 reproduce the CI failures before and pass after.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/models/runtimeEnvironment.server.ts

@@ -358,8 +358,11 @@ export async function disconnectSession(environmentId: string) {
   return session;
 }
 
-export async function findLatestSession(environmentId: string) {
-  const session = await $replica.runtimeEnvironmentSession.findFirst({
+export async function findLatestSession(
+  environmentId: string,
+  client: PrismaClientOrTransaction = $replica
+) {
+  const session = await client.runtimeEnvironmentSession.findFirst({
     where: {
       environmentId,
     },

apps/webapp/app/runEngine/services/triggerFailedTask.server.ts

@@ -13,6 +13,7 @@ import { resolveInheritedMintKind } from "~/v3/runOpsMigration/resolveInheritedM
 import { getEventRepository } from "~/v3/eventRepository/index.server";
 import { runStore as defaultRunStore } from "~/v3/runStore.server";
 import type { RunStore } from "@internal/run-store";
+import type { IEventRepository } from "~/v3/eventRepository/eventRepository.types";
 import { PerformTaskRunAlertsService } from "~/v3/services/alerts/performTaskRunAlerts.server";
 import { DefaultQueueManager } from "../concerns/queues.server";
 import type { TriggerTaskRequest } from "../types";
@@ -65,17 +66,22 @@ export class TriggerFailedTaskService {
   // singleton (in production the same store the engine writes through). Injected in
   // tests so the read resolves on the same store the engine wrote to.
   private readonly runStore: RunStore;
+  // Defaults to getEventRepository's org-flag resolution, which reads through the
+  // global prisma client; tests inject a repository bound to their testcontainer DB.
+  private readonly eventRepository?: { repository: IEventRepository; store: string };
 
   constructor(opts: {
     prisma: PrismaClientOrTransaction;
     engine: RunEngine;
     replicaPrisma?: PrismaClientOrTransaction;
     runStore?: RunStore;
+    eventRepository?: { repository: IEventRepository; store: string };
   }) {
     this.prisma = opts.prisma;
     this.replicaPrisma = opts.replicaPrisma ?? opts.prisma;
     this.engine = opts.engine;
     this.runStore = opts.runStore ?? defaultRunStore;
+    this.eventRepository = opts.eventRepository;
   }
 
   // Mint a failed run's friendlyId. The id-kind decides which store the run is
@@ -122,11 +128,13 @@ export class TriggerFailedTaskService {
       });
       mintedFriendlyId = failedRunFriendlyId;
 
-      const { repository, store } = await getEventRepository(
-        request.environment.organization.id,
-        request.environment.organization.featureFlags as Record<string, unknown>,
-        undefined
-      );
+      const { repository, store } =
+        this.eventRepository ??
+        (await getEventRepository(
+          request.environment.organization.id,
+          request.environment.organization.featureFlags as Record<string, unknown>,
+          undefined
+        ));
 
       // Resolve parent run for rootTaskRunId and depth (same as triggerTask.server.ts)
       const parentRun = request.parentRunId

apps/webapp/app/v3/services/cancelDevSessionRuns.server.ts

@@ -43,7 +43,7 @@ export class CancelDevSessionRunsService extends BaseService {
       : undefined;
 
     if (cancelledSession) {
-      const latestSession = await findLatestSession(cancelledSession.environmentId);
+      const latestSession = await findLatestSession(cancelledSession.environmentId, this._replica);
 
       if (
         latestSession &&

apps/webapp/test/cancelDevSessionRunsStoreRouting.test.ts

@@ -226,6 +226,7 @@ describe("CancelDevSessionRunsService passthrough (single-DB)", () => {
       // control-plane read runs on the same prisma.
       const service = new CancelDevSessionRunsService({
         prisma,
+        replica: prisma,
         readThroughDeps: {
           splitEnabled: false,
           newClient: prisma as unknown as PrismaReplicaClient,

apps/webapp/test/engine/triggerFailedTask.test.ts

@@ -6,9 +6,31 @@ import { containerTest } from "@internal/testcontainers";
 import { trace } from "@opentelemetry/api";
 import { RunId, classifyKind, generateKsuidId } from "@trigger.dev/core/v3/isomorphic";
 import { TriggerFailedTaskService } from "../../app/runEngine/services/triggerFailedTask.server";
+import { EventRepository } from "../../app/v3/eventRepository/eventRepository.server";
 
 vi.setConfig?.({ testTimeout: 60_000 });
 
+// Bind the service's trace-event writes to the testcontainer DB. Without this,
+// call() resolves the repository via getEventRepository → global prisma, which
+// points at a database that doesn't exist in CI.
+function makeService(prisma: any, engine: RunEngine) {
+  return new TriggerFailedTaskService({
+    prisma,
+    engine,
+    // Read the parent through the same store the engine wrote it to.
+    runStore: engine.runStore,
+    eventRepository: {
+      repository: new EventRepository(prisma, prisma, {
+        batchSize: 100,
+        batchInterval: 1000,
+        retentionInDays: 30,
+        partitioningEnabled: false,
+      }),
+      store: "taskEvent",
+    },
+  });
+}
+
 function makeEngine(prisma: any, redisOptions: any) {
   return new RunEngine({
     prisma,
@@ -40,12 +62,7 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const taskIdentifier = "failed-residency-task";
       await setupBackgroundWorker(engine, environment, taskIdentifier);
 
-      const service = new TriggerFailedTaskService({
-        prisma,
-        engine,
-        // Read the parent through the same store the engine wrote it to.
-        runStore: engine.runStore,
-      });
+      const service = makeService(prisma, engine);
 
       const friendlyId = await service.call({
         taskId: taskIdentifier,
@@ -95,12 +112,7 @@ describe("TriggerFailedTaskService — failed run residency", () => {
         prisma
       );
 
-      const service = new TriggerFailedTaskService({
-        prisma,
-        engine,
-        // Read the parent through the same store the engine wrote it to.
-        runStore: engine.runStore,
-      });
+      const service = makeService(prisma, engine);
 
       const friendlyId = await service.call({
         taskId: taskIdentifier,
@@ -153,12 +165,7 @@ describe("TriggerFailedTaskService — failed run residency", () => {
         prisma
       );
 
-      const service = new TriggerFailedTaskService({
-        prisma,
-        engine,
-        // Read the parent through the same store the engine wrote it to.
-        runStore: engine.runStore,
-      });
+      const service = makeService(prisma, engine);
 
       const friendlyId = await service.call({
         taskId: taskIdentifier,
@@ -200,12 +207,7 @@ describe("TriggerFailedTaskService — failed run residency", () => {
         prisma
       );
 
-      const service = new TriggerFailedTaskService({
-        prisma,
-        engine,
-        // Read the parent through the same store the engine wrote it to.
-        runStore: engine.runStore,
-      });
+      const service = makeService(prisma, engine);
 
       const friendlyId = await service.callWithoutTraceEvents({
         environmentId: environment.id,
@@ -232,12 +234,7 @@ describe("TriggerFailedTaskService — failed run residency", () => {
       const taskIdentifier = "failed-residency-task";
       await setupBackgroundWorker(engine, environment, taskIdentifier);
 
-      const service = new TriggerFailedTaskService({
-        prisma,
-        engine,
-        // Read the parent through the same store the engine wrote it to.
-        runStore: engine.runStore,
-      });
+      const service = makeService(prisma, engine);
 
       // A well-formed ksuid parent friendlyId that was NEVER triggered → no row.
       // Exercises the missing-parent fallback in callWithoutTraceEvents.

apps/webapp/test/setup.ts

@@ -6,6 +6,12 @@ import { vi } from "vitest";
 
 config({ path: path.resolve(__dirname, "../.env") });
 
+// CI has no .env and no REDIS_HOST/REDIS_PORT, so import-time guards like
+// autoIncrementCounter.server.ts throw and their suites fail to collect. Default
+// the pair — the ioredis mock below forces lazyConnect, so nothing ever dials.
+process.env.REDIS_HOST ??= "localhost";
+process.env.REDIS_PORT ??= "6379";
+
 // Worker singletons construct a RedisWorker at import time whose ioredis client
 // connects eagerly, so any test importing the service graph opens real Redis
 // connections on import — which floods and fails in CI (no Redis). Mock them to