@things-factory/dataset 9.1.19 → 9.2.5

package/spec/unit/controllers/activity-callbacks.spec.ts

@@ -0,0 +1,609 @@
+/**
+ * Activity Callback Unit Tests
+ * OOC Review/Resolve Activity callback 테스트
+ */
+
+import { TestDatabase } from '../../../../../test/test-database'
+import { withTestTransaction } from '../../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  dataSetFactory,
+  dataOocFactory,
+  activityFactory,
+  activityInstanceFactory,
+  activityThreadFactory
+} from '../../../../../test/factories'
+import {
+  DataOocStatus,
+  ActivityInstanceStatus,
+  ActivityThreadStatus
+} from '../../../../../test/entities/schemas'
+
+describe('Activity Callbacks', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('ActivityOocReview Callback', () => {
+    describe('Review Activity 완료 시 동작', () => {
+      it('ActivityInstance가 Ended 상태가 되면 DataOoc 상태가 REVIEWED로 전이되어야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain, user } = context.state
+
+          // Given: Review Activity와 DataOoc 설정
+          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
+          )
+
+          // Review ActivityInstance 생성
+          const reviewInstance = await activityInstanceFactory.createWithActivity(
+            {
+              name: `[OOC 검토] ${dataSet.name}`,
+              state: ActivityInstanceStatus.Issued,
+              input: { dataOocId: dataOoc.id },
+              output: {},
+              assigneeRole: supervisoryRole
+            },
+            reviewActivity,
+            domain,
+            tx
+          )
+
+          // When: ActivityInstance가 Ended 상태로 변경 (callback 시뮬레이션)
+          const terminatedAt = new Date()
+          const correctiveInstruction = 'Temperature를 정상 범위로 조절하세요'
+
+          reviewInstance.state = ActivityInstanceStatus.Ended
+          reviewInstance.terminatedAt = terminatedAt
+          reviewInstance.output = { instruction: correctiveInstruction }
+          await tx.save('ActivityInstance', reviewInstance)
+
+          // Callback 로직 시뮬레이션: DataOoc 업데이트
+          dataOoc = await tx.getRepository('DataOoc').findOne({
+            where: { id: dataOoc.id },
+            relations: ['dataSet']
+          }) as any
+
+          dataOoc.reviewedAt = terminatedAt
+          dataOoc.reviewer = user
+          dataOoc.correctiveInstruction = correctiveInstruction
+          dataOoc.state = DataOocStatus.REVIEWED
+          dataOoc = await tx.save('DataOoc', dataOoc)
+
+          // Then
+          expect(dataOoc.state).toBe(DataOocStatus.REVIEWED)
+          expect(dataOoc.reviewedAt).toEqual(terminatedAt)
+          expect(dataOoc.reviewer?.id).toBe(user.id)
+          expect(dataOoc.correctiveInstruction).toBe(correctiveInstruction)
+        })
+      })
+
+      it('Review 완료 시 correctiveInstruction이 output.instruction에서 가져와야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain, user } = context.state
+
+          // Given
+          const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+          const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+          let dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.ISSUED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          const instruction = '습도 레벨을 30-70% 사이로 유지하세요'
+          const reviewInstance = await activityInstanceFactory.createWithActivity(
+            {
+              state: ActivityInstanceStatus.Ended,
+              input: { dataOocId: dataOoc.id },
+              output: { instruction },
+              terminatedAt: new Date()
+            },
+            reviewActivity,
+            domain,
+            tx
+          )
+
+          // When: Callback 로직
+          const outputInstruction = reviewInstance.output?.instruction
+
+          dataOoc.correctiveInstruction = outputInstruction
+          dataOoc.state = DataOocStatus.REVIEWED
+          dataOoc = await tx.save('DataOoc', dataOoc)
+
+          // Then
+          expect(dataOoc.correctiveInstruction).toBe(instruction)
+        })
+      })
+
+      it('Review 완료 후 issueOocResolve가 호출되어야 한다 (Resolve 발행)', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain, user } = context.state
+
+          // Given
+          const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+          const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+          const { dataSet, supervisoryRole, resolverRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+
+          let dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.ISSUED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          const instruction = 'Fix the issue'
+          const terminatedAt = new Date()
+
+          // When: Review 완료 및 Callback 전체 로직 시뮬레이션
+          // 1. DataOoc REVIEWED로 업데이트
+          dataOoc.reviewedAt = terminatedAt
+          dataOoc.reviewer = user
+          dataOoc.correctiveInstruction = instruction
+          dataOoc.state = DataOocStatus.REVIEWED
+          dataOoc = await tx.save('DataOoc', dataOoc)
+
+          // 2. issueOocResolve 호출 (Resolve Activity 발행)
+          const resolveInstance = await activityInstanceFactory.createWithActivity(
+            {
+              name: `[OOC 조치] ${dataSet.name}`,
+              state: ActivityInstanceStatus.Issued,
+              input: {
+                dataOocId: dataOoc.id,
+                instruction
+              },
+              assigneeRole: resolverRole,
+              approvalLine: dataSet.outlierApprovalLine || []
+            },
+            resolveActivity,
+            domain,
+            tx
+          )
+
+          dataOoc.resolveActivityInstance = resolveInstance
+          dataOoc = await tx.save('DataOoc', dataOoc)
+
+          // Then
+          expect(dataOoc.state).toBe(DataOocStatus.REVIEWED)
+          expect(dataOoc.resolveActivityInstance).toBeDefined()
+          expect(dataOoc.resolveActivityInstance?.input?.instruction).toBe(instruction)
+        })
+      })
+
+      it('Ended가 아닌 상태에서는 callback 로직이 실행되지 않아야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain } = context.state
+
+          // Given
+          const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+          const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+          const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.ISSUED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          const reviewInstance = await activityInstanceFactory.createWithActivity(
+            {
+              state: ActivityInstanceStatus.Started, // Ended가 아님
+              input: { dataOocId: dataOoc.id }
+            },
+            reviewActivity,
+            domain,
+            tx
+          )
+
+          // When: Callback 조건 체크
+          const shouldExecuteCallback = reviewInstance.state === ActivityInstanceStatus.Ended
+
+          // Then
+          expect(shouldExecuteCallback).toBe(false)
+        })
+      })
+    })
+  })
+
+  describe('ActivityOocResolve Callback', () => {
+    describe('Resolve Activity 완료 시 동작', () => {
+      it('ActivityInstance가 Ended 상태가 되면 DataOoc 상태가 CORRECTED로 전이되어야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain, user } = context.state
+
+          // Given: REVIEWED 상태의 DataOoc과 Resolve Activity
+          const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+          const { dataSet, resolverRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+          let dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            {
+              state: DataOocStatus.REVIEWED,
+              reviewedAt: new Date(),
+              correctiveInstruction: 'Fix temperature'
+            },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          // Resolve ActivityInstance 생성
+          const resolveInstance = await activityInstanceFactory.createWithActivity(
+            {
+              name: `[OOC 조치] ${dataSet.name}`,
+              state: ActivityInstanceStatus.Issued,
+              input: {
+                dataOocId: dataOoc.id,
+                instruction: dataOoc.correctiveInstruction
+              },
+              output: {},
+              assigneeRole: resolverRole
+            },
+            resolveActivity,
+            domain,
+            tx
+          )
+
+          // Thread 생성 (corrector 정보 획득용)
+          const assignee = await userFactory.create({ name: 'Corrector User' }, tx)
+          const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+            {
+              state: ActivityThreadStatus.Ended,
+              terminatedAt: new Date()
+            },
+            resolveInstance,
+            assignee,
+            tx
+          )
+
+          // When: ActivityInstance가 Ended 상태로 변경 (callback 시뮬레이션)
+          const terminatedAt = new Date()
+          const correctiveAction = 'Temperature를 정상 범위로 조절 완료'
+
+          resolveInstance.state = ActivityInstanceStatus.Ended
+          resolveInstance.terminatedAt = terminatedAt
+          resolveInstance.output = { action: correctiveAction }
+          await tx.save('ActivityInstance', resolveInstance)
+
+          // Callback 로직 시뮬레이션:
+          // 1. Ended 상태의 ActivityThread에서 corrector 조회
+          const endedThreads = await tx.getRepository('ActivityThread').find({
+            where: {
+              domain: { id: domain.id },
+              activityInstance: { id: resolveInstance.id },
+              state: ActivityThreadStatus.Ended
+            },
+            relations: ['assignee']
+          })
+          const corrector = endedThreads[0]?.assignee
+
+          // 2. DataOoc 업데이트
+          dataOoc = await tx.getRepository('DataOoc').findOne({
+            where: { id: dataOoc.id }
+          }) as any
+
+          dataOoc.correctedAt = terminatedAt
+          dataOoc.corrector = corrector
+          dataOoc.correctiveAction = correctiveAction
+          dataOoc.state = DataOocStatus.CORRECTED
+          dataOoc = await tx.save('DataOoc', dataOoc)
+
+          // Then
+          expect(dataOoc.state).toBe(DataOocStatus.CORRECTED)
+          expect(dataOoc.correctedAt).toEqual(terminatedAt)
+          expect(dataOoc.corrector?.id).toBe(assignee.id)
+          expect(dataOoc.correctiveAction).toBe(correctiveAction)
+        })
+      })
+
+      it('correctiveAction은 output.action에서 가져와야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain, user } = context.state
+
+          // Given
+          const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+          const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+          let dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.REVIEWED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          const action = '온도 조절 밸브를 교체하고 캘리브레이션 수행'
+          const resolveInstance = await activityInstanceFactory.createWithActivity(
+            {
+              state: ActivityInstanceStatus.Ended,
+              input: { dataOocId: dataOoc.id },
+              output: { action },
+              terminatedAt: new Date()
+            },
+            resolveActivity,
+            domain,
+            tx
+          )
+
+          // When: Callback 로직
+          const outputAction = resolveInstance.output?.action
+
+          dataOoc.correctiveAction = outputAction
+          dataOoc.state = DataOocStatus.CORRECTED
+          dataOoc = await tx.save('DataOoc', dataOoc)
+
+          // Then
+          expect(dataOoc.correctiveAction).toBe(action)
+        })
+      })
+
+      it('corrector는 Ended 상태의 ActivityThread의 assignee여야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain } = context.state
+
+          // Given
+          const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+          const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+          const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.REVIEWED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          const resolveInstance = await activityInstanceFactory.createWithActivity(
+            {
+              state: ActivityInstanceStatus.Ended,
+              input: { dataOocId: dataOoc.id }
+            },
+            resolveActivity,
+            domain,
+            tx
+          )
+
+          // 여러 Thread 중 Ended 상태인 Thread의 assignee
+          const worker1 = await userFactory.create({ name: 'Worker 1' }, tx)
+          const worker2 = await userFactory.create({ name: 'Worker 2' }, tx)
+
+          await activityThreadFactory.createWithInstanceAndAssignee(
+            { state: ActivityThreadStatus.Aborted }, // Aborted - 제외
+            resolveInstance,
+            worker1,
+            tx
+          )
+
+          const endedThread = await activityThreadFactory.createWithInstanceAndAssignee(
+            { state: ActivityThreadStatus.Ended }, // Ended - 선택됨
+            resolveInstance,
+            worker2,
+            tx
+          )
+
+          // When: Ended 상태의 Thread 조회
+          const endedThreads = await tx.getRepository('ActivityThread').find({
+            where: {
+              activityInstance: { id: resolveInstance.id },
+              state: ActivityThreadStatus.Ended
+            },
+            relations: ['assignee']
+          })
+
+          // Then: Ended 상태의 Thread의 assignee가 corrector
+          expect(endedThreads.length).toBe(1)
+          expect(endedThreads[0].assignee?.id).toBe(worker2.id)
+        })
+      })
+
+      it('Ended가 아닌 상태에서는 callback 로직이 실행되지 않아야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain } = context.state
+
+          // Given
+          const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+          const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+          const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.REVIEWED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          const resolveInstance = await activityInstanceFactory.createWithActivity(
+            {
+              state: ActivityInstanceStatus.Submitted, // Ended가 아님
+              input: { dataOocId: dataOoc.id }
+            },
+            resolveActivity,
+            domain,
+            tx
+          )
+
+          // When: Callback 조건 체크
+          const shouldExecuteCallback = resolveInstance.state === ActivityInstanceStatus.Ended
+
+          // Then
+          expect(shouldExecuteCallback).toBe(false)
+        })
+      })
+    })
+
+    describe('DataOoc 조회 및 업데이트', () => {
+      it('callback에서 dataOocId로 DataOoc을 조회할 수 있어야 한다', async () => {
+        await withTestTransaction(async (context) => {
+          const { tx, domain } = context.state
+
+          // Given
+          const { dataSet } = await dataSetFactory.createWithRoles({}, domain, tx)
+          const dataOoc = await dataOocFactory.createWithDataSetAndSample(
+            { state: DataOocStatus.REVIEWED },
+            dataSet,
+            undefined,
+            tx
+          )
+
+          // When: input에서 dataOocId 추출 후 조회
+          const input = { dataOocId: dataOoc.id }
+          const foundDataOoc = await tx.getRepository('DataOoc').findOne({
+            where: {
+              domain: { id: domain.id },
+              id: input.dataOocId
+            },
+            relations: ['dataSet']
+          })
+
+          // Then
+          expect(foundDataOoc).toBeDefined()
+          expect(foundDataOoc?.id).toBe(dataOoc.id)
+          expect(foundDataOoc?.dataSet?.id).toBe(dataSet.id)
+        })
+      })
+    })
+  })
+
+  describe('전체 워크플로우 Callback 연계', () => {
+    it('OOC 생성 → Review Callback → Resolve Callback 전체 플로우', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Setup
+        const reviewActivity = await activityFactory.createOocReviewActivity(domain, tx)
+        const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+        const { dataSet, supervisoryRole, resolverRole } = await dataSetFactory.createWithRoles({}, domain, tx)
+
+        const reviewer = await userFactory.create({ name: 'Reviewer' }, tx)
+        const corrector = await userFactory.create({ name: 'Corrector' }, tx)
+
+        // 1. DataOoc 생성 (ISSUED)
+        let dataOoc = await dataOocFactory.createWithDataSetAndSample(
+          {
+            state: DataOocStatus.ISSUED,
+            history: [
+              {
+                user: { id: user.id, name: user.name },
+                state: DataOocStatus.ISSUED,
+                timestamp: new Date().toISOString()
+              }
+            ]
+          },
+          dataSet,
+          undefined,
+          tx
+        )
+        expect(dataOoc.state).toBe(DataOocStatus.ISSUED)
+
+        // 2. Review Activity 발행
+        const reviewInstance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            input: { dataOocId: dataOoc.id },
+            assigneeRole: supervisoryRole
+          },
+          reviewActivity,
+          domain,
+          tx
+        )
+
+        // 3. Review Callback 시뮬레이션 (Ended 상태로)
+        const reviewTerminatedAt = new Date()
+        const instruction = 'Temperature 조절 필요'
+
+        reviewInstance.state = ActivityInstanceStatus.Ended
+        reviewInstance.terminatedAt = reviewTerminatedAt
+        reviewInstance.output = { instruction }
+        await tx.save('ActivityInstance', reviewInstance)
+
+        // DataOoc 업데이트 (Review Callback)
+        dataOoc = await tx.getRepository('DataOoc').findOne({
+          where: { id: dataOoc.id },
+          relations: ['dataSet']
+        }) as any
+
+        dataOoc.reviewedAt = reviewTerminatedAt
+        dataOoc.reviewer = reviewer
+        dataOoc.correctiveInstruction = instruction
+        dataOoc.state = DataOocStatus.REVIEWED
+
+        // history 업데이트
+        const history = dataOoc.history || []
+        history.push({
+          user: { id: reviewer.id, name: reviewer.name },
+          state: DataOocStatus.REVIEWED,
+          timestamp: reviewTerminatedAt.toISOString()
+        })
+        dataOoc.history = history
+        dataOoc = await tx.save('DataOoc', dataOoc)
+
+        expect(dataOoc.state).toBe(DataOocStatus.REVIEWED)
+
+        // 4. Resolve Activity 발행 (Review Callback에서 호출)
+        const resolveInstance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            input: { dataOocId: dataOoc.id, instruction },
+            assigneeRole: resolverRole
+          },
+          resolveActivity,
+          domain,
+          tx
+        )
+
+        // 5. Resolve Thread 생성 및 완료
+        const resolveThread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Ended, terminatedAt: new Date() },
+          resolveInstance,
+          corrector,
+          tx
+        )
+
+        // 6. Resolve Callback 시뮬레이션 (Ended 상태로)
+        const resolveTerminatedAt = new Date()
+        const action = 'Temperature를 정상 범위로 조절함'
+
+        resolveInstance.state = ActivityInstanceStatus.Ended
+        resolveInstance.terminatedAt = resolveTerminatedAt
+        resolveInstance.output = { action }
+        await tx.save('ActivityInstance', resolveInstance)
+
+        // DataOoc 업데이트 (Resolve Callback)
+        dataOoc = await tx.getRepository('DataOoc').findOne({
+          where: { id: dataOoc.id },
+          relations: ['reviewer']
+        }) as any
+
+        dataOoc.correctedAt = resolveTerminatedAt
+        dataOoc.corrector = corrector
+        dataOoc.correctiveAction = action
+        dataOoc.state = DataOocStatus.CORRECTED
+
+        // history 업데이트
+        dataOoc.history.push({
+          user: { id: corrector.id, name: corrector.name },
+          state: DataOocStatus.CORRECTED,
+          comment: action,
+          timestamp: resolveTerminatedAt.toISOString()
+        })
+        dataOoc = await tx.save('DataOoc', dataOoc)
+
+        // Then: 최종 상태 확인 - 다시 조회하여 relations 포함
+        const finalDataOoc = await tx.getRepository('DataOoc').findOne({
+          where: { id: dataOoc.id },
+          relations: ['reviewer', 'corrector']
+        }) as any
+
+        expect(finalDataOoc.state).toBe(DataOocStatus.CORRECTED)
+        expect(finalDataOoc.reviewedAt).toBeDefined()
+        expect(finalDataOoc.correctedAt).toBeDefined()
+        expect(finalDataOoc.reviewer?.id).toBe(reviewer.id)
+        expect(finalDataOoc.corrector?.id).toBe(corrector.id)
+        expect(finalDataOoc.correctiveInstruction).toBe(instruction)
+        expect(finalDataOoc.correctiveAction).toBe(action)
+        expect(finalDataOoc.history.length).toBe(3)
+      })
+    })
+  })
+})