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

package/spec/unit/role-approval-escalate-logic.spec.ts

@@ -0,0 +1,499 @@
+/**
+ * ROLE Approval Escalate Logic Tests
+ * ROLE 타입 승인라인 에스컬레이션 로직 검증 테스트
+ *
+ * 수정된 버그:
+ * - approve.ts:66 - approvalLine[0].value → approvalLine[order].value
+ * - approve.ts:68 - if (approverRoleId) → if (!approverRoleId)
+ */
+
+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'
+
+import {
+  createRoleApprovalLineItem,
+  createUserApprovalLineItem,
+  createMultiLevelApprovalLine
+} from '../../../../test/helpers/workflow-helpers'
+
+describe('ROLE Approval Escalate Logic Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('단일 ROLE 승인 (에스컬레이션 없음)', () => {
+    it('단일 ROLE 승인라인에서 승인 시 judgment가 Approved가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+        const approver = await userFactory.createWithRole({}, approverRole, tx)
+
+        // Given: 단일 ROLE 승인라인
+        const approvalLine = [createRoleApprovalLineItem(approverRole)]
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          approver,
+          tx
+        )
+
+        // Given: order=1인 Pending approval
+        const approval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          approverRole: approverRole,
+          creator: approver,
+          updater: approver
+        }) as any
+
+        // When: 승인 (approvalLine[order]가 없으므로 최종 승인)
+        const order = approval.order // 1
+        const hasNextLevel = approvalLine.length > order // 1 > 1 = false
+        expect(hasNextLevel).toBe(false)
+
+        approval.judgment = ActivityApprovalJudgment.Approved
+        approval.approver = approver
+        approval.terminatedAt = new Date()
+        const approved = await tx.save('ActivityApproval', approval) as any
+
+        // Then
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approved.approver?.id).toBe(approver.id)
+        expect(approved.terminatedAt).toBeDefined()
+      })
+    })
+  })
+
+  describe('다단계 ROLE 에스컬레이션', () => {
+    it('2단계 ROLE 승인라인에서 첫 번째 승인 시 Escalated가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const firstRole = await roleFactory.create({ name: 'First Approver', domain }, tx)
+        const secondRole = await roleFactory.create({ name: 'Second Approver', domain }, tx)
+        const firstApprover = await userFactory.createWithRole({}, firstRole, tx)
+
+        // Given: 2단계 ROLE 승인라인
+        const approvalLine = [
+          createRoleApprovalLineItem(firstRole),
+          createRoleApprovalLineItem(secondRole)
+        ]
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          firstApprover,
+          tx
+        )
+
+        // Given: order=1인 첫 번째 approval
+        const firstApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          approverRole: firstRole,
+          creator: firstApprover,
+          updater: firstApprover
+        }) as any
+
+        // When: 첫 번째 승인 (order=1, approvalLine[1] 존재)
+        const order = firstApproval.order // 1
+        const hasNextLevel = approvalLine.length > order // 2 > 1 = true
+        expect(hasNextLevel).toBe(true)
+
+        // Then: Escalated 상태가 됨
+        firstApproval.judgment = ActivityApprovalJudgment.Escalated
+        firstApproval.approver = firstApprover
+        firstApproval.terminatedAt = new Date()
+        const escalated = await tx.save('ActivityApproval', firstApproval) as any
+
+        expect(escalated.judgment).toBe(ActivityApprovalJudgment.Escalated)
+      })
+    })
+
+    it('에스컬레이션 시 다음 레벨의 roleId를 올바르게 참조해야 한다 (버그 수정 검증)', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const firstRole = await roleFactory.create({ name: 'First Role', domain }, tx)
+        const secondRole = await roleFactory.create({ name: 'Second Role', domain }, tx)
+        const thirdRole = await roleFactory.create({ name: 'Third Role', domain }, tx)
+
+        // Given: 3단계 ROLE 승인라인
+        const approvalLine = [
+          createRoleApprovalLineItem(firstRole),
+          createRoleApprovalLineItem(secondRole),
+          createRoleApprovalLineItem(thirdRole)
+        ]
+
+        // 버그 수정 검증: approvalLine[order].value를 사용해야 함
+        // 수정 전: approvalLine[0].value - 항상 첫 번째 역할만 참조
+        // 수정 후: approvalLine[order].value - 올바른 인덱스 참조
+
+        // order=1일 때 (첫 번째 approval 완료 후)
+        const order1 = 1
+        const nextRoleId1 = approvalLine[order1].value
+        expect(nextRoleId1).toBe(secondRole.id)
+        expect(nextRoleId1).not.toBe(firstRole.id) // 수정 전 버그는 firstRole.id 반환
+
+        // order=2일 때 (두 번째 approval 완료 후)
+        const order2 = 2
+        const nextRoleId2 = approvalLine[order2].value
+        expect(nextRoleId2).toBe(thirdRole.id)
+        expect(nextRoleId2).not.toBe(firstRole.id) // 수정 전 버그는 firstRole.id 반환
+      })
+    })
+
+    it('3단계 ROLE 승인라인에서 각 레벨의 roleId가 올바르게 추출되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const role1 = await roleFactory.create({ name: 'Level 1', domain }, tx)
+        const role2 = await roleFactory.create({ name: 'Level 2', domain }, tx)
+        const role3 = await roleFactory.create({ name: 'Level 3', domain }, tx)
+
+        const approvalLine = [
+          createRoleApprovalLineItem(role1),
+          createRoleApprovalLineItem(role2),
+          createRoleApprovalLineItem(role3)
+        ]
+
+        // order=0 (첫 번째 승인자 할당 시)
+        expect(approvalLine[0].value).toBe(role1.id)
+        expect(approvalLine[0].type).toBe('Role')
+
+        // order=1 (첫 번째 에스컬레이션 시)
+        expect(approvalLine[1].value).toBe(role2.id)
+        expect(approvalLine[1].type).toBe('Role')
+
+        // order=2 (두 번째 에스컬레이션 시)
+        expect(approvalLine[2].value).toBe(role3.id)
+        expect(approvalLine[2].type).toBe('Role')
+      })
+    })
+
+    it('에스컬레이션 시 다음 레벨 ActivityApproval이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const firstRole = await roleFactory.create({ name: 'First', domain }, tx)
+        const secondRole = await roleFactory.create({ name: 'Second', domain }, tx)
+        const firstApprover = await userFactory.createWithRole({}, firstRole, tx)
+
+        // Given: 2단계 승인라인
+        const approvalLine = [
+          createRoleApprovalLineItem(firstRole),
+          createRoleApprovalLineItem(secondRole)
+        ]
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          firstApprover,
+          tx
+        )
+
+        // Given: 첫 번째 approval 완료
+        const firstApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Escalated,
+          approverRole: firstRole,
+          approver: firstApprover,
+          terminatedAt: new Date(),
+          creator: firstApprover,
+          updater: firstApprover
+        }) as any
+
+        // When: 다음 레벨 approval 생성
+        const order = firstApproval.order // 1
+        const nextApproverRoleId = approvalLine[order].value // approvalLine[1].value = secondRole.id
+        expect(nextApproverRoleId).toBe(secondRole.id)
+
+        const secondApproval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: order + 1, // 2
+          judgment: ActivityApprovalJudgment.Pending,
+          approverRole: secondRole,
+          transaction: 'escalate',
+          creator: firstApprover,
+          updater: firstApprover
+        }) as any
+
+        // Then
+        expect(secondApproval.order).toBe(2)
+        expect(secondApproval.approverRole?.id).toBe(secondRole.id)
+        expect(secondApproval.approver).toBeUndefined()
+        expect(secondApproval.judgment).toBe(ActivityApprovalJudgment.Pending)
+      })
+    })
+  })
+
+  describe('에스컬레이션 후 스레드 상태', () => {
+    it('에스컬레이션 시 스레드 상태가 Escalated가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: Submitted 상태 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          user,
+          tx
+        )
+
+        // When: 에스컬레이션
+        thread.state = ActivityThreadStatus.Escalated
+        const escalated = await tx.save('ActivityThread', thread) as any
+
+        // Then
+        expect(escalated.state).toBe(ActivityThreadStatus.Escalated)
+      })
+    })
+
+    it('최종 승인 시 스레드 상태가 Ended가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: Escalated 상태 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Escalated },
+          instance,
+          user,
+          tx
+        )
+
+        // When: 최종 승인
+        thread.state = ActivityThreadStatus.Ended
+        thread.terminatedAt = new Date()
+        const ended = await tx.save('ActivityThread', thread) as any
+
+        // Then
+        expect(ended.state).toBe(ActivityThreadStatus.Ended)
+        expect(ended.terminatedAt).toBeDefined()
+      })
+    })
+  })
+
+  describe('승인 전 조건 검증', () => {
+    it('Pending 상태의 approval만 승인/반려 가능해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // Pending 상태: 승인 가능
+        const pendingApproval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+        expect(pendingApproval.judgment).toBe(ActivityApprovalJudgment.Pending)
+        const canApprovePending = pendingApproval.judgment === ActivityApprovalJudgment.Pending
+        expect(canApprovePending).toBe(true)
+
+        // Approved 상태: 승인 불가
+        const approvedApproval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Approved },
+          undefined,
+          approverRole,
+          tx
+        )
+        const canApproveApproved = approvedApproval.judgment === ActivityApprovalJudgment.Pending
+        expect(canApproveApproved).toBe(false)
+
+        // Rejected 상태: 승인 불가
+        const rejectedApproval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Rejected },
+          undefined,
+          approverRole,
+          tx
+        )
+        const canApproveRejected = rejectedApproval.judgment === ActivityApprovalJudgment.Pending
+        expect(canApproveRejected).toBe(false)
+      })
+    })
+  })
+
+  describe('ROLE approval 권한 검증', () => {
+    it('해당 Role을 가진 사용자만 승인할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+        const otherRole = await roleFactory.create({ name: 'Other', domain }, tx)
+
+        // Given: approverRole을 가진 사용자와 다른 역할을 가진 사용자
+        const userWithApproverRole = await userFactory.createWithRole({}, approverRole, tx)
+        const userWithOtherRole = await userFactory.createWithRole({}, otherRole, tx)
+        const userWithNoRole = await userFactory.create({}, tx)
+
+        // 역할 확인 로직 시뮬레이션
+        const approverRoleId = approverRole.id
+
+        // userWithApproverRole: 역할 일치 - 승인 가능
+        const hasApproverRole1 = userWithApproverRole.roles?.some(
+          (r: any) => r.id === approverRoleId
+        )
+        expect(hasApproverRole1).toBe(true)
+
+        // userWithOtherRole: 역할 불일치 - 승인 불가
+        const hasApproverRole2 = userWithOtherRole.roles?.some(
+          (r: any) => r.id === approverRoleId
+        )
+        expect(hasApproverRole2).toBe(false)
+
+        // userWithNoRole: 역할 없음 - 승인 불가
+        const hasApproverRole3 = userWithNoRole.roles?.some(
+          (r: any) => r.id === approverRoleId
+        )
+        expect(hasApproverRole3).toBeFalsy()
+      })
+    })
+  })
+
+  describe('null/undefined roleId 처리', () => {
+    it('approvalLine[order].value가 undefined이면 오류가 발생해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: value가 undefined인 승인라인
+        const invalidApprovalLine = [
+          { type: 'Role', value: undefined }
+        ]
+
+        // When: value 추출
+        const order = 0
+        const approverRoleId = invalidApprovalLine[order].value
+
+        // Then: null check 실패
+        const shouldThrowError = !approverRoleId
+        expect(shouldThrowError).toBe(true)
+      })
+    })
+
+    it('approvalLine[order].value가 null이면 오류가 발생해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: value가 null인 승인라인
+        const invalidApprovalLine = [
+          { type: 'Role', value: null }
+        ]
+
+        // When: value 추출
+        const order = 0
+        const approverRoleId = invalidApprovalLine[order].value
+
+        // Then: null check 실패
+        const shouldThrowError = !approverRoleId
+        expect(shouldThrowError).toBe(true)
+      })
+    })
+  })
+
+  describe('order 인덱스 경계 검증', () => {
+    it('approvalLine.length > order 조건으로 다음 레벨 존재 여부를 확인해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const role1 = await roleFactory.create({ name: 'Role 1', domain }, tx)
+        const role2 = await roleFactory.create({ name: 'Role 2', domain }, tx)
+
+        // Given: 2단계 승인라인
+        const approvalLine = [
+          createRoleApprovalLineItem(role1),
+          createRoleApprovalLineItem(role2)
+        ]
+
+        // order=1 (첫 번째 approval): approvalLine[1] 존재 → 에스컬레이션
+        const order1 = 1
+        const hasNextLevel1 = approvalLine.length > order1 // 2 > 1 = true
+        expect(hasNextLevel1).toBe(true)
+
+        // order=2 (두 번째 approval): approvalLine[2] 없음 → 최종 승인
+        const order2 = 2
+        const hasNextLevel2 = approvalLine.length > order2 // 2 > 2 = false
+        expect(hasNextLevel2).toBe(false)
+      })
+    })
+
+    it('배열 인덱스 범위를 벗어나면 undefined가 반환되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const role = await roleFactory.create({ name: 'Only Role', domain }, tx)
+
+        // Given: 단일 승인라인
+        const approvalLine = [createRoleApprovalLineItem(role)]
+
+        // Then: 범위 밖 인덱스는 undefined
+        expect(approvalLine[0]).toBeDefined()
+        expect(approvalLine[1]).toBeUndefined()
+        expect(approvalLine[2]).toBeUndefined()
+      })
+    })
+  })
+})