Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix: let failed tasks outrank running ones in stage status aggregation (#20749)

boojacke70c0dbf43cf
diff --git a/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.test.tsx b/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.test.tsx
index 7b461a015e..1d62521612 100644
--- a/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.test.tsx
+++ b/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.test.tsx
@@ -22,6 +22,7 @@ const mocks = vi.hoisted(() => ({
vi.stubGlobal("localStorage", mocks.localStorage);
vi.mock("react-i18next", () => ({
+ initReactI18next: { type: "3rdParty", init: () => {} },
useTranslation: () => ({ t: (key: string) => key }),
}));
diff --git a/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.tsx b/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.tsx
index a04d67da20..e3c8364da7 100644
--- a/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.tsx
+++ b/frontend/src/react/pages/project/plan-detail/ProjectPlanDetailPage.tsx
@@ -20,6 +20,7 @@ import {
import { cn } from "@/react/lib/utils";
import { IssueStatus } from "@/types/proto-es/v1/issue_service_pb";
import { Task_Status } from "@/types/proto-es/v1/rollout_service_pb";
+import { getRolloutStatus } from "@/utils";
import { getReviewBadge } from "../utils/reviewBadge";
import { DeployBranch } from "./components/deploy/DeployBranch";
import { DeployTaskDetailPanel } from "./components/deploy/DeployTaskDetailPanel";
@@ -193,21 +194,30 @@ function ProjectPlanDetailPageInner({
: undefined;
const deployBadge = (() => {
if (deployStatus !== "active" || !page.rollout) return undefined;
- const hasCompletedTasks = allTasks.some(
- (task) =>
- task.status === Task_Status.DONE ||
- task.status === Task_Status.SKIPPED
- );
- if (allTasks.some((task) => task.status === Task_Status.FAILED)) {
+ const rolloutStatus = getRolloutStatus(page.rollout);
+ if (rolloutStatus === Task_Status.FAILED) {
return { label: t("common.failed"), variant: "destructive" as const };
}
+ if (
+ rolloutStatus === Task_Status.RUNNING ||
+ rolloutStatus === Task_Status.PENDING
+ ) {
+ return {
+ label: t("common.in-progress"),
+ variant: "secondary" as const,
+ };
+ }
+ if (rolloutStatus === Task_Status.CANCELED) {
+ return { label: t("common.canceled"), variant: "default" as const };
+ }
+ // A NOT_STARTED aggregate can still mean earlier stages already finished
+ // (partially deployed) — at the phase level that's progress, not idle.
if (
allTasks.some(
(task) =>
- task.status === Task_Status.RUNNING ||
- task.status === Task_Status.PENDING
- ) ||
- hasCompletedTasks
+ task.status === Task_Status.DONE ||
+ task.status === Task_Status.SKIPPED
+ )
) {
return {
label: t("common.in-progress"),
diff --git a/frontend/src/utils/v1/issue/rollout.test.ts b/frontend/src/utils/v1/issue/rollout.test.ts
new file mode 100644
index 0000000000..263af1d699
--- /dev/null
+++ b/frontend/src/utils/v1/issue/rollout.test.ts
@@ -0,0 +1,120 @@
+import { create } from "@bufbuild/protobuf";
+import { describe, expect, test } from "vitest";
+import { Plan_TaskStatusCountSchema } from "@/types/proto-es/v1/plan_service_pb";
+import {
+ RolloutSchema,
+ StageSchema,
+ Task_Status,
+ TaskSchema,
+} from "@/types/proto-es/v1/rollout_service_pb";
+import {
+ getRolloutStatus,
+ getStageStatus,
+ getStageStatusFromCounts,
+} from "./rollout";
+
+const stage = (...statuses: Task_Status[]) =>
+ create(StageSchema, {
+ tasks: statuses.map((status) => create(TaskSchema, { status })),
+ });
+
+const rollout = (...stages: ReturnType<typeof stage>[]) =>
+ create(RolloutSchema, { stages });
+
+const counts = (...statuses: Task_Status[]) =>
+ statuses.map((status) =>
+ create(Plan_TaskStatusCountSchema, { status, count: 1 })
+ );
+
+describe("getStageStatus", () => {
+ test("failed outranks running (BYT-9822)", () => {
+ expect(
+ getStageStatus(
+ stage(Task_Status.RUNNING, Task_Status.RUNNING, Task_Status.FAILED)
+ )
+ ).toBe(Task_Status.FAILED);
+ expect(getStageStatus(stage(Task_Status.FAILED, Task_Status.PENDING))).toBe(
+ Task_Status.FAILED
+ );
+ expect(
+ getStageStatus(stage(Task_Status.FAILED, Task_Status.CANCELED))
+ ).toBe(Task_Status.FAILED);
+ });
+
+ test("active work outranks a canceled sibling", () => {
+ expect(
+ getStageStatus(stage(Task_Status.CANCELED, Task_Status.RUNNING))
+ ).toBe(Task_Status.RUNNING);
+ expect(
+ getStageStatus(stage(Task_Status.CANCELED, Task_Status.PENDING))
+ ).toBe(Task_Status.PENDING);
+ });
+
+ test("a cancel surfaces once nothing is active", () => {
+ expect(
+ getStageStatus(stage(Task_Status.CANCELED, Task_Status.NOT_STARTED))
+ ).toBe(Task_Status.CANCELED);
+ expect(getStageStatus(stage(Task_Status.CANCELED, Task_Status.DONE))).toBe(
+ Task_Status.CANCELED
+ );
+ expect(getStageStatus(stage(Task_Status.CANCELED))).toBe(
+ Task_Status.CANCELED
+ );
+ });
+
+ test("plain progressions", () => {
+ expect(getStageStatus(stage(Task_Status.RUNNING, Task_Status.DONE))).toBe(
+ Task_Status.RUNNING
+ );
+ expect(
+ getStageStatus(stage(Task_Status.PENDING, Task_Status.NOT_STARTED))
+ ).toBe(Task_Status.PENDING);
+ expect(getStageStatus(stage(Task_Status.DONE, Task_Status.SKIPPED))).toBe(
+ Task_Status.DONE
+ );
+ expect(getStageStatus(stage(Task_Status.SKIPPED))).toBe(
+ Task_Status.SKIPPED
+ );
+ expect(getStageStatus(stage())).toBe(Task_Status.NOT_STARTED);
+ });
+});
+
+describe("getRolloutStatus", () => {
+ test("a failure anywhere fails the rollout, even with later idle stages", () => {
+ expect(
+ getRolloutStatus(
+ rollout(
+ stage(Task_Status.DONE),
+ stage(Task_Status.FAILED, Task_Status.RUNNING),
+ stage(Task_Status.NOT_STARTED)
+ )
+ )
+ ).toBe(Task_Status.FAILED);
+ });
+
+ test("partially deployed rollout aggregates to the idle frontier", () => {
+ // The Deploy phase badge maps this to "In progress" via its
+ // completed-tasks refinement; the raw aggregate stays NOT_STARTED.
+ expect(
+ getRolloutStatus(
+ rollout(stage(Task_Status.DONE), stage(Task_Status.NOT_STARTED))
+ )
+ ).toBe(Task_Status.NOT_STARTED);
+ });
+
+ test("empty rollout is not started", () => {
+ expect(getRolloutStatus(rollout())).toBe(Task_Status.NOT_STARTED);
+ });
+});
+
+describe("getStageStatusFromCounts", () => {
+ test("failed outranks running", () => {
+ expect(
+ getStageStatusFromCounts(counts(Task_Status.RUNNING, Task_Status.FAILED))
+ ).toBe(Task_Status.FAILED);
+ });
+
+ test("empty counts fall back to unspecified", () => {
+ expect(getStageStatusFromCounts([])).toBe(Task_Status.STATUS_UNSPECIFIED);
+ });
+});
diff --git a/frontend/src/utils/v1/issue/rollout.ts b/frontend/src/utils/v1/issue/rollout.ts
index d083d246de..37e6b53eca 100644
--- a/frontend/src/utils/v1/issue/rollout.ts
+++ b/frontend/src/utils/v1/issue/rollout.ts
@@ -18,7 +18,21 @@ import {
extractCoreDatabaseInfoFromDatabaseCreateTask,
mockDatabase,
} from "./issue";
-import { TASK_STATUS_FILTERS } from "./task";
+
+// Priority order for aggregating child task statuses into a parent (stage /
+// rollout) status: the highest-priority status present wins. Failure outranks
+// active work (a failed task needs attention even while siblings run — see
+// BYT-9822); a cancel is deliberate rather than an error, so it stays below
+// active statuses but above NOT_STARTED, surfacing once nothing is in motion.
+const TASK_STATUS_AGGREGATION_PRIORITY: Task_Status[] = [
+ Task_Status.FAILED,
+ Task_Status.RUNNING,
+ Task_Status.PENDING,
+ Task_Status.CANCELED,
+ Task_Status.NOT_STARTED,
+ Task_Status.DONE,
+ Task_Status.SKIPPED,
+];
export const extractPlanUIDFromRolloutName = (name: string) => {
const pattern = /(?:^|\/)plans\/([^/]+)\/rollout(?:$|\/)/;
@@ -151,14 +165,14 @@ export const stringifyTaskStatus = (
}
};
-// Return the highest-priority Task_Status (per TASK_STATUS_FILTERS) for which
-// `has` reports a member, or `fallback` when none match. Shared by the stage
-// and rollout status reducers below.
+// Return the highest-priority Task_Status (per TASK_STATUS_AGGREGATION_PRIORITY)
+// for which `has` reports a member, or `fallback` when none match. Shared by the
+// stage and rollout status reducers below.
const foldByStatusPriority = (
has: (status: Task_Status) => boolean,
fallback: Task_Status
): Task_Status => {
- for (const status of TASK_STATUS_FILTERS) {
+ for (const status of TASK_STATUS_AGGREGATION_PRIORITY) {
if (has(status)) return status;
}
return fallback;
diff --git a/frontend/src/utils/v1/issue/task.ts b/frontend/src/utils/v1/issue/task.ts
index 09f2cc3323..820a16c513 100644
--- a/frontend/src/utils/v1/issue/task.ts
+++ b/frontend/src/utils/v1/issue/task.ts
@@ -1,15 +1,5 @@
import { Task_Status } from "@/types/proto-es/v1/rollout_service_pb";
-export const TASK_STATUS_FILTERS: Task_Status[] = [
- Task_Status.RUNNING,
- Task_Status.FAILED,
- Task_Status.PENDING,
- Task_Status.NOT_STARTED,
- Task_Status.CANCELED,
- Task_Status.DONE,
- Task_Status.SKIPPED,
-];
-
/**
* Task statuses that allow run/skip actions.
* Tasks in these states can be started, restarted, or skipped.