fix(testcontainers): per-test redis for background-worker tests + faster redis boot

Author: nicktrn

internal-packages/run-engine/src/engine/tests/batchTriggerAndWait.test.ts

@@ -1,4 +1,4 @@
-import { assertNonNullable, containerTest } from "@internal/testcontainers";
+import { assertNonNullable, containerTestWithIsolatedRedis as containerTest } from "@internal/testcontainers";
 import { trace } from "@internal/tracing";
 import { expect, describe } from "vitest";
 import { RunEngine } from "../index.js";

internal-packages/run-engine/src/engine/tests/batchTwoPhase.test.ts

@@ -1,4 +1,4 @@
-import { assertNonNullable, containerTest } from "@internal/testcontainers";
+import { assertNonNullable, containerTestWithIsolatedRedis as containerTest } from "@internal/testcontainers";
 import { trace } from "@internal/tracing";
 import { expect, describe, vi } from "vitest";
 import { RunEngine } from "../index.js";

internal-packages/testcontainers/src/index.ts

@@ -260,13 +260,9 @@ export const redisOptions = async (
   await use(options);
 };
 
-type RedisTestContext = {
-  redisContainer: StartedRedisContainer;
-  resetRedis: void;
-  redisOptions: RedisOptions;
-};
-
-// Boot redis once per worker.
+// Worker-scoped redis: booted once per worker, FLUSHALL per test. Big win for redis-heavy files
+// (buffer.test.ts: 88 boots -> 1). Safe ONLY for tests that don't leave background redis work
+// (a Worker loop, BatchQueue) running past the test body - use isolatedRedisTest for those.
 const bootWorkerRedis = async ({}, use: Use<StartedRedisContainer>) => {
   const { container } = await createRedisContainer({ port: 6379 });
   try {
@@ -276,7 +272,6 @@ const bootWorkerRedis = async ({}, use: Use<StartedRedisContainer>) => {
   }
 };
 
-// Per test: FLUSHALL the shared redis (auto fixture so it runs for every test).
 const flushRedis = async (
   { redisContainer }: { redisContainer: StartedRedisContainer },
   use: Use<void>
@@ -295,12 +290,23 @@ const flushRedis = async (
   await use();
 };
 
+type RedisTestContext = {
+  redisContainer: StartedRedisContainer;
+  resetRedis: void;
+  redisOptions: RedisOptions;
+};
+
 export const redisTest = test.extend<RedisTestContext>({
   redisContainer: [bootWorkerRedis, { scope: "worker" }],
   resetRedis: [flushRedis, { auto: true }],
   redisOptions,
 });
 
+// Per-test redis for tests with background redis work (redis-worker Workers, BatchQueue) that can
+// outlive the test body - a shared redis would let leaked work hit a closed connection / next test
+// ("Connection is closed"). Boot is kept fast (see createRedisContainer).
+export const isolatedRedisTest = test.extend<RedisContext>({ network, redisContainer, redisOptions });
+
 const electricOrigin = async (
   {
     postgresContainer,
@@ -424,9 +430,9 @@ type ContainerTestContext = {
   clickhouseClient: ClickHouseClient;
 };
 
-// The workhorse fixture (~36 files). Boots postgres+redis+clickhouse ONCE per worker and isolates
-// per test (postgres template-clone, redis FLUSHALL, clickhouse TRUNCATE) - no per-test boots, no
-// shared docker network needed.
+// The workhorse fixture (~36 files). Postgres (template-clone), Redis (FLUSHALL) and ClickHouse
+// (truncate) all boot once per worker - no per-test container boots. Use containerTestWithIsolatedRedis
+// for tests that run background redis work (BatchQueue, redis-worker Workers) past the test body.
 export const containerTest = test.extend<ContainerTestContext>({
   postgresContainer: clonedPostgresContainer,
   prisma: prismaFromContainer,
@@ -438,18 +444,41 @@ export const containerTest = test.extend<ContainerTestContext>({
   clickhouseClient: scopedClickhouseClient,
 });
 
+type ContainerWithIsolatedRedisContext = {
+  network: StartedNetwork;
+  postgresContainer: StartedPostgreSqlContainer;
+  prisma: PrismaClient;
+  redisContainer: StartedRedisContainer;
+  redisOptions: RedisOptions;
+  clickhouseContainer: StartedClickHouseContainer;
+  resetClickhouse: void;
+  clickhouseClient: ClickHouseClient;
+};
+
+// Same as containerTest but Redis is PER-TEST - for tests whose background redis work (BatchQueue,
+// Workers) outlives the test body and would otherwise hit a closed/shared connection.
+export const containerTestWithIsolatedRedis = test.extend<ContainerWithIsolatedRedisContext>({
+  network,
+  postgresContainer: clonedPostgresContainer,
+  prisma: prismaFromContainer,
+  redisContainer,
+  redisOptions,
+  clickhouseContainer: [bootWorkerClickhouse, { scope: "worker" }],
+  resetClickhouse: [truncateClickhouseFixture, { auto: true }],
+  clickhouseClient: scopedClickhouseClient,
+});
+
 // For tests that exercise the Postgres -> ClickHouse logical-replication pipeline (WAL slots,
 // publications, REPLICA IDENTITY). These need a dedicated Postgres per test - the worker-scoped +
 // template-clone model used by containerTest doesn't carry logical replication across cloned dbs.
-// ONLY postgres needs to be per-test (the WAL slot/publication lives in the db it writes to). Redis
-// and ClickHouse are still worker-scoped + reset per test - the pipeline writes pg->clickhouse and a
-// shared+truncated clickhouse is fine - so we only pay a postgres boot per test, not all three.
+// Postgres is per-test (the WAL slot/publication lives in the db it writes to); ClickHouse is
+// worker-scoped + truncated (the pipeline writes pg->clickhouse and a shared+truncated clickhouse is
+// fine). Redis is per-test too (background work safety, same as containerTest).
 type ReplicationContainerTestContext = {
   network: StartedNetwork;
   postgresContainer: StartedPostgreSqlContainer;
   prisma: PrismaClient;
   redisContainer: StartedRedisContainer;
-  resetRedis: void;
   redisOptions: RedisOptions;
   clickhouseContainer: StartedClickHouseContainer;
   resetClickhouse: void;
@@ -460,8 +489,7 @@ export const replicationContainerTest = test.extend<ReplicationContainerTestCont
   network,
   postgresContainer,
   prisma,
-  redisContainer: [bootWorkerRedis, { scope: "worker" }],
-  resetRedis: [flushRedis, { auto: true }],
+  redisContainer,
   redisOptions,
   clickhouseContainer: [bootWorkerClickhouse, { scope: "worker" }],
   resetClickhouse: [truncateClickhouseFixture, { auto: true }],

internal-packages/testcontainers/src/utils.ts

@@ -114,16 +114,11 @@ export async function createRedisContainer({
     container = container.withNetwork(network).withNetworkAliases("redis");
   }
 
+  // Wait only on the readiness log (RedisContainer's default) - the previous Docker healthcheck added
+  // a full poll-cycle of latency per boot, which dominates per-test redis. verifyRedisConnection
+  // below still confirms the container actually accepts connections before we hand it to the test.
   const startedContainer = await container
-    .withHealthCheck({
-      test: ["CMD", "redis-cli", "ping"],
-      interval: 1000,
-      timeout: 3000,
-      retries: 5,
-    })
-    .withWaitStrategy(
-      Wait.forAll([Wait.forHealthCheck(), Wait.forLogMessage("Ready to accept connections")])
-    )
+    .withWaitStrategy(Wait.forLogMessage("Ready to accept connections"))
     .start();
 
   // Add a verification step

packages/redis-worker/src/worker.test.ts

@@ -1,4 +1,4 @@
-import { redisTest } from "@internal/testcontainers";
+import { isolatedRedisTest as redisTest } from "@internal/testcontainers";
 import { Logger } from "@trigger.dev/core/logger";
 import { describe } from "node:test";
 import { expect } from "vitest";