test(webapp): load service after pointing env at the redis container

Author: nicktrn

apps/webapp/test/pauseEnvironment.server.test.ts

@@ -1,9 +1,8 @@
-import { postgresTest } from "@internal/testcontainers";
+import { containerTest } from "@internal/testcontainers";
 import { EnvironmentPauseSource, type PrismaClient } from "@trigger.dev/database";
+import type { RedisOptions } from "ioredis";
 import { describe, expect, vi } from "vitest";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
-import { authIncludeBase, toAuthenticated } from "~/models/runtimeEnvironment.server";
-import { PauseEnvironmentService } from "~/v3/services/pauseEnvironment.server";
 import {
   createRuntimeEnvironment,
   createTestOrgProjectWithMember,
@@ -12,15 +11,34 @@ import {
 
 vi.setConfig({ testTimeout: 60_000 });
 
+// The service's import chain reaches module-level singletons that throw at load
+// time when REDIS_HOST/REDIS_PORT are unset (autoIncrementCounter via
+// triggerTaskV1), so the env must point at the redis container BEFORE the
+// module is imported. Hence dynamic imports; vitest runs each file in its own
+// fork, so the env mutation cannot leak into other suites.
+async function loadService(redisOptions: RedisOptions) {
+  process.env.REDIS_HOST = redisOptions.host;
+  process.env.REDIS_PORT = String(redisOptions.port);
+  process.env.REDIS_TLS_DISABLED = "true";
+  const [{ PauseEnvironmentService }, { authIncludeBase, toAuthenticated }] = await Promise.all([
+    import("~/v3/services/pauseEnvironment.server"),
+    import("~/models/runtimeEnvironment.server"),
+  ]);
+  return { PauseEnvironmentService, authIncludeBase, toAuthenticated };
+}
+
+type Loaded = Awaited<ReturnType<typeof loadService>>;
+
 async function authEnv(
+  loaded: Loaded,
   prisma: PrismaClient,
   environmentId: string
 ): Promise<AuthenticatedEnvironment> {
   const row = await prisma.runtimeEnvironment.findFirstOrThrow({
     where: { id: environmentId },
-    include: authIncludeBase,
+    include: loaded.authIncludeBase,
   });
-  return toAuthenticated(row);
+  return loaded.toAuthenticated(row);
 }
 
 async function seedProductionEnv(prisma: PrismaClient) {
@@ -35,12 +53,13 @@ async function seedProductionEnv(prisma: PrismaClient) {
 }
 
 describe("PauseEnvironmentService", () => {
-  postgresTest(
+  containerTest(
     "resumes a manually paused env (pauseSource stays null through pause and resume)",
-    async ({ prisma }) => {
+    async ({ prisma, redisOptions }) => {
+      const loaded = await loadService(redisOptions);
       const { environment } = await seedProductionEnv(prisma);
-      const service = new PauseEnvironmentService(prisma);
-      const env = await authEnv(prisma, environment.id);
+      const service = new loaded.PauseEnvironmentService(prisma);
+      const env = await authEnv(loaded, prisma, environment.id);
 
       const paused = await service.call(env, "paused");
       expect(paused).toEqual({ success: true, state: "paused" });
@@ -64,17 +83,18 @@ describe("PauseEnvironmentService", () => {
     }
   );
 
-  postgresTest(
+  containerTest(
     "rejects resume of a billing-limit paused env and leaves it paused",
-    async ({ prisma }) => {
+    async ({ prisma, redisOptions }) => {
+      const loaded = await loadService(redisOptions);
       const { environment } = await seedProductionEnv(prisma);
       await prisma.runtimeEnvironment.update({
         where: { id: environment.id },
         data: { paused: true, pauseSource: EnvironmentPauseSource.BILLING_LIMIT },
       });
 
-      const service = new PauseEnvironmentService(prisma);
-      const env = await authEnv(prisma, environment.id);
+      const service = new loaded.PauseEnvironmentService(prisma);
+      const env = await authEnv(loaded, prisma, environment.id);
 
       const result = await service.call(env, "resumed");
       expect(result.success).toBe(false);
@@ -89,17 +109,18 @@ describe("PauseEnvironmentService", () => {
     }
   );
 
-  postgresTest(
+  containerTest(
     "manual pause while billing-limit paused is a no-op that preserves pauseSource",
-    async ({ prisma }) => {
+    async ({ prisma, redisOptions }) => {
+      const loaded = await loadService(redisOptions);
       const { environment } = await seedProductionEnv(prisma);
       await prisma.runtimeEnvironment.update({
         where: { id: environment.id },
         data: { paused: true, pauseSource: EnvironmentPauseSource.BILLING_LIMIT },
       });
 
-      const service = new PauseEnvironmentService(prisma);
-      const env = await authEnv(prisma, environment.id);
+      const service = new loaded.PauseEnvironmentService(prisma);
+      const env = await authEnv(loaded, prisma, environment.id);
 
       const result = await service.call(env, "paused");
       // Idempotent success without overwriting pauseSource, so billing-limit