@elevasis/core 0.21.0 → 0.23.0

package/src/organization-model/__tests__/lookup-helpers.test.ts

@@ -0,0 +1,438 @@
+/**
+ * lookup-helpers.test.ts
+ *
+ * Tests for the Wave 1B recursive system-tree helpers:
+ *   getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent
+ *
+ * NOTE: getSystem / getSystemAncestors / getContent / resolveSystemContent walk
+ * systems via the `subsystems` nesting field (per the Wave 1B docstrings). The
+ * `model.systems` map holds TOP-LEVEL systems only; nested systems live in
+ * `parent.subsystems.<childKey>`. Fixtures must author hierarchies via
+ * `subsystems`, not via flat dot-notation keys in `model.systems`.
+ */
+import { describe, expect, it } from 'vitest'
+import { resolveOrganizationModel } from '../resolve'
+import { getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent } from '../helpers'
+import type { OrganizationModel } from '../types'
+
+// ---------------------------------------------------------------------------
+// Minimal model factory — uses `subsystems` nesting so Wave 1B helpers work
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal valid model with a 3-level nested system tree:
+ *   root (top-level, no content)
+ *   └── mid  (subsystem of root, has content)
+ *       └── leaf (subsystem of mid, has content)
+ */
+function makeNestedModel(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      root: {
+        id: 'root',
+        order: 10,
+        label: 'Root',
+        enabled: true,
+        path: '/root',
+        subsystems: {
+          mid: {
+            id: 'mid',
+            order: 20,
+            label: 'Mid',
+            enabled: true,
+            path: '/root/mid',
+            content: {
+              'mid-pipeline': {
+                kind: 'schema',
+                type: 'pipeline',
+                label: 'Mid Pipeline',
+                data: { entityId: 'crm.deal' }
+              }
+            },
+            subsystems: {
+              leaf: {
+                id: 'leaf',
+                order: 30,
+                label: 'Leaf',
+                enabled: true,
+                path: '/root/mid/leaf',
+                content: {
+                  'leaf-config': {
+                    kind: 'config',
+                    type: 'kv',
+                    label: 'Leaf Config',
+                    data: { entries: { timeout: 5000 } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+/**
+ * Build a model where 'ancestor' has content and 'ancestor.child' (in subsystems)
+ * overrides one localId while inheriting the other.
+ */
+function makeInheritanceModel(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      ancestor: {
+        id: 'ancestor',
+        order: 10,
+        label: 'Ancestor',
+        enabled: true,
+        path: '/ancestor',
+        content: {
+          shared: {
+            kind: 'config',
+            type: 'kv',
+            label: 'Shared Config',
+            order: 10,
+            data: { entries: { globalFlag: true } }
+          },
+          'ancestor-only': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Ancestor Only',
+            order: 20,
+            data: { entries: { ancestorProp: 'yes' } }
+          }
+        },
+        subsystems: {
+          child: {
+            id: 'child',
+            order: 20,
+            label: 'Child',
+            enabled: true,
+            path: '/ancestor/child',
+            content: {
+              // 'shared' localId shadows the ancestor's 'shared' — override
+              shared: {
+                kind: 'config',
+                type: 'kv',
+                label: 'Child Override Config',
+                order: 10,
+                data: { entries: { localFlag: false } }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+// ---------------------------------------------------------------------------
+// getSystem
+// ---------------------------------------------------------------------------
+
+describe('getSystem', () => {
+  it('returns a root-level system by single-segment path', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Root')
+  })
+
+  it('returns a 2-level nested system by dot-separated path', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root.mid')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Mid')
+  })
+
+  it('returns a 3-level nested system by dot-separated path', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root.mid.leaf')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Leaf')
+  })
+
+  it('returns undefined for an unknown top-level segment', () => {
+    const model = makeNestedModel()
+    expect(getSystem(model, 'nonexistent')).toBeUndefined()
+  })
+
+  it('returns undefined when a middle segment is missing', () => {
+    const model = makeNestedModel()
+    expect(getSystem(model, 'root.missing.leaf')).toBeUndefined()
+  })
+
+  it('returns undefined for a path that is too deep (past a leaf)', () => {
+    const model = makeNestedModel()
+    // 'leaf' has no subsystems, so 'root.mid.leaf.deeper' must return undefined
+    expect(getSystem(model, 'root.mid.leaf.deeper')).toBeUndefined()
+  })
+
+  it('returns the content map for a system that has content', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root.mid')
+    expect(sys?.content).toBeDefined()
+    expect(Object.keys(sys?.content ?? {})).toContain('mid-pipeline')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getSystemAncestors
+// ---------------------------------------------------------------------------
+
+describe('getSystemAncestors', () => {
+  it('returns [root] for a single-segment path (root-first order)', () => {
+    const model = makeNestedModel()
+    const ancestors = getSystemAncestors(model, 'root')
+    expect(ancestors).toHaveLength(1)
+    expect(ancestors[0]?.label).toBe('Root')
+  })
+
+  it('returns [root, mid] for a 2-level path', () => {
+    const model = makeNestedModel()
+    const ancestors = getSystemAncestors(model, 'root.mid')
+    expect(ancestors).toHaveLength(2)
+    expect(ancestors[0]?.label).toBe('Root')
+    expect(ancestors[1]?.label).toBe('Mid')
+  })
+
+  it('returns [root, mid, leaf] for a 3-level path', () => {
+    const model = makeNestedModel()
+    const ancestors = getSystemAncestors(model, 'root.mid.leaf')
+    expect(ancestors).toHaveLength(3)
+    expect(ancestors[0]?.label).toBe('Root')
+    expect(ancestors[1]?.label).toBe('Mid')
+    expect(ancestors[2]?.label).toBe('Leaf')
+  })
+
+  it('returns empty array when the path does not resolve', () => {
+    const model = makeNestedModel()
+    expect(getSystemAncestors(model, 'does.not.exist')).toEqual([])
+  })
+
+  it('returns empty array when the first segment is unknown', () => {
+    const model = makeNestedModel()
+    expect(getSystemAncestors(model, 'unknown.mid')).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listAllSystems
+// ---------------------------------------------------------------------------
+
+describe('listAllSystems', () => {
+  it('enumerates root-level systems from the default model', () => {
+    const model = resolveOrganizationModel()
+    const all = listAllSystems(model)
+    const paths = all.map((e) => e.path)
+    // Default model has 'sales', 'dashboard', etc. as top-level systems
+    expect(paths.some((p) => p === 'sales')).toBe(true)
+    expect(paths.some((p) => p === 'dashboard')).toBe(true)
+  })
+
+  it('enumerates nested systems via subsystems when they exist', () => {
+    const model = makeNestedModel()
+    const all = listAllSystems(model)
+    const paths = all.map((e) => e.path)
+    expect(paths).toContain('root')
+    expect(paths).toContain('root.mid')
+    expect(paths).toContain('root.mid.leaf')
+  })
+
+  it('returns pre-order DFS order (parent before children)', () => {
+    const model = makeNestedModel()
+    const all = listAllSystems(model)
+    const rootIdx = all.findIndex((e) => e.path === 'root')
+    const midIdx = all.findIndex((e) => e.path === 'root.mid')
+    const leafIdx = all.findIndex((e) => e.path === 'root.mid.leaf')
+    expect(rootIdx).toBeGreaterThanOrEqual(0)
+    expect(midIdx).toBeGreaterThanOrEqual(0)
+    expect(leafIdx).toBeGreaterThanOrEqual(0)
+    expect(rootIdx).toBeLessThan(midIdx)
+    expect(midIdx).toBeLessThan(leafIdx)
+  })
+
+  it('each entry has a non-empty string path and an object system', () => {
+    const model = makeNestedModel()
+    const all = listAllSystems(model)
+    for (const entry of all) {
+      expect(typeof entry.path).toBe('string')
+      expect(entry.path.length).toBeGreaterThan(0)
+      expect(typeof entry.system).toBe('object')
+      expect(entry.system).not.toBeNull()
+    }
+  })
+
+  it('flat model (no subsystems) returns only top-level systems', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        lone: { id: 'lone', order: 10, label: 'Lone', enabled: true, path: '/lone' }
+      }
+    })
+    const all = listAllSystems(model)
+    const paths = all.map((e) => e.path)
+    expect(paths).toContain('lone')
+    // Should not contain any path with a dot from 'lone'
+    expect(paths.filter((p) => p.startsWith('lone.')).length).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getContent
+// ---------------------------------------------------------------------------
+
+describe('getContent', () => {
+  it('resolves a content node by qualified id for a 2-level path', () => {
+    const model = makeNestedModel()
+    const node = getContent(model, 'root.mid:mid-pipeline')
+    expect(node).toBeDefined()
+    expect(node?.label).toBe('Mid Pipeline')
+    expect(node?.kind).toBe('schema')
+    expect(node?.type).toBe('pipeline')
+  })
+
+  it('resolves a leaf system content node by 3-level qualified id', () => {
+    const model = makeNestedModel()
+    const node = getContent(model, 'root.mid.leaf:leaf-config')
+    expect(node).toBeDefined()
+    expect(node?.label).toBe('Leaf Config')
+    expect(node?.kind).toBe('config')
+    expect(node?.type).toBe('kv')
+  })
+
+  it('returns undefined for an unknown local-id within a valid system', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'root.mid:does-not-exist')).toBeUndefined()
+  })
+
+  it('returns undefined for an unknown system path', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'ghost:some-node')).toBeUndefined()
+  })
+
+  it('returns undefined for a qualified id with no colon separator', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'root.mid')).toBeUndefined()
+  })
+
+  it('returns undefined when the system path segment is empty (colon at start)', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, ':local-id')).toBeUndefined()
+  })
+
+  it('returns undefined when the local-id is empty (colon at end)', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'root.mid:')).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveSystemContent — own, inherited, and override-by-localId
+// ---------------------------------------------------------------------------
+
+describe('resolveSystemContent', () => {
+  it('returns empty own and inherited for a system with no content and no ancestor content', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        bare: { id: 'bare', order: 10, label: 'Bare', enabled: true, path: '/bare' }
+      }
+    })
+    const result = resolveSystemContent(model, 'bare')
+    expect(result.own).toEqual({})
+    expect(result.inherited).toEqual([])
+  })
+
+  it('returns empty own and inherited for an unknown system path', () => {
+    const model = makeNestedModel()
+    const result = resolveSystemContent(model, 'nonexistent')
+    expect(result.own).toEqual({})
+    expect(result.inherited).toEqual([])
+  })
+
+  it('returns only own content for a system whose ancestor has no content', () => {
+    const model = makeNestedModel()
+    // 'root' has no content, so 'root.mid' inherits nothing
+    const result = resolveSystemContent(model, 'root.mid')
+    expect(Object.keys(result.own)).toContain('mid-pipeline')
+    expect(result.inherited).toHaveLength(0)
+  })
+
+  it('own section contains only the direct content of the queried system', () => {
+    const model = makeInheritanceModel()
+    // 'ancestor.child' path = 'ancestor.child' using subsystems nesting
+    const result = resolveSystemContent(model, 'ancestor.child')
+    expect(Object.keys(result.own)).toContain('shared')
+    expect(Object.keys(result.own)).not.toContain('ancestor-only')
+  })
+
+  it('inherited section contains ancestor content not shadowed by own', () => {
+    const model = makeInheritanceModel()
+    const result = resolveSystemContent(model, 'ancestor.child')
+    const inheritedIds = result.inherited.map((e) => e.localId)
+    expect(inheritedIds).toContain('ancestor-only')
+  })
+
+  it('override-by-localId: shadowed ancestor entry does NOT appear in inherited', () => {
+    const model = makeInheritanceModel()
+    const result = resolveSystemContent(model, 'ancestor.child')
+    // 'shared' is in both ancestor and child; child's own shadows it
+    const inheritedIds = result.inherited.map((e) => e.localId)
+    expect(inheritedIds).not.toContain('shared')
+  })
+
+  it('inherited entries carry fromPath pointing to the source ancestor system', () => {
+    const model = makeInheritanceModel()
+    const result = resolveSystemContent(model, 'ancestor.child')
+    const ancestorEntry = result.inherited.find((e) => e.localId === 'ancestor-only')
+    expect(ancestorEntry).toBeDefined()
+    expect(ancestorEntry?.fromPath).toBe('ancestor')
+  })
+
+  it('inherited entries appear in root-first display order (shallower before deeper)', () => {
+    // 3-level chain: gp → parent → child
+    // gp has 'gp-node', parent has 'p-node', child has own content
+    const model = resolveOrganizationModel({
+      systems: {
+        gp: {
+          id: 'gp',
+          order: 10,
+          label: 'Grandparent',
+          enabled: true,
+          path: '/gp',
+          content: {
+            'gp-node': { kind: 'config', type: 'kv', label: 'GP Node', data: { entries: { a: 1 } } }
+          },
+          subsystems: {
+            parent: {
+              id: 'parent',
+              order: 20,
+              label: 'Parent',
+              enabled: true,
+              path: '/gp/parent',
+              content: {
+                'p-node': { kind: 'config', type: 'kv', label: 'P Node', data: { entries: { b: 2 } } }
+              },
+              subsystems: {
+                child: {
+                  id: 'child',
+                  order: 30,
+                  label: 'Child',
+                  enabled: true,
+                  path: '/gp/parent/child'
+                }
+              }
+            }
+          }
+        }
+      }
+    })
+    const result = resolveSystemContent(model, 'gp.parent.child')
+    const fromPaths = result.inherited.map((e) => e.fromPath)
+    const gpIdx = fromPaths.indexOf('gp')
+    const pIdx = fromPaths.indexOf('gp.parent')
+    expect(gpIdx).toBeGreaterThanOrEqual(0)
+    expect(pIdx).toBeGreaterThanOrEqual(0)
+    // Shallow ancestor (gp) must appear before deeper ancestor (gp.parent)
+    expect(gpIdx).toBeLessThan(pIdx)
+  })
+})