@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/reportingAggregate.test.ts

@@ -0,0 +1,325 @@
+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);
+  });
+});