@things-factory/dataset 9.1.19 → 9.2.5

package/spec/unit/controllers/issue-ooc-review.spec.ts

@@ -0,0 +1,288 @@
+/**
+ * issue-ooc-review Controller Unit Tests
+ * OOC Review Activity 발행 컨트롤러 테스트
+ */
+
+import { TestDatabase } from '../../../../../test/test-database'
+import { withTestTransaction } from '../../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  dataSetFactory,
+  dataSampleFactory,
+  dataOocFactory,
+  activityFactory,
+  activityInstanceFactory
+} from '../../../../../test/factories'
+import { DataOocStatus, ActivityInstanceStatus } from '../../../../../test/entities/schemas'
+
+describe('issue-ooc-review Controller', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('OOC Review Activity 발행 조건', () => {
+    it('Activity가 존재하고 supervisoryRole이 있으면 Review Instance가 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: OOC Review Activity와 supervisoryRole이 있는 DataSet
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const supervisoryRole = await roleFactory.create({ name: 'Supervisor', domain }, tx)
+        const dataSet = await dataSetFactory.createWithDomain(
+          { supervisoryRole },
+          domain,
+          tx
+        )
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.ISSUED },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // When: issueOocReview 로직 시뮬레이션
+        const activityInstance = await activityInstanceFactory.createWithActivity(
+          {
+            name: `[OOC 검토] ${dataSet.name}`,
+            description: dataSet.description,
+            state: ActivityInstanceStatus.Issued,
+            dueAt: new Date(dataOoc.collectedAt.getTime() + reviewActivity.standardTime * 1000),
+            input: { dataOocId: dataOoc.id },
+            assigneeRole: supervisoryRole,
+            threadsMin: 1,
+            threadsMax: 1,
+            approvalLine: []
+          },
+          reviewActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(activityInstance).toBeDefined()
+        expect(activityInstance.name).toBe(`[OOC 검토] ${dataSet.name}`)
+        expect(activityInstance.input?.dataOocId).toBe(dataOoc.id)
+        expect(activityInstance.assigneeRole?.id).toBe(supervisoryRole.id)
+        expect(activityInstance.activity?.id).toBe(reviewActivity.id)
+      })
+    })
+
+    it('supervisoryRole이 없으면 Review Activity가 발행되지 않아야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: supervisoryRole이 없는 DataSet
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const dataSet = await dataSetFactory.createWithDomain(
+          { supervisoryRole: undefined, supervisoryRoleId: undefined },
+          domain,
+          tx
+        )
+
+        // When & Then: supervisoryRole 체크
+        const supervisoryRoleId = dataSet.supervisoryRoleId
+        expect(supervisoryRoleId).toBeFalsy()
+
+        // issueOocReview 로직에서는 이 경우 console.error만 출력하고 리턴
+        // Activity Instance가 생성되지 않음
+      })
+    })
+
+    it('OOC Review Activity가 설치되지 않으면 Review가 발행되지 않아야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: OOC Review Activity가 없는 상태
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+
+        // When: Activity 조회
+        const activity = await tx
+          .getRepository('Activity')
+          .findOne({ where: { domain: { id: domain.id }, name: 'OOC Review' } })
+
+        // Then: Activity가 없음
+        expect(activity).toBeNull()
+        // issueOocReview 로직에서는 이 경우 console.warn만 출력하고 리턴
+      })
+    })
+  })
+
+  describe('OOC Review Instance 속성', () => {
+    it('dueAt은 collectedAt + standardTime으로 계산되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const standardTime = 48 * 60 * 60 // 48시간
+        const reviewActivity = await activityFactory.createWithDomain(
+          {
+            name: 'OOC Review',
+            standardTime
+          },
+          domain,
+          tx
+        )
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+        const collectedAt = new Date('2024-01-15T10:00:00.000Z')
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.ISSUED, collectedAt },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // When: dueAt 계산
+        const expectedDueAt = new Date(collectedAt.getTime() + standardTime * 1000)
+
+        // Then
+        expect(expectedDueAt.getTime()).toBe(collectedAt.getTime() + standardTime * 1000)
+      })
+    })
+
+    it('input에 dataOocId가 포함되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+        const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.ISSUED },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // When: issueOocReview 입력 구성
+        const input = { dataOocId: dataOoc.id }
+
+        // Then
+        expect(input.dataOocId).toBe(dataOoc.id)
+      })
+    })
+
+    it('threadsMin과 threadsMax가 1로 설정되어야 한다 (single 담당자)', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+
+        // When: ActivityInstance 생성
+        const activityInstance = await activityInstanceFactory.createWithActivity(
+          {
+            threadsMin: 1,
+            threadsMax: 1,
+            assigneeRole: supervisoryRole
+          },
+          reviewActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(activityInstance.threadsMin).toBe(1)
+        expect(activityInstance.threadsMax).toBe(1)
+      })
+    })
+
+    it('approvalLine은 빈 배열이어야 한다 (Review는 결재 없음)', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+
+        // When: ActivityInstance 생성 (issueOocReview 방식)
+        const activityInstance = await activityInstanceFactory.createWithActivity(
+          {
+            approvalLine: [],
+            assigneeRole: supervisoryRole
+          },
+          reviewActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(activityInstance.approvalLine).toEqual([])
+      })
+    })
+  })
+
+  describe('DataOoc과 ReviewActivityInstance 연결', () => {
+    it('DataOoc의 reviewActivityInstance 필드에 생성된 Instance가 저장되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const { dataSet, supervisoryRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+        let dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          { state: DataOocStatus.ISSUED },
+          dataSet,
+          undefined,
+          tx
+        )
+
+        // When: Review Instance 생성 및 DataOoc에 연결
+        const reviewInstance = await activityInstanceFactory.createWithActivity(
+          {
+            name: `[OOC 검토] ${dataSet.name}`,
+            state: ActivityInstanceStatus.Issued,
+            input: { dataOocId: dataOoc.id },
+            assigneeRole: supervisoryRole
+          },
+          reviewActivity,
+          domain,
+          tx
+        )
+
+        dataOoc.reviewActivityInstance = reviewInstance
+        dataOoc = await tx.save('DataOoc', dataOoc)
+
+        // Then
+        expect(dataOoc.reviewActivityInstance).toBeDefined()
+        expect(dataOoc.reviewActivityInstance?.id).toBe(reviewInstance.id)
+      })
+    })
+  })
+
+  describe('Parent Domain 지원', () => {
+    it('domain.parentId가 있으면 parent domain의 Activity도 조회해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: Parent Domain과 Child Domain 구조
+        const parentDomain = await domainFactory.create({ name: 'Parent Domain' }, tx)
+        const childDomain = await domainFactory.create(
+          {
+            name: 'Child Domain',
+            parentId: parentDomain.id
+          },
+          tx
+        )
+
+        // Parent Domain에 Activity 생성
+        const reviewActivity = await activityFactory.createOocReviewActivity(parentDomain, tx)
+
+        // When: Child Domain에서 Activity 조회 (In 연산자 사용)
+        const activities = await tx.getRepository('Activity').find({
+          where: [
+            { domain: { id: childDomain.id }, name: 'OOC Review' },
+            { domain: { id: parentDomain.id }, name: 'OOC Review' }
+          ]
+        })
+
+        // Then: Parent의 Activity가 조회됨
+        expect(activities.length).toBeGreaterThan(0)
+        expect(activities[0].id).toBe(reviewActivity.id)
+      })
+    })
+  })
+})

package/spec/unit/data-use-case.spec.ts

@@ -0,0 +1,150 @@
+/**
+ * DataUseCase Unit Tests
+ * 데이터 평가 로직 단위 테스트
+ */
+
+// 단위 테스트에서는 dist 파일에서 직접 import하여 패키지 의존성 우회
+import { DataUseCase } from '../../dist-server/controllers/data-use-case'
+
+// 테스트용 타입 정의 (실제 타입과 호환)
+interface DataItem {
+  name: string
+  tag?: string
+  active: boolean
+  type: string
+  spec?: Record<string, any>
+}
+
+interface DataSet {
+  useCase: string | null
+}
+
+describe('DataUseCase', () => {
+  describe('evaluate', () => {
+    it('useCase가 없으면 ooc/oos 모두 false를 반환해야 한다', () => {
+      // Given
+      const dataSet = { useCase: null } as DataSet
+      const dataItems: DataItem[] = []
+      const data = {}
+
+      // When
+      const result = DataUseCase.evaluate(dataSet, dataItems, data)
+
+      // Then
+      expect(result.ooc).toBe(false)
+      expect(result.oos).toBe(false)
+    })
+
+    it('active가 false인 dataItem은 평가하지 않아야 한다', () => {
+      // Given
+      const dataSet = { useCase: 'QA' } as DataSet
+      const dataItems: DataItem[] = [
+        {
+          name: 'Temperature',
+          tag: 'temperature',
+          active: false,
+          type: 'number' as any,
+          spec: {
+            QA: { ucl: 80, lcl: 20 }
+          }
+        }
+      ]
+      const data = { temperature: 100 } // UCL 초과하지만 inactive
+
+      // When
+      const result = DataUseCase.evaluate(dataSet, dataItems, data)
+
+      // Then
+      expect(result.ooc).toBe(false)
+      expect(result.judgment).toEqual({})
+    })
+
+    it('tag가 없는 dataItem은 평가하지 않아야 한다', () => {
+      // Given
+      const dataSet = { useCase: 'QA' } as DataSet
+      const dataItems: DataItem[] = [
+        {
+          name: 'Temperature',
+          tag: undefined,
+          active: true,
+          type: 'number' as any,
+          spec: {
+            QA: { ucl: 80, lcl: 20 }
+          }
+        }
+      ]
+      const data = { temperature: 100 }
+
+      // When
+      const result = DataUseCase.evaluate(dataSet, dataItems, data)
+
+      // Then
+      expect(result.ooc).toBe(false)
+    })
+
+    it('값이 null이면 해당 항목을 건너뛰어야 한다', () => {
+      // Given
+      const dataSet = { useCase: 'QA' } as DataSet
+      const dataItems: DataItem[] = [
+        {
+          name: 'Temperature',
+          tag: 'temperature',
+          active: true,
+          type: 'number' as any,
+          spec: {
+            QA: { ucl: 80, lcl: 20 }
+          }
+        }
+      ]
+      const data = { temperature: null }
+
+      // When
+      const result = DataUseCase.evaluate(dataSet, dataItems, data)
+
+      // Then
+      expect(result.ooc).toBe(false)
+      expect(result.judgment).toEqual({})
+    })
+
+    it('배열 형태의 값도 처리할 수 있어야 한다', () => {
+      // Given
+      const dataSet = { useCase: 'QA' } as DataSet
+      const dataItems: DataItem[] = [
+        {
+          name: 'Temperature',
+          tag: 'temperature',
+          active: true,
+          type: 'number' as any,
+          spec: {
+            QA: { ucl: 80, lcl: 20 }
+          }
+        }
+      ]
+      const data = { temperature: [50, 60, 70] } // 배열 형태
+
+      // When
+      const result = DataUseCase.evaluate(dataSet, dataItems, data)
+
+      // Then: 에러 없이 처리되어야 함
+      expect(result).toBeDefined()
+    })
+  })
+
+  describe('registry', () => {
+    it('등록된 useCase 이름 목록을 반환해야 한다', () => {
+      // When
+      const names = DataUseCase.getUseCaseNames()
+
+      // Then
+      expect(Array.isArray(names)).toBe(true)
+    })
+
+    it('존재하지 않는 useCase는 undefined를 반환해야 한다', () => {
+      // When
+      const useCase = DataUseCase.getUseCase('non-existent-use-case')
+
+      // Then
+      expect(useCase).toBeUndefined()
+    })
+  })
+})

package/spec/unit/ooc-state-transition.spec.ts

@@ -0,0 +1,233 @@
+/**
+ * OOC State Transition Unit Tests
+ * DataOoc 상태 전이 로직 단위 테스트
+ */
+
+import {
+  isValidOocState,
+  isValidOocTransition
+} from '../../../../test/helpers/workflow-helpers'
+import { DataOocStatus } from '../../../../test/entities/schemas'
+
+describe('OOC State Transition Logic', () => {
+  describe('isValidOocState', () => {
+    it('ISSUED 상태는 유효해야 한다', () => {
+      const dataOoc = { state: DataOocStatus.ISSUED } as any
+      expect(isValidOocState(dataOoc)).toBe(true)
+    })
+
+    it('REVIEWED 상태는 유효해야 한다', () => {
+      const dataOoc = { state: DataOocStatus.REVIEWED } as any
+      expect(isValidOocState(dataOoc)).toBe(true)
+    })
+
+    it('CORRECTED 상태는 유효해야 한다', () => {
+      const dataOoc = { state: DataOocStatus.CORRECTED } as any
+      expect(isValidOocState(dataOoc)).toBe(true)
+    })
+
+    it('REJECTED 상태는 유효해야 한다', () => {
+      const dataOoc = { state: DataOocStatus.REJECTED } as any
+      expect(isValidOocState(dataOoc)).toBe(true)
+    })
+
+    it('유효하지 않은 상태는 false를 반환해야 한다', () => {
+      const dataOoc = { state: 'INVALID_STATE' } as any
+      expect(isValidOocState(dataOoc)).toBe(false)
+    })
+  })
+
+  describe('isValidOocTransition', () => {
+    describe('유효한 상태 전이', () => {
+      it('ISSUED -> REVIEWED 전이는 유효해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.ISSUED, DataOocStatus.REVIEWED)).toBe(true)
+      })
+
+      it('REVIEWED -> CORRECTED 전이는 유효해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.REVIEWED, DataOocStatus.CORRECTED)).toBe(true)
+      })
+    })
+
+    describe('유효하지 않은 상태 전이', () => {
+      it('ISSUED -> CORRECTED 직접 전이는 불가능해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.ISSUED, DataOocStatus.CORRECTED)).toBe(false)
+      })
+
+      it('REVIEWED -> ISSUED 역방향 전이는 불가능해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.REVIEWED, DataOocStatus.ISSUED)).toBe(false)
+      })
+
+      it('CORRECTED -> REVIEWED 역방향 전이는 불가능해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.REVIEWED)).toBe(false)
+      })
+
+      it('CORRECTED -> ISSUED 역방향 전이는 불가능해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.ISSUED)).toBe(false)
+      })
+
+      it('CORRECTED는 종료 상태이므로 더 이상 전이할 수 없다', () => {
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.CORRECTED)).toBe(false)
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.REVIEWED)).toBe(false)
+        expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.ISSUED)).toBe(false)
+      })
+
+      it('REJECTED는 종료 상태이므로 더 이상 전이할 수 없다', () => {
+        expect(isValidOocTransition(DataOocStatus.REJECTED, DataOocStatus.ISSUED)).toBe(false)
+        expect(isValidOocTransition(DataOocStatus.REJECTED, DataOocStatus.REVIEWED)).toBe(false)
+        expect(isValidOocTransition(DataOocStatus.REJECTED, DataOocStatus.CORRECTED)).toBe(false)
+      })
+
+      it('같은 상태로의 전이는 불가능해야 한다', () => {
+        expect(isValidOocTransition(DataOocStatus.ISSUED, DataOocStatus.ISSUED)).toBe(false)
+        expect(isValidOocTransition(DataOocStatus.REVIEWED, DataOocStatus.REVIEWED)).toBe(false)
+      })
+    })
+  })
+
+  describe('DataOocStatus Enum', () => {
+    it('모든 상태 값이 정의되어야 한다', () => {
+      expect(DataOocStatus.ISSUED).toBe('ISSUED')
+      expect(DataOocStatus.REVIEWED).toBe('REVIEWED')
+      expect(DataOocStatus.CORRECTED).toBe('CORRECTED')
+      expect(DataOocStatus.REJECTED).toBe('REJECTED')
+    })
+
+    it('총 4개의 상태가 있어야 한다', () => {
+      const statusValues = Object.values(DataOocStatus)
+      expect(statusValues.length).toBe(4)
+    })
+  })
+})
+
+describe('OOC State Rules', () => {
+  describe('ISSUED 상태 규칙', () => {
+    it('OOC 생성 시 초기 상태는 ISSUED여야 한다', () => {
+      // DataOoc이 생성될 때 기본 state는 ISSUED
+      expect(DataOocStatus.ISSUED).toBe('ISSUED')
+    })
+
+    it('ISSUED 상태에서는 reviewedAt이 설정되지 않아야 한다', () => {
+      const dataOoc = {
+        state: DataOocStatus.ISSUED,
+        reviewedAt: null,
+        correctedAt: null
+      }
+      expect(dataOoc.reviewedAt).toBeNull()
+      expect(dataOoc.correctedAt).toBeNull()
+    })
+  })
+
+  describe('REVIEWED 상태 규칙', () => {
+    it('REVIEWED로 전이 시 reviewedAt이 설정되어야 한다', () => {
+      const now = new Date()
+      const dataOoc = {
+        state: DataOocStatus.REVIEWED,
+        reviewedAt: now,
+        correctedAt: null
+      }
+      expect(dataOoc.reviewedAt).toEqual(now)
+      expect(dataOoc.correctedAt).toBeNull()
+    })
+
+    it('REVIEWED로 전이 시 reviewer가 설정되어야 한다', () => {
+      const reviewer = { id: 'user-1', name: 'Reviewer' }
+      const dataOoc = {
+        state: DataOocStatus.REVIEWED,
+        reviewer
+      }
+      expect(dataOoc.reviewer).toBeDefined()
+      expect(dataOoc.reviewer.id).toBe('user-1')
+    })
+
+    it('REVIEWED로 전이 시 correctiveInstruction이 설정될 수 있다', () => {
+      const dataOoc = {
+        state: DataOocStatus.REVIEWED,
+        correctiveInstruction: 'Temperature를 조절하세요'
+      }
+      expect(dataOoc.correctiveInstruction).toBe('Temperature를 조절하세요')
+    })
+  })
+
+  describe('CORRECTED 상태 규칙', () => {
+    it('CORRECTED로 전이 시 correctedAt이 설정되어야 한다', () => {
+      const now = new Date()
+      const dataOoc = {
+        state: DataOocStatus.CORRECTED,
+        reviewedAt: new Date(Date.now() - 3600000), // 1시간 전
+        correctedAt: now
+      }
+      expect(dataOoc.correctedAt).toEqual(now)
+    })
+
+    it('CORRECTED로 전이 시 corrector가 설정되어야 한다', () => {
+      const corrector = { id: 'user-2', name: 'Corrector' }
+      const dataOoc = {
+        state: DataOocStatus.CORRECTED,
+        corrector
+      }
+      expect(dataOoc.corrector).toBeDefined()
+      expect(dataOoc.corrector.id).toBe('user-2')
+    })
+
+    it('CORRECTED로 전이 시 correctiveAction이 설정되어야 한다', () => {
+      const dataOoc = {
+        state: DataOocStatus.CORRECTED,
+        correctiveAction: 'Temperature를 정상 범위로 조절함'
+      }
+      expect(dataOoc.correctiveAction).toBe('Temperature를 정상 범위로 조절함')
+    })
+
+    it('CORRECTED는 종료 상태이다', () => {
+      // 더 이상 전이 불가
+      expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.ISSUED)).toBe(false)
+      expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.REVIEWED)).toBe(false)
+      expect(isValidOocTransition(DataOocStatus.CORRECTED, DataOocStatus.CORRECTED)).toBe(false)
+    })
+  })
+
+  describe('History 추적 규칙', () => {
+    it('상태 전이 시 history에 기록이 추가되어야 한다', () => {
+      const history = [
+        {
+          user: { id: 'user-1', name: 'Creator' },
+          state: DataOocStatus.ISSUED,
+          timestamp: '2024-01-01T00:00:00.000Z'
+        },
+        {
+          user: { id: 'user-2', name: 'Reviewer' },
+          state: DataOocStatus.REVIEWED,
+          timestamp: '2024-01-01T01:00:00.000Z'
+        }
+      ]
+
+      expect(history.length).toBe(2)
+      expect(history[0].state).toBe(DataOocStatus.ISSUED)
+      expect(history[1].state).toBe(DataOocStatus.REVIEWED)
+    })
+
+    it('history 엔트리에는 user, state, timestamp가 있어야 한다', () => {
+      const historyEntry = {
+        user: { id: 'user-1', name: 'User' },
+        state: DataOocStatus.ISSUED,
+        timestamp: new Date().toISOString()
+      }
+
+      expect(historyEntry.user).toBeDefined()
+      expect(historyEntry.user.id).toBeDefined()
+      expect(historyEntry.user.name).toBeDefined()
+      expect(historyEntry.state).toBeDefined()
+      expect(historyEntry.timestamp).toBeDefined()
+    })
+
+    it('CORRECTED 전이 시 history에 comment(correctiveAction)가 포함될 수 있다', () => {
+      const historyEntry = {
+        user: { id: 'user-1', name: 'Corrector' },
+        state: DataOocStatus.CORRECTED,
+        comment: 'Temperature를 정상 범위로 조절함',
+        timestamp: new Date().toISOString()
+      }
+
+      expect(historyEntry.comment).toBe('Temperature를 정상 범위로 조절함')
+    })
+  })
+})