business-as-code 2.1.1 → 2.3.0

package/test/organization.test.ts

@@ -0,0 +1,548 @@
+/**
+ * Tests for organization.ts - Organizational structure and permissions
+ */
+
+import { describe, it, expect } from 'vitest'
+import { resolvePermissions, getApprovalChainForRequest, findManager } from '../src/organization.js'
+import type {
+  Organization,
+  Department,
+  Team,
+  Position,
+  ApprovalChain,
+} from '../src/organization.js'
+import type { BusinessRole } from '../src/roles.js'
+
+describe('Organization', () => {
+  // Helper function to create a test organization
+  const createTestOrganization = (): Organization => ({
+    id: 'org_acme',
+    name: 'Acme Corp',
+    domain: 'acme.com',
+    industry: 'technology',
+    roles: [
+      {
+        id: 'role_cto',
+        name: 'CTO',
+        type: 'cto',
+        permissions: {
+          repository: ['read', 'edit', 'manage'],
+          project: ['manage'],
+        },
+        canApprove: ['technical-decision', 'architecture'],
+        canHandle: ['architecture-review'],
+      },
+      {
+        id: 'role_lead',
+        name: 'Engineering Lead',
+        type: 'lead',
+        permissions: {
+          repository: ['read', 'edit', 'act:merge'],
+          project: ['read', 'edit'],
+        },
+        canApprove: ['code-review'],
+        canHandle: ['code-review', 'mentoring'],
+      },
+      {
+        id: 'role_engineer',
+        name: 'Software Engineer',
+        type: 'engineer',
+        permissions: {
+          repository: ['read', 'edit'],
+          project: ['read'],
+        },
+        canHandle: ['coding', 'testing'],
+      },
+    ],
+    departments: [
+      {
+        id: 'dept_eng',
+        name: 'Engineering',
+        code: 'ENG',
+        defaultPermissions: {
+          documentation: ['read'],
+        },
+        teams: [
+          {
+            id: 'team_platform',
+            name: 'Platform Team',
+            departmentId: 'dept_eng',
+            defaultPermissions: {
+              infrastructure: ['read'],
+            },
+            resources: {
+              repositories: ['platform-core', 'platform-api'],
+            },
+            positions: [
+              {
+                id: 'pos_cto',
+                title: 'CTO',
+                roleId: 'role_cto',
+                workerId: 'worker_jane',
+                status: 'active',
+              },
+              {
+                id: 'pos_lead',
+                title: 'Engineering Lead',
+                roleId: 'role_lead',
+                workerId: 'worker_bob',
+                reportsTo: 'pos_cto',
+                status: 'active',
+              },
+              {
+                id: 'pos_eng_1',
+                title: 'Senior Software Engineer',
+                roleId: 'role_engineer',
+                workerId: 'worker_alice',
+                reportsTo: 'pos_lead',
+                status: 'active',
+                additionalPermissions: {
+                  'repository:platform-core': ['manage'],
+                },
+              },
+              {
+                id: 'pos_eng_2',
+                title: 'Software Engineer',
+                roleId: 'role_engineer',
+                workerId: 'worker_charlie',
+                reportsTo: 'pos_lead',
+                status: 'active',
+              },
+            ],
+          },
+          {
+            id: 'team_product',
+            name: 'Product Team',
+            departmentId: 'dept_eng',
+            positions: [
+              {
+                id: 'pos_pm',
+                title: 'Product Manager',
+                roleId: 'role_lead',
+                workerId: 'worker_dave',
+                status: 'active',
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    teams: [
+      {
+        id: 'team_special',
+        name: 'Special Projects',
+        positions: [
+          {
+            id: 'pos_special',
+            title: 'Special Projects Lead',
+            roleId: 'role_lead',
+            workerId: 'worker_eve',
+            status: 'active',
+          },
+        ],
+      },
+    ],
+    approvalChains: [
+      {
+        id: 'chain_expense',
+        name: 'Expense Approval',
+        type: 'expense',
+        active: true,
+        levels: [
+          {
+            threshold: 1000,
+            approvers: [{ type: 'direct-manager' }],
+          },
+          {
+            threshold: 5000,
+            approvers: [{ type: 'direct-manager' }, { type: 'role', roleId: 'director' }],
+          },
+          {
+            threshold: 25000,
+            approvers: [{ type: 'direct-manager' }, { type: 'role', roleId: 'cfo' }],
+          },
+        ],
+      },
+      {
+        id: 'chain_deployment',
+        name: 'Deployment Approval',
+        type: 'deployment',
+        active: true,
+        levels: [
+          {
+            approvers: [{ type: 'role', roleId: 'role_lead' }],
+          },
+        ],
+      },
+      {
+        id: 'chain_inactive',
+        name: 'Inactive Chain',
+        type: 'inactive-type',
+        active: false,
+        levels: [
+          {
+            approvers: [{ type: 'direct-manager' }],
+          },
+        ],
+      },
+    ],
+  })
+
+  describe('resolvePermissions()', () => {
+    it('should resolve permissions for a position in the org hierarchy', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved).not.toBeNull()
+      expect(resolved?.workerId).toBe('worker_alice')
+      expect(resolved?.positionId).toBe('pos_eng_1')
+    })
+
+    it('should include department permissions', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved?.permissions.documentation).toContain('read')
+    })
+
+    it('should include team permissions', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved?.permissions.infrastructure).toContain('read')
+    })
+
+    it('should include role permissions', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved?.permissions.repository).toContain('read')
+      expect(resolved?.permissions.repository).toContain('edit')
+    })
+
+    it('should include position-specific permissions', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved?.resourcePermissions['repository:platform-core']).toBeDefined()
+    })
+
+    it('should include canHandle from role', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved?.canHandle).toContain('coding')
+      expect(resolved?.canHandle).toContain('testing')
+    })
+
+    it('should include canApprove from role', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_lead')
+
+      expect(resolved?.canApprove).toContain('code-review')
+    })
+
+    it('should track inheritance chain', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      expect(resolved?.inheritanceChain).toContain('department:dept_eng')
+      expect(resolved?.inheritanceChain).toContain('team:team_platform')
+      expect(resolved?.inheritanceChain).toContain('role:role_engineer')
+      expect(resolved?.inheritanceChain).toContain('position:pos_eng_1')
+    })
+
+    it('should return null for non-existent position', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'non_existent')
+
+      expect(resolved).toBeNull()
+    })
+
+    it('should find positions in standalone teams', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_special')
+
+      expect(resolved).not.toBeNull()
+      expect(resolved?.workerId).toBe('worker_eve')
+    })
+
+    it('should merge permissions without duplicates', () => {
+      const org = createTestOrganization()
+      const resolved = resolvePermissions(org, 'pos_eng_1')
+
+      // Both role and team might have 'read' permission
+      const readCount = resolved?.permissions.repository?.filter((p) => p === 'read').length
+      expect(readCount).toBe(1)
+    })
+  })
+
+  describe('getApprovalChainForRequest()', () => {
+    it('should return approvers for expense requests', () => {
+      const org = createTestOrganization()
+      const approvers = getApprovalChainForRequest(org, 'expense', 500)
+
+      // The function returns approvers - check that we get some
+      expect(approvers.length).toBeGreaterThan(0)
+      expect(approvers[0]?.type).toBe('direct-manager')
+    })
+
+    it('should return approvers based on amount thresholds', () => {
+      const org = createTestOrganization()
+      const approvers = getApprovalChainForRequest(org, 'expense', 3000)
+
+      // Should return approvers for the appropriate level
+      expect(approvers.length).toBeGreaterThan(0)
+      expect(approvers[0]?.type).toBe('direct-manager')
+    })
+
+    it('should return approvers for high amounts', () => {
+      const org = createTestOrganization()
+      const approvers = getApprovalChainForRequest(org, 'expense', 50000)
+
+      // Should return some approvers
+      expect(approvers.length).toBeGreaterThan(0)
+    })
+
+    it('should return empty array for non-existent request type', () => {
+      const org = createTestOrganization()
+      const approvers = getApprovalChainForRequest(org, 'non-existent', 1000)
+
+      expect(approvers).toEqual([])
+    })
+
+    it('should not return approvers from inactive chains', () => {
+      const org = createTestOrganization()
+      const approvers = getApprovalChainForRequest(org, 'inactive-type', 1000)
+
+      expect(approvers).toEqual([])
+    })
+
+    it('should return approvers when no amount specified', () => {
+      const org = createTestOrganization()
+      const approvers = getApprovalChainForRequest(org, 'deployment')
+
+      expect(approvers).toHaveLength(1)
+      expect(approvers[0]?.type).toBe('role')
+      expect(approvers[0]?.roleId).toBe('role_lead')
+    })
+  })
+
+  describe('findManager()', () => {
+    it('should find direct manager', () => {
+      const org = createTestOrganization()
+      const manager = findManager(org, 'pos_eng_1')
+
+      expect(manager).not.toBeNull()
+      expect(manager?.id).toBe('pos_lead')
+      expect(manager?.workerId).toBe('worker_bob')
+    })
+
+    it('should find second-level manager', () => {
+      const org = createTestOrganization()
+      const manager = findManager(org, 'pos_lead')
+
+      expect(manager).not.toBeNull()
+      expect(manager?.id).toBe('pos_cto')
+      expect(manager?.workerId).toBe('worker_jane')
+    })
+
+    it('should return null for position without manager', () => {
+      const org = createTestOrganization()
+      const manager = findManager(org, 'pos_cto')
+
+      expect(manager).toBeNull()
+    })
+
+    it('should return null for non-existent position', () => {
+      const org = createTestOrganization()
+      const manager = findManager(org, 'non_existent')
+
+      expect(manager).toBeNull()
+    })
+  })
+
+  describe('Organization interface', () => {
+    it('should support full organization structure', () => {
+      const org: Organization = {
+        id: 'org_test',
+        name: 'Test Corp',
+        domain: 'test.com',
+        legalName: 'Test Corporation Inc.',
+        industry: 'technology',
+        mission: 'To make testing easy',
+        values: ['quality', 'speed', 'reliability'],
+        foundedAt: new Date('2020-01-01'),
+        headquarters: {
+          street: '123 Main St',
+          city: 'San Francisco',
+          state: 'CA',
+          postalCode: '94105',
+          country: 'USA',
+        },
+        settings: {
+          defaultCurrency: 'USD',
+          timezone: 'America/Los_Angeles',
+          workWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'],
+          businessHours: {
+            start: '09:00',
+            end: '17:00',
+            timezone: 'America/Los_Angeles',
+          },
+          fiscalYearStart: 1,
+          language: 'en',
+          dateFormat: 'MM/DD/YYYY',
+        },
+        departments: [],
+        teams: [],
+        roles: [],
+        metadata: { tier: 'enterprise' },
+      }
+
+      expect(org.name).toBe('Test Corp')
+      expect(org.headquarters?.city).toBe('San Francisco')
+      expect(org.settings?.timezone).toBe('America/Los_Angeles')
+    })
+  })
+
+  describe('Department interface', () => {
+    it('should support full department structure', () => {
+      const dept: Department = {
+        id: 'dept_test',
+        name: 'Test Department',
+        code: 'TEST',
+        description: 'Department for testing',
+        head: { positionId: 'pos_head', roleId: 'role_director' },
+        parentId: 'dept_parent',
+        teams: [],
+        budget: {
+          annual: 1000000,
+          currency: 'USD',
+          period: '2024',
+          categories: {
+            salaries: 700000,
+            tools: 100000,
+            training: 50000,
+          },
+          spent: 250000,
+          remaining: 750000,
+        },
+        costCenter: 'CC-100',
+        goals: ['Deliver Q1 roadmap', 'Improve team velocity'],
+        defaultPermissions: {
+          document: ['read', 'edit'],
+        },
+        metadata: { level: 'division' },
+      }
+
+      expect(dept.name).toBe('Test Department')
+      expect(dept.budget?.annual).toBe(1000000)
+    })
+  })
+
+  describe('Team interface', () => {
+    it('should support full team structure', () => {
+      const team: Team = {
+        id: 'team_test',
+        name: 'Test Team',
+        departmentId: 'dept_eng',
+        description: 'A team for testing',
+        lead: { positionId: 'pos_lead', roleId: 'role_lead' },
+        positions: [],
+        objectives: ['Ship feature X', 'Reduce tech debt'],
+        resources: {
+          repositories: ['repo-1', 'repo-2'],
+          projects: ['project-1'],
+        },
+        defaultPermissions: {
+          repository: ['read', 'edit'],
+        },
+        channels: {
+          slack: '#team-test',
+          email: 'team-test@acme.com',
+        },
+        metadata: { squad: true },
+      }
+
+      expect(team.name).toBe('Test Team')
+      expect(team.resources?.repositories).toContain('repo-1')
+    })
+  })
+
+  describe('Position interface', () => {
+    it('should support full position structure', () => {
+      const position: Position = {
+        id: 'pos_test',
+        title: 'Senior Engineer',
+        roleId: 'role_engineer',
+        workerId: 'worker_123',
+        workerType: 'human',
+        teamId: 'team_platform',
+        reportsTo: 'pos_lead',
+        directReports: ['pos_jr_1', 'pos_jr_2'],
+        additionalPermissions: {
+          'repository:special': ['manage'],
+        },
+        startDate: new Date('2023-01-15'),
+        endDate: undefined,
+        status: 'active',
+        fte: 1.0,
+        location: 'San Francisco',
+        workModel: 'hybrid',
+        compensation: {
+          baseSalary: 180000,
+          currency: 'USD',
+          frequency: 'annual',
+          bonusTarget: 15,
+          equity: {
+            type: 'rsu',
+            amount: 10000,
+            vestingSchedule: '4 years with 1 year cliff',
+          },
+          band: 'L5',
+        },
+        metadata: { promoted: true },
+      }
+
+      expect(position.title).toBe('Senior Engineer')
+      expect(position.compensation?.baseSalary).toBe(180000)
+    })
+  })
+
+  describe('ApprovalChain interface', () => {
+    it('should support full approval chain structure', () => {
+      const chain: ApprovalChain = {
+        id: 'chain_test',
+        name: 'Test Approval Chain',
+        type: 'purchase',
+        levels: [
+          {
+            threshold: 1000,
+            approvers: [{ type: 'direct-manager' }],
+            requiredApprovals: 1,
+            approvalMode: 'any',
+            slaHours: 24,
+          },
+          {
+            threshold: 10000,
+            approvers: [{ type: 'direct-manager' }, { type: 'role', roleId: 'finance_manager' }],
+            requiredApprovals: 2,
+            approvalMode: 'sequential',
+            slaHours: 48,
+          },
+        ],
+        escalation: {
+          afterHours: 48,
+          escalateTo: 'skip-level-manager',
+          maxEscalations: 2,
+        },
+        active: true,
+        metadata: { version: 2 },
+      }
+
+      expect(chain.name).toBe('Test Approval Chain')
+      expect(chain.levels).toHaveLength(2)
+      expect(chain.escalation?.afterHours).toBe(48)
+    })
+  })
+})