test: add unit tests for core utilities (Phase 4)

Add comprehensive unit tests for core utility functions:
- utils.ts: 12 tests for cn() function (class name merging with Tailwind)
- stageUtils.ts: 11 tests for sortStagesByOrder() sorting algorithm
- markdown.ts: 21 tests for parseMarkdown() with GFM support
- timeUtils.ts: 44 tests for time formatting and timezone conversion functions
  - formatTimeRange, formatDateTime, formatTimeOnly
  - toDatetimeLocal, toISOString
  - combineDateAndTime, convertLocalTimeToUTC

All utilities tests include:
- Edge cases and null/undefined handling
- Format validation
- Timezone conversions
- Complex data scenarios

Total: 292 tests passing (Phases 1-4 combined)

Author: claude

src/lib/__tests__/markdown.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { parseMarkdown } from "../markdown";
+
+describe("parseMarkdown", () => {
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore();
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(parseMarkdown("")).toBe("");
+  });
+
+  it("parses basic markdown text", () => {
+    const result = parseMarkdown("Hello world");
+    expect(result).toContain("Hello world");
+  });
+
+  it("parses bold text", () => {
+    const result = parseMarkdown("**bold text**");
+    expect(result).toContain("<strong>");
+    expect(result).toContain("bold text");
+    expect(result).toContain("</strong>");
+  });
+
+  it("parses italic text", () => {
+    const result = parseMarkdown("*italic text*");
+    expect(result).toContain("<em>");
+    expect(result).toContain("italic text");
+    expect(result).toContain("</em>");
+  });
+
+  it("parses links", () => {
+    const result = parseMarkdown("[link text](https://example.com)");
+    expect(result).toContain('<a href="https://example.com">');
+    expect(result).toContain("link text");
+    expect(result).toContain("</a>");
+  });
+
+  it("parses headings", () => {
+    const result = parseMarkdown("# Heading 1");
+    expect(result).toContain("<h1>");
+    expect(result).toContain("Heading 1");
+    expect(result).toContain("</h1>");
+  });
+
+  it("parses multiple heading levels", () => {
+    const result = parseMarkdown("## Heading 2\n### Heading 3");
+    expect(result).toContain("<h2>");
+    expect(result).toContain("<h3>");
+  });
+
+  it("parses unordered lists", () => {
+    const result = parseMarkdown("- Item 1\n- Item 2");
+    expect(result).toContain("<ul>");
+    expect(result).toContain("<li>");
+    expect(result).toContain("Item 1");
+    expect(result).toContain("Item 2");
+    expect(result).toContain("</ul>");
+  });
+
+  it("parses ordered lists", () => {
+    const result = parseMarkdown("1. First\n2. Second");
+    expect(result).toContain("<ol>");
+    expect(result).toContain("<li>");
+    expect(result).toContain("First");
+    expect(result).toContain("Second");
+    expect(result).toContain("</ol>");
+  });
+
+  it("converts line breaks with breaks: true option", () => {
+    const result = parseMarkdown("Line 1\nLine 2");
+    expect(result).toContain("<br>");
+  });
+
+  it("parses code blocks", () => {
+    const result = parseMarkdown("`code here`");
+    expect(result).toContain("<code>");
+    expect(result).toContain("code here");
+    expect(result).toContain("</code>");
+  });
+
+  it("parses fenced code blocks", () => {
+    const result = parseMarkdown("```\ncode block\n```");
+    expect(result).toContain("<pre>");
+    expect(result).toContain("<code>");
+    expect(result).toContain("code block");
+  });
+
+  it("parses blockquotes", () => {
+    const result = parseMarkdown("> Quote here");
+    expect(result).toContain("<blockquote>");
+    expect(result).toContain("Quote here");
+    expect(result).toContain("</blockquote>");
+  });
+
+  it("handles mixed markdown elements", () => {
+    const markdown = "# Title\n\n**Bold** and *italic* text\n\n- List item";
+    const result = parseMarkdown(markdown);
+    expect(result).toContain("<h1>");
+    expect(result).toContain("<strong>");
+    expect(result).toContain("<em>");
+    expect(result).toContain("<ul>");
+  });
+
+  it("supports GitHub Flavored Markdown (GFM)", () => {
+    const result = parseMarkdown("~~strikethrough~~");
+    expect(result).toContain("strikethrough");
+  });
+
+  it("handles tables (GFM feature)", () => {
+    const markdown = "| Header |\n| ------ |\n| Cell |";
+    const result = parseMarkdown(markdown);
+    expect(result).toContain("<table>");
+    expect(result).toContain("Header");
+    expect(result).toContain("Cell");
+  });
+
+  it("returns plain text with line breaks on parse error", () => {
+    expect(parseMarkdown("Normal text\nWith newline")).toBeTruthy();
+  });
+
+  it("handles special characters", () => {
+    const result = parseMarkdown("Text with & and < and >");
+    expect(result).toContain("&amp;");
+    expect(result).toContain("&lt;");
+    expect(result).toContain("&gt;");
+  });
+
+  it("handles URLs in text", () => {
+    const result = parseMarkdown("Visit https://example.com");
+    expect(result).toBeTruthy();
+  });
+
+  it("parses nested markdown", () => {
+    const result = parseMarkdown("**bold with *italic* inside**");
+    expect(result).toContain("<strong>");
+    expect(result).toContain("<em>");
+  });
+
+  it("handles multiple paragraphs", () => {
+    const result = parseMarkdown("Paragraph 1\n\nParagraph 2");
+    expect(result).toContain("<p>");
+    expect(result).toContain("Paragraph 1");
+    expect(result).toContain("Paragraph 2");
+  });
+});

src/lib/__tests__/stageUtils.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it } from "vitest";
+import { sortStagesByOrder } from "../stageUtils";
+
+describe("sortStagesByOrder", () => {
+  it("sorts stages with order > 0 by their order value", () => {
+    const stages = [
+      { name: "Stage C", stage_order: 3 },
+      { name: "Stage A", stage_order: 1 },
+      { name: "Stage B", stage_order: 2 },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Stage A");
+    expect(sorted[1].name).toBe("Stage B");
+    expect(sorted[2].name).toBe("Stage C");
+  });
+
+  it("places stages with order 0 at the end, sorted alphabetically", () => {
+    const stages = [
+      { name: "Stage B", stage_order: 0 },
+      { name: "Stage A", stage_order: 0 },
+      { name: "Stage C", stage_order: 0 },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Stage A");
+    expect(sorted[1].name).toBe("Stage B");
+    expect(sorted[2].name).toBe("Stage C");
+  });
+
+  it("places ordered stages before unordered stages", () => {
+    const stages = [
+      { name: "Zebra Stage", stage_order: 0 },
+      { name: "Main Stage", stage_order: 1 },
+      { name: "Second Stage", stage_order: 2 },
+      { name: "Alpha Stage", stage_order: 0 },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Main Stage");
+    expect(sorted[1].name).toBe("Second Stage");
+    expect(sorted[2].name).toBe("Alpha Stage");
+    expect(sorted[3].name).toBe("Zebra Stage");
+  });
+
+  it("handles null stage_order as 0", () => {
+    const stages = [
+      { name: "Stage B", stage_order: null },
+      { name: "Stage A", stage_order: 1 },
+      { name: "Stage C", stage_order: null },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Stage A");
+    expect(sorted[1].name).toBe("Stage B");
+    expect(sorted[2].name).toBe("Stage C");
+  });
+
+  it("handles undefined stage_order as 0", () => {
+    const stages = [
+      { name: "Stage B", stage_order: undefined },
+      { name: "Stage A", stage_order: 1 },
+      { name: "Stage C", stage_order: undefined },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Stage A");
+    expect(sorted[1].name).toBe("Stage B");
+    expect(sorted[2].name).toBe("Stage C");
+  });
+
+  it("handles mixed ordered and unordered stages", () => {
+    const stages = [
+      { name: "Unordered Z", stage_order: 0 },
+      { name: "Ordered 3", stage_order: 3 },
+      { name: "Unordered A", stage_order: 0 },
+      { name: "Ordered 1", stage_order: 1 },
+      { name: "Ordered 2", stage_order: 2 },
+      { name: "Unordered M", stage_order: 0 },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Ordered 1");
+    expect(sorted[1].name).toBe("Ordered 2");
+    expect(sorted[2].name).toBe("Ordered 3");
+    expect(sorted[3].name).toBe("Unordered A");
+    expect(sorted[4].name).toBe("Unordered M");
+    expect(sorted[5].name).toBe("Unordered Z");
+  });
+
+  it("handles empty array", () => {
+    const stages: Array<{ name: string; stage_order: number | null }> = [];
+    const sorted = sortStagesByOrder(stages);
+    expect(sorted).toEqual([]);
+  });
+
+  it("handles single stage", () => {
+    const stages = [{ name: "Only Stage", stage_order: 1 }];
+    const sorted = sortStagesByOrder(stages);
+    expect(sorted).toHaveLength(1);
+    expect(sorted[0].name).toBe("Only Stage");
+  });
+
+  it("preserves other properties of stages", () => {
+    const stages = [
+      { name: "Stage B", stage_order: 2, color: "#ff0000", id: "b" },
+      { name: "Stage A", stage_order: 1, color: "#00ff00", id: "a" },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0]).toEqual({
+      name: "Stage A",
+      stage_order: 1,
+      color: "#00ff00",
+      id: "a",
+    });
+    expect(sorted[1]).toEqual({
+      name: "Stage B",
+      stage_order: 2,
+      color: "#ff0000",
+      id: "b",
+    });
+  });
+
+  it("is stable for stages with same order", () => {
+    const stages = [
+      { name: "Stage C", stage_order: 1 },
+      { name: "Stage A", stage_order: 1 },
+      { name: "Stage B", stage_order: 1 },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted).toHaveLength(3);
+    expect(sorted.every((s) => s.stage_order === 1)).toBe(true);
+  });
+
+  it("handles case-sensitive alphabetical sorting", () => {
+    const stages = [
+      { name: "zebra", stage_order: 0 },
+      { name: "Apple", stage_order: 0 },
+      { name: "banana", stage_order: 0 },
+    ];
+
+    const sorted = sortStagesByOrder(stages);
+
+    expect(sorted[0].name).toBe("Apple");
+    expect(sorted[1].name).toBe("banana");
+    expect(sorted[2].name).toBe("zebra");
+  });
+});