@things-factory/worklist 9.1.19 → 10.0.0-beta.2

package/spec/unit/controllers/activity-thread-submit.spec.ts

@@ -0,0 +1,384 @@
+/**
+ * ActivityThread Submit Controller Tests
+ * ActivityThread 제출 컨트롤러 테스트
+ */
+
+import { TestDatabase } from '../../../../../test/test-database'
+import { withTestTransaction } from '../../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  activityInstanceFactory,
+  activityThreadFactory,
+  activityApprovalFactory
+} from '../../../../../test/factories'
+import {
+  ActivityInstanceStatus,
+  ActivityThreadStatus,
+  ActivityApprovalJudgment
+} from '../../../../../test/entities/schemas'
+
+describe('ActivityThread Submit Controller', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('Submit 기본 동작', () => {
+    it('Started 상태의 Thread를 Submit할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: Started 상태의 Thread
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          {
+            state: ActivityThreadStatus.Started,
+            startedAt: new Date()
+          },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 시뮬레이션
+        const output = { action: 'Temperature adjusted to normal range' }
+        thread.output = output
+        thread.state = ActivityThreadStatus.Ended
+        thread.terminatedAt = new Date()
+        const submitted = await tx.save('ActivityThread', thread)
+
+        // Then
+        expect(submitted.state).toBe(ActivityThreadStatus.Ended)
+        expect(submitted.output).toEqual(output)
+        expect(submitted.terminatedAt).toBeDefined()
+      })
+    })
+
+    it('output이 Thread에 저장되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When
+        const output = {
+          instruction: 'Adjust temperature',
+          result: 'success',
+          notes: 'Completed without issues'
+        }
+        thread.output = output
+        const updated = await tx.save('ActivityThread', thread)
+
+        // Then
+        expect(updated.output).toEqual(output)
+        expect(updated.output?.result).toBe('success')
+      })
+    })
+  })
+
+  describe('결재라인 없는 경우', () => {
+    it('결재라인이 없으면 바로 Ended 상태가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: 결재라인 없는 Instance
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started,
+            approvalLine: [] // 빈 결재라인
+          },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit
+        thread.state = ActivityThreadStatus.Ended
+        thread.terminatedAt = new Date()
+        const submitted = await tx.save('ActivityThread', thread)
+
+        // Then: 바로 Ended
+        expect(submitted.state).toBe(ActivityThreadStatus.Ended)
+      })
+    })
+  })
+
+  describe('결재라인 있는 경우', () => {
+    it('결재라인이 있으면 Submitted 상태가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: 결재라인 있는 Instance
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started,
+            approvalLine: [
+              { type: 'Role', value: approverRole.id, approver: { id: approverRole.id, name: approverRole.name } }
+            ]
+          },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit (결재 필요)
+        thread.state = ActivityThreadStatus.Submitted
+        const submitted = await tx.save('ActivityThread', thread)
+
+        // Then: Submitted 상태로 대기
+        expect(submitted.state).toBe(ActivityThreadStatus.Submitted)
+      })
+    })
+
+    it('Submit 시 ActivityApproval이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started,
+            approvalLine: [
+              { type: 'Role', value: approverRole.id, approver: { id: approverRole.id, name: approverRole.name } }
+            ]
+          },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 후 Approval 생성 시뮬레이션
+        thread.state = ActivityThreadStatus.Submitted
+        await tx.save('ActivityThread', thread)
+
+        const approval = await activityApprovalFactory.createWithRole(
+          {
+            round: 1,
+            order: 1,
+            judgment: ActivityApprovalJudgment.Pending
+          },
+          thread,
+          approverRole,
+          tx
+        )
+
+        // Then
+        expect(approval).toBeDefined()
+        expect(approval.judgment).toBe(ActivityApprovalJudgment.Pending)
+        expect(approval.approverRole?.id).toBe(approverRole.id)
+      })
+    })
+  })
+
+  describe('다중 레벨 결재', () => {
+    it('첫 번째 결재자에게만 Approval이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: 2단계 결재라인
+        const firstApproverRole = await roleFactory.create({ name: 'Team Lead', domain }, tx)
+        const secondApproverRole = await roleFactory.create({ name: 'Manager', domain }, tx)
+
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started,
+            approvalLine: [
+              { type: 'Role', value: firstApproverRole.id, approver: { id: firstApproverRole.id, name: firstApproverRole.name } },
+              { type: 'Role', value: secondApproverRole.id, approver: { id: secondApproverRole.id, name: secondApproverRole.name } }
+            ]
+          },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 시 첫 번째 결재자만 생성
+        thread.state = ActivityThreadStatus.Submitted
+        await tx.save('ActivityThread', thread)
+
+        const firstApproval = await activityApprovalFactory.createWithRole(
+          {
+            round: 1,
+            order: 1,
+            judgment: ActivityApprovalJudgment.Pending
+          },
+          thread,
+          firstApproverRole,
+          tx
+        )
+
+        // Then
+        expect(firstApproval.order).toBe(1)
+
+        // 조회해서 1개만 있는지 확인
+        const approvals = await tx.getRepository('ActivityApproval').find({
+          where: { activityThread: { id: thread.id } }
+        })
+        expect(approvals.length).toBe(1)
+      })
+    })
+  })
+
+  describe('Instance 상태 동기화', () => {
+    it('모든 Thread가 Ended되면 Instance도 Ended가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: 단일 Thread Instance
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started,
+            threadsMin: 1,
+            threadsMax: 1
+          },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Thread Ended
+        thread.state = ActivityThreadStatus.Ended
+        thread.terminatedAt = new Date()
+        await tx.save('ActivityThread', thread)
+
+        // Instance도 Ended로 업데이트 시뮬레이션
+        instance.state = ActivityInstanceStatus.Ended
+        instance.terminatedAt = new Date()
+        const endedInstance = await tx.save('ActivityInstance', instance)
+
+        // Then
+        expect(endedInstance.state).toBe(ActivityInstanceStatus.Ended)
+      })
+    })
+
+    it('일부 Thread만 Ended되면 Instance는 Started 유지되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: 복수 Thread Instance
+        const user1 = await userFactory.create({ name: 'User 1' }, tx)
+        const user2 = await userFactory.create({ name: 'User 2' }, tx)
+
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started,
+            threadsMin: 2,
+            threadsMax: 2
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        const thread1 = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user1,
+          tx
+        )
+        const thread2 = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user2,
+          tx
+        )
+
+        // When: thread1만 Ended
+        thread1.state = ActivityThreadStatus.Ended
+        thread1.terminatedAt = new Date()
+        await tx.save('ActivityThread', thread1)
+
+        // Then: Instance는 아직 Started
+        // (thread2가 아직 진행 중)
+        expect(instance.state).toBe(ActivityInstanceStatus.Started)
+      })
+    })
+  })
+
+  describe('Output 집계', () => {
+    it('Thread의 output이 Instance의 output으로 집계되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Thread output 설정 후 Instance에 집계
+        const threadOutput = { action: 'Fixed', result: 'success' }
+        thread.output = threadOutput
+        thread.state = ActivityThreadStatus.Ended
+        await tx.save('ActivityThread', thread)
+
+        // Instance output 업데이트
+        instance.output = threadOutput
+        const updated = await tx.save('ActivityInstance', instance)
+
+        // Then
+        expect(updated.output).toEqual(threadOutput)
+      })
+    })
+  })
+})