More wip trying to make test containers more reliable

Author: matt-aitken

internal-packages/testcontainers/src/index.ts

@@ -17,7 +17,10 @@ type PostgresContext = NetworkContext & {
   prisma: PrismaClient;
 };
 
-type RedisContext = { redisContainer: StartedRedisContainer; redisOptions: RedisOptions };
+type RedisContext = NetworkContext & {
+  redisContainer: StartedRedisContainer;
+  redisOptions: RedisOptions;
+};
 
 type ElectricContext = {
   electricOrigin: string;
@@ -71,9 +74,13 @@ const prisma = async (
 
 export const postgresTest = test.extend<PostgresContext>({ network, postgresContainer, prisma });
 
-const redisContainer = async ({}, use: Use<StartedRedisContainer>) => {
+const redisContainer = async (
+  { network }: { network: StartedNetwork },
+  use: Use<StartedRedisContainer>
+) => {
   const { container } = await createRedisContainer({
     port: 6379,
+    network,
   });
   try {
     await use(container);
@@ -97,20 +104,25 @@ const redisOptions = async (
     },
     connectTimeout: 10000, // 10 seconds
     // Add more robust connection options
-    enableOfflineQueue: false,
+    enableOfflineQueue: true,
     reconnectOnError: (err) => {
       const targetError = "READONLY";
       if (err.message.includes(targetError)) {
         return true;
       }
       return false;
     },
+    enableAutoPipelining: true,
+    autoResubscribe: true,
+    autoResendUnfulfilledCommands: true,
+    lazyConnect: false,
+    showFriendlyErrorStack: true,
   };
 
   await use(options);
 };
 
-export const redisTest = test.extend<RedisContext>({ redisContainer, redisOptions });
+export const redisTest = test.extend<RedisContext>({ network, redisContainer, redisOptions });
 
 const electricOrigin = async (
   {

internal-packages/testcontainers/src/utils.ts

@@ -1,5 +1,6 @@
 import { PostgreSqlContainer, StartedPostgreSqlContainer } from "@testcontainers/postgresql";
-import { RedisContainer } from "@testcontainers/redis";
+import { RedisContainer, StartedRedisContainer } from "@testcontainers/redis";
+import Redis from "ioredis";
 import path from "path";
 import { GenericContainer, StartedNetwork, Wait } from "testcontainers";
 import { x } from "tinyexec";
@@ -40,24 +41,59 @@ export async function createPostgresContainer(network: StartedNetwork) {
   return { url: container.getConnectionUri(), container, network };
 }
 
-export async function createRedisContainer({ port }: { port?: number }) {
-  const container = await new RedisContainer()
-    .withExposedPorts(port ?? 6379)
-    .withStartupTimeout(120_000) // 2 minutes
+export async function createRedisContainer({
+  port,
+  network,
+}: {
+  port?: number;
+  network?: StartedNetwork;
+}) {
+  let container = new RedisContainer().withExposedPorts(port ?? 6379).withStartupTimeout(120_000); // 2 minutes
+
+  if (network) {
+    container = container.withNetwork(network).withNetworkAliases("redis");
+  }
+
+  const startedContainer = await container
     .withHealthCheck({
       test: ["CMD", "redis-cli", "ping"],
       interval: 1000,
       timeout: 3000,
       retries: 5,
     })
-    .withWaitStrategy(Wait.forHealthCheck())
+    .withWaitStrategy(
+      Wait.forAll([Wait.forHealthCheck(), Wait.forLogMessage("Ready to accept connections")])
+    )
     .start();
 
+  // Add a verification step
+  await verifyRedisConnection(startedContainer);
+
   return {
-    container,
+    container: startedContainer,
   };
 }
 
+async function verifyRedisConnection(container: StartedRedisContainer) {
+  const redis = new Redis({
+    host: container.getHost(),
+    port: container.getPort(),
+    password: container.getPassword(),
+    maxRetriesPerRequest: 3,
+    connectTimeout: 10000,
+    retryStrategy(times) {
+      const delay = Math.min(times * 50, 2000);
+      return delay;
+    },
+  });
+
+  try {
+    await redis.ping();
+  } finally {
+    await redis.quit();
+  }
+}
+
 export async function createElectricContainer(
   postgresContainer: StartedPostgreSqlContainer,
   network: StartedNetwork