@elevasis/core 0.7.0 → 0.8.0

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

@@ -1,203 +1,203 @@
-import { describe, expect, it } from 'vitest'
-import {
-  DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
-  OperationEntrySchema,
-  OperationsDomainSchema,
-  OperationSemanticClassSchema
-} from '../../domains/operations'
-
-// ---------------------------------------------------------------------------
-// Group 1: OperationEntrySchema — positive parse
-// ---------------------------------------------------------------------------
-
-describe('OperationEntrySchema — positive parse', () => {
-  it('accepts a fully-specified entry (id, label, semanticClass, featureId, supportedStatusSemanticClass)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      label: 'HITL Queue',
-      semanticClass: 'queue',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['queue']
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('accepts a minimal entry without optional fields', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.sessions',
-      label: 'Sessions',
-      semanticClass: 'sessions'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.featureId).toBeUndefined()
-      expect(result.data.supportedStatusSemanticClass).toBeUndefined()
-    }
-  })
-
-  it('trims whitespace from id and label', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: '  trimmed-id  ',
-      label: '  Trimmed Label  ',
-      semanticClass: 'executions'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('trimmed-id')
-      expect(result.data.label).toBe('Trimmed Label')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 2: OperationEntrySchema — negative parse
-// ---------------------------------------------------------------------------
-
-describe('OperationEntrySchema — negative parse', () => {
-  it('rejects a missing id field', () => {
-    const result = OperationEntrySchema.safeParse({
-      label: 'No ID',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a missing label field', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a missing semanticClass field', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      label: 'HITL Queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an unknown semanticClass value', () => {
-    const result = OperationEntrySchema.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 = OperationEntrySchema.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 = OperationEntrySchema.safeParse({
-      id: 'some.entry',
-      label: '   ',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 3: OperationsDomainSchema — structural tests
-// ---------------------------------------------------------------------------
-
-describe('OperationsDomainSchema — structural tests', () => {
-  it('accepts an entries-empty domain object', () => {
-    const result = OperationsDomainSchema.safeParse({ entries: [] })
-    expect(result.success).toBe(true)
-  })
-
-  it('applies an empty-array default when entries is omitted', () => {
-    const result = OperationsDomainSchema.safeParse({})
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.entries).toEqual([])
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 4: Semantic class enum — all 5 values declared
-// ---------------------------------------------------------------------------
-
-describe('OperationSemanticClassSchema — enum coverage', () => {
-  const expectedClasses = ['queue', 'executions', 'sessions', 'notifications', 'schedules'] as const
-
-  it('enum exposes exactly 5 semantic classes', () => {
-    expect(OperationSemanticClassSchema.options).toHaveLength(5)
-  })
-
-  it.each(expectedClasses)('"%s" is a valid semanticClass value', (cls) => {
-    const result = OperationSemanticClassSchema.safeParse(cls)
-    expect(result.success).toBe(true)
-  })
-
-  it('every entry in the seed uses one of the 5 known semanticClass values', () => {
-    const valid = new Set<string>(OperationSemanticClassSchema.options)
-    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
-      expect(
-        valid.has(entry.semanticClass),
-        `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
-      ).toBe(true)
-    }
-  })
-
-  it('all 5 semanticClass values have exactly one seed entry', () => {
-    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.semanticClass))
-    for (const cls of OperationSemanticClassSchema.options) {
-      expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 5: Seed completeness
-// ---------------------------------------------------------------------------
-
-describe('DEFAULT_ORGANIZATION_MODEL_OPERATIONS seed — completeness', () => {
-  it('has exactly 5 entries (one per entity category)', () => {
-    expect(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries).toHaveLength(5)
-  })
-
-  it('all entry ids are unique', () => {
-    const ids = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.id)
-    const uniqueIds = new Set(ids)
-    expect(uniqueIds.size).toBe(ids.length)
-  })
-
-  it('every entry has a non-empty id, label, and semanticClass', () => {
-    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
-      expect(entry.id.length).toBeGreaterThan(0)
-      expect(entry.label.length).toBeGreaterThan(0)
-      expect(entry.semanticClass.length).toBeGreaterThan(0)
-    }
-  })
-
-  it('queue entry references queue status semantic class', () => {
-    const queueEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'queue')
-    expect(queueEntry).toBeDefined()
-    expect(queueEntry?.supportedStatusSemanticClass).toContain('queue')
-  })
-
-  it('executions entry references execution status semantic class', () => {
-    const execEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'executions')
-    expect(execEntry).toBeDefined()
-    expect(execEntry?.supportedStatusSemanticClass).toContain('execution')
-  })
-
-  it('schedules entry references schedule and schedule.run status semantic classes', () => {
-    const schedEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'schedules')
-    expect(schedEntry).toBeDefined()
-    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule')
-    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule.run')
-  })
-})
+import { describe, expect, it } from 'vitest'
+import {
+  DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
+  OperationEntrySchema,
+  OperationsDomainSchema,
+  OperationSemanticClassSchema
+} from '../../domains/operations'
+
+// ---------------------------------------------------------------------------
+// Group 1: OperationEntrySchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('OperationEntrySchema — positive parse', () => {
+  it('accepts a fully-specified entry (id, label, semanticClass, featureId, supportedStatusSemanticClass)', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.queue',
+      label: 'HITL Queue',
+      semanticClass: 'queue',
+      featureId: 'operations',
+      supportedStatusSemanticClass: ['queue']
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a minimal entry without optional fields', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.sessions',
+      label: 'Sessions',
+      semanticClass: 'sessions'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.featureId).toBeUndefined()
+      expect(result.data.supportedStatusSemanticClass).toBeUndefined()
+    }
+  })
+
+  it('trims whitespace from id and label', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: '  trimmed-id  ',
+      label: '  Trimmed Label  ',
+      semanticClass: 'executions'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('trimmed-id')
+      expect(result.data.label).toBe('Trimmed Label')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: OperationEntrySchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('OperationEntrySchema — negative parse', () => {
+  it('rejects a missing id field', () => {
+    const result = OperationEntrySchema.safeParse({
+      label: 'No ID',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a missing label field', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.queue',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a missing semanticClass field', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.queue',
+      label: 'HITL Queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an unknown semanticClass value', () => {
+    const result = OperationEntrySchema.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 = OperationEntrySchema.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 = OperationEntrySchema.safeParse({
+      id: 'some.entry',
+      label: '   ',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: OperationsDomainSchema — structural tests
+// ---------------------------------------------------------------------------
+
+describe('OperationsDomainSchema — structural tests', () => {
+  it('accepts an entries-empty domain object', () => {
+    const result = OperationsDomainSchema.safeParse({ entries: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('applies an empty-array default when entries is omitted', () => {
+    const result = OperationsDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.entries).toEqual([])
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: Semantic class enum — all 5 values declared
+// ---------------------------------------------------------------------------
+
+describe('OperationSemanticClassSchema — enum coverage', () => {
+  const expectedClasses = ['queue', 'executions', 'sessions', 'notifications', 'schedules'] as const
+
+  it('enum exposes exactly 5 semantic classes', () => {
+    expect(OperationSemanticClassSchema.options).toHaveLength(5)
+  })
+
+  it.each(expectedClasses)('"%s" is a valid semanticClass value', (cls) => {
+    const result = OperationSemanticClassSchema.safeParse(cls)
+    expect(result.success).toBe(true)
+  })
+
+  it('every entry in the seed uses one of the 5 known semanticClass values', () => {
+    const valid = new Set<string>(OperationSemanticClassSchema.options)
+    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
+      expect(
+        valid.has(entry.semanticClass),
+        `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
+      ).toBe(true)
+    }
+  })
+
+  it('all 5 semanticClass values have exactly one seed entry', () => {
+    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.semanticClass))
+    for (const cls of OperationSemanticClassSchema.options) {
+      expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: Seed completeness
+// ---------------------------------------------------------------------------
+
+describe('DEFAULT_ORGANIZATION_MODEL_OPERATIONS seed — completeness', () => {
+  it('has exactly 5 entries (one per entity category)', () => {
+    expect(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries).toHaveLength(5)
+  })
+
+  it('all entry ids are unique', () => {
+    const ids = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.id)
+    const uniqueIds = new Set(ids)
+    expect(uniqueIds.size).toBe(ids.length)
+  })
+
+  it('every entry has a non-empty id, label, and semanticClass', () => {
+    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
+      expect(entry.id.length).toBeGreaterThan(0)
+      expect(entry.label.length).toBeGreaterThan(0)
+      expect(entry.semanticClass.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('queue entry references queue status semantic class', () => {
+    const queueEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'queue')
+    expect(queueEntry).toBeDefined()
+    expect(queueEntry?.supportedStatusSemanticClass).toContain('queue')
+  })
+
+  it('executions entry references execution status semantic class', () => {
+    const execEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'executions')
+    expect(execEntry).toBeDefined()
+    expect(execEntry?.supportedStatusSemanticClass).toContain('execution')
+  })
+
+  it('schedules entry references schedule and schedule.run status semantic classes', () => {
+    const schedEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'schedules')
+    expect(schedEntry).toBeDefined()
+    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule')
+    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule.run')
+  })
+})