test(webapp): cover runs live fields mapping and hasNewRuns

Author: Ekaterina Bulatova

apps/webapp/test/presenters/mapRunToLiveFields.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { mapRunToLiveFields } from "~/presenters/v3/mapRunToLiveFields.server";
+
+describe("mapRunToLiveFields", () => {
+  it("maps an executing run with lockedAt fallback and non-final flags", () => {
+    const updatedAt = new Date("2026-05-07T10:00:00.000Z");
+    const lockedAt = new Date("2026-05-07T09:59:50.000Z");
+
+    const result = mapRunToLiveFields({
+      friendlyId: "run_123",
+      status: "EXECUTING",
+      updatedAt,
+      startedAt: null,
+      lockedAt,
+      completedAt: null,
+      usageDurationMs: BigInt(2500),
+      costInCents: 10,
+      baseCostInCents: 5,
+    });
+
+    expect(result).toEqual({
+      friendlyId: "run_123",
+      status: "EXECUTING",
+      updatedAt: updatedAt.toISOString(),
+      startedAt: lockedAt.toISOString(),
+      finishedAt: undefined,
+      hasFinished: false,
+      isCancellable: true,
+      isPending: false,
+      usageDurationMs: 2500,
+      costInCents: 10,
+      baseCostInCents: 5,
+    });
+  });
+
+  it("maps a final run and prefers completedAt for finishedAt", () => {
+    const updatedAt = new Date("2026-05-07T10:00:00.000Z");
+    const startedAt = new Date("2026-05-07T09:59:00.000Z");
+    const completedAt = new Date("2026-05-07T09:59:30.000Z");
+
+    const result = mapRunToLiveFields({
+      friendlyId: "run_456",
+      status: "COMPLETED_SUCCESSFULLY",
+      updatedAt,
+      startedAt,
+      lockedAt: null,
+      completedAt,
+      usageDurationMs: 1200,
+      costInCents: 20,
+      baseCostInCents: 7,
+    });
+
+    expect(result.finishedAt).toBe(completedAt.toISOString());
+    expect(result.startedAt).toBe(startedAt.toISOString());
+    expect(result.hasFinished).toBe(true);
+    expect(result.isCancellable).toBe(false);
+  });
+
+  it("falls back to updatedAt when a final run has no completedAt", () => {
+    const updatedAt = new Date("2026-05-07T10:00:00.000Z");
+
+    const result = mapRunToLiveFields({
+      friendlyId: "run_789",
+      status: "CRASHED",
+      updatedAt,
+      startedAt: null,
+      lockedAt: null,
+      completedAt: null,
+      usageDurationMs: 0,
+      costInCents: 0,
+      baseCostInCents: 0,
+    });
+
+    expect(result.finishedAt).toBe(updatedAt.toISOString());
+    expect(result.hasFinished).toBe(true);
+    expect(result.isPending).toBe(false);
+    expect(result.isCancellable).toBe(false);
+  });
+});

apps/webapp/test/runsRepository.part2.test.ts

@@ -789,4 +789,107 @@ describe("RunsRepository (part 2/2)", () => {
       expect(secondPage.pagination.previousCursor).toBeTruthy();
     }
   );
+
+  containerTest(
+    "should detect new runs with hasNewRuns",
+    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
+      const { clickhouse } = await setupClickhouseReplication({
+        prisma,
+        databaseUrl: postgresContainer.getConnectionUri(),
+        clickhouseUrl: clickhouseContainer.getConnectionUrl(),
+        redisOptions,
+      });
+
+      const organization = await prisma.organization.create({
+        data: {
+          title: "test",
+          slug: "test",
+        },
+      });
+
+      const project = await prisma.project.create({
+        data: {
+          name: "test",
+          slug: "test",
+          organizationId: organization.id,
+          externalRef: "test",
+        },
+      });
+
+      const runtimeEnvironment = await prisma.runtimeEnvironment.create({
+        data: {
+          slug: "test",
+          type: "DEVELOPMENT",
+          projectId: project.id,
+          organizationId: organization.id,
+          apiKey: "test",
+          pkApiKey: "test",
+          shortcode: "test",
+        },
+      });
+
+      const taskRun = await prisma.taskRun.create({
+        data: {
+          friendlyId: "run_has_new",
+          taskIdentifier: "my-task",
+          payload: JSON.stringify({ foo: "bar" }),
+          traceId: "1234",
+          spanId: "1234",
+          queue: "test",
+          runtimeEnvironmentId: runtimeEnvironment.id,
+          projectId: project.id,
+          organizationId: organization.id,
+          environmentType: "DEVELOPMENT",
+          engine: "V2",
+        },
+      });
+
+      await setTimeout(1000);
+
+      const runsRepository = new RunsRepository({
+        prisma,
+        clickhouse,
+      });
+
+      const baseOptions = {
+        projectId: project.id,
+        environmentId: runtimeEnvironment.id,
+        organizationId: organization.id,
+      };
+
+      const createdAtMs = taskRun.createdAt.getTime();
+
+      await expect(
+        runsRepository.hasNewRuns({
+          ...baseOptions,
+          from: createdAtMs - 1,
+        })
+      ).resolves.toBe(true);
+
+      await expect(
+        runsRepository.hasNewRuns({
+          ...baseOptions,
+          from: createdAtMs + 60_000,
+        })
+      ).resolves.toBe(false);
+
+      const fromBeforeRun = createdAtMs - 1;
+
+      await expect(
+        runsRepository.hasNewRuns({
+          ...baseOptions,
+          from: fromBeforeRun,
+          tasks: ["my-task"],
+        })
+      ).resolves.toBe(true);
+
+      await expect(
+        runsRepository.hasNewRuns({
+          ...baseOptions,
+          from: fromBeforeRun,
+          tasks: ["other-task"],
+        })
+      ).resolves.toBe(false);
+    }
+  );
 });