@dssp/dkpi 1.0.0-alpha.53 → 1.0.0-alpha.55

package/kpi-module-unit-tests-detailed.md

@@ -0,0 +1,1452 @@
+# KPI 모듈 단위 테스트 상세 코드
+
+## 개요
+본 문서는 Things Factory KPI 모듈의 단위 테스트 코드를 상세하게 제공합니다.
+
+## 1. KPI 엔티티 테스트 (kpi.spec.ts)
+
+```typescript
+import { describe, it, expect, beforeEach } from '@jest/globals'
+import { Repository, DataSource } from 'typeorm'
+import { Kpi, KpiStatus, KpiVizType, KpiPeriodType } from '../server/service/kpi/kpi'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { createTestingModule } from './test-utils'
+
+describe('KPI Entity Tests', () => {
+  let dataSource: DataSource
+  let kpiRepository: Repository<Kpi>
+  let domainRepository: Repository<Domain>
+  let userRepository: Repository<User>
+  let testDomain: Domain
+  let testUser: User
+
+  beforeEach(async () => {
+    const module = await createTestingModule()
+    dataSource = module.get<DataSource>(DataSource)
+    kpiRepository = dataSource.getRepository(Kpi)
+    domainRepository = dataSource.getRepository(Domain)
+    userRepository = dataSource.getRepository(User)
+
+    // 테스트용 도메인 생성
+    testDomain = await domainRepository.save({
+      name: 'TEST_DOMAIN',
+      description: 'Test Domain for KPI Tests'
+    })
+
+    // 테스트용 사용자 생성
+    testUser = await userRepository.save({
+      name: 'Test User',
+      email: 'test@example.com',
+      domain: testDomain
+    })
+  })
+
+  describe('KPI 생성 테스트', () => {
+    it('기본 KPI 생성이 성공해야 한다', async () => {
+      // Given
+      const kpiData = {
+        name: '안전사고율',
+        description: '월별 안전사고 발생률',
+        domain: testDomain,
+        creator: testUser,
+        isLeaf: true,
+        formula: 'accident_count / total_hours * 1000',
+        active: true,
+        state: KpiStatus.DRAFT,
+        vizType: KpiVizType.GAUGE,
+        vizMeta: {
+          unit: '건/천시간',
+          min: 0,
+          max: 10,
+          thresholds: [2, 5, 8],
+          color: '#ff6b6b'
+        },
+        periodType: KpiPeriodType.MONTH,
+        weight: 1.0
+      }
+
+      // When
+      const savedKpi = await kpiRepository.save(kpiData)
+
+      // Then
+      expect(savedKpi.id).toBeDefined()
+      expect(savedKpi.name).toBe('안전사고율')
+      expect(savedKpi.version).toBe(1)
+      expect(savedKpi.isLeaf).toBe(true)
+      expect(savedKpi.formula).toBe('accident_count / total_hours * 1000')
+      expect(savedKpi.active).toBe(true)
+      expect(savedKpi.state).toBe(KpiStatus.DRAFT)
+      expect(savedKpi.vizType).toBe(KpiVizType.GAUGE)
+      expect(savedKpi.vizMeta.unit).toBe('건/천시간')
+      expect(savedKpi.periodType).toBe(KpiPeriodType.MONTH)
+      expect(savedKpi.weight).toBe(1.0)
+      expect(savedKpi.createdAt).toBeDefined()
+    })
+
+    it('필수 필드가 누락된 경우 에러가 발생해야 한다', async () => {
+      // Given
+      const invalidKpiData = {
+        description: '이름이 없는 KPI',
+        domain: testDomain
+        // name 필드가 누락됨
+      }
+
+      // When & Then
+      await expect(kpiRepository.save(invalidKpiData))
+        .rejects.toThrow()
+    })
+
+    it('중복된 이름의 KPI 생성이 실패해야 한다', async () => {
+      // Given
+      const kpiData = {
+        name: '중복_KPI',
+        domain: testDomain,
+        creator: testUser
+      }
+
+      await kpiRepository.save(kpiData)
+
+      // When & Then
+      await expect(kpiRepository.save({...kpiData}))
+        .rejects.toThrow(/duplicate key value violates unique constraint/)
+    })
+  })
+
+  describe('KPI 계층 구조 테스트', () => {
+    it('부모-자식 KPI 관계가 정상 설정되어야 한다', async () => {
+      // Given - 부모 KPI 생성
+      const parentKpi = await kpiRepository.save({
+        name: '전체 안전 지수',
+        domain: testDomain,
+        creator: testUser,
+        isLeaf: false,
+        formula: 'avg(child_kpis)',
+        active: true
+      })
+
+      // When - 자식 KPI 생성
+      const childKpi = await kpiRepository.save({
+        name: '안전사고율',
+        domain: testDomain,
+        creator: testUser,
+        parent: parentKpi,
+        isLeaf: true,
+        formula: 'accident_count / total_hours * 1000',
+        active: true
+      })
+
+      // Then
+      const savedChildKpi = await kpiRepository.findOne({
+        where: { id: childKpi.id },
+        relations: ['parent']
+      })
+
+      expect(savedChildKpi.parent).toBeDefined()
+      expect(savedChildKpi.parent.id).toBe(parentKpi.id)
+      expect(savedChildKpi.parent.name).toBe('전체 안전 지수')
+
+      // 부모에서 자식 조회
+      const savedParentKpi = await kpiRepository.findOne({
+        where: { id: parentKpi.id },
+        relations: ['children']
+      })
+
+      expect(savedParentKpi.children).toHaveLength(1)
+      expect(savedParentKpi.children[0].id).toBe(childKpi.id)
+    })
+
+    it('3단계 계층 구조가 정상 동작해야 한다', async () => {
+      // Given - 레벨 1 (최상위)
+      const level1Kpi = await kpiRepository.save({
+        name: '종합 성과 지수',
+        domain: testDomain,
+        creator: testUser,
+        isLeaf: false
+      })
+
+      // 레벨 2 (중간)
+      const level2Kpi = await kpiRepository.save({
+        name: '안전 성과',
+        domain: testDomain,
+        creator: testUser,
+        parent: level1Kpi,
+        isLeaf: false
+      })
+
+      // 레벨 3 (말단)
+      const level3Kpi = await kpiRepository.save({
+        name: '안전사고율',
+        domain: testDomain,
+        creator: testUser,
+        parent: level2Kpi,
+        isLeaf: true,
+        formula: 'accident_count / total_hours'
+      })
+
+      // When - 전체 계층 조회
+      const hierarchyKpi = await kpiRepository.findOne({
+        where: { id: level1Kpi.id },
+        relations: ['children', 'children.children']
+      })
+
+      // Then
+      expect(hierarchyKpi.children).toHaveLength(1)
+      expect(hierarchyKpi.children[0].name).toBe('안전 성과')
+      expect(hierarchyKpi.children[0].children).toHaveLength(1)
+      expect(hierarchyKpi.children[0].children[0].name).toBe('안전사고율')
+      expect(hierarchyKpi.children[0].children[0].isLeaf).toBe(true)
+    })
+  })
+
+  describe('KPI 상태 변경 테스트', () => {
+    it('DRAFT에서 RELEASE로 상태 변경이 성공해야 한다', async () => {
+      // Given
+      const kpi = await kpiRepository.save({
+        name: '품질지수',
+        domain: testDomain,
+        creator: testUser,
+        state: KpiStatus.DRAFT,
+        version: 1
+      })
+
+      // When
+      kpi.state = KpiStatus.RELEASE
+      const updatedKpi = await kpiRepository.save(kpi)
+
+      // Then
+      expect(updatedKpi.state).toBe(KpiStatus.RELEASE)
+      expect(updatedKpi.version).toBe(2) // 버전이 증가해야 함
+    })
+
+    it('RELEASE에서 수정 시 버전이 증가하고 DRAFT로 변경되어야 한다', async () => {
+      // Given
+      const kpi = await kpiRepository.save({
+        name: '생산성지수',
+        domain: testDomain,
+        creator: testUser,
+        state: KpiStatus.RELEASE,
+        version: 1,
+        formula: 'output / input'
+      })
+
+      // When - 수식 변경
+      kpi.formula = 'output / (input * 1.2)'
+      const updatedKpi = await kpiRepository.save(kpi)
+
+      // Then
+      expect(updatedKpi.state).toBe(KpiStatus.DRAFT)
+      expect(updatedKpi.version).toBe(2)
+      expect(updatedKpi.formula).toBe('output / (input * 1.2)')
+    })
+
+    it('ARCHIVED 상태의 KPI는 수정할 수 없어야 한다', async () => {
+      // Given
+      const kpi = await kpiRepository.save({
+        name: '폐기_KPI',
+        domain: testDomain,
+        creator: testUser,
+        state: KpiStatus.ARCHIVED,
+        active: false
+      })
+
+      // When & Then
+      kpi.formula = 'new_formula'
+      await expect(kpiRepository.save(kpi))
+        .rejects.toThrow(/cannot modify archived KPI/)
+    })
+  })
+
+  describe('KPI 수식 유효성 검사', () => {
+    it('유효한 수식이 저장되어야 한다', async () => {
+      const validFormulas = [
+        'metric1 + metric2',
+        'sum(metric1, metric2, metric3)',
+        'if(metric1 > 0, metric2 / metric1 * 100, 0)',
+        'performance_index(value, 2.5, 3.2, 2.0, 3.5)',
+        'round(avg(metric1, metric2), 2)'
+      ]
+
+      for (const formula of validFormulas) {
+        const kpi = await kpiRepository.save({
+          name: `Test_KPI_${formula.replace(/[^a-zA-Z0-9]/g, '_')}`,
+          domain: testDomain,
+          creator: testUser,
+          formula: formula
+        })
+
+        expect(kpi.formula).toBe(formula)
+      }
+    })
+
+    it('잘못된 수식은 에러를 발생시켜야 한다', async () => {
+      const invalidFormulas = [
+        'metric1 +',           // 불완전한 수식
+        'unknown_func(metric1)', // 정의되지 않은 함수
+        'metric1 / 0',         // Zero division (런타임에서 체크)
+        'if(metric1)',         // 인수 개수 불일치
+        'metric1 ** metric2'   // 지원하지 않는 연산자
+      ]
+
+      for (const formula of invalidFormulas) {
+        await expect(kpiRepository.save({
+          name: `Invalid_KPI_${Math.random()}`,
+          domain: testDomain,
+          creator: testUser,
+          formula: formula
+        })).rejects.toThrow()
+      }
+    })
+  })
+
+  describe('KPI 시각화 메타데이터 테스트', () => {
+    it('게이지 차트 메타데이터가 정상 저장되어야 한다', async () => {
+      // Given
+      const gaugeVizMeta = {
+        unit: '%',
+        min: 0,
+        max: 100,
+        thresholds: [30, 70, 90],
+        colors: ['#ff4757', '#ffa726', '#66bb6a', '#43a047'],
+        showTarget: true,
+        targetValue: 85,
+        decimals: 1
+      }
+
+      // When
+      const kpi = await kpiRepository.save({
+        name: '성과율',
+        domain: testDomain,
+        creator: testUser,
+        vizType: KpiVizType.GAUGE,
+        vizMeta: gaugeVizMeta
+      })
+
+      // Then
+      expect(kpi.vizMeta.unit).toBe('%')
+      expect(kpi.vizMeta.thresholds).toEqual([30, 70, 90])
+      expect(kpi.vizMeta.colors).toHaveLength(4)
+      expect(kpi.vizMeta.targetValue).toBe(85)
+    })
+
+    it('라인 차트 메타데이터가 정상 저장되어야 한다', async () => {
+      // Given
+      const lineVizMeta = {
+        dateRange: '30d',
+        aggregation: 'daily',
+        showTrend: true,
+        trendType: 'linear',
+        yAxisRange: { min: 0, max: 'auto' },
+        colors: {
+          line: '#2196f3',
+          area: 'rgba(33, 150, 243, 0.1)'
+        }
+      }
+
+      // When
+      const kpi = await kpiRepository.save({
+        name: '일일 처리량',
+        domain: testDomain,
+        creator: testUser,
+        vizType: KpiVizType.LINE,
+        vizMeta: lineVizMeta
+      })
+
+      // Then
+      expect(kpi.vizMeta.dateRange).toBe('30d')
+      expect(kpi.vizMeta.aggregation).toBe('daily')
+      expect(kpi.vizMeta.showTrend).toBe(true)
+      expect(kpi.vizMeta.colors.line).toBe('#2196f3')
+    })
+  })
+})
+```
+
+## 2. 수식 계산기 테스트 (calculator.spec.ts)
+
+```typescript
+import { describe, it, expect, beforeEach } from '@jest/globals'
+import { parseFormula } from '../server/calculator/parser'
+import { evaluateFormula } from '../server/calculator/evaluator'
+import { builtinFunctions } from '../server/calculator/functions'
+import { ValueProvider } from '../server/calculator/provider'
+
+class MockValueProvider implements ValueProvider {
+  private values = new Map<string, number>()
+
+  set(key: string, value: number) {
+    this.values.set(key, value)
+  }
+
+  async get(key: string): Promise<number> {
+    const value = this.values.get(key)
+    if (value === undefined) {
+      throw new Error(`Variable not found: ${key}`)
+    }
+    return value
+  }
+}
+
+describe('Formula Calculator Tests', () => {
+  let provider: MockValueProvider
+
+  beforeEach(() => {
+    provider = new MockValueProvider()
+  })
+
+  describe('기본 사칙연산 테스트', () => {
+    it('덧셈 연산이 정확해야 한다', async () => {
+      // Given
+      const formula = '10 + 5'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(15)
+    })
+
+    it('뺄셈 연산이 정확해야 한다', async () => {
+      const formula = '20 - 8'
+      const node = parseFormula(formula)
+
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      expect(result).toBe(12)
+    })
+
+    it('곱셈 연산이 정확해야 한다', async () => {
+      const formula = '7 * 6'
+      const node = parseFormula(formula)
+
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      expect(result).toBe(42)
+    })
+
+    it('나눗셈 연산이 정확해야 한다', async () => {
+      const formula = '100 / 4'
+      const node = parseFormula(formula)
+
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      expect(result).toBe(25)
+    })
+
+    it('복합 사칙연산의 우선순위가 정확해야 한다', async () => {
+      const testCases = [
+        { formula: '2 + 3 * 4', expected: 14 },      // 곱셈 우선
+        { formula: '(2 + 3) * 4', expected: 20 },   // 괄호 우선
+        { formula: '10 - 6 / 2', expected: 7 },     // 나눗셈 우선
+        { formula: '(10 - 6) / 2', expected: 2 },   // 괄호 우선
+        { formula: '2 * 3 + 4 * 5', expected: 26 }  // 곱셈들 먼저
+      ]
+
+      for (const testCase of testCases) {
+        const node = parseFormula(testCase.formula)
+        const result = await evaluateFormula(node, {
+          functions: builtinFunctions,
+          provider: provider
+        })
+        expect(result).toBe(testCase.expected)
+      }
+    })
+
+    it('음수 연산이 정확해야 한다', async () => {
+      const formula = '-5 + 3'
+      const node = parseFormula(formula)
+
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      expect(result).toBe(-2)
+    })
+  })
+
+  describe('변수 참조 테스트', () => {
+    it('단일 변수 참조가 정확해야 한다', async () => {
+      // Given
+      provider.set('total_count', 100)
+      const formula = 'total_count'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(100)
+    })
+
+    it('여러 변수를 사용한 연산이 정확해야 한다', async () => {
+      // Given
+      provider.set('defect_count', 5)
+      provider.set('total_count', 100)
+      const formula = 'defect_count / total_count * 100'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(5) // 5% 불량률
+    })
+
+    it('정의되지 않은 변수 참조 시 에러가 발생해야 한다', async () => {
+      // Given
+      const formula = 'undefined_variable'
+      const node = parseFormula(formula)
+
+      // When & Then
+      await expect(evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })).rejects.toThrow('Variable not found: undefined_variable')
+    })
+
+    it('변수명에 언더스코어와 숫자가 포함된 경우도 동작해야 한다', async () => {
+      // Given
+      provider.set('metric_1', 10)
+      provider.set('metric_2', 20)
+      provider.set('total_sum_123', 30)
+
+      const formula = 'metric_1 + metric_2 + total_sum_123'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(60)
+    })
+  })
+
+  describe('함수 호출 테스트', () => {
+    it('sum 함수가 정확해야 한다', async () => {
+      const testCases = [
+        { args: [1, 2, 3, 4, 5], expected: 15 },
+        { args: [10, 20], expected: 30 },
+        { args: [0, 0, 0], expected: 0 },
+        { args: [-5, 10, -3], expected: 2 },
+        { args: [100], expected: 100 } // 단일 인수
+      ]
+
+      for (const testCase of testCases) {
+        const result = builtinFunctions.sum(...testCase.args)
+        expect(result).toBe(testCase.expected)
+      }
+    })
+
+    it('avg 함수가 정확해야 한다', async () => {
+      const testCases = [
+        { args: [1, 2, 3, 4, 5], expected: 3 },
+        { args: [10, 20], expected: 15 },
+        { args: [0, 0, 0], expected: 0 },
+        { args: [100], expected: 100 },
+        { args: [], expected: 0 } // 빈 배열
+      ]
+
+      for (const testCase of testCases) {
+        const result = builtinFunctions.avg(...testCase.args)
+        expect(result).toBe(testCase.expected)
+      }
+    })
+
+    it('min/max 함수가 정확해야 한다', async () => {
+      expect(builtinFunctions.min(5, 2, 8, 1, 9)).toBe(1)
+      expect(builtinFunctions.max(5, 2, 8, 1, 9)).toBe(9)
+      expect(builtinFunctions.min(-5, -2, -8)).toBe(-8)
+      expect(builtinFunctions.max(-5, -2, -8)).toBe(-2)
+    })
+
+    it('round 함수가 정확해야 한다', async () => {
+      expect(builtinFunctions.round(3.14159, 2)).toBe(3.14)
+      expect(builtinFunctions.round(3.14159, 0)).toBe(3)
+      expect(builtinFunctions.round(3.14159)).toBe(3) // 기본값 0
+      expect(builtinFunctions.round(3.9)).toBe(4)
+      expect(builtinFunctions.round(123.456, 1)).toBe(123.5)
+    })
+
+    it('수식에서 함수 호출이 정확해야 한다', async () => {
+      // Given
+      provider.set('value1', 10)
+      provider.set('value2', 20)
+      provider.set('value3', 30)
+
+      const formula = 'avg(value1, value2, value3) + sum(1, 2, 3)'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(26) // avg(10,20,30) + sum(1,2,3) = 20 + 6 = 26
+    })
+  })
+
+  describe('조건부 함수 테스트', () => {
+    it('if 함수의 참 조건이 정확해야 한다', async () => {
+      const result = builtinFunctions.if(true, 'YES', 'NO')
+      expect(result).toBe('YES')
+    })
+
+    it('if 함수의 거짓 조건이 정확해야 한다', async () => {
+      const result = builtinFunctions.if(false, 'YES', 'NO')
+      expect(result).toBe('NO')
+    })
+
+    it('if 함수의 숫자 조건이 정확해야 한다', async () => {
+      expect(builtinFunctions.if(1, 'TRUE', 'FALSE')).toBe('TRUE')   // 1은 참
+      expect(builtinFunctions.if(0, 'TRUE', 'FALSE')).toBe('FALSE')  // 0은 거짓
+      expect(builtinFunctions.if(-1, 'TRUE', 'FALSE')).toBe('TRUE')  // -1은 참
+    })
+
+    it('중첩된 if 함수가 정확해야 한다', async () => {
+      // Given
+      provider.set('score', 85)
+      const formula = 'if(score >= 90, "A", if(score >= 80, "B", if(score >= 70, "C", "F")))'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe('B') // 85점은 B등급
+    })
+
+    it('Zero Division 방지를 위한 if 사용이 정확해야 한다', async () => {
+      // Given
+      provider.set('numerator', 100)
+      provider.set('denominator', 0)
+
+      const formula = 'if(denominator > 0, numerator / denominator, 0)'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(0) // 0으로 나누기 방지
+    })
+  })
+
+  describe('성과지수 함수 테스트', () => {
+    it('performance_index 함수가 올바른 범위의 값을 반환해야 한다', async () => {
+      const testCases = [
+        { x: 0.1, alpha1: 2, beta1: 3, alpha2: 2, beta2: 3 },
+        { x: 0.5, alpha1: 2, beta1: 3, alpha2: 2, beta2: 3 },
+        { x: 0.9, alpha1: 2, beta1: 3, alpha2: 2, beta2: 3 }
+      ]
+
+      for (const testCase of testCases) {
+        const result = builtinFunctions.performance_index(
+          testCase.x, testCase.alpha1, testCase.beta1,
+          testCase.alpha2, testCase.beta2
+        )
+
+        expect(result).toBeGreaterThanOrEqual(0)
+        expect(result).toBeLessThanOrEqual(1)
+        expect(typeof result).toBe('number')
+        expect(Number.isFinite(result)).toBe(true)
+      }
+    })
+
+    it('베타 분포 관련 함수들이 수치적으로 안정해야 한다', async () => {
+      // incomplete_beta 함수 테스트
+      const incBeta = builtinFunctions.incomplete_beta(0.5, 2, 3)
+      expect(Number.isFinite(incBeta)).toBe(true)
+      expect(incBeta).toBeGreaterThanOrEqual(0)
+
+      // complete_beta 함수 테스트
+      const compBeta = builtinFunctions.complete_beta(2, 3)
+      expect(Number.isFinite(compBeta)).toBe(true)
+      expect(compBeta).toBeGreaterThan(0)
+    })
+  })
+
+  describe('지수감쇠 함수 테스트', () => {
+    it('exponential_decay 함수가 정확해야 한다', async () => {
+      const testCases = [
+        { value: 0, scale: 1, power: 1, expected: 1 },      // exp(-0) = 1
+        { value: 1, scale: 1, power: 1, expected: Math.exp(-1) }, // exp(-1)
+        { value: 2, scale: 1, power: 2, expected: Math.exp(-4) }  // exp(-2^2)
+      ]
+
+      for (const testCase of testCases) {
+        const result = builtinFunctions.exponential_decay(
+          testCase.value, testCase.scale, testCase.power
+        )
+        expect(result).toBeCloseTo(testCase.expected, 10)
+      }
+    })
+
+    it('지수 함수들이 정확해야 한다', async () => {
+      expect(builtinFunctions.exp(0)).toBe(1)
+      expect(builtinFunctions.exp(1)).toBeCloseTo(Math.E, 10)
+      expect(builtinFunctions.log(Math.E)).toBeCloseTo(1, 10)
+      expect(builtinFunctions.pow(2, 3)).toBe(8)
+      expect(builtinFunctions.pow(3, 2)).toBe(9)
+    })
+  })
+
+  describe('복합 수식 테스트', () => {
+    it('실제 KPI 수식이 정확하게 계산되어야 한다', async () => {
+      // Given - 불량률 KPI
+      provider.set('defect_count', 25)
+      provider.set('total_count', 1000)
+
+      const formula = 'if(total_count > 0, round(defect_count / total_count * 100, 2), 0)'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(2.5) // 2.5% 불량률
+    })
+
+    it('생산성 지수 계산이 정확해야 한다', async () => {
+      // Given
+      provider.set('output_qty', 1200)
+      provider.set('input_hours', 40)
+      provider.set('standard_rate', 25)
+
+      const formula = 'round((output_qty / input_hours) / standard_rate * 100, 1)'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(120) // 120% 생산성 (30/25 * 100)
+    })
+
+    it('가중 평균 계산이 정확해야 한다', async () => {
+      // Given
+      provider.set('kpi1_value', 80)
+      provider.set('kpi1_weight', 0.4)
+      provider.set('kpi2_value', 90)
+      provider.set('kpi2_weight', 0.6)
+
+      const formula = 'kpi1_value * kpi1_weight + kpi2_value * kpi2_weight'
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      expect(result).toBe(86) // 80*0.4 + 90*0.6 = 32 + 54 = 86
+    })
+
+    it('안전지수 복합 계산이 정확해야 한다', async () => {
+      // Given
+      provider.set('accident_count', 2)
+      provider.set('near_miss_count', 5)
+      provider.set('total_hours', 10000)
+      provider.set('safety_training_completion', 0.95)
+
+      const formula = `
+        if(total_hours > 0,
+          round(
+            (1 - (accident_count + near_miss_count * 0.1) / (total_hours / 1000)) *
+            safety_training_completion * 100,
+            2
+          ),
+          0
+        )
+      `.replace(/\s+/g, ' ').trim()
+
+      const node = parseFormula(formula)
+
+      // When
+      const result = await evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })
+
+      // Then
+      // (1 - (2 + 5*0.1) / 10) * 0.95 * 100 = (1 - 2.5/10) * 0.95 * 100 = 0.75 * 0.95 * 100 = 71.25
+      expect(result).toBe(71.25)
+    })
+  })
+
+  describe('에러 처리 테스트', () => {
+    it('잘못된 함수명 사용 시 에러가 발생해야 한다', async () => {
+      // Given
+      const formula = 'unknown_function(10, 20)'
+      const node = parseFormula(formula)
+
+      // When & Then
+      await expect(evaluateFormula(node, {
+        functions: builtinFunctions,
+        provider: provider
+      })).rejects.toThrow('Unknown function: unknown_function')
+    })
+
+    it('잘못된 연산자 사용 시 에러가 발생해야 한다', async () => {
+      // Given - 파싱 단계에서 에러 발생
+      expect(() => parseFormula('10 ** 20')).toThrow()
+      expect(() => parseFormula('10 % 3')).toThrow()
+    })
+
+    it('불완전한 수식에서 파싱 에러가 발생해야 한다', async () => {
+      const invalidFormulas = [
+        '10 +',           // 불완전한 이항 연산
+        '(10 + 20',       // 닫히지 않은 괄호
+        '10 + 20)',       // 열리지 않은 괄호
+        'sum(10, 20,',    // 불완전한 함수 호출
+        ''                // 빈 수식
+      ]
+
+      for (const formula of invalidFormulas) {
+        expect(() => parseFormula(formula)).toThrow()
+      }
+    })
+  })
+})
+```
+
+## 3. KPI 값 관리 테스트 (kpi-value.spec.ts)
+
+```typescript
+import { describe, it, expect, beforeEach } from '@jest/globals'
+import { Repository, DataSource } from 'typeorm'
+import { KpiValue, KpiValueInputType } from '../server/service/kpi-value/kpi-value'
+import { Kpi, KpiPeriodType } from '../server/service/kpi/kpi'
+import { KpiOrgScope } from '../server/service/kpi-org-scope/kpi-org-scope'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { createTestingModule } from './test-utils'
+
+describe('KPI Value Management Tests', () => {
+  let dataSource: DataSource
+  let kpiValueRepository: Repository<KpiValue>
+  let kpiRepository: Repository<Kpi>
+  let domainRepository: Repository<Domain>
+  let userRepository: Repository<User>
+  let kpiOrgScopeRepository: Repository<KpiOrgScope>
+
+  let testDomain: Domain
+  let testUser: User
+  let testKpi: Kpi
+  let testOrgScope: KpiOrgScope
+
+  beforeEach(async () => {
+    const module = await createTestingModule()
+    dataSource = module.get<DataSource>(DataSource)
+    kpiValueRepository = dataSource.getRepository(KpiValue)
+    kpiRepository = dataSource.getRepository(Kpi)
+    domainRepository = dataSource.getRepository(Domain)
+    userRepository = dataSource.getRepository(User)
+    kpiOrgScopeRepository = dataSource.getRepository(KpiOrgScope)
+
+    // 테스트 데이터 준비
+    testDomain = await domainRepository.save({
+      name: 'TEST_DOMAIN',
+      description: 'Test Domain for KPI Value Tests'
+    })
+
+    testUser = await userRepository.save({
+      name: 'Test User',
+      email: 'test@example.com',
+      domain: testDomain
+    })
+
+    testKpi = await kpiRepository.save({
+      name: '안전사고율',
+      description: '월별 안전사고 발생률',
+      domain: testDomain,
+      creator: testUser,
+      isLeaf: true,
+      formula: 'accident_count / total_hours * 1000',
+      periodType: KpiPeriodType.MONTH,
+      active: true
+    })
+
+    testOrgScope = await kpiOrgScopeRepository.save({
+      name: '본사',
+      code: 'HQ',
+      domain: testDomain
+    })
+  })
+
+  describe('KPI 값 생성 테스트', () => {
+    it('기본 KPI 값 생성이 성공해야 한다', async () => {
+      // Given
+      const kpiValueData = {
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.5,
+        score: 85.0,
+        periodType: KpiPeriodType.MONTH,
+        inputType: KpiValueInputType.MANUAL,
+        source: 'Safety Department',
+        creator: testUser,
+        domain: testDomain
+      }
+
+      // When
+      const savedKpiValue = await kpiValueRepository.save(kpiValueData)
+
+      // Then
+      expect(savedKpiValue.id).toBeDefined()
+      expect(savedKpiValue.kpi.id).toBe(testKpi.id)
+      expect(savedKpiValue.orgScope.id).toBe(testOrgScope.id)
+      expect(savedKpiValue.value).toBe(2.5)
+      expect(savedKpiValue.score).toBe(85.0)
+      expect(savedKpiValue.inputType).toBe(KpiValueInputType.MANUAL)
+      expect(savedKpiValue.source).toBe('Safety Department')
+      expect(savedKpiValue.createdAt).toBeDefined()
+    })
+
+    it('자동 입력 KPI 값이 정상 생성되어야 한다', async () => {
+      // Given
+      const autoKpiValue = {
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 1.8,
+        score: 92.0,
+        periodType: KpiPeriodType.MONTH,
+        inputType: KpiValueInputType.AUTO,
+        source: 'SYSTEM_BATCH_JOB',
+        creator: testUser,
+        domain: testDomain
+      }
+
+      // When
+      const savedValue = await kpiValueRepository.save(autoKpiValue)
+
+      // Then
+      expect(savedValue.inputType).toBe(KpiValueInputType.AUTO)
+      expect(savedValue.source).toBe('SYSTEM_BATCH_JOB')
+      expect(savedValue.value).toBe(1.8)
+    })
+
+    it('필수 필드가 누락된 경우 에러가 발생해야 한다', async () => {
+      // Given
+      const invalidKpiValue = {
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.5
+        // kpi 필드가 누락됨
+      }
+
+      // When & Then
+      await expect(kpiValueRepository.save(invalidKpiValue))
+        .rejects.toThrow()
+    })
+
+    it('동일한 KPI, 조직, 날짜의 값이 중복 생성되면 기존값이 업데이트되어야 한다', async () => {
+      // Given - 첫 번째 값 생성
+      const firstValue = await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.0,
+        periodType: KpiPeriodType.MONTH,
+        inputType: KpiValueInputType.MANUAL,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // When - 동일한 조건으로 두 번째 값 생성
+      const secondValue = await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 3.0,
+        periodType: KpiPeriodType.MONTH,
+        inputType: KpiValueInputType.MANUAL,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // Then - 하나의 값만 존재해야 함
+      const values = await kpiValueRepository.find({
+        where: {
+          kpi: { id: testKpi.id },
+          orgScope: { id: testOrgScope.id },
+          valueDate: new Date('2024-01-01')
+        }
+      })
+
+      expect(values).toHaveLength(1)
+      expect(values[0].value).toBe(3.0) // 최신 값으로 업데이트됨
+    })
+  })
+
+  describe('KPI 값 업데이트 테스트', () => {
+    it('기존 KPI 값 수정이 성공해야 한다', async () => {
+      // Given
+      const originalValue = await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.5,
+        score: 80.0,
+        periodType: KpiPeriodType.MONTH,
+        inputType: KpiValueInputType.MANUAL,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // When
+      originalValue.value = 3.2
+      originalValue.score = 75.0
+      originalValue.source = 'Updated by Manager'
+      const updatedValue = await kpiValueRepository.save(originalValue)
+
+      // Then
+      expect(updatedValue.id).toBe(originalValue.id)
+      expect(updatedValue.value).toBe(3.2)
+      expect(updatedValue.score).toBe(75.0)
+      expect(updatedValue.source).toBe('Updated by Manager')
+      expect(updatedValue.updatedAt).toBeDefined()
+      expect(updatedValue.updatedAt > updatedValue.createdAt).toBe(true)
+    })
+
+    it('입력 타입 변경이 가능해야 한다', async () => {
+      // Given
+      const kpiValue = await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.0,
+        inputType: KpiValueInputType.AUTO,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // When - AUTO에서 MANUAL로 변경
+      kpiValue.inputType = KpiValueInputType.MANUAL
+      kpiValue.source = 'Manual Override'
+      const updatedValue = await kpiValueRepository.save(kpiValue)
+
+      // Then
+      expect(updatedValue.inputType).toBe(KpiValueInputType.MANUAL)
+      expect(updatedValue.source).toBe('Manual Override')
+    })
+  })
+
+  describe('KPI 값 삭제 테스트', () => {
+    it('KPI 값 소프트 삭제가 성공해야 한다', async () => {
+      // Given
+      const kpiValue = await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.5,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // When
+      await kpiValueRepository.softDelete(kpiValue.id)
+
+      // Then
+      const deletedValue = await kpiValueRepository.findOne({
+        where: { id: kpiValue.id },
+        withDeleted: true
+      })
+
+      expect(deletedValue.deletedAt).toBeDefined()
+
+      // 일반 조회에서는 보이지 않아야 함
+      const normalValue = await kpiValueRepository.findOne({
+        where: { id: kpiValue.id }
+      })
+      expect(normalValue).toBeNull()
+    })
+
+    it('KPI 값 하드 삭제가 성공해야 한다', async () => {
+      // Given
+      const kpiValue = await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: testOrgScope,
+        valueDate: new Date('2024-01-01'),
+        value: 2.5,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // When
+      await kpiValueRepository.delete(kpiValue.id)
+
+      // Then
+      const deletedValue = await kpiValueRepository.findOne({
+        where: { id: kpiValue.id },
+        withDeleted: true
+      })
+      expect(deletedValue).toBeNull()
+    })
+  })
+
+  describe('KPI 값 쿼리 테스트', () => {
+    beforeEach(async () => {
+      // 테스트용 KPI 값들 생성
+      const dates = [
+        new Date('2024-01-01'),
+        new Date('2024-02-01'),
+        new Date('2024-03-01'),
+        new Date('2024-04-01')
+      ]
+
+      for (let i = 0; i < dates.length; i++) {
+        await kpiValueRepository.save({
+          kpi: testKpi,
+          orgScope: testOrgScope,
+          valueDate: dates[i],
+          value: 2.0 + i * 0.5, // 2.0, 2.5, 3.0, 3.5
+          score: 90 - i * 5,    // 90, 85, 80, 75
+          periodType: KpiPeriodType.MONTH,
+          inputType: i % 2 === 0 ? KpiValueInputType.AUTO : KpiValueInputType.MANUAL,
+          creator: testUser,
+          domain: testDomain
+        })
+      }
+    })
+
+    it('날짜 범위로 KPI 값 조회가 정확해야 한다', async () => {
+      // Given
+      const startDate = new Date('2024-01-01')
+      const endDate = new Date('2024-03-01')
+
+      // When
+      const values = await kpiValueRepository
+        .createQueryBuilder('kv')
+        .where('kv.valueDate >= :startDate', { startDate })
+        .andWhere('kv.valueDate <= :endDate', { endDate })
+        .andWhere('kv.kpiId = :kpiId', { kpiId: testKpi.id })
+        .orderBy('kv.valueDate', 'ASC')
+        .getMany()
+
+      // Then
+      expect(values).toHaveLength(3) // 1월, 2월, 3월
+      expect(values[0].value).toBe(2.0)
+      expect(values[1].value).toBe(2.5)
+      expect(values[2].value).toBe(3.0)
+    })
+
+    it('입력 타입별 KPI 값 조회가 정확해야 한다', async () => {
+      // When - 자동 입력값만 조회
+      const autoValues = await kpiValueRepository.find({
+        where: {
+          kpi: { id: testKpi.id },
+          inputType: KpiValueInputType.AUTO
+        },
+        order: { valueDate: 'ASC' }
+      })
+
+      const manualValues = await kpiValueRepository.find({
+        where: {
+          kpi: { id: testKpi.id },
+          inputType: KpiValueInputType.MANUAL
+        },
+        order: { valueDate: 'ASC' }
+      })
+
+      // Then
+      expect(autoValues).toHaveLength(2) // 짝수 인덱스 (0, 2)
+      expect(manualValues).toHaveLength(2) // 홀수 인덱스 (1, 3)
+      expect(autoValues[0].value).toBe(2.0)
+      expect(autoValues[1].value).toBe(3.0)
+    })
+
+    it('KPI별 최신값 조회가 정확해야 한다', async () => {
+      // When
+      const latestValue = await kpiValueRepository
+        .createQueryBuilder('kv')
+        .where('kv.kpiId = :kpiId', { kpiId: testKpi.id })
+        .orderBy('kv.valueDate', 'DESC')
+        .getOne()
+
+      // Then
+      expect(latestValue.valueDate).toEqual(new Date('2024-04-01'))
+      expect(latestValue.value).toBe(3.5)
+      expect(latestValue.score).toBe(75)
+    })
+
+    it('조직별 KPI 값 집계가 정확해야 한다', async () => {
+      // Given - 추가 조직 생성
+      const subOrg = await kpiOrgScopeRepository.save({
+        name: '지사',
+        code: 'BRANCH',
+        domain: testDomain
+      })
+
+      // 지사용 KPI 값 생성
+      await kpiValueRepository.save({
+        kpi: testKpi,
+        orgScope: subOrg,
+        valueDate: new Date('2024-01-01'),
+        value: 1.5,
+        score: 95,
+        creator: testUser,
+        domain: testDomain
+      })
+
+      // When - 조직별 평균 조회
+      const orgStats = await kpiValueRepository
+        .createQueryBuilder('kv')
+        .select('org.name', 'orgName')
+        .addSelect('AVG(kv.value)', 'avgValue')
+        .addSelect('AVG(kv.score)', 'avgScore')
+        .addSelect('COUNT(kv.id)', 'count')
+        .innerJoin('kv.orgScope', 'org')
+        .where('kv.kpiId = :kpiId', { kpiId: testKpi.id })
+        .groupBy('org.id, org.name')
+        .getRawMany()
+
+      // Then
+      expect(orgStats).toHaveLength(2)
+
+      const hqStats = orgStats.find(s => s.orgName === '본사')
+      const branchStats = orgStats.find(s => s.orgName === '지사')
+
+      expect(hqStats.count).toBe('4')
+      expect(parseFloat(hqStats.avgValue)).toBe(2.75) // (2.0+2.5+3.0+3.5)/4
+      expect(branchStats.count).toBe('1')
+      expect(parseFloat(branchStats.avgValue)).toBe(1.5)
+    })
+  })
+
+  describe('점수 계산 테스트', () => {
+    it('등급 기반 점수 계산이 정확해야 한다', async () => {
+      // Given - 등급 정보가 있는 KPI
+      const gradeKpi = await kpiRepository.save({
+        name: '품질지수',
+        domain: testDomain,
+        creator: testUser,
+        grades: {
+          '1': { minValue: 0, maxValue: 60, score: 20, color: '#ff4757' },
+          '2': { minValue: 60, maxValue: 70, score: 40, color: '#ffa726' },
+          '3': { minValue: 70, maxValue: 80, score: 60, color: '#ffeb3b' },
+          '4': { minValue: 80, maxValue: 90, score: 80, color: '#66bb6a' },
+          '5': { minValue: 90, maxValue: 100, score: 100, color: '#43a047' }
+        }
+      })
+
+      const testCases = [
+        { value: 55, expectedScore: 20 },   // 1등급
+        { value: 65, expectedScore: 40 },   // 2등급
+        { value: 75, expectedScore: 60 },   // 3등급
+        { value: 85, expectedScore: 80 },   // 4등급
+        { value: 95, expectedScore: 100 }   // 5등급
+      ]
+
+      for (const testCase of testCases) {
+        // When
+        const kpiValue = await kpiValueRepository.save({
+          kpi: gradeKpi,
+          orgScope: testOrgScope,
+          valueDate: new Date(`2024-0${testCases.indexOf(testCase) + 1}-01`),
+          value: testCase.value,
+          creator: testUser,
+          domain: testDomain
+        })
+
+        // 점수 계산 로직 실행 (실제로는 서비스 레이어에서 처리)
+        let calculatedScore = 0
+        for (const grade in gradeKpi.grades) {
+          const gradeInfo = gradeKpi.grades[grade]
+          if (testCase.value >= gradeInfo.minValue && testCase.value < gradeInfo.maxValue) {
+            calculatedScore = gradeInfo.score
+            break
+          }
+        }
+
+        kpiValue.score = calculatedScore
+        const savedValue = await kpiValueRepository.save(kpiValue)
+
+        // Then
+        expect(savedValue.score).toBe(testCase.expectedScore)
+      }
+    })
+
+    it('수식 기반 점수 계산이 정확해야 한다', async () => {
+      // Given - 점수 계산 수식이 있는 KPI
+      const formulaKpi = await kpiRepository.save({
+        name: '효율성지수',
+        domain: testDomain,
+        creator: testUser,
+        scoreFormula: 'if(value >= 90, 100, if(value >= 80, value * 0.9, value * 0.7))'
+      })
+
+      const testCases = [
+        { value: 95, expectedScore: 100 },      // >= 90이면 100
+        { value: 85, expectedScore: 76.5 },     // 80~90이면 value * 0.9
+        { value: 75, expectedScore: 52.5 }      // < 80이면 value * 0.7
+      ]
+
+      for (const testCase of testCases) {
+        // When - 실제 점수 계산은 서비스 레이어에서 수행
+        let calculatedScore = 0
+        if (testCase.value >= 90) {
+          calculatedScore = 100
+        } else if (testCase.value >= 80) {
+          calculatedScore = testCase.value * 0.9
+        } else {
+          calculatedScore = testCase.value * 0.7
+        }
+
+        const kpiValue = await kpiValueRepository.save({
+          kpi: formulaKpi,
+          orgScope: testOrgScope,
+          valueDate: new Date(`2024-0${testCases.indexOf(testCase) + 1}-01`),
+          value: testCase.value,
+          score: calculatedScore,
+          creator: testUser,
+          domain: testDomain
+        })
+
+        // Then
+        expect(kpiValue.score).toBe(testCase.expectedScore)
+      }
+    })
+
+    it('점수가 0-100 범위를 벗어나면 에러가 발생해야 한다', async () => {
+      const invalidScores = [-10, 150, -1, 101]
+
+      for (const invalidScore of invalidScores) {
+        await expect(kpiValueRepository.save({
+          kpi: testKpi,
+          orgScope: testOrgScope,
+          valueDate: new Date('2024-01-01'),
+          value: 50,
+          score: invalidScore,
+          creator: testUser,
+          domain: testDomain
+        })).rejects.toThrow(/score must be between 0 and 100/)
+      }
+    })
+  })
+
+  describe('배치 처리 테스트', () => {
+    it('대용량 KPI 값 배치 삽입이 성공해야 한다', async () => {
+      // Given
+      const batchSize = 1000
+      const kpiValues = []
+
+      for (let i = 0; i < batchSize; i++) {
+        kpiValues.push({
+          kpi: testKpi,
+          orgScope: testOrgScope,
+          valueDate: new Date(`2024-01-${String(i % 28 + 1).padStart(2, '0')}`),
+          value: Math.random() * 10,
+          score: Math.random() * 100,
+          inputType: KpiValueInputType.AUTO,
+          source: 'BATCH_JOB',
+          creator: testUser,
+          domain: testDomain
+        })
+      }
+
+      // When
+      const startTime = Date.now()
+      await kpiValueRepository
+        .createQueryBuilder()
+        .insert()
+        .into(KpiValue)
+        .values(kpiValues)
+        .execute()
+      const endTime = Date.now()
+
+      // Then
+      const insertedCount = await kpiValueRepository.count({
+        where: { source: 'BATCH_JOB' }
+      })
+
+      expect(insertedCount).toBe(batchSize)
+      expect(endTime - startTime).toBeLessThan(5000) // 5초 이내
+    })
+
+    it('배치 업데이트가 효율적으로 처리되어야 한다', async () => {
+      // Given - 기존 데이터 준비
+      const existingValues = []
+      for (let i = 0; i < 100; i++) {
+        const value = await kpiValueRepository.save({
+          kpi: testKpi,
+          orgScope: testOrgScope,
+          valueDate: new Date(`2024-01-${String(i % 28 + 1).padStart(2, '0')}`),
+          value: i,
+          score: i,
+          creator: testUser,
+          domain: testDomain
+        })
+        existingValues.push(value)
+      }
+
+      // When - 배치 업데이트
+      const startTime = Date.now()
+      await kpiValueRepository
+        .createQueryBuilder()
+        .update(KpiValue)
+        .set({ score: () => 'value * 2' }) // 점수를 값의 2배로 업데이트
+        .where('kpiId = :kpiId', { kpiId: testKpi.id })
+        .execute()
+      const endTime = Date.now()
+
+      // Then
+      const updatedValues = await kpiValueRepository.find({
+        where: { kpi: { id: testKpi.id } },
+        order: { valueDate: 'ASC' }
+      })
+
+      expect(updatedValues).toHaveLength(100)
+      expect(updatedValues[50].score).toBe(updatedValues[50].value * 2)
+      expect(endTime - startTime).toBeLessThan(1000) // 1초 이내
+    })
+  })
+})
+```
+
+이제 단위 테스트가 훨씬 더 상세하게 작성되었습니다. 각 테스트는 실제 코드 예제와 함께 다음 항목들을 다룹니다:
+
+1. **KPI 엔티티 테스트**: 생성, 계층 구조, 상태 변경, 수식 검증, 시각화 메타데이터
+2. **수식 계산기 테스트**: 사칙연산, 변수 참조, 함수 호출, 조건문, 성과지수, 복합 수식, 에러 처리
+3. **KPI 값 관리 테스트**: CRUD 작업, 쿼리, 점수 계산, 배치 처리
+
+각 테스트는 Given-When-Then 패턴을 따르며, 엣지 케이스와 에러 상황도 포함하고 있습니다.