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

package/lib/reportingWeekLayout.test.ts

@@ -1,239 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  addDaysYmd,
-  buildKeyedWeekCalendarRows,
-  buildProjectWeekCalendarRows,
-  buildTagWeekCalendarRows,
-  formatWeekRangeLabel,
-  localCalendarDaysBetween,
-  localWeekStartKeyFromDayKey,
-  weekdayColumnLabels,
-  weekdayDateColumnHeaders,
-} from "./reportingWeekLayout";
-
-// ---------------------------------------------------------------------------
-// addDaysYmd
-// ---------------------------------------------------------------------------
-describe("addDaysYmd", () => {
-  it("ajoute des jours positifs", () => {
-    expect(addDaysYmd("2026-04-29", 1)).toBe("2026-04-30");
-    expect(addDaysYmd("2026-04-29", 7)).toBe("2026-05-06");
-  });
-
-  it("soustrait des jours (delta négatif)", () => {
-    expect(addDaysYmd("2026-05-01", -1)).toBe("2026-04-30");
-  });
-
-  it("traverse les fins de mois et d'année", () => {
-    expect(addDaysYmd("2026-12-31", 1)).toBe("2027-01-01");
-    expect(addDaysYmd("2026-02-28", 1)).toBe("2026-03-01");
-  });
-
-  it("delta = 0 retourne la même date", () => {
-    expect(addDaysYmd("2026-04-15", 0)).toBe("2026-04-15");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// localCalendarDaysBetween
-// ---------------------------------------------------------------------------
-describe("localCalendarDaysBetween", () => {
-  it("même jour → 0", () => {
-    expect(localCalendarDaysBetween("2026-04-29", "2026-04-29")).toBe(0);
-  });
-
-  it("différence positive", () => {
-    expect(localCalendarDaysBetween("2026-04-20", "2026-04-27")).toBe(7);
-  });
-
-  it("différence négative (fin < début)", () => {
-    expect(localCalendarDaysBetween("2026-04-27", "2026-04-20")).toBe(-7);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// localWeekStartKeyFromDayKey
-// ---------------------------------------------------------------------------
-describe("localWeekStartKeyFromDayKey", () => {
-  it("retourne null pour chaîne vide", () => {
-    expect(localWeekStartKeyFromDayKey("", "monday")).toBeNull();
-  });
-
-  it("retourne null pour 'undated'", () => {
-    expect(localWeekStartKeyFromDayKey("undated", "monday")).toBeNull();
-  });
-
-  it("retourne null pour format invalide", () => {
-    expect(localWeekStartKeyFromDayKey("2026-04", "monday")).toBeNull();
-  });
-
-  it("lundi de la semaine contenant mercredi 2026-04-29 (weekStartsOn=monday)", () => {
-    // 2026-04-29 est un mercredi → lundi = 2026-04-27
-    expect(localWeekStartKeyFromDayKey("2026-04-29", "monday")).toBe("2026-04-27");
-  });
-
-  it("dimanche de la semaine contenant mercredi 2026-04-29 (weekStartsOn=sunday)", () => {
-    // semaine commence dimanche → 2026-04-26
-    expect(localWeekStartKeyFromDayKey("2026-04-29", "sunday")).toBe("2026-04-26");
-  });
-
-  it("samedi de la semaine (weekStartsOn=saturday)", () => {
-    // semaine commence samedi → 2026-04-25
-    expect(localWeekStartKeyFromDayKey("2026-04-29", "saturday")).toBe("2026-04-25");
-  });
-
-  it("le premier jour de la semaine pointe sur lui-même", () => {
-    // 2026-04-27 est un lundi
-    expect(localWeekStartKeyFromDayKey("2026-04-27", "monday")).toBe("2026-04-27");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// weekdayColumnLabels
-// ---------------------------------------------------------------------------
-describe("weekdayColumnLabels", () => {
-  it("retourne 7 libellés", () => {
-    expect(weekdayColumnLabels("monday", "en-CA")).toHaveLength(7);
-    expect(weekdayColumnLabels("sunday", "fr-CA")).toHaveLength(7);
-  });
-
-  it("les libellés sont non vides", () => {
-    const labels = weekdayColumnLabels("monday", "en-CA");
-    for (const l of labels) {
-      expect(l.trim().length).toBeGreaterThan(0);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// weekdayDateColumnHeaders
-// ---------------------------------------------------------------------------
-describe("weekdayDateColumnHeaders", () => {
-  it("retourne 7 en-têtes depuis le weekStartKey", () => {
-    const headers = weekdayDateColumnHeaders("2026-04-27", "en-CA");
-    expect(headers).toHaveLength(7);
-  });
-
-  it("le premier dateKey correspond au weekStartKey", () => {
-    const headers = weekdayDateColumnHeaders("2026-04-27", "en-CA");
-    expect(headers[0].dateKey).toBe("2026-04-27");
-  });
-
-  it("le dernier dateKey est weekStart + 6 jours", () => {
-    const headers = weekdayDateColumnHeaders("2026-04-27", "en-CA");
-    expect(headers[6].dateKey).toBe("2026-05-03");
-  });
-
-  it("chaque en-tête a weekdayShort et calendarDateShort non vides", () => {
-    const headers = weekdayDateColumnHeaders("2026-04-27", "fr-CA");
-    for (const h of headers) {
-      expect(h.weekdayShort.trim().length).toBeGreaterThan(0);
-      expect(h.calendarDateShort.trim().length).toBeGreaterThan(0);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatWeekRangeLabel
-// ---------------------------------------------------------------------------
-describe("formatWeekRangeLabel", () => {
-  it("retourne une chaîne non vide", () => {
-    const label = formatWeekRangeLabel("2026-04-27", "fr-CA");
-    expect(label.trim().length).toBeGreaterThan(0);
-  });
-
-  it("inclut l'année dans le label", () => {
-    const label = formatWeekRangeLabel("2026-04-27", "en-CA");
-    expect(label).toContain("2026");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildKeyedWeekCalendarRows
-// ---------------------------------------------------------------------------
-describe("buildKeyedWeekCalendarRows", () => {
-  it("retourne un tableau vide pour une entrée vide", () => {
-    expect(buildKeyedWeekCalendarRows([], "monday")).toEqual([]);
-  });
-
-  it("ignore les lignes 'undated'", () => {
-    const rows = [{ day: "undated", rowKey: "dev", displayLabel: "Dev", minutes: 60 }];
-    expect(buildKeyedWeekCalendarRows(rows, "monday")).toEqual([]);
-  });
-
-  it("ignore les lignes avec minutes <= 0", () => {
-    const rows = [{ day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 0 }];
-    expect(buildKeyedWeekCalendarRows(rows, "monday")).toEqual([]);
-  });
-
-  it("agrège correctement deux entrées dans la même semaine pour la même clé", () => {
-    const rows = [
-      { day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 30 },
-      { day: "2026-04-28", rowKey: "dev", displayLabel: "Dev", minutes: 45 },
-    ];
-    const result = buildKeyedWeekCalendarRows(rows, "monday");
-    expect(result).toHaveLength(1);
-    expect(result[0].total).toBe(75);
-    expect(result[0].slots[0]).toBe(30); // lundi (idx 0)
-    expect(result[0].slots[1]).toBe(45); // mardi (idx 1)
-  });
-
-  it("deux clés différentes → deux lignes", () => {
-    const rows = [
-      { day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 30 },
-      { day: "2026-04-27", rowKey: "design", displayLabel: "Design", minutes: 20 },
-    ];
-    const result = buildKeyedWeekCalendarRows(rows, "monday");
-    expect(result).toHaveLength(2);
-  });
-
-  it("deux semaines différentes → deux lignes pour la même clé", () => {
-    const rows = [
-      { day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 30 },
-      { day: "2026-05-04", rowKey: "dev", displayLabel: "Dev", minutes: 60 },
-    ];
-    const result = buildKeyedWeekCalendarRows(rows, "monday");
-    expect(result).toHaveLength(2);
-  });
-
-  it("la clé vide est triée en dernier (empty key last)", () => {
-    const rows = [
-      { day: "2026-04-27", rowKey: "", displayLabel: "", minutes: 10 },
-      { day: "2026-04-27", rowKey: "zzz", displayLabel: "Zzz", minutes: 10 },
-      { day: "2026-04-27", rowKey: "aaa", displayLabel: "Aaa", minutes: 10 },
-    ];
-    const result = buildKeyedWeekCalendarRows(rows, "monday");
-    expect(result[result.length - 1].rowKey).toBe("");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildTagWeekCalendarRows (wrapper)
-// ---------------------------------------------------------------------------
-describe("buildTagWeekCalendarRows", () => {
-  it("mappe correctement tagKey et displayTag", () => {
-    const rows = [
-      { day: "2026-04-27", tagKey: "dev", displayTag: "Développement", minutes: 60 },
-    ];
-    const result = buildTagWeekCalendarRows(rows, "monday");
-    expect(result[0].tagKey).toBe("dev");
-    expect(result[0].displayTag).toBe("Développement");
-    expect(result[0].total).toBe(60);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildProjectWeekCalendarRows (wrapper)
-// ---------------------------------------------------------------------------
-describe("buildProjectWeekCalendarRows", () => {
-  it("mappe correctement projectKey et displayProject", () => {
-    const rows = [
-      { day: "2026-04-27", projectKey: "acme", displayProject: "Acme Corp", minutes: 90 },
-    ];
-    const result = buildProjectWeekCalendarRows(rows, "monday");
-    expect(result[0].projectKey).toBe("acme");
-    expect(result[0].displayProject).toBe("Acme Corp");
-    expect(result[0].total).toBe(90);
-  });
-});

package/lib/sessionAssiduity.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { assiduityFromScheduledStart } from "./sessionAssiduity";
-
-describe("sessionAssiduity", () => {
-  it("retourne un écart positif si l’ouverture est après l’heure prévue", () => {
-    const a = assiduityFromScheduledStart(
-      Date.parse("2026-04-24T09:15:00.000Z"),
-      "2026-04-24T09:00:00.000Z"
-    );
-    expect(a?.sessionStartOffsetMinutes).toBe(15);
-    expect(a?.scheduledStartAt).toBe("2026-04-24T09:00:00.000Z");
-  });
-
-  it("retourne un écart négatif si l’ouverture est en avance", () => {
-    const a = assiduityFromScheduledStart(
-      Date.parse("2026-04-24T08:50:00.000Z"),
-      "2026-04-24T09:00:00.000Z"
-    );
-    expect(a?.sessionStartOffsetMinutes).toBe(-10);
-  });
-
-  it("refuse une chaîne d’horodatage invalide", () => {
-    expect(assiduityFromScheduledStart(Date.now(), "pas-une-date")).toBeNull();
-  });
-});

package/lib/sessionEndWarnings.test.ts

@@ -1,200 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  formatEndLiveSessionConfirmMessage,
-  formatEndLiveSessionModalIntro,
-  getEndLiveSessionWarningFlags,
-  shouldConfirmEndLiveSession,
-} from "./sessionEndWarnings";
-
-const STRINGS = {
-  sessionEndLiveConfirmIntro: "Attention :",
-  sessionEndLiveConfirmIntroCalm: "Tout est tranquille.",
-  sessionEndLiveWarnActiveTask: "Une tâche est en cours.",
-  sessionEndLiveWarnPausedTasks: "Des tâches sont en attente.",
-  sessionEndLiveWarnIncompleteSubtasks: "Des sous-tâches sont ouvertes.",
-};
-
-describe("getEndLiveSessionWarningFlags", () => {
-  it("retourne tout false si live est null", () => {
-    const flags = getEndLiveSessionWarningFlags(null);
-    expect(flags).toEqual({
-      hasActiveTracking: false,
-      hasPausedOrPendingTasks: false,
-      hasIncompleteSubtasks: false,
-    });
-  });
-
-  it("retourne tout false si live est undefined", () => {
-    expect(getEndLiveSessionWarningFlags(undefined)).toEqual({
-      hasActiveTracking: false,
-      hasPausedOrPendingTasks: false,
-      hasIncompleteSubtasks: false,
-    });
-  });
-
-  it("hasActiveTracking=true si activeTasks contient une tâche non terminée non en pause", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      activeTasks: [{ id: "t1", isDone: false, manualTaskTimerPaused: false }],
-    });
-    expect(flags.hasActiveTracking).toBe(true);
-  });
-
-  it("hasActiveTracking=false si la tâche active est en pause manuelle", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      activeTasks: [{ id: "t1", isDone: false, manualTaskTimerPaused: true }],
-    });
-    expect(flags.hasActiveTracking).toBe(false);
-  });
-
-  it("hasActiveTracking=false si la tâche active est terminée", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      activeTasks: [{ id: "t1", isDone: true }],
-    });
-    expect(flags.hasActiveTracking).toBe(false);
-  });
-
-  it("utilise activeTask (forme simple) si activeTasks est absent", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      activeTask: { id: "t1", isDone: false, manualTaskTimerPaused: false },
-    });
-    expect(flags.hasActiveTracking).toBe(true);
-  });
-
-  it("hasPausedOrPendingTasks=true si tasks contient une tâche non terminée", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      tasks: [{ id: "t1", isDone: false }],
-    });
-    expect(flags.hasPausedOrPendingTasks).toBe(true);
-  });
-
-  it("hasPausedOrPendingTasks=false si toutes les tâches sont terminées", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      tasks: [{ id: "t1", isDone: true }, { id: "t2", isDone: true }],
-    });
-    expect(flags.hasPausedOrPendingTasks).toBe(false);
-  });
-
-  it("hasIncompleteSubtasks=true si une tâche a une sous-tâche non terminée", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      tasks: [{ id: "t1", isDone: false, subtasks: [{ done: false }] }],
-    });
-    expect(flags.hasIncompleteSubtasks).toBe(true);
-  });
-
-  it("hasIncompleteSubtasks=false si toutes les sous-tâches sont done", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      tasks: [{ id: "t1", isDone: false, subtasks: [{ done: true }] }],
-    });
-    expect(flags.hasIncompleteSubtasks).toBe(false);
-  });
-
-  it("tâche active avec sous-tâche incomplète est détectée même si absente de tasks", () => {
-    const flags = getEndLiveSessionWarningFlags({
-      activeTasks: [{ id: "t-unique", isDone: false, subtasks: [{ done: false }] }],
-      tasks: [],
-    });
-    expect(flags.hasIncompleteSubtasks).toBe(true);
-  });
-
-  it("avertit pour une tâche active non terminée absente de la liste tasks", () => {
-    expect(
-      getEndLiveSessionWarningFlags({
-        tasks: [],
-        activeTasks: [{ id: "a", isDone: false }],
-      })
-    ).toEqual({
-      hasActiveTracking: true,
-      hasPausedOrPendingTasks: true,
-      hasIncompleteSubtasks: false,
-    });
-  });
-
-  it("avertit pour une tâche active en pause absente de la liste tasks", () => {
-    expect(
-      getEndLiveSessionWarningFlags({
-        tasks: [],
-        activeTasks: [{ id: "a", isDone: false, manualTaskTimerPaused: true }],
-      }).hasPausedOrPendingTasks
-    ).toBe(true);
-  });
-
-  it("avertit pour une sous-tâche ouverte sur activeTask quand activeTasks existe aussi", () => {
-    expect(
-      getEndLiveSessionWarningFlags({
-        tasks: [],
-        activeTasks: [{ id: "a", isDone: true }],
-        activeTask: {
-          id: "b",
-          isDone: true,
-          subtasks: [{ done: true }, { done: false }],
-        },
-      }).hasIncompleteSubtasks
-    ).toBe(true);
-  });
-});
-
-describe("shouldConfirmEndLiveSession", () => {
-  it("retourne false si aucun flag", () => {
-    expect(shouldConfirmEndLiveSession({
-      hasActiveTracking: false,
-      hasPausedOrPendingTasks: false,
-      hasIncompleteSubtasks: false,
-    })).toBe(false);
-  });
-
-  it("retourne true si hasActiveTracking", () => {
-    expect(shouldConfirmEndLiveSession({
-      hasActiveTracking: true,
-      hasPausedOrPendingTasks: false,
-      hasIncompleteSubtasks: false,
-    })).toBe(true);
-  });
-
-  it("retourne true si hasPausedOrPendingTasks seulement", () => {
-    expect(shouldConfirmEndLiveSession({
-      hasActiveTracking: false,
-      hasPausedOrPendingTasks: true,
-      hasIncompleteSubtasks: false,
-    })).toBe(true);
-  });
-});
-
-describe("formatEndLiveSessionConfirmMessage", () => {
-  it("inclut uniquement les bullets correspondant aux flags actifs", () => {
-    const msg = formatEndLiveSessionConfirmMessage(
-      { hasActiveTracking: true, hasPausedOrPendingTasks: false, hasIncompleteSubtasks: true },
-      STRINGS,
-    );
-    expect(msg).toContain("Attention :");
-    expect(msg).toContain("• Une tâche est en cours.");
-    expect(msg).toContain("• Des sous-tâches sont ouvertes.");
-    expect(msg).not.toContain("attente");
-  });
-
-  it("message vide de bullets si aucun flag (cas théorique)", () => {
-    const msg = formatEndLiveSessionConfirmMessage(
-      { hasActiveTracking: false, hasPausedOrPendingTasks: false, hasIncompleteSubtasks: false },
-      STRINGS,
-    );
-    expect(msg).toBe("Attention :\n");
-  });
-});
-
-describe("formatEndLiveSessionModalIntro", () => {
-  it("retourne le message calme si aucun flag", () => {
-    const intro = formatEndLiveSessionModalIntro(
-      { hasActiveTracking: false, hasPausedOrPendingTasks: false, hasIncompleteSubtasks: false },
-      STRINGS,
-    );
-    expect(intro).toBe("Tout est tranquille.");
-  });
-
-  it("retourne le message d'avertissement si au moins un flag", () => {
-    const intro = formatEndLiveSessionModalIntro(
-      { hasActiveTracking: false, hasPausedOrPendingTasks: true, hasIncompleteSubtasks: false },
-      STRINGS,
-    );
-    expect(intro).toContain("Des tâches sont en attente.");
-  });
-});

package/lib/sessionListMerge.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { mergeLiveSessionIntoHistory } from "./sessionListMerge";
-
-const BASE_ENTRY = {
-  sessionId: "ses-1",
-  sessionName: "Session A",
-  savedAt: "2026-04-01T10:00:00Z",
-};
-
-describe("mergeLiveSessionIntoHistory", () => {
-  it("retourne l'historique tel quel si live est undefined", () => {
-    const history = [BASE_ENTRY];
-    expect(mergeLiveSessionIntoHistory(history, undefined)).toEqual(history);
-  });
-
-  it("retourne l'historique tel quel si live n'a pas de sessionId", () => {
-    const history = [BASE_ENTRY];
-    expect(mergeLiveSessionIntoHistory(history, {})).toEqual(history);
-  });
-
-  it("retourne l'historique tel quel si sessionId est une chaîne vide", () => {
-    const history = [BASE_ENTRY];
-    expect(mergeLiveSessionIntoHistory(history, { sessionId: "  " })).toEqual(history);
-  });
-
-  it("prépose la session live en tête si absente de l'historique", () => {
-    const history = [BASE_ENTRY];
-    const live = { sessionId: "ses-live", sessionName: "Live" };
-    const result = mergeLiveSessionIntoHistory(history, live);
-    expect(result[0].sessionId).toBe("ses-live");
-    expect(result[1]).toEqual(BASE_ENTRY);
-  });
-
-  it("remplace l'entrée existante par la version live (déduplique)", () => {
-    const history = [
-      { ...BASE_ENTRY, sessionName: "Ancienne" },
-      { sessionId: "ses-2", sessionName: "Autre" },
-    ];
-    const live = { sessionId: "ses-1", sessionName: "Mise à jour" };
-    const result = mergeLiveSessionIntoHistory(history, live);
-    expect(result).toHaveLength(2);
-    expect(result[0].sessionId).toBe("ses-1");
-    expect(result[0].sessionName).toBe("Mise à jour");
-  });
-
-  it("copie sessionDurationMinutes si numérique fini", () => {
-    const result = mergeLiveSessionIntoHistory([], {
-      sessionId: "ses-x",
-      sessionDurationMinutes: 42,
-    });
-    expect(result[0].sessionDurationMinutes).toBe(42);
-  });
-
-  it("ignore sessionDurationMinutes si Infinity", () => {
-    const result = mergeLiveSessionIntoHistory([], {
-      sessionId: "ses-x",
-      sessionDurationMinutes: Infinity,
-    });
-    expect(result[0].sessionDurationMinutes).toBeUndefined();
-  });
-
-  it("copie mongoPushedAt et mongoLastPushedSavedAt si définis", () => {
-    const result = mergeLiveSessionIntoHistory([], {
-      sessionId: "ses-x",
-      mongoPushedAt: "2026-01-01T00:00:00Z",
-      mongoLastPushedSavedAt: "2026-01-02T00:00:00Z",
-    });
-    expect(result[0].mongoPushedAt).toBe("2026-01-01T00:00:00Z");
-    expect(result[0].mongoLastPushedSavedAt).toBe("2026-01-02T00:00:00Z");
-  });
-
-  it("copie sessionEndReasonKind si non vide", () => {
-    const result = mergeLiveSessionIntoHistory([], {
-      sessionId: "ses-x",
-      sessionEndReasonKind: "done",
-    });
-    expect(result[0].sessionEndReasonKind).toBe("done");
-  });
-
-  it("ignore sessionEndReasonKind si chaîne vide ou espaces", () => {
-    const result = mergeLiveSessionIntoHistory([], {
-      sessionId: "ses-x",
-      sessionEndReasonKind: "   ",
-    });
-    expect(result[0].sessionEndReasonKind).toBeUndefined();
-  });
-
-  it("normalise sessionId numérique en chaîne", () => {
-    const result = mergeLiveSessionIntoHistory([], { sessionId: 99 });
-    expect(result[0].sessionId).toBe("99");
-  });
-
-  it("endAt null est préservé", () => {
-    const result = mergeLiveSessionIntoHistory([], {
-      sessionId: "ses-x",
-      endAt: null,
-    });
-    expect(result[0].endAt).toBeNull();
-  });
-});

package/lib/sessionTaskSidebarStats.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { countSessionTasksForSidebar } from "./sessionTaskSidebarStats";
-
-describe("countSessionTasksForSidebar", () => {
-  it("session ouverte : compte les non terminées en liste en pause", () => {
-    expect(
-      countSessionTasksForSidebar({
-        endAt: null,
-        tasks: [{ isDone: true }, { isDone: false }, { isDone: false }],
-        activeTasks: [],
-      })
-    ).toEqual({ running: 0, pausedList: 2, completed: 1 });
-  });
-
-  it("session terminée (endAt) : pas d’en cours ni de liste en pause, seulement les terminées", () => {
-    expect(
-      countSessionTasksForSidebar({
-        endAt: "2026-04-16T12:00:00.000Z",
-        tasks: [{ isDone: true }, { isDone: false }, { isDone: false }],
-        activeTasks: [{ isDone: false, manualTaskTimerPaused: false }],
-      })
-    ).toEqual({ running: 0, pausedList: 0, completed: 1 });
-  });
-});