@elevasis/core 0.7.0 → 0.8.0

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

@@ -1,347 +1,347 @@
-import { describe, expect, it } from 'vitest'
-import { RoleSchema, RolesDomainSchema, DEFAULT_ORGANIZATION_MODEL_ROLES } from '../../domains/roles'
-import { resolveOrganizationModel } from '../../resolve'
-
-// ---------------------------------------------------------------------------
-// Group 1: RoleSchema — positive parse
-// ---------------------------------------------------------------------------
-
-describe('RoleSchema — positive parse', () => {
-  it('accepts a fully-populated role', () => {
-    const result = RoleSchema.safeParse({
-      id: 'role-ceo',
-      title: 'CEO',
-      responsibilities: ['Set company direction', 'Hire and develop leadership team'],
-      reportsToId: undefined,
-      heldBy: 'Alice Johnson'
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('accepts a minimal role — only id and title required', () => {
-    const result = RoleSchema.safeParse({ id: 'role-minimal', title: 'Head of Sales' })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('role-minimal')
-      expect(result.data.title).toBe('Head of Sales')
-      expect(result.data.responsibilities).toEqual([])
-      expect(result.data.reportsToId).toBeUndefined()
-      expect(result.data.heldBy).toBeUndefined()
-    }
-  })
-
-  it('accepts a role with heldBy set to a name', () => {
-    const result = RoleSchema.safeParse({
-      id: 'role-cfo',
-      title: 'CFO',
-      heldBy: 'Bob Smith'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.heldBy).toBe('Bob Smith')
-    }
-  })
-
-  it('accepts a role with heldBy set to an email address', () => {
-    const result = RoleSchema.safeParse({
-      id: 'role-cto',
-      title: 'CTO',
-      heldBy: 'carol@example.com'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.heldBy).toBe('carol@example.com')
-    }
-  })
-
-  it('accepts a role with a non-empty responsibilities list', () => {
-    const result = RoleSchema.safeParse({
-      id: 'role-ops',
-      title: 'Operations Manager',
-      responsibilities: ['Oversee daily operations', 'Manage vendor relationships', 'Report KPIs']
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.responsibilities).toHaveLength(3)
-    }
-  })
-
-  it('trims whitespace from id and title', () => {
-    const result = RoleSchema.safeParse({
-      id: '  role-trim  ',
-      title: '  Trimmed Title  '
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('role-trim')
-      expect(result.data.title).toBe('Trimmed Title')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 2: RoleSchema — default values
-// ---------------------------------------------------------------------------
-
-describe('RoleSchema — default values', () => {
-  it('responsibilities defaults to empty array when omitted', () => {
-    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.responsibilities).toEqual([])
-    }
-  })
-
-  it('reportsToId is optional — absent by default', () => {
-    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.reportsToId).toBeUndefined()
-    }
-  })
-
-  it('heldBy is optional — absent by default', () => {
-    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.heldBy).toBeUndefined()
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 3: RoleSchema — negative parse
-// ---------------------------------------------------------------------------
-
-describe('RoleSchema — negative parse', () => {
-  it('rejects missing id', () => {
-    const result = RoleSchema.safeParse({ title: 'No ID Role' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects empty string id', () => {
-    const result = RoleSchema.safeParse({ id: '', title: 'Empty ID' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects whitespace-only id (trims to empty string)', () => {
-    const result = RoleSchema.safeParse({ id: '   ', title: 'Whitespace ID' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects missing title', () => {
-    const result = RoleSchema.safeParse({ id: 'role-no-title' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects empty string title', () => {
-    const result = RoleSchema.safeParse({ id: 'role-empty-title', title: '' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects whitespace-only title (trims to empty string)', () => {
-    const result = RoleSchema.safeParse({ id: 'role-whitespace-title', title: '   ' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects responsibilities as a non-array value', () => {
-    const result = RoleSchema.safeParse({
-      id: 'role-bad-resp',
-      title: 'Bad Role',
-      responsibilities: 'single string'
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 4: Plain-language field names assertion
-// No EOS jargon — parsed role must have `title`, `responsibilities`,
-// `reportsToId`, `heldBy` as literal property names; must NOT have
-// `seatTitle`, `accountabilities`, `seat`, or `seats`.
-// ---------------------------------------------------------------------------
-
-describe('RoleSchema — plain-language field names (no EOS jargon)', () => {
-  it('parsed role has the plain-language keys title / responsibilities / reportsToId / heldBy', () => {
-    const result = RoleSchema.safeParse({
-      id: 'role-plain',
-      title: 'Product Lead',
-      responsibilities: ['Own roadmap'],
-      reportsToId: 'role-ceo',
-      heldBy: 'Dave'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      const keys = Object.keys(result.data)
-      expect(keys).toContain('title')
-      expect(keys).toContain('responsibilities')
-      expect(keys).toContain('reportsToId')
-      expect(keys).toContain('heldBy')
-      // Ensure no EOS jargon field names survive
-      expect(keys).not.toContain('seatTitle')
-      expect(keys).not.toContain('accountabilities')
-      expect(keys).not.toContain('seat')
-      expect(keys).not.toContain('seats')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 5: RolesDomainSchema — structural
-// ---------------------------------------------------------------------------
-
-describe('RolesDomainSchema — structural', () => {
-  it('accepts an empty roles array', () => {
-    const result = RolesDomainSchema.safeParse({ roles: [] })
-    expect(result.success).toBe(true)
-  })
-
-  it('defaults roles to empty array when key is omitted', () => {
-    const result = RolesDomainSchema.safeParse({})
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.roles).toEqual([])
-    }
-  })
-
-  it('accepts multiple valid roles', () => {
-    const result = RolesDomainSchema.safeParse({
-      roles: [
-        { id: 'role-a', title: 'CEO' },
-        { id: 'role-b', title: 'COO', reportsToId: 'role-a' }
-      ]
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.roles).toHaveLength(2)
-    }
-  })
-
-  it('rejects roles as a non-array value', () => {
-    const result = RolesDomainSchema.safeParse({ roles: 'not an array' })
-    expect(result.success).toBe(false)
-  })
-
-  it('DEFAULT_ORGANIZATION_MODEL_ROLES constant matches schema parse of empty object', () => {
-    const result = RolesDomainSchema.safeParse({})
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_ROLES)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 6: Cross-ref validation — reportsToId via resolveOrganizationModel
-// ---------------------------------------------------------------------------
-
-describe('resolveOrganizationModel — roles cross-ref (reportsToId)', () => {
-  it('passes when reportsToId references a declared role id', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: {
-          roles: [
-            { id: 'role-ceo', title: 'CEO' },
-            { id: 'role-coo', title: 'COO', reportsToId: 'role-ceo' }
-          ]
-        }
-      })
-    ).not.toThrow()
-  })
-
-  it('throws when reportsToId references a non-existent role', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: {
-          roles: [{ id: 'role-orphan', title: 'Orphan Role', reportsToId: 'nonexistent-role' }]
-        }
-      })
-    ).toThrow()
-  })
-
-  it('throws with a message referencing the unknown reportsToId', () => {
-    let errorMessage = ''
-    try {
-      resolveOrganizationModel({
-        roles: {
-          roles: [{ id: 'role-bad-ref', title: 'Bad Ref Role', reportsToId: 'ghost-role' }]
-        }
-      })
-    } catch (e) {
-      errorMessage = String(e)
-    }
-    expect(errorMessage).toContain('ghost-role')
-  })
-
-  it('passes when reportsToId is absent (top-level role, no reporting line)', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: {
-          roles: [{ id: 'role-top', title: 'Top Level Role' }]
-        }
-      })
-    ).not.toThrow()
-  })
-
-  it('passes when multiple roles form a valid reporting chain', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: {
-          roles: [
-            { id: 'role-ceo', title: 'CEO' },
-            { id: 'role-vp', title: 'VP of Engineering', reportsToId: 'role-ceo' },
-            { id: 'role-eng', title: 'Senior Engineer', reportsToId: 'role-vp' }
-          ]
-        }
-      })
-    ).not.toThrow()
-  })
-
-  it('passes when roles array is empty (no refs to validate)', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: { roles: [] }
-      })
-    ).not.toThrow()
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 7: Integration — resolveOrganizationModel general
-// ---------------------------------------------------------------------------
-
-describe('resolveOrganizationModel — roles domain integration', () => {
-  it('merges partial roles override and preserves empty roles default', () => {
-    const model = resolveOrganizationModel({ roles: { roles: [] } })
-    expect(model.roles.roles).toEqual([])
-  })
-
-  it('omitting roles key entirely resolves to default empty roles', () => {
-    const model = resolveOrganizationModel({})
-    expect(model.roles).toBeDefined()
-    expect(model.roles.roles).toEqual([])
-  })
-
-  it('does not bleed roles changes into other top-level domains', () => {
-    const model = resolveOrganizationModel({
-      roles: {
-        roles: [{ id: 'role-ceo', title: 'CEO' }]
-      }
-    })
-    expect(model.identity).toBeDefined()
-    expect(model.customers).toBeDefined()
-    expect(model.offerings).toBeDefined()
-    expect(model.features).toBeDefined()
-    expect(model.navigation).toBeDefined()
-  })
-
-  it('resolved model includes roles domain alongside other new domains', () => {
-    const model = resolveOrganizationModel({
-      customers: { segments: [{ id: 'seg-a', name: 'Segment A' }] },
-      roles: { roles: [{ id: 'role-ceo', title: 'CEO', heldBy: 'Alice' }] }
-    })
-    expect(model.customers.segments).toHaveLength(1)
-    expect(model.roles.roles).toHaveLength(1)
-    expect(model.roles.roles[0].heldBy).toBe('Alice')
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { RoleSchema, RolesDomainSchema, DEFAULT_ORGANIZATION_MODEL_ROLES } from '../../domains/roles'
+import { resolveOrganizationModel } from '../../resolve'
+
+// ---------------------------------------------------------------------------
+// Group 1: RoleSchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — positive parse', () => {
+  it('accepts a fully-populated role', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-ceo',
+      title: 'CEO',
+      responsibilities: ['Set company direction', 'Hire and develop leadership team'],
+      reportsToId: undefined,
+      heldBy: 'Alice Johnson'
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a minimal role — only id and title required', () => {
+    const result = RoleSchema.safeParse({ id: 'role-minimal', title: 'Head of Sales' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('role-minimal')
+      expect(result.data.title).toBe('Head of Sales')
+      expect(result.data.responsibilities).toEqual([])
+      expect(result.data.reportsToId).toBeUndefined()
+      expect(result.data.heldBy).toBeUndefined()
+    }
+  })
+
+  it('accepts a role with heldBy set to a name', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-cfo',
+      title: 'CFO',
+      heldBy: 'Bob Smith'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.heldBy).toBe('Bob Smith')
+    }
+  })
+
+  it('accepts a role with heldBy set to an email address', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-cto',
+      title: 'CTO',
+      heldBy: 'carol@example.com'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.heldBy).toBe('carol@example.com')
+    }
+  })
+
+  it('accepts a role with a non-empty responsibilities list', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-ops',
+      title: 'Operations Manager',
+      responsibilities: ['Oversee daily operations', 'Manage vendor relationships', 'Report KPIs']
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.responsibilities).toHaveLength(3)
+    }
+  })
+
+  it('trims whitespace from id and title', () => {
+    const result = RoleSchema.safeParse({
+      id: '  role-trim  ',
+      title: '  Trimmed Title  '
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('role-trim')
+      expect(result.data.title).toBe('Trimmed Title')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: RoleSchema — default values
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — default values', () => {
+  it('responsibilities defaults to empty array when omitted', () => {
+    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.responsibilities).toEqual([])
+    }
+  })
+
+  it('reportsToId is optional — absent by default', () => {
+    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.reportsToId).toBeUndefined()
+    }
+  })
+
+  it('heldBy is optional — absent by default', () => {
+    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.heldBy).toBeUndefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: RoleSchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — negative parse', () => {
+  it('rejects missing id', () => {
+    const result = RoleSchema.safeParse({ title: 'No ID Role' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string id', () => {
+    const result = RoleSchema.safeParse({ id: '', title: 'Empty ID' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects whitespace-only id (trims to empty string)', () => {
+    const result = RoleSchema.safeParse({ id: '   ', title: 'Whitespace ID' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing title', () => {
+    const result = RoleSchema.safeParse({ id: 'role-no-title' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string title', () => {
+    const result = RoleSchema.safeParse({ id: 'role-empty-title', title: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects whitespace-only title (trims to empty string)', () => {
+    const result = RoleSchema.safeParse({ id: 'role-whitespace-title', title: '   ' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects responsibilities as a non-array value', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-bad-resp',
+      title: 'Bad Role',
+      responsibilities: 'single string'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: Plain-language field names assertion
+// No EOS jargon — parsed role must have `title`, `responsibilities`,
+// `reportsToId`, `heldBy` as literal property names; must NOT have
+// `seatTitle`, `accountabilities`, `seat`, or `seats`.
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — plain-language field names (no EOS jargon)', () => {
+  it('parsed role has the plain-language keys title / responsibilities / reportsToId / heldBy', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-plain',
+      title: 'Product Lead',
+      responsibilities: ['Own roadmap'],
+      reportsToId: 'role-ceo',
+      heldBy: 'Dave'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      const keys = Object.keys(result.data)
+      expect(keys).toContain('title')
+      expect(keys).toContain('responsibilities')
+      expect(keys).toContain('reportsToId')
+      expect(keys).toContain('heldBy')
+      // Ensure no EOS jargon field names survive
+      expect(keys).not.toContain('seatTitle')
+      expect(keys).not.toContain('accountabilities')
+      expect(keys).not.toContain('seat')
+      expect(keys).not.toContain('seats')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: RolesDomainSchema — structural
+// ---------------------------------------------------------------------------
+
+describe('RolesDomainSchema — structural', () => {
+  it('accepts an empty roles array', () => {
+    const result = RolesDomainSchema.safeParse({ roles: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('defaults roles to empty array when key is omitted', () => {
+    const result = RolesDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.roles).toEqual([])
+    }
+  })
+
+  it('accepts multiple valid roles', () => {
+    const result = RolesDomainSchema.safeParse({
+      roles: [
+        { id: 'role-a', title: 'CEO' },
+        { id: 'role-b', title: 'COO', reportsToId: 'role-a' }
+      ]
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.roles).toHaveLength(2)
+    }
+  })
+
+  it('rejects roles as a non-array value', () => {
+    const result = RolesDomainSchema.safeParse({ roles: 'not an array' })
+    expect(result.success).toBe(false)
+  })
+
+  it('DEFAULT_ORGANIZATION_MODEL_ROLES constant matches schema parse of empty object', () => {
+    const result = RolesDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_ROLES)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 6: Cross-ref validation — reportsToId via resolveOrganizationModel
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — roles cross-ref (reportsToId)', () => {
+  it('passes when reportsToId references a declared role id', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [
+            { id: 'role-ceo', title: 'CEO' },
+            { id: 'role-coo', title: 'COO', reportsToId: 'role-ceo' }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when reportsToId references a non-existent role', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [{ id: 'role-orphan', title: 'Orphan Role', reportsToId: 'nonexistent-role' }]
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws with a message referencing the unknown reportsToId', () => {
+    let errorMessage = ''
+    try {
+      resolveOrganizationModel({
+        roles: {
+          roles: [{ id: 'role-bad-ref', title: 'Bad Ref Role', reportsToId: 'ghost-role' }]
+        }
+      })
+    } catch (e) {
+      errorMessage = String(e)
+    }
+    expect(errorMessage).toContain('ghost-role')
+  })
+
+  it('passes when reportsToId is absent (top-level role, no reporting line)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [{ id: 'role-top', title: 'Top Level Role' }]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('passes when multiple roles form a valid reporting chain', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [
+            { id: 'role-ceo', title: 'CEO' },
+            { id: 'role-vp', title: 'VP of Engineering', reportsToId: 'role-ceo' },
+            { id: 'role-eng', title: 'Senior Engineer', reportsToId: 'role-vp' }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('passes when roles array is empty (no refs to validate)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: { roles: [] }
+      })
+    ).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 7: Integration — resolveOrganizationModel general
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — roles domain integration', () => {
+  it('merges partial roles override and preserves empty roles default', () => {
+    const model = resolveOrganizationModel({ roles: { roles: [] } })
+    expect(model.roles.roles).toEqual([])
+  })
+
+  it('omitting roles key entirely resolves to default empty roles', () => {
+    const model = resolveOrganizationModel({})
+    expect(model.roles).toBeDefined()
+    expect(model.roles.roles).toEqual([])
+  })
+
+  it('does not bleed roles changes into other top-level domains', () => {
+    const model = resolveOrganizationModel({
+      roles: {
+        roles: [{ id: 'role-ceo', title: 'CEO' }]
+      }
+    })
+    expect(model.identity).toBeDefined()
+    expect(model.customers).toBeDefined()
+    expect(model.offerings).toBeDefined()
+    expect(model.features).toBeDefined()
+    expect(model.navigation).toBeDefined()
+  })
+
+  it('resolved model includes roles domain alongside other new domains', () => {
+    const model = resolveOrganizationModel({
+      customers: { segments: [{ id: 'seg-a', name: 'Segment A' }] },
+      roles: { roles: [{ id: 'role-ceo', title: 'CEO', heldBy: 'Alice' }] }
+    })
+    expect(model.customers.segments).toHaveLength(1)
+    expect(model.roles.roles).toHaveLength(1)
+    expect(model.roles.roles[0].heldBy).toBe('Alice')
+  })
+})