@nightkatana/kronosys-app 1.0.0-beta.2 → 1.0.0-beta.21

package/lib/reportingAggregate.test.ts

@@ -1,325 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  UNDATED_KEY,
-  aggregateArchivedExcludedTaskMinutes,
-  aggregateProjectTaskMinutesByDay,
-  aggregateReporting,
-  aggregateReportingByProject,
-  aggregateTagTaskMinutesByDayAndWeek,
-  buildTagFilterSet,
-  collectTasksDeduped,
-  dayInRange,
-  localWeekMondayFromDayKey,
-  maxBucket,
-  mergeSessionsFromPayload,
-  sessionWallClockMinutes,
-  sortedDayKeys,
-  taskMatchesTags,
-} from "./reportingAggregate";
-import { calendarDateKeyInTimeZone } from "./dashboardTimeZone";
-import type { KronosysUpdatePayload } from "./kronosysApi";
-
-const TZ = "America/Toronto";
-
-describe("reportingAggregate basic utils", () => {
-  it("calendarDateKeyInTimeZone produit le jour attendu pour un instant UTC", () => {
-    expect(calendarDateKeyInTimeZone("2026-06-15T04:00:00.000Z", TZ)).toBe("2026-06-15");
-    expect(calendarDateKeyInTimeZone("2026-06-15T03:59:59.999Z", TZ)).toBe("2026-06-14");
-  });
-
-  it("calendarDateKeyInTimeZone refuse les entrées invalides", () => {
-    expect(calendarDateKeyInTimeZone(null, TZ)).toBeNull();
-    expect(calendarDateKeyInTimeZone("", TZ)).toBeNull();
-    expect(calendarDateKeyInTimeZone("pas-une-date", TZ)).toBeNull();
-    expect(calendarDateKeyInTimeZone("2026-01-01T00:00:00.000Z", "Not/A_Timezone")).toBeNull();
-  });
-});
-
-describe("reportingAggregate", () => {
-  it("mergeSessionsFromPayload fusionne courant, historique et archives", () => {
-    const payload = {
-      history: [{ sessionId: "a", archived: false }],
-      historyArchived: [{ sessionId: "b", archived: true }],
-      current: { sessionId: "c", archived: false },
-    } as unknown as KronosysUpdatePayload;
-    const merged = mergeSessionsFromPayload(payload);
-    const ids = merged.map((s) => s.sessionId).sort();
-    expect(ids).toEqual(["a", "b", "c"]);
-  });
-
-  it("aggregateArchivedExcludedTaskMinutes compte le temps des tâches d’archives non finalisées", () => {
-    const sessions = [
-      {
-        sessionId: "arch-1",
-        archived: true,
-        tasks: [
-          {
-            isDone: false,
-            project: "acme",
-            durationMs: 6 * 60_000,
-            startTime: "2026-04-23T10:00:00.000Z",
-            endTime: "2026-04-23T10:06:00.000Z",
-            tags: ["default"],
-            subtasks: [],
-          },
-        ],
-      },
-    ];
-    const m = aggregateArchivedExcludedTaskMinutes(
-      sessions,
-      buildTagFilterSet([]),
-      "2026-04-23",
-      "2026-04-23",
-      TZ,
-      true
-    );
-    expect(m).toBe(6);
-  });
-
-  it("aggregateReporting agrège l’assiduité (référence, retards, somme, moyenne si en retard)", () => {
-    const sessions = [
-      {
-        sessionId: "on-time",
-        savedAt: "2026-04-24T12:00:00.000Z",
-        startAt: "2026-04-24T12:00:00.000Z",
-        sessionStartOffsetMinutes: 0,
-        tasks: [{ id: "t", isDone: true, durationMs: 1, tags: ["a"] }],
-      },
-      {
-        sessionId: "late",
-        savedAt: "2026-04-24T12:00:00.000Z",
-        startAt: "2026-04-24T12:20:00.000Z",
-        sessionStartOffsetMinutes: 20,
-        tasks: [{ id: "t2", isDone: true, durationMs: 1, tags: ["a"] }],
-      },
-      {
-        sessionId: "no-ref",
-        savedAt: "2026-04-24T12:00:00.000Z",
-        tasks: [{ id: "t3", isDone: true, durationMs: 1, tags: ["a"] }],
-      },
-    ];
-    const r = aggregateReporting(sessions, buildTagFilterSet([]), "2026-04-24", "2026-04-24", TZ, true);
-    expect(r.assiduityReferenceSessionCount).toBe(2);
-    expect(r.assiduityLateSessionCount).toBe(1);
-    expect(r.assiduityLateMinutesTotal).toBe(20);
-    expect(r.assiduityAverageLateMinutesWhenLate).toBe(20);
-  });
-
-  it("aggregateReportingByProject utilise la durée enregistrée sur la tâche parente", () => {
-    const sessions = [
-      {
-        sessionId: "s1",
-        archived: false,
-        tasks: [
-          {
-            isDone: true,
-            project: "acme",
-            durationMs: 6 * 60_000,
-            startTime: "2026-04-23T10:00:00.000Z",
-            endTime: "2026-04-23T10:06:00.000Z",
-            tags: ["default"],
-            subtasks: [{ done: true, durationMs: 6 * 60_000 }],
-          },
-        ],
-      },
-    ];
-    const rows = aggregateReportingByProject(sessions, buildTagFilterSet([]), "2026-04-23", "2026-04-23", TZ, true);
-    const acme = rows.find((r) => r.projectKey === "acme");
-    expect(acme?.minutes).toBe(6);
-  });
-
-  it("aggregateTagTaskMinutesByDayAndWeek compte la durée complète pour chaque étiquette d’une tâche", () => {
-    const sessions = [
-      {
-        sessionId: "s1",
-        archived: false,
-        tasks: [
-          {
-            isDone: true,
-            durationMs: 60 * 60_000,
-            startTime: "2026-04-23T10:00:00.000Z",
-            endTime: "2026-04-23T11:00:00.000Z",
-            tags: ["alpha", "beta"],
-            subtasks: [],
-          },
-        ],
-      },
-    ];
-    const { byDay } = aggregateTagTaskMinutesByDayAndWeek(
-      sessions,
-      buildTagFilterSet([]),
-      "2026-04-23",
-      "2026-04-23",
-      TZ,
-      "monday",
-      "défaut",
-      true
-    );
-    const alpha = byDay.find((r) => r.tagKey === "alpha");
-    const beta = byDay.find((r) => r.tagKey === "beta");
-    expect(alpha?.minutes).toBe(60);
-    expect(beta?.minutes).toBe(60);
-  });
-
-  it("mergeSessionsFromPayload fusionne courant et historique", () => {
-    const payload = {
-      history: [{ sessionId: "a", archived: false }],
-      historyArchived: [{ sessionId: "b", archived: true }],
-      current: { sessionId: "c", archived: false },
-    } as unknown as KronosysUpdatePayload;
-    const merged = mergeSessionsFromPayload(payload);
-    const ids = merged.map((s) => s.sessionId).sort();
-    expect(ids).toEqual(["a", "b", "c"]);
-  });
-
-  it("collectTasksDeduped fusionne tasks et activeTasks sans doublons", () => {
-    const s = {
-      sessionId: "s1",
-      tasks: [{ id: "t1", name: "T1" }],
-      activeTasks: [{ id: "t1", name: "T1-active" }, { id: "t2", name: "T2" }],
-    };
-    const tasks = collectTasksDeduped(s);
-    expect(tasks).toHaveLength(2);
-    expect(tasks.find(t => t.id === "t1")?.name).toBe("T1"); // Priorité à la liste tasks existante
-    expect(tasks.find(t => t.id === "t2")).toBeDefined();
-  });
-
-  it("buildTagFilterSet normalise les tags", () => {
-    const set = buildTagFilterSet(["#Bug", "Feature"]);
-    expect(set.has("bug")).toBe(true);
-    expect(set.has("feature")).toBe(true);
-    expect(set.size).toBe(2);
-  });
-
-  it("dayInRange respecte les bornes", () => {
-    expect(dayInRange("2026-04-20", "2026-04-01", "2026-04-30")).toBe(true);
-    expect(dayInRange("2026-04-20", "2026-04-21", "2026-04-30")).toBe(false);
-    expect(dayInRange("2026-04-20", null, null)).toBe(true);
-    expect(dayInRange(null, "2026-04-01", null)).toBe(false);
-  });
-
-  it("localWeekMondayFromDayKey renvoie le lundi", () => {
-    // 2026-04-29 est un mercredi
-    expect(localWeekMondayFromDayKey("2026-04-29")).toBe("2026-04-27");
-  });
-
-  it("sessionWallClockMinutes utilise la durée persistée si valide", () => {
-    expect(sessionWallClockMinutes({ sessionId: "x", sessionDurationMinutes: 15 })).toBe(15);
-  });
-
-  it("sessionWallClockMinutes calcule à partir de start/end si non persisté", () => {
-    const s = {
-      sessionId: "x",
-      startAt: "2026-04-29T10:00:00Z",
-      endAt: "2026-04-29T10:10:00Z",
-    };
-    expect(sessionWallClockMinutes(s)).toBe(10);
-  });
-});
-
-describe("taskMatchesTags", () => {
-  it("true si filtre vide", () => {
-    expect(taskMatchesTags({ tags: ["dev"] }, new Set())).toBe(true);
-  });
-
-  it("filtre les tâches par tags", () => {
-    const filter = new Set(["bug"]);
-    expect(taskMatchesTags({ tags: ["bug"] }, filter)).toBe(true);
-    expect(taskMatchesTags({ tags: ["feature"] }, filter)).toBe(false);
-  });
-
-  it("gère le default bucket pour les tâches sans tags", () => {
-    const filter = new Set(["default"]);
-    expect(taskMatchesTags({ tags: [] }, filter, true)).toBe(true);
-    expect(taskMatchesTags({ tags: [] }, filter, false)).toBe(false);
-  });
-});
-
-describe("aggregations", () => {
-  const sessions = [
-    {
-      sessionId: "s1",
-      savedAt: "2026-04-29T12:00:00Z",
-      tasks: [
-        {
-          id: "t1",
-          durationMs: 600000, // 10 min
-          isDone: true,
-          project: "acme",
-          tags: ["dev"],
-          startTime: "2026-04-29T10:00:00Z",
-        },
-      ],
-    },
-    {
-      sessionId: "arch-1",
-      archived: true,
-      tasks: [
-        {
-          id: "t2",
-          durationMs: 300000, // 5 min
-          isDone: false,
-          tags: ["bug"],
-          startTime: "2026-04-29T11:00:00Z",
-        }
-      ]
-    }
-  ];
-
-  it("aggregateReportingByProject regroupe correctement", () => {
-    const result = aggregateReportingByProject(sessions, new Set(), null, null, TZ, true);
-    const acme = result.find(r => r.projectKey === "acme");
-    expect(acme?.minutes).toBe(10);
-    expect(acme?.taskCount).toBe(1);
-  });
-
-  it("aggregateProjectTaskMinutesByDay regroupe par projet et jour", () => {
-    const result = aggregateProjectTaskMinutesByDay(sessions, new Set(), null, null, TZ, true);
-    expect(result).toHaveLength(1); // Seul t1 (acme) est inclus ; t2 est exclu car archivé+non-terminé
-    const acmeDay = result.find(r => r.projectKey === "acme");
-    expect(acmeDay?.minutes).toBe(10);
-    expect(acmeDay?.day).toBe("2026-04-29");
-  });
-
-  it("aggregateTagTaskMinutesByDayAndWeek répartit le temps", () => {
-    const sMulti = [{
-      sessionId: "sm",
-      tasks: [{
-        durationMs: 60000,
-        tags: ["a", "b"],
-        startTime: "2026-04-27T10:00:00Z"
-      }]
-    }];
-    const { byDay } = aggregateTagTaskMinutesByDayAndWeek(sMulti, new Set(), null, null, TZ, "monday", "default", true);
-    expect(byDay).toHaveLength(2);
-    expect(byDay[0].minutes).toBe(1);
-    expect(byDay[1].minutes).toBe(1);
-  });
-
-  it("aggregateReporting calcule les totaux globaux", () => {
-    const res = aggregateReporting(sessions, new Set(), null, null, TZ, true);
-    expect(res.taskMinutesTotal).toBe(10); // t2 est exclue car archivée et non terminée
-    expect(res.taskCountContributing).toBe(1);
-    expect(res.sessionCountContributing).toBe(2);
-  });
-
-  it("aggregateArchivedExcludedTaskMinutes compte t2", () => {
-    const m = aggregateArchivedExcludedTaskMinutes(sessions, new Set(), null, null, TZ, true);
-    expect(m).toBe(5);
-  });
-});
-
-describe("helpers", () => {
-  it("sortedDayKeys combine et trie", () => {
-    const m1 = { "2026-04-30": 1, "2026-04-28": 1 };
-    const m2 = { "2026-04-29": 1 };
-    expect(sortedDayKeys(m1, m2)).toEqual(["2026-04-28", "2026-04-29", "2026-04-30"]);
-  });
-
-  it("maxBucket trouve le maximum", () => {
-    const m1 = { a: 10, b: 5 };
-    const m2 = { c: 20 };
-    expect(maxBucket([m1, m2])).toBe(20);
-  });
-});

package/lib/reportingNonFinalIndicators.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { computeReportingNonFinalFlags } from "./reportingNonFinalIndicators";
-import type { KronosysUpdatePayload } from "./kronosysApi";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function makePayload(overrides: Partial<KronosysUpdatePayload> = {}): KronosysUpdatePayload {
-  return {
-    viewType: "dashboard",
-    cfg: {},
-    history: [],
-    historyArchived: [],
-    inspectingSessionId: null,
-    knownTags: [],
-    knownProjects: [],
-    userKnownTags: [],
-    excludedSuggestionTags: [],
-    tagDescriptions: {},
-    projectDescriptions: {},
-    gitIdentity: {},
-    dashboardDataOrigin: "local_next",
-    ...overrides,
-  } as KronosysUpdatePayload;
-}
-
-const ALL_TAGS = new Set<string>();
-const DATE_FROM = "";
-const DATE_TO = "";
-
-// ---------------------------------------------------------------------------
-describe("computeReportingNonFinalFlags", () => {
-  it("retourne tout false si payload est null", () => {
-    const flags = computeReportingNonFinalFlags(null, ALL_TAGS, DATE_FROM, DATE_TO, undefined, "America/Toronto");
-    expect(flags).toEqual({
-      sessionsNonFinal: false,
-      projectsNonFinal: false,
-      tagsNonFinal: false,
-    });
-  });
-
-  it("sessionsNonFinal=true si session live ouverte (sessionId non vide, non archivée)", () => {
-    const p = makePayload({ current: { sessionId: "ses-live" } } as Partial<KronosysUpdatePayload>);
-    const flags = computeReportingNonFinalFlags(p, ALL_TAGS, DATE_FROM, DATE_TO, undefined, "America/Toronto");
-    expect(flags.sessionsNonFinal).toBe(true);
-  });
-
-  it("sessionsNonFinal=false si session live est archivée", () => {
-    const p = makePayload({ current: { sessionId: "ses-archived", archived: true } } as Partial<KronosysUpdatePayload>);
-    const flags = computeReportingNonFinalFlags(p, ALL_TAGS, DATE_FROM, DATE_TO, undefined, "America/Toronto");
-    expect(flags.sessionsNonFinal).toBe(false);
-  });
-
-  it("sessionsNonFinal=true si tasksByDayActive contient des valeurs > 0", () => {
-    const p = makePayload();
-    const flags = computeReportingNonFinalFlags(
-      p, ALL_TAGS, DATE_FROM, DATE_TO, { "2026-04-29": 2 }, "America/Toronto"
-    );
-    expect(flags.sessionsNonFinal).toBe(true);
-  });
-
-  it("sessionsNonFinal=false si tasksByDayActive est vide", () => {
-    const p = makePayload();
-    const flags = computeReportingNonFinalFlags(
-      p, ALL_TAGS, DATE_FROM, DATE_TO, { "2026-04-29": 0 }, "America/Toronto"
-    );
-    expect(flags.sessionsNonFinal).toBe(false);
-  });
-
-  it("projectsNonFinal=true si tâche non terminée avec @projet dans l'historique", () => {
-    const p = makePayload({
-      history: [
-        {
-          sessionId: "ses-1",
-          tasks: [
-            {
-              id: "t1",
-              isDone: false,
-              project: "acme",
-              tags: [],
-              startTime: "2026-04-29T10:00:00Z",
-            },
-          ],
-        },
-      ],
-    } as Partial<KronosysUpdatePayload>);
-    const flags = computeReportingNonFinalFlags(p, ALL_TAGS, DATE_FROM, DATE_TO, undefined, "America/Toronto");
-    expect(flags.projectsNonFinal).toBe(true);
-  });
-
-  it("tagsNonFinal=true si tâche non terminée avec #tag dans l'historique", () => {
-    const p = makePayload({
-      history: [
-        {
-          sessionId: "ses-1",
-          tasks: [
-            {
-              id: "t1",
-              isDone: false,
-              project: "",
-              tags: ["dev"],
-              startTime: "2026-04-29T10:00:00Z",
-            },
-          ],
-        },
-      ],
-    } as Partial<KronosysUpdatePayload>);
-    const flags = computeReportingNonFinalFlags(p, ALL_TAGS, DATE_FROM, DATE_TO, undefined, "America/Toronto");
-    expect(flags.tagsNonFinal).toBe(true);
-  });
-
-  it("projectsNonFinal=false si toutes les tâches sont terminées", () => {
-    const p = makePayload({
-      history: [
-        {
-          sessionId: "ses-1",
-          tasks: [
-            {
-              id: "t1",
-              isDone: true,
-              project: "acme",
-              tags: ["dev"],
-              startTime: "2026-04-29T10:00:00Z",
-            },
-          ],
-        },
-      ],
-    } as Partial<KronosysUpdatePayload>);
-    const flags = computeReportingNonFinalFlags(p, ALL_TAGS, DATE_FROM, DATE_TO, undefined, "America/Toronto");
-    expect(flags.projectsNonFinal).toBe(false);
-    expect(flags.tagsNonFinal).toBe(false);
-  });
-
-  it("hors de la plage de dates → non compté", () => {
-    const p = makePayload({
-      history: [
-        {
-          sessionId: "ses-1",
-          tasks: [
-            {
-              id: "t1",
-              isDone: false,
-              project: "acme",
-              tags: ["dev"],
-              startTime: "2025-01-01T10:00:00Z",
-            },
-          ],
-        },
-      ],
-    } as Partial<KronosysUpdatePayload>);
-    const flags = computeReportingNonFinalFlags(
-      p, ALL_TAGS, "2026-04-01", "2026-04-30", undefined, "America/Toronto"
-    );
-    expect(flags.projectsNonFinal).toBe(false);
-  });
-});

package/lib/reportingTagWeekBreakdown.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  buildTagWeekDisplayBlocks,
-  groupTagDayRowsForDisplay,
-} from "./reportingTagWeekBreakdown";
-import type { TagWeekCalendarRow } from "./reportingWeekLayout";
-import type { ReportingTagTimeDayRow } from "./reportingAggregate";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function makeWeekRow(tagKey: string, slots: number[] = [0, 0, 0, 0, 0, 0, 0]): TagWeekCalendarRow {
-  return {
-    tagKey,
-    displayTag: tagKey,
-    weekStart: "2026-04-20",
-    slots,
-    total: slots.reduce((s, v) => s + v, 0),
-  };
-}
-
-function makeDayRow(tagKey: string, day: string, minutes: number): ReportingTagTimeDayRow {
-  return { tagKey, displayTag: tagKey, day, minutes };
-}
-
-// ---------------------------------------------------------------------------
-// buildTagWeekDisplayBlocks
-// ---------------------------------------------------------------------------
-describe("buildTagWeekDisplayBlocks", () => {
-  it("retourne un tableau vide pour une entrée vide", () => {
-    expect(buildTagWeekDisplayBlocks([])).toEqual([]);
-  });
-
-  it("étiquette globale → leaf", () => {
-    const rows = [makeWeekRow("dev")];
-    const blocks = buildTagWeekDisplayBlocks(rows);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0].kind).toBe("leaf");
-  });
-
-  it("étiquette fallback (default) placée en dernier", () => {
-    const rows = [makeWeekRow("default"), makeWeekRow("design")];
-    const blocks = buildTagWeekDisplayBlocks(rows);
-    expect(blocks[blocks.length - 1].kind).toBe("leaf");
-    if (blocks[blocks.length - 1].kind === "leaf") {
-      expect(blocks[blocks.length - 1].row.tagKey).toBe("default");
-    }
-  });
-
-  it("étiquette unique projet#code → leaf (pas de rollup)", () => {
-    const rows = [makeWeekRow("acme#frontend")];
-    const blocks = buildTagWeekDisplayBlocks(rows);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0].kind).toBe("leaf");
-  });
-
-  it("deux étiquettes projet#code du même projet → rollup", () => {
-    const rows = [makeWeekRow("acme#frontend", [30, 0, 0, 0, 0, 0, 0]), makeWeekRow("acme#backend", [0, 60, 0, 0, 0, 0, 0])];
-    const blocks = buildTagWeekDisplayBlocks(rows);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0].kind).toBe("rollup");
-    if (blocks[0].kind === "rollup") {
-      expect(blocks[0].children).toHaveLength(2);
-      expect(blocks[0].parentTotal).toBe(90);
-      expect(blocks[0].parentSlots[0]).toBe(30);
-      expect(blocks[0].parentSlots[1]).toBe(60);
-    }
-  });
-
-  it("deux projets différents → deux rollups distincts", () => {
-    const rows = [
-      makeWeekRow("acme#a"),
-      makeWeekRow("acme#b"),
-      makeWeekRow("beta#x"),
-      makeWeekRow("beta#y"),
-    ];
-    const blocks = buildTagWeekDisplayBlocks(rows);
-    const rollups = blocks.filter((b) => b.kind === "rollup");
-    expect(rollups).toHaveLength(2);
-  });
-
-  it("les globales sont triées alphabétiquement avant les rollups projet", () => {
-    const rows = [makeWeekRow("zzz"), makeWeekRow("aaa"), makeWeekRow("proj#x"), makeWeekRow("proj#y")];
-    const blocks = buildTagWeekDisplayBlocks(rows);
-    expect(blocks[0].kind).toBe("leaf");
-    if (blocks[0].kind === "leaf") expect(blocks[0].row.tagKey).toBe("aaa");
-    expect(blocks[1].kind).toBe("leaf");
-    if (blocks[1].kind === "leaf") expect(blocks[1].row.tagKey).toBe("zzz");
-    expect(blocks[2].kind).toBe("rollup");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// groupTagDayRowsForDisplay
-// ---------------------------------------------------------------------------
-describe("groupTagDayRowsForDisplay", () => {
-  it("retourne un tableau vide pour entrée vide", () => {
-    expect(groupTagDayRowsForDisplay([])).toEqual([]);
-  });
-
-  it("regroupe les lignes par jour et trie les jours", () => {
-    const rows = [
-      makeDayRow("dev", "2026-04-22", 30),
-      makeDayRow("design", "2026-04-21", 60),
-      makeDayRow("dev", "2026-04-21", 15),
-    ];
-    const groups = groupTagDayRowsForDisplay(rows);
-    expect(groups).toHaveLength(2);
-    expect(groups[0].day).toBe("2026-04-21");
-    expect(groups[1].day).toBe("2026-04-22");
-  });
-
-  it("chaque groupe contient les bons blocs", () => {
-    const rows = [
-      makeDayRow("dev", "2026-04-21", 30),
-      makeDayRow("design", "2026-04-21", 45),
-    ];
-    const groups = groupTagDayRowsForDisplay(rows);
-    expect(groups[0].blocks).toHaveLength(2);
-  });
-
-  it("projet#code unique dans un groupe → leaf", () => {
-    const rows = [makeDayRow("acme#frontend", "2026-04-21", 60)];
-    const groups = groupTagDayRowsForDisplay(rows);
-    expect(groups[0].blocks[0].kind).toBe("leaf");
-  });
-
-  it("deux proj#code mêmes projet dans un groupe → rollup", () => {
-    const rows = [
-      makeDayRow("acme#frontend", "2026-04-21", 30),
-      makeDayRow("acme#backend", "2026-04-21", 90),
-    ];
-    const groups = groupTagDayRowsForDisplay(rows);
-    const rollup = groups[0].blocks.find((b) => b.kind === "rollup");
-    expect(rollup).toBeDefined();
-    if (rollup?.kind === "rollup") {
-      expect(rollup.parentMinutes).toBe(120);
-    }
-  });
-});