test(web): add 291 tests for parsers, hooks, and UI components

Lib utilities: scopeImportParser (31), status-styles (58), planningEntryIds (10), uuid (11). Hooks: useFilters (28), useRowOrder (18), usePermissions (30), useViewPrefs (24). Components: AnimatedModal (14), DateInput (22), InfoTooltip (13), ProgressRing (19). Web test suite: 75 → 87 files, 553 → 844 tests. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-04-10 17:14:11 +02:00
parent 98dca6126f
commit a3d75973ee
12 changed files with 2626 additions and 0 deletions
@@ -0,0 +1,344 @@
+import { describe, expect, it } from "vitest";
+import {
+  ALLOCATION_STATUS_BADGE,
+  VACATION_STATUS_BADGE,
+  VACATION_TYPE_LABELS,
+  VACATION_TYPE_BADGE,
+  PROJECT_STATUS_BADGE,
+  ORDER_TYPE_BADGE,
+  VACATION_TIMELINE_COLORS,
+  VACATION_TIMELINE_BORDER,
+  VACATION_TYPE_LABELS_SHORT,
+  VACATION_CALENDAR_COLORS,
+} from "./status-styles.js";
+
+// ---------------------------------------------------------------------------
+// ALLOCATION_STATUS_BADGE
+// ---------------------------------------------------------------------------
+
+describe("ALLOCATION_STATUS_BADGE", () => {
+  const expectedKeys = ["ACTIVE", "PROPOSED", "CONFIRMED", "COMPLETED", "CANCELLED"];
+
+  it("contains all expected allocation status keys", () => {
+    expectedKeys.forEach((key) => {
+      expect(ALLOCATION_STATUS_BADGE).toHaveProperty(key);
+    });
+  });
+
+  it("has no extra unexpected keys", () => {
+    expect(Object.keys(ALLOCATION_STATUS_BADGE).sort()).toEqual(expectedKeys.sort());
+  });
+
+  it.each(expectedKeys)("value for %s is a non-empty string", (key) => {
+    expect(typeof ALLOCATION_STATUS_BADGE[key]).toBe("string");
+    expect(ALLOCATION_STATUS_BADGE[key]!.length).toBeGreaterThan(0);
+  });
+
+  it("ACTIVE uses green classes", () => {
+    expect(ALLOCATION_STATUS_BADGE.ACTIVE).toContain("green");
+  });
+
+  it("CANCELLED uses red classes", () => {
+    expect(ALLOCATION_STATUS_BADGE.CANCELLED).toContain("red");
+  });
+
+  it("PROPOSED uses yellow classes", () => {
+    expect(ALLOCATION_STATUS_BADGE.PROPOSED).toContain("yellow");
+  });
+
+  it("CONFIRMED uses blue classes", () => {
+    expect(ALLOCATION_STATUS_BADGE.CONFIRMED).toContain("blue");
+  });
+
+  it("COMPLETED uses gray classes", () => {
+    expect(ALLOCATION_STATUS_BADGE.COMPLETED).toContain("gray");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_STATUS_BADGE
+// ---------------------------------------------------------------------------
+
+describe("VACATION_STATUS_BADGE", () => {
+  const expectedKeys = ["PENDING", "APPROVED", "REJECTED", "CANCELLED"];
+
+  it("contains all expected vacation status keys", () => {
+    expectedKeys.forEach((key) => {
+      expect(VACATION_STATUS_BADGE).toHaveProperty(key);
+    });
+  });
+
+  it("has no extra unexpected keys", () => {
+    expect(Object.keys(VACATION_STATUS_BADGE).sort()).toEqual(expectedKeys.sort());
+  });
+
+  it.each(expectedKeys)("value for %s is a non-empty string", (key) => {
+    expect(typeof VACATION_STATUS_BADGE[key]).toBe("string");
+    expect(VACATION_STATUS_BADGE[key]!.length).toBeGreaterThan(0);
+  });
+
+  it("APPROVED uses green/emerald classes", () => {
+    expect(VACATION_STATUS_BADGE.APPROVED).toMatch(/emerald|green/);
+  });
+
+  it("REJECTED uses red classes", () => {
+    expect(VACATION_STATUS_BADGE.REJECTED).toContain("red");
+  });
+
+  it("PENDING uses amber/yellow classes", () => {
+    expect(VACATION_STATUS_BADGE.PENDING).toMatch(/amber|yellow/);
+  });
+
+  it("CANCELLED uses gray classes", () => {
+    expect(VACATION_STATUS_BADGE.CANCELLED).toContain("gray");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_TYPE_LABELS
+// ---------------------------------------------------------------------------
+
+describe("VACATION_TYPE_LABELS", () => {
+  it("provides human-readable label for ANNUAL", () => {
+    expect(VACATION_TYPE_LABELS.ANNUAL).toBe("Annual Leave");
+  });
+
+  it("provides human-readable label for SICK", () => {
+    expect(VACATION_TYPE_LABELS.SICK).toBe("Sick Leave");
+  });
+
+  it("provides human-readable label for PUBLIC_HOLIDAY", () => {
+    expect(VACATION_TYPE_LABELS.PUBLIC_HOLIDAY).toBe("Public Holiday");
+  });
+
+  it("provides human-readable label for OTHER", () => {
+    expect(VACATION_TYPE_LABELS.OTHER).toBe("Other");
+  });
+
+  it("covers exactly the four expected types", () => {
+    expect(Object.keys(VACATION_TYPE_LABELS).sort()).toEqual([
+      "ANNUAL",
+      "OTHER",
+      "PUBLIC_HOLIDAY",
+      "SICK",
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_TYPE_BADGE
+// ---------------------------------------------------------------------------
+
+describe("VACATION_TYPE_BADGE", () => {
+  const expectedKeys = ["ANNUAL", "SICK", "PUBLIC_HOLIDAY", "OTHER"];
+
+  it("contains all expected vacation type keys", () => {
+    expectedKeys.forEach((key) => {
+      expect(VACATION_TYPE_BADGE).toHaveProperty(key);
+    });
+  });
+
+  it("has no extra unexpected keys", () => {
+    expect(Object.keys(VACATION_TYPE_BADGE).sort()).toEqual(expectedKeys.sort());
+  });
+
+  it.each(expectedKeys)("value for %s is a non-empty string", (key) => {
+    expect(typeof VACATION_TYPE_BADGE[key]).toBe("string");
+    expect(VACATION_TYPE_BADGE[key]!.length).toBeGreaterThan(0);
+  });
+
+  it("SICK uses red classes", () => {
+    expect(VACATION_TYPE_BADGE.SICK).toContain("red");
+  });
+
+  it("OTHER uses purple classes", () => {
+    expect(VACATION_TYPE_BADGE.OTHER).toContain("purple");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PROJECT_STATUS_BADGE
+// ---------------------------------------------------------------------------
+
+describe("PROJECT_STATUS_BADGE", () => {
+  const expectedKeys = ["DRAFT", "ACTIVE", "ON_HOLD", "COMPLETED", "CANCELLED"];
+
+  it("contains all expected project status keys", () => {
+    expectedKeys.forEach((key) => {
+      expect(PROJECT_STATUS_BADGE).toHaveProperty(key);
+    });
+  });
+
+  it("has no extra unexpected keys", () => {
+    expect(Object.keys(PROJECT_STATUS_BADGE).sort()).toEqual(expectedKeys.sort());
+  });
+
+  it.each(expectedKeys)("value for %s is a non-empty string", (key) => {
+    expect(typeof PROJECT_STATUS_BADGE[key]).toBe("string");
+    expect(PROJECT_STATUS_BADGE[key]!.length).toBeGreaterThan(0);
+  });
+
+  it("DRAFT uses gray classes", () => {
+    expect(PROJECT_STATUS_BADGE.DRAFT).toContain("gray");
+  });
+
+  it("ACTIVE uses green classes", () => {
+    expect(PROJECT_STATUS_BADGE.ACTIVE).toContain("green");
+  });
+
+  it("ON_HOLD uses yellow classes", () => {
+    expect(PROJECT_STATUS_BADGE.ON_HOLD).toContain("yellow");
+  });
+
+  it("COMPLETED uses blue classes", () => {
+    expect(PROJECT_STATUS_BADGE.COMPLETED).toContain("blue");
+  });
+
+  it("CANCELLED uses red classes", () => {
+    expect(PROJECT_STATUS_BADGE.CANCELLED).toContain("red");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ORDER_TYPE_BADGE
+// ---------------------------------------------------------------------------
+
+describe("ORDER_TYPE_BADGE", () => {
+  const expectedKeys = ["BD", "CHARGEABLE", "INTERNAL", "OVERHEAD"];
+
+  it("contains all expected order type keys", () => {
+    expectedKeys.forEach((key) => {
+      expect(ORDER_TYPE_BADGE).toHaveProperty(key);
+    });
+  });
+
+  it("has no extra unexpected keys", () => {
+    expect(Object.keys(ORDER_TYPE_BADGE).sort()).toEqual(expectedKeys.sort());
+  });
+
+  it.each(expectedKeys)("value for %s is a non-empty string", (key) => {
+    expect(typeof ORDER_TYPE_BADGE[key]).toBe("string");
+    expect(ORDER_TYPE_BADGE[key]!.length).toBeGreaterThan(0);
+  });
+
+  it("BD uses purple classes", () => {
+    expect(ORDER_TYPE_BADGE.BD).toContain("purple");
+  });
+
+  it("CHARGEABLE uses green classes", () => {
+    expect(ORDER_TYPE_BADGE.CHARGEABLE).toContain("green");
+  });
+
+  it("INTERNAL uses blue classes", () => {
+    expect(ORDER_TYPE_BADGE.INTERNAL).toContain("blue");
+  });
+
+  it("OVERHEAD uses gray classes", () => {
+    expect(ORDER_TYPE_BADGE.OVERHEAD).toContain("gray");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_TIMELINE_COLORS
+// ---------------------------------------------------------------------------
+
+describe("VACATION_TIMELINE_COLORS", () => {
+  const expectedKeys = ["ANNUAL", "SICK", "PUBLIC_HOLIDAY", "OTHER"];
+
+  it("covers all vacation types", () => {
+    expectedKeys.forEach((key) => {
+      expect(VACATION_TIMELINE_COLORS).toHaveProperty(key);
+    });
+  });
+
+  it.each(expectedKeys)("value for %s is a non-empty string", (key) => {
+    expect(typeof VACATION_TIMELINE_COLORS[key]).toBe("string");
+    expect(VACATION_TIMELINE_COLORS[key]!.length).toBeGreaterThan(0);
+  });
+
+  it("SICK uses red classes", () => {
+    expect(VACATION_TIMELINE_COLORS.SICK).toContain("red");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_TIMELINE_BORDER
+// ---------------------------------------------------------------------------
+
+describe("VACATION_TIMELINE_BORDER", () => {
+  const expectedKeys = ["ANNUAL", "SICK", "PUBLIC_HOLIDAY", "OTHER"];
+
+  it("covers all vacation types", () => {
+    expectedKeys.forEach((key) => {
+      expect(VACATION_TIMELINE_BORDER).toHaveProperty(key);
+    });
+  });
+
+  it.each(expectedKeys)("value for %s starts with 'border-'", (key) => {
+    expect(VACATION_TIMELINE_BORDER[key]).toMatch(/^border-/);
+  });
+
+  it("SICK uses red border", () => {
+    expect(VACATION_TIMELINE_BORDER.SICK).toContain("red");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_TYPE_LABELS_SHORT
+// ---------------------------------------------------------------------------
+
+describe("VACATION_TYPE_LABELS_SHORT", () => {
+  it("provides short label for ANNUAL", () => {
+    expect(VACATION_TYPE_LABELS_SHORT.ANNUAL).toBe("Annual");
+  });
+
+  it("provides short label for SICK", () => {
+    expect(VACATION_TYPE_LABELS_SHORT.SICK).toBe("Sick");
+  });
+
+  it("provides short label for PUBLIC_HOLIDAY", () => {
+    expect(VACATION_TYPE_LABELS_SHORT.PUBLIC_HOLIDAY).toBe("Holiday");
+  });
+
+  it("provides short label for OTHER", () => {
+    expect(VACATION_TYPE_LABELS_SHORT.OTHER).toBe("Other");
+  });
+
+  it("short labels are shorter than or equal to full labels", () => {
+    (Object.keys(VACATION_TYPE_LABELS_SHORT) as string[]).forEach((key) => {
+      const short = VACATION_TYPE_LABELS_SHORT[key]!;
+      const full = VACATION_TYPE_LABELS[key] ?? short;
+      expect(short.length).toBeLessThanOrEqual(full.length);
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VACATION_CALENDAR_COLORS
+// ---------------------------------------------------------------------------
+
+describe("VACATION_CALENDAR_COLORS", () => {
+  const expectedKeys = ["ANNUAL", "SICK", "PUBLIC_HOLIDAY", "OTHER"];
+
+  it("covers all vacation types", () => {
+    expectedKeys.forEach((key) => {
+      expect(VACATION_CALENDAR_COLORS).toHaveProperty(key);
+    });
+  });
+
+  it.each(expectedKeys)("value for %s starts with 'bg-'", (key) => {
+    expect(VACATION_CALENDAR_COLORS[key]).toMatch(/^bg-/);
+  });
+
+  it("SICK uses red", () => {
+    expect(VACATION_CALENDAR_COLORS.SICK).toContain("red");
+  });
+
+  it("PUBLIC_HOLIDAY uses emerald", () => {
+    expect(VACATION_CALENDAR_COLORS.PUBLIC_HOLIDAY).toContain("emerald");
+  });
+
+  it("OTHER uses purple", () => {
+    expect(VACATION_CALENDAR_COLORS.OTHER).toContain("purple");
+  });
+});