@startsimpli/ui 0.4.6 → 0.4.8

package/src/components/gantt/__tests__/gantt-utils.test.ts

@@ -0,0 +1,341 @@
+import { parseDateRangeFromTitle, getHierarchyLevel } from '../lib/dates'
+import {
+  calculateExpectedProgress,
+  calculateHealthStatus,
+  getHealthColor,
+} from '../lib/progress'
+
+// ---------------------------------------------------------------------------
+// dates.ts
+// ---------------------------------------------------------------------------
+
+describe('parseDateRangeFromTitle', () => {
+  const REF_YEAR = 2025
+
+  describe('no tag prefix', () => {
+    it('returns null when title has no bracket tag', () => {
+      expect(parseDateRangeFromTitle('Plain title', REF_YEAR)).toBeNull()
+    })
+
+    it('returns null for empty string', () => {
+      expect(parseDateRangeFromTitle('', REF_YEAR)).toBeNull()
+    })
+  })
+
+  describe('year range — Nyr', () => {
+    it('parses [1yr] as the reference year', () => {
+      const result = parseDateRangeFromTitle('[1yr] Company goal', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getFullYear()).toBe(REF_YEAR)
+      expect(result!.start.getMonth()).toBe(0)
+      expect(result!.start.getDate()).toBe(1)
+      expect(result!.end.getFullYear()).toBe(REF_YEAR)
+    })
+
+    it('parses [3yr] spanning three years from the reference year', () => {
+      const result = parseDateRangeFromTitle('[3yr] Three-year plan', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getFullYear()).toBe(REF_YEAR)
+      expect(result!.end.getFullYear()).toBe(REF_YEAR + 2)
+    })
+
+    it('is case-insensitive — [2YR] works', () => {
+      const result = parseDateRangeFromTitle('[2YR] Two-year plan', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.end.getFullYear()).toBe(REF_YEAR + 1)
+    })
+  })
+
+  describe('half-year — H1 / H2', () => {
+    it('parses [H1] as Jan 1 – Jun 30', () => {
+      const result = parseDateRangeFromTitle('[H1] First half', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start).toEqual(new Date(REF_YEAR, 0, 1))
+      expect(result!.end).toEqual(new Date(REF_YEAR, 5, 30))
+    })
+
+    it('parses [H2] as Jul 1 – Dec 31', () => {
+      const result = parseDateRangeFromTitle('[H2] Second half', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start).toEqual(new Date(REF_YEAR, 6, 1))
+      expect(result!.end).toEqual(new Date(REF_YEAR, 11, 31))
+    })
+  })
+
+  describe('quarter — Q1–Q4', () => {
+    it('parses [Q1] as Jan–Mar', () => {
+      const result = parseDateRangeFromTitle('[Q1] First quarter', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(0) // Jan
+      expect(result!.end.getMonth()).toBe(2)   // Mar
+    })
+
+    it('parses [Q2] as Apr–Jun', () => {
+      const result = parseDateRangeFromTitle('[Q2] Q2 goals', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(3)
+      expect(result!.end.getMonth()).toBe(5)
+    })
+
+    it('parses [Q3] as Jul–Sep', () => {
+      const result = parseDateRangeFromTitle('[Q3] Q3 goals', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(6)
+      expect(result!.end.getMonth()).toBe(8)
+    })
+
+    it('parses [Q4] as Oct–Dec', () => {
+      const result = parseDateRangeFromTitle('[Q4] Q4 goals', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(9)
+      expect(result!.end.getMonth()).toBe(11)
+    })
+  })
+
+  describe('month tags', () => {
+    it('parses [Jan] as January', () => {
+      const result = parseDateRangeFromTitle('[Jan] January sprint', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(0)
+      expect(result!.end.getMonth()).toBe(0)
+    })
+
+    it('parses [Jun] as June', () => {
+      const result = parseDateRangeFromTitle('[Jun] Mid-year review', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(5)
+      expect(result!.end.getMonth()).toBe(5)
+    })
+
+    it('parses [Dec] as December', () => {
+      const result = parseDateRangeFromTitle('[Dec] Year-end', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getMonth()).toBe(11)
+      expect(result!.end.getMonth()).toBe(11)
+    })
+
+    it('month start date is the 1st', () => {
+      const result = parseDateRangeFromTitle('[Mar] Sprint', REF_YEAR)
+      expect(result!.start.getDate()).toBe(1)
+    })
+  })
+
+  describe('week tags — Wn', () => {
+    it('parses [W1] as the first week of the year', () => {
+      const result = parseDateRangeFromTitle('[W1] Week 1', REF_YEAR)
+      expect(result).not.toBeNull()
+      expect(result!.start.getFullYear()).toBe(REF_YEAR)
+      // W1 should be 7 days
+      const diff = result!.end.getTime() - result!.start.getTime()
+      expect(diff).toBe(6 * 24 * 60 * 60 * 1000)
+    })
+
+    it('parses [W10] as the 10th week', () => {
+      const result = parseDateRangeFromTitle('[W10] Sprint', REF_YEAR)
+      expect(result).not.toBeNull()
+      // W10 starts 63 days into the year (0-indexed: (10-1)*7 = 63)
+      const expectedStart = new Date(REF_YEAR, 0, 1 + 63)
+      expect(result!.start.toDateString()).toBe(expectedStart.toDateString())
+    })
+  })
+
+  describe('unknown tag', () => {
+    it('returns null for an unrecognised bracket tag', () => {
+      expect(parseDateRangeFromTitle('[FOO] Something', REF_YEAR)).toBeNull()
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+
+describe('getHierarchyLevel', () => {
+  it('returns 0 for plain titles with no bracket tag', () => {
+    expect(getHierarchyLevel('Plain milestone')).toBe(0)
+    expect(getHierarchyLevel('')).toBe(0)
+  })
+
+  it('returns highest level (100+) for year tags', () => {
+    expect(getHierarchyLevel('[1yr] Company OKR')).toBe(101)
+    expect(getHierarchyLevel('[3yr] Long-term')).toBe(103)
+  })
+
+  it('returns 50 for H1 / H2 tags', () => {
+    expect(getHierarchyLevel('[H1] First half')).toBe(50)
+    expect(getHierarchyLevel('[H2] Second half')).toBe(50)
+  })
+
+  it('returns 40 for quarter tags', () => {
+    expect(getHierarchyLevel('[Q1] Quarter one')).toBe(40)
+    expect(getHierarchyLevel('[Q4] Quarter four')).toBe(40)
+  })
+
+  it('returns 30 for month tags', () => {
+    expect(getHierarchyLevel('[Jan] January')).toBe(30)
+    expect(getHierarchyLevel('[Dec] December')).toBe(30)
+  })
+
+  it('returns 20 for week tags', () => {
+    expect(getHierarchyLevel('[W1] Week 1')).toBe(20)
+    expect(getHierarchyLevel('[W52] Week 52')).toBe(20)
+  })
+
+  it('returns 10 for unrecognised bracket tags', () => {
+    expect(getHierarchyLevel('[FOO] Something')).toBe(10)
+  })
+
+  it('enforces ordering: year > half > quarter > month > week > custom', () => {
+    const levels = [
+      getHierarchyLevel('[1yr] Goal'),
+      getHierarchyLevel('[H1] Goal'),
+      getHierarchyLevel('[Q2] Goal'),
+      getHierarchyLevel('[Mar] Goal'),
+      getHierarchyLevel('[W5] Goal'),
+      getHierarchyLevel('[FOO] Goal'),
+      getHierarchyLevel('No tag'),
+    ]
+    // Each subsequent level should be strictly less than the previous
+    for (let i = 1; i < levels.length; i++) {
+      expect(levels[i]).toBeLessThan(levels[i - 1])
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// progress.ts
+// ---------------------------------------------------------------------------
+
+describe('calculateExpectedProgress', () => {
+  it('returns 0 when current date equals start date', () => {
+    const start = new Date('2025-01-01')
+    const end = new Date('2025-12-31')
+    expect(calculateExpectedProgress(start, end, start)).toBe(0)
+  })
+
+  it('returns 0 when current date is before start date', () => {
+    const start = new Date('2025-06-01')
+    const end = new Date('2025-12-31')
+    const before = new Date('2025-01-01')
+    expect(calculateExpectedProgress(start, end, before)).toBe(0)
+  })
+
+  it('returns 100 when current date equals end date', () => {
+    const start = new Date('2025-01-01')
+    const end = new Date('2025-12-31')
+    expect(calculateExpectedProgress(start, end, end)).toBe(100)
+  })
+
+  it('returns 100 when current date is after end date', () => {
+    const start = new Date('2025-01-01')
+    const end = new Date('2025-06-01')
+    const after = new Date('2025-12-31')
+    expect(calculateExpectedProgress(start, end, after)).toBe(100)
+  })
+
+  it('returns ~50 when current date is halfway through', () => {
+    const start = new Date('2025-01-01')
+    const end = new Date('2025-01-11') // 10 days
+    const mid = new Date('2025-01-06')  // 5 days elapsed
+    const result = calculateExpectedProgress(start, end, mid)
+    // 5/10 = 50%
+    expect(result).toBe(50)
+  })
+
+  it('returns a value between 0 and 100 exclusive for a mid-point', () => {
+    const start = new Date('2025-01-01')
+    const end = new Date('2025-12-31')
+    const mid = new Date('2025-07-01')
+    const result = calculateExpectedProgress(start, end, mid)
+    expect(result).toBeGreaterThan(0)
+    expect(result).toBeLessThan(100)
+  })
+
+  it('rounds to an integer', () => {
+    const start = new Date('2025-01-01')
+    const end = new Date('2025-01-04') // 3 days
+    const current = new Date('2025-01-02') // 1 day elapsed → 33.33%
+    const result = calculateExpectedProgress(start, end, current)
+    expect(Number.isInteger(result)).toBe(true)
+    expect(result).toBe(33)
+  })
+})
+
+// ---------------------------------------------------------------------------
+
+describe('calculateHealthStatus', () => {
+  it('returns "blocked" when hasBlockers is true, regardless of progress', () => {
+    const result = calculateHealthStatus(80, 30, true)
+    expect(result.status).toBe('blocked')
+    expect(result.reason).toBeDefined()
+  })
+
+  it('returns "not_started" when progress is 0 and expected > 0', () => {
+    const result = calculateHealthStatus(0, 25)
+    expect(result.status).toBe('not_started')
+    expect(result.reason).toBeDefined()
+  })
+
+  it('returns "on_track" when progress is 0 and expected is also 0', () => {
+    const result = calculateHealthStatus(0, 0)
+    expect(result.status).toBe('on_track')
+  })
+
+  it('returns "at_risk" when progress is more than 10 points behind expected', () => {
+    const result = calculateHealthStatus(30, 50) // 20 points behind
+    expect(result.status).toBe('at_risk')
+    expect(result.reason).toBeDefined()
+  })
+
+  it('returns "on_track" when actual progress equals expected', () => {
+    const result = calculateHealthStatus(60, 60)
+    expect(result.status).toBe('on_track')
+  })
+
+  it('returns "on_track" when actual progress is ahead of expected', () => {
+    const result = calculateHealthStatus(70, 50)
+    expect(result.status).toBe('on_track')
+  })
+
+  it('returns "on_track" when actual is exactly 10 points behind (boundary)', () => {
+    // diff = 40 - 50 = -10, which is NOT < -10, so on_track
+    const result = calculateHealthStatus(40, 50)
+    expect(result.status).toBe('on_track')
+  })
+
+  it('returns "at_risk" when actual is 11 points behind (just past boundary)', () => {
+    const result = calculateHealthStatus(39, 50)
+    expect(result.status).toBe('at_risk')
+  })
+
+  it('blocked takes precedence over not_started', () => {
+    const result = calculateHealthStatus(0, 50, true)
+    expect(result.status).toBe('blocked')
+  })
+})
+
+// ---------------------------------------------------------------------------
+
+describe('getHealthColor', () => {
+  it('returns green for on_track', () => {
+    expect(getHealthColor('on_track')).toBe('#22c55e')
+  })
+
+  it('returns yellow for at_risk', () => {
+    expect(getHealthColor('at_risk')).toBe('#eab308')
+  })
+
+  it('returns red for blocked', () => {
+    expect(getHealthColor('blocked')).toBe('#ef4444')
+  })
+
+  it('returns gray for not_started', () => {
+    expect(getHealthColor('not_started')).toBe('#9ca3af')
+  })
+
+  it('returns a non-empty CSS color string for every valid status', () => {
+    const statuses = ['on_track', 'at_risk', 'blocked', 'not_started'] as const
+    for (const s of statuses) {
+      const color = getHealthColor(s)
+      expect(color).toMatch(/^#[0-9a-f]{6}$/i)
+    }
+  })
+})