Remove waitpoint test for QUEUED_EXECUTING

Author: ericallam

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

@@ -1129,219 +1129,6 @@ describe("RunEngine Waitpoints", () => {
     }
   });
 
-  containerTest(
-    "continueRunIfUnblocked enqueues run when cannot reacquire concurrency",
-    async ({ prisma, redisOptions }) => {
-      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
-
-      const engine = new RunEngine({
-        prisma,
-        worker: {
-          redis: redisOptions,
-          workers: 1,
-          tasksPerWorker: 10,
-          pollIntervalMs: 100,
-        },
-        queue: {
-          redis: redisOptions,
-        },
-        runLock: {
-          redis: redisOptions,
-        },
-        machines: {
-          defaultMachine: "small-1x",
-          machines: {
-            "small-1x": {
-              name: "small-1x" as const,
-              cpu: 0.5,
-              memory: 0.5,
-              centsPerMs: 0.0001,
-            },
-          },
-          baseCostInCents: 0.0001,
-        },
-        tracer: trace.getTracer("test", "0.0.0"),
-      });
-
-      try {
-        const taskIdentifier = "test-task";
-
-        // Create background worker
-        await setupBackgroundWorker(
-          engine,
-          authenticatedEnvironment,
-          taskIdentifier,
-          undefined,
-          undefined,
-          {
-            concurrencyLimit: 1,
-          }
-        );
-
-        // Create first run with queue concurrency limit of 1
-        const firstRun = await engine.trigger(
-          {
-            number: 1,
-            friendlyId: "run_first",
-            environment: authenticatedEnvironment,
-            taskIdentifier,
-            payload: "{}",
-            payloadType: "application/json",
-            context: {},
-            traceContext: {},
-            traceId: "t12345-first",
-            spanId: "s12345-first",
-            workerQueue: "main",
-            queue: "task/test-task",
-            isTest: false,
-            tags: [],
-          },
-          prisma
-        );
-
-        // Dequeue and start the first run
-        await setTimeout(500);
-        const dequeuedFirst = await engine.dequeueFromWorkerQueue({
-          consumerId: "test_12345",
-          workerQueue: "main",
-        });
-
-        const firstAttempt = await engine.startRunAttempt({
-          runId: dequeuedFirst[0].run.id,
-          snapshotId: dequeuedFirst[0].snapshot.id,
-        });
-        expect(firstAttempt.snapshot.executionStatus).toBe("EXECUTING");
-
-        // Create a manual waitpoint for the first run
-        const waitpoint = await engine.createManualWaitpoint({
-          environmentId: authenticatedEnvironment.id,
-          projectId: authenticatedEnvironment.projectId,
-        });
-        expect(waitpoint.waitpoint.status).toBe("PENDING");
-
-        // Block the first run
-        const blockedResult = await engine.blockRunWithWaitpoint({
-          runId: firstRun.id,
-          waitpoints: waitpoint.waitpoint.id,
-          projectId: authenticatedEnvironment.projectId,
-          organizationId: authenticatedEnvironment.organizationId,
-        });
-
-        // Verify first run is blocked
-        const firstRunData = await engine.getRunExecutionData({ runId: firstRun.id });
-        expect(firstRunData?.snapshot.executionStatus).toBe("EXECUTING_WITH_WAITPOINTS");
-
-        // Create and start second run on the same queue
-        const secondRun = await engine.trigger(
-          {
-            number: 2,
-            friendlyId: "run_second",
-            environment: authenticatedEnvironment,
-            taskIdentifier,
-            payload: "{}",
-            payloadType: "application/json",
-            context: {},
-            traceContext: {},
-            traceId: "t12345-second",
-            spanId: "s12345-second",
-            workerQueue: "main",
-            queue: "task/test-task",
-            isTest: false,
-            tags: [],
-          },
-          prisma
-        );
-
-        // Dequeue and start the second run
-        await setTimeout(500);
-        const dequeuedSecond = await engine.dequeueFromWorkerQueue({
-          consumerId: "test_12345",
-          workerQueue: "main",
-        });
-
-        const secondAttempt = await engine.startRunAttempt({
-          runId: dequeuedSecond[0].run.id,
-          snapshotId: dequeuedSecond[0].snapshot.id,
-        });
-        expect(secondAttempt.snapshot.executionStatus).toBe("EXECUTING");
-
-        // Now complete the waitpoint for the first run
-        await engine.completeWaitpoint({
-          id: waitpoint.waitpoint.id,
-        });
-
-        // Wait for the continueRunIfUnblocked to process
-        await setTimeout(500);
-
-        // Verify the first run is now in QUEUED_EXECUTING state
-        const executionDataAfter = await engine.getRunExecutionData({ runId: firstRun.id });
-        expect(executionDataAfter?.snapshot.executionStatus).toBe("QUEUED_EXECUTING");
-        expect(executionDataAfter?.snapshot.description).toBe(
-          "Run can continue, but is waiting for concurrency"
-        );
-
-        // Verify the waitpoint is no longer blocking the first run
-        const runWaitpoint = await prisma.taskRunWaitpoint.findFirst({
-          where: {
-            taskRunId: firstRun.id,
-          },
-          include: {
-            waitpoint: true,
-          },
-        });
-        expect(runWaitpoint).toBeNull();
-
-        // Verify the waitpoint itself is completed
-        const completedWaitpoint = await prisma.waitpoint.findUnique({
-          where: {
-            id: waitpoint.waitpoint.id,
-          },
-        });
-        assertNonNullable(completedWaitpoint);
-        expect(completedWaitpoint.status).toBe("COMPLETED");
-
-        // Complete the second run so the first run can be dequeued
-        const result = await engine.completeRunAttempt({
-          runId: dequeuedSecond[0].run.id,
-          snapshotId: secondAttempt.snapshot.id,
-          completion: {
-            ok: true,
-            id: dequeuedSecond[0].run.id,
-            output: `{"foo":"bar"}`,
-            outputType: "application/json",
-          },
-        });
-
-        await setTimeout(500);
-
-        let event: EventBusEventArgs<"workerNotification">[0] | undefined = undefined;
-        engine.eventBus.on("workerNotification", (result) => {
-          event = result;
-        });
-
-        // Verify the first run is back in the queue
-        const queuedRun = await engine.dequeueFromWorkerQueue({
-          consumerId: "test_12345",
-          workerQueue: "main",
-        });
-
-        expect(queuedRun.length).toBe(0);
-
-        // Get the latest execution snapshot and make sure it's EXECUTING
-        const executionData = await engine.getRunExecutionData({ runId: firstRun.id });
-        assertNonNullable(executionData);
-        expect(executionData.snapshot.executionStatus).toBe("EXECUTING");
-
-        assertNonNullable(event);
-        const notificationEvent = event as EventBusEventArgs<"workerNotification">[0];
-        expect(notificationEvent.run.id).toBe(firstRun.id);
-        expect(notificationEvent.snapshot.executionStatus).toBe("EXECUTING");
-      } finally {
-        await engine.quit();
-      }
-    }
-  );
-
   containerTest(
     "getSnapshotsSince returns correct snapshots and handles errors",
     async ({ prisma, redisOptions }) => {