@elevasis/core 0.5.0 → 0.6.0

package/src/organization-model/__tests__/domains/goals.test.ts

@@ -0,0 +1,479 @@
+import { describe, expect, it } from 'vitest'
+import {
+  KeyResultSchema,
+  ObjectiveSchema,
+  GoalsDomainSchema,
+  DEFAULT_ORGANIZATION_MODEL_GOALS
+} from '../../domains/goals'
+import { resolveOrganizationModel } from '../../resolve'
+
+// ---------------------------------------------------------------------------
+// Group 1: KeyResultSchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('KeyResultSchema — positive parse', () => {
+  it('accepts a fully-populated measurable outcome', () => {
+    const result = KeyResultSchema.safeParse({
+      id: 'kr-revenue-q1',
+      description: 'Increase monthly recurring revenue',
+      targetMetric: 'monthly revenue',
+      currentValue: 12000,
+      targetValue: 20000
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('kr-revenue-q1')
+      expect(result.data.currentValue).toBe(12000)
+      expect(result.data.targetValue).toBe(20000)
+    }
+  })
+
+  it('accepts a minimal measurable outcome — targetValue optional', () => {
+    const result = KeyResultSchema.safeParse({
+      id: 'kr-nps',
+      description: 'Improve net promoter score',
+      targetMetric: 'NPS score'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.currentValue).toBe(0)
+      expect(result.data.targetValue).toBeUndefined()
+    }
+  })
+
+  it('currentValue defaults to 0 when omitted', () => {
+    const result = KeyResultSchema.safeParse({
+      id: 'kr-default',
+      description: 'Reduce churn',
+      targetMetric: 'monthly churn rate'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.currentValue).toBe(0)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: KeyResultSchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('KeyResultSchema — negative parse', () => {
+  it('rejects missing id', () => {
+    const result = KeyResultSchema.safeParse({
+      description: 'No id provided',
+      targetMetric: 'something'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string id', () => {
+    const result = KeyResultSchema.safeParse({
+      id: '',
+      description: 'Empty id',
+      targetMetric: 'something'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing description', () => {
+    const result = KeyResultSchema.safeParse({
+      id: 'kr-no-desc',
+      targetMetric: 'something'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string description', () => {
+    const result = KeyResultSchema.safeParse({
+      id: 'kr-empty-desc',
+      description: '',
+      targetMetric: 'something'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: ObjectiveSchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('ObjectiveSchema — positive parse', () => {
+  it('accepts a fully-populated objective with measurable outcomes', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-grow-arr-q1-2026',
+      description: 'Grow annual recurring revenue by 50% in Q1 2026',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-03-31',
+      keyResults: [
+        {
+          id: 'kr-arr',
+          description: 'Reach $500k ARR',
+          targetMetric: 'annual recurring revenue',
+          currentValue: 330000,
+          targetValue: 500000
+        }
+      ]
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('goal-grow-arr-q1-2026')
+      expect(result.data.keyResults).toHaveLength(1)
+      expect(result.data.keyResults[0].id).toBe('kr-arr')
+    }
+  })
+
+  it('accepts a minimal objective — no measurable outcomes', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-minimal',
+      description: 'Establish brand presence in new market',
+      periodStart: '2026-04-01',
+      periodEnd: '2026-06-30'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.keyResults).toEqual([])
+    }
+  })
+
+  it('keyResults defaults to empty array when omitted', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-defaults',
+      description: 'Launch new product line',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.keyResults).toEqual([])
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: ObjectiveSchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('ObjectiveSchema — negative parse', () => {
+  it('rejects missing id', () => {
+    const result = ObjectiveSchema.safeParse({
+      description: 'No id provided',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string id', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: '',
+      description: 'Empty id',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing description', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-no-desc',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string description', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-empty-desc',
+      description: '',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects periodStart with wrong date format (non-ISO string)', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-bad-start',
+      description: 'Bad date format',
+      periodStart: '01/01/2026',
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects periodEnd with wrong date format (non-ISO string)', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-bad-end',
+      description: 'Bad date format',
+      periodStart: '2026-01-01',
+      periodEnd: 'December 31, 2026'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects periodStart as a Date object (must be ISO string)', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-date-obj',
+      description: 'Date object not allowed',
+      periodStart: new Date('2026-01-01'),
+      periodEnd: '2026-12-31'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: GoalsDomainSchema — structural
+// ---------------------------------------------------------------------------
+
+describe('GoalsDomainSchema — structural', () => {
+  it('accepts an empty objectives array', () => {
+    const result = GoalsDomainSchema.safeParse({ objectives: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('defaults objectives to empty array when key is omitted', () => {
+    const result = GoalsDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.objectives).toEqual([])
+    }
+  })
+
+  it('DEFAULT_ORGANIZATION_MODEL_GOALS constant matches schema parse of empty object', () => {
+    const result = GoalsDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_GOALS)
+    }
+  })
+
+  it('accepts multiple valid objectives', () => {
+    const result = GoalsDomainSchema.safeParse({
+      objectives: [
+        { id: 'goal-a', description: 'First goal', periodStart: '2026-01-01', periodEnd: '2026-03-31' },
+        { id: 'goal-b', description: 'Second goal', periodStart: '2026-04-01', periodEnd: '2026-06-30' }
+      ]
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.objectives).toHaveLength(2)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 6: Plain-language field names assertion
+// Schema must NOT expose OKR jargon as a top-level property name.
+// Field name `keyResults` is kept for tooling compat but "okr" must not appear.
+// ---------------------------------------------------------------------------
+
+describe('ObjectiveSchema — plain-language field names (no OKR jargon exposed)', () => {
+  it('parsed objective has expected field names including keyResults for tooling compat', () => {
+    const result = ObjectiveSchema.safeParse({
+      id: 'goal-plain',
+      description: 'Expand into new markets',
+      periodStart: '2026-01-01',
+      periodEnd: '2026-12-31',
+      keyResults: []
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      const keys = Object.keys(result.data)
+      expect(keys).toContain('id')
+      expect(keys).toContain('description')
+      expect(keys).toContain('periodStart')
+      expect(keys).toContain('periodEnd')
+      expect(keys).toContain('keyResults')
+      // No top-level property named "okr" — user-facing labels use "goals"
+      expect(keys).not.toContain('okr')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 7: Period-range validation via resolveOrganizationModel
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — goals period-range validation', () => {
+  it('passes when periodEnd is strictly after periodStart', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        goals: {
+          objectives: [
+            {
+              id: 'goal-valid',
+              description: 'Valid date range',
+              periodStart: '2026-01-01',
+              periodEnd: '2026-12-31'
+            }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('passes when periodEnd is the next day after periodStart', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        goals: {
+          objectives: [
+            {
+              id: 'goal-one-day',
+              description: 'Single day range',
+              periodStart: '2026-06-01',
+              periodEnd: '2026-06-02'
+            }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when periodEnd equals periodStart', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        goals: {
+          objectives: [
+            {
+              id: 'goal-same-date',
+              description: 'Same start and end',
+              periodStart: '2026-03-01',
+              periodEnd: '2026-03-01'
+            }
+          ]
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws when periodEnd is before periodStart', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        goals: {
+          objectives: [
+            {
+              id: 'goal-reversed',
+              description: 'Reversed date range',
+              periodStart: '2026-12-31',
+              periodEnd: '2026-01-01'
+            }
+          ]
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws with a message referencing periodEnd path', () => {
+    let errorMessage = ''
+    try {
+      resolveOrganizationModel({
+        goals: {
+          objectives: [
+            {
+              id: 'goal-bad-range',
+              description: 'Bad range for error message check',
+              periodStart: '2026-06-01',
+              periodEnd: '2026-01-01'
+            }
+          ]
+        }
+      })
+    } catch (e) {
+      errorMessage = String(e)
+    }
+    expect(errorMessage).toContain('periodEnd')
+  })
+
+  it('passes when goals objectives array is empty (no ranges to validate)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        goals: { objectives: [] }
+      })
+    ).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 8: Integration — resolveOrganizationModel general
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — goals domain integration', () => {
+  it('omitting goals key entirely resolves to default empty objectives', () => {
+    const model = resolveOrganizationModel({})
+    expect(model.goals).toBeDefined()
+    expect(model.goals.objectives).toEqual([])
+  })
+
+  it('merges partial goals override and preserves empty objectives default', () => {
+    const model = resolveOrganizationModel({ goals: { objectives: [] } })
+    expect(model.goals.objectives).toEqual([])
+  })
+
+  it('goals domain is registered after roles — both present in resolved model', () => {
+    const model = resolveOrganizationModel({
+      roles: { roles: [{ id: 'role-ceo', title: 'CEO' }] },
+      goals: {
+        objectives: [
+          {
+            id: 'goal-grow',
+            description: 'Grow the business',
+            periodStart: '2026-01-01',
+            periodEnd: '2026-12-31'
+          }
+        ]
+      }
+    })
+    expect(model.roles.roles).toHaveLength(1)
+    expect(model.goals.objectives).toHaveLength(1)
+    expect(model.goals.objectives[0].id).toBe('goal-grow')
+  })
+
+  it('does not bleed goals changes into other top-level domains', () => {
+    const model = resolveOrganizationModel({
+      goals: {
+        objectives: [
+          {
+            id: 'goal-isolated',
+            description: 'Should not affect other domains',
+            periodStart: '2026-01-01',
+            periodEnd: '2026-06-30'
+          }
+        ]
+      }
+    })
+    expect(model.identity).toBeDefined()
+    expect(model.customers).toBeDefined()
+    expect(model.offerings).toBeDefined()
+    expect(model.roles).toBeDefined()
+    expect(model.features).toBeDefined()
+  })
+
+  it('resolved objective carries keyResults with defaulted currentValue', () => {
+    const model = resolveOrganizationModel({
+      goals: {
+        objectives: [
+          {
+            id: 'goal-with-kr',
+            description: 'Goal with measurable outcomes',
+            periodStart: '2026-01-01',
+            periodEnd: '2026-12-31',
+            keyResults: [
+              {
+                id: 'kr-1',
+                description: 'Hit revenue target',
+                targetMetric: 'monthly revenue',
+                targetValue: 50000
+              }
+            ]
+          }
+        ]
+      }
+    })
+    expect(model.goals.objectives[0].keyResults).toHaveLength(1)
+    expect(model.goals.objectives[0].keyResults[0].currentValue).toBe(0)
+    expect(model.goals.objectives[0].keyResults[0].targetValue).toBe(50000)
+  })
+})