@elevasis/core 0.4.0 → 0.6.0

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

@@ -0,0 +1,243 @@
+import { describe, expect, it } from 'vitest'
+import type { QueueTaskStatus } from '../../../commands/queue/types/task'
+import type { TaskStatus } from '../../../business/projects/types'
+import {
+  DEFAULT_ORGANIZATION_MODEL_STATUSES,
+  StatusEntrySchema,
+  StatusesDomainSchema,
+  StatusSemanticClassSchema
+} from '../../domains/statuses'
+
+// ---------------------------------------------------------------------------
+// Group 1: StatusEntrySchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('StatusEntrySchema — positive parse', () => {
+  it('accepts a fully-specified entry (id, label, semanticClass, category)', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 'delivery.task.planned',
+      label: 'Planned',
+      semanticClass: 'delivery.task',
+      category: 'delivery'
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a minimal entry without category (category is optional)', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 'queue.pending',
+      label: 'Pending',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.category).toBeUndefined()
+    }
+  })
+
+  it('trims whitespace from id and label', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: '  trimmed-id  ',
+      label: '  Trimmed Label  ',
+      semanticClass: 'execution'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('trimmed-id')
+      expect(result.data.label).toBe('Trimmed Label')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: StatusEntrySchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('StatusEntrySchema — negative parse', () => {
+  it('rejects a missing id field', () => {
+    const result = StatusEntrySchema.safeParse({
+      label: 'No ID',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a missing label field', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 'queue.pending',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a missing semanticClass field', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 'queue.pending',
+      label: 'Pending'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an unknown semanticClass value', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 'some.entry',
+      label: 'Some Entry',
+      semanticClass: 'not-a-real-class'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a non-string id (number)', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 42,
+      label: 'Label',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an empty string label (min length 1 after trim)', () => {
+    const result = StatusEntrySchema.safeParse({
+      id: 'some.entry',
+      label: '   ',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: StatusesDomainSchema — structural tests
+// ---------------------------------------------------------------------------
+
+describe('StatusesDomainSchema — structural tests', () => {
+  it('accepts an entries-empty domain object', () => {
+    const result = StatusesDomainSchema.safeParse({ entries: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('applies an empty-array default when entries is omitted', () => {
+    const result = StatusesDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.entries).toEqual([])
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: Semantic class enum — all 8 values declared
+// ---------------------------------------------------------------------------
+
+describe('StatusSemanticClassSchema — enum coverage', () => {
+  const expectedClasses = [
+    'delivery.task',
+    'delivery.project',
+    'delivery.milestone',
+    'queue',
+    'execution',
+    'schedule',
+    'schedule.run',
+    'request'
+  ] as const
+
+  it('enum exposes exactly 8 semantic classes', () => {
+    expect(StatusSemanticClassSchema.options).toHaveLength(8)
+  })
+
+  it.each(expectedClasses)('"%s" is a valid semanticClass value', (cls) => {
+    const result = StatusSemanticClassSchema.safeParse(cls)
+    expect(result.success).toBe(true)
+  })
+
+  it('every entry in the seed uses one of the 8 known semanticClass values', () => {
+    const valid = new Set<string>(StatusSemanticClassSchema.options)
+    for (const entry of DEFAULT_ORGANIZATION_MODEL_STATUSES.entries) {
+      expect(
+        valid.has(entry.semanticClass),
+        `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
+      ).toBe(true)
+    }
+  })
+
+  it('all 8 semanticClass values have at least one seed entry', () => {
+    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.map((e) => e.semanticClass))
+    for (const cls of StatusSemanticClassSchema.options) {
+      expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: Seed completeness — per-group counts
+// ---------------------------------------------------------------------------
+
+describe('DEFAULT_ORGANIZATION_MODEL_STATUSES seed — per-group counts', () => {
+  function countBySemClass(cls: string) {
+    return DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.filter((e) => e.semanticClass === cls).length
+  }
+
+  it('has 6 delivery.project entries', () => {
+    expect(countBySemClass('delivery.project')).toBe(6)
+  })
+
+  it('has 5 delivery.milestone entries', () => {
+    expect(countBySemClass('delivery.milestone')).toBe(5)
+  })
+
+  it('has 5 execution entries', () => {
+    expect(countBySemClass('execution')).toBe(5)
+  })
+
+  it('has 4 schedule entries', () => {
+    expect(countBySemClass('schedule')).toBe(4)
+  })
+
+  it('has 4 schedule.run entries', () => {
+    expect(countBySemClass('schedule.run')).toBe(4)
+  })
+
+  it('has 4 request entries', () => {
+    expect(countBySemClass('request')).toBe(4)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 6: QueueTaskStatus values — all 5 present in seed with class "queue"
+// ---------------------------------------------------------------------------
+
+describe('QueueTaskStatus coverage in seed', () => {
+  const queueValues: QueueTaskStatus[] = ['pending', 'processing', 'completed', 'failed', 'expired']
+  const queueIds = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries
+    .filter((e) => e.semanticClass === 'queue')
+    .map((e) => e.id)
+
+  it.each(queueValues)('queue.%s is present as a seed entry id', (status) => {
+    expect(queueIds).toContain(`queue.${status}`)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 7: Delivery TaskStatus values — all 9 present in seed with class "delivery.task"
+// ---------------------------------------------------------------------------
+
+describe('TaskStatus (delivery) coverage in seed', () => {
+  const taskValues: TaskStatus[] = [
+    'planned',
+    'in_progress',
+    'blocked',
+    'submitted',
+    'approved',
+    'revision_requested',
+    'rejected',
+    'cancelled',
+    'completed'
+  ]
+  const taskIds = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries
+    .filter((e) => e.semanticClass === 'delivery.task')
+    .map((e) => e.id)
+
+  it.each(taskValues)('delivery.task.%s is present as a seed entry id', (status) => {
+    expect(taskIds).toContain(`delivery.task.${status}`)
+  })
+})

package/src/organization-model/__tests__/foundation.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest'
+import { createFoundationOrganizationModel } from '../foundation'
+
+describe('createFoundationOrganizationModel', () => {
+  it('builds the foundation model from a branding-only override', () => {
+    const result = createFoundationOrganizationModel({
+      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
+    })
+
+    expect(result.canonical.branding.organizationName).toBe('Acme')
+    expect(result.homeLabel).toBe('Dashboard')
+    expect(result.model.navigation.defaultSurfaceId).toBe('operations')
+
+    const surfaces = result.model.navigation.surfaces
+    expect(surfaces.find((s) => s.id === 'crm')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'lead-gen')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'projects')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'operations')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'settings')).toBeDefined()
+
+    expect(result.quickAccessSurfaceIds).toContain('operations')
+    expect(result.quickAccessSurfaceIds).toContain('projects')
+    expect(result.quickAccessSurfaceIds).toContain('lead-gen')
+    expect(result.quickAccessSurfaceIds).toContain('crm')
+  })
+
+  it('passes deeper overrides through to the canonical model', () => {
+    const result = createFoundationOrganizationModel({
+      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' },
+      sales: {
+        pipelines: [
+          {
+            id: 'custom-pipeline',
+            label: 'Custom Pipeline',
+            description: 'A custom pipeline',
+            entityId: 'crm.deal',
+            stages: [
+              {
+                id: 'stage-1',
+                label: 'Stage 1',
+                color: 'blue',
+                order: 0,
+                semanticClass: 'open' as const,
+                surfaceIds: ['crm.pipeline'],
+                resourceIds: []
+              }
+            ]
+          }
+        ]
+      }
+    })
+
+    expect(result.canonical.sales.pipelines).toHaveLength(1)
+    expect(result.canonical.sales.pipelines[0]?.id).toBe('custom-pipeline')
+  })
+
+  it('exposes a working getOrganizationSurface lookup', () => {
+    const result = createFoundationOrganizationModel({
+      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
+    })
+
+    const crmSurface = result.getOrganizationSurface('crm')
+    expect(crmSurface).toBeDefined()
+    expect(crmSurface?.id).toBe('crm')
+    expect(crmSurface?.icon).toBe('crm')
+
+    expect(result.getOrganizationSurface('nonexistent')).toBeUndefined()
+  })
+
+  it('throws when a required core surface is missing', () => {
+    const override = {
+      features: [
+        {
+          id: 'crm',
+          label: 'CRM',
+          description: 'CRM workspace',
+          enabled: true,
+          color: 'blue',
+          entityIds: [],
+          surfaceIds: ['custom.home'],
+          resourceIds: [],
+          capabilityIds: []
+        }
+      ],
+      navigation: {
+        defaultSurfaceId: 'custom.home',
+        surfaces: [
+          {
+            id: 'custom.home',
+            label: 'Home',
+            path: '/home',
+            surfaceType: 'page' as const,
+            featureIds: ['crm'],
+            entityIds: [],
+            resourceIds: [],
+            capabilityIds: []
+          }
+        ],
+        groups: [{ id: 'primary', label: 'Primary', placement: 'primary', surfaceIds: ['custom.home'] }]
+      }
+    }
+
+    expect(() => createFoundationOrganizationModel(override)).toThrow(/Missing organization surface/)
+  })
+})