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

package/spec/integration/role-approval-edge-cases.spec.ts

@@ -0,0 +1,581 @@
+/**
+ * ROLE Approval Edge Cases and Error Conditions Tests
+ * ROLE 승인 엣지 케이스 및 오류 조건 테스트
+ */
+
+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
+} from '../../../../test/helpers/workflow-helpers'
+
+describe('ROLE Approval Edge Cases and Error Conditions', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('빈 승인라인', () => {
+    it('승인라인이 undefined이면 승인 프로세스를 건너뛰어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: 승인라인이 없는 Instance
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        // approvalLine 체크
+        const approvalLine = instance.approvalLine
+        const hasApprovalLine = approvalLine && approvalLine.length > 0
+        expect(hasApprovalLine).toBeFalsy()
+
+        // Then: Submit 시 즉시 Ended
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        thread.state = ActivityThreadStatus.Ended
+        thread.terminatedAt = new Date()
+        const ended = await tx.save('ActivityThread', thread) as any
+
+        expect(ended.state).toBe(ActivityThreadStatus.Ended)
+      })
+    })
+
+    it('승인라인이 빈 배열이면 승인 프로세스를 건너뛰어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: 빈 배열 승인라인
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          [],
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        const approvalLine = instance.approvalLine
+        const hasApprovalLine = approvalLine && approvalLine.length > 0
+        expect(hasApprovalLine).toBe(false)
+
+        // Then: Submit 시 즉시 Ended
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        thread.state = ActivityThreadStatus.Ended
+        thread.terminatedAt = new Date()
+        const ended = await tx.save('ActivityThread', thread) as any
+
+        expect(ended.state).toBe(ActivityThreadStatus.Ended)
+      })
+    })
+  })
+
+  describe('존재하지 않는 Role', () => {
+    it('삭제된 roleId를 참조하면 Role을 찾을 수 없어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: 존재하지 않는 roleId
+        const nonExistentRoleId = 'non-existent-role-id'
+        const invalidApprovalLine = [
+          { type: 'Role', value: nonExistentRoleId }
+        ]
+
+        // When: Role 조회
+        const role = await tx.findOne('Role', { where: { id: nonExistentRoleId } })
+
+        // Then: Role이 없음
+        expect(role).toBeNull()
+      })
+    })
+  })
+
+  describe('역할에 사용자가 없는 경우', () => {
+    it('사용자가 없는 Role로도 approval이 생성될 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: 사용자가 할당되지 않은 빈 역할
+        const emptyRole = await roleFactory.create({ name: 'Empty Role', domain }, tx)
+
+        // When: ROLE 기반 approval 생성
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          emptyRole,
+          tx
+        )
+
+        // Then: approval은 생성됨 (나중에 역할에 사용자가 추가될 수 있음)
+        expect(approval).toBeDefined()
+        expect(approval.approverRole?.id).toBe(emptyRole.id)
+        expect(approval.approver).toBeUndefined()
+      })
+    })
+  })
+
+  describe('동일 approval 중복 처리 방지', () => {
+    it('이미 Approved된 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)
+
+        // Given: 이미 Approved 상태인 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          {
+            judgment: ActivityApprovalJudgment.Approved,
+            terminatedAt: new Date()
+          },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // Then: Pending이 아니므로 재승인 불가
+        const canApprove = approval.judgment === ActivityApprovalJudgment.Pending
+        expect(canApprove).toBe(false)
+      })
+    })
+
+    it('이미 Rejected된 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)
+
+        // Given: 이미 Rejected 상태인 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          {
+            judgment: ActivityApprovalJudgment.Rejected,
+            terminatedAt: new Date()
+          },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // Then: Pending이 아니므로 재승인 불가
+        const canApprove = approval.judgment === ActivityApprovalJudgment.Pending
+        expect(canApprove).toBe(false)
+      })
+    })
+
+    it('이미 Escalated된 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)
+
+        // Given: 이미 Escalated 상태인 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          {
+            judgment: ActivityApprovalJudgment.Escalated,
+            terminatedAt: new Date()
+          },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // Then: Pending이 아니므로 재처리 불가
+        const canApprove = approval.judgment === ActivityApprovalJudgment.Pending
+        expect(canApprove).toBe(false)
+      })
+    })
+  })
+
+  describe('스레드 상태 검증', () => {
+    it('Unassigned 상태 스레드는 submit할 수 없어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: Unassigned 상태 스레드 (assignee 없이 생성)
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Issued },
+          undefined,
+          domain,
+          tx
+        )
+
+        const thread = await tx.save('ActivityThread', {
+          state: ActivityThreadStatus.Unassigned,
+          round: 1,
+          activityInstance: instance,
+          domain
+        }) as any
+
+        // Then: Submit 불가능한 상태
+        const canSubmit =
+          thread.state === ActivityThreadStatus.Assigned ||
+          thread.state === ActivityThreadStatus.Started
+        expect(canSubmit).toBe(false)
+      })
+    })
+
+    it('Submitted 상태 스레드는 다시 submit할 수 없어야 한다', 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
+        )
+
+        // Then: Submit 불가능한 상태
+        const canSubmit =
+          thread.state === ActivityThreadStatus.Assigned ||
+          thread.state === ActivityThreadStatus.Started
+        expect(canSubmit).toBe(false)
+      })
+    })
+  })
+
+  describe('order 경계 조건', () => {
+    it('order가 0이면 잘못된 상태여야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const role = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // order는 1부터 시작해야 함
+        const invalidOrder = 0
+        const validOrders = [1, 2, 3]
+
+        expect(validOrders.includes(invalidOrder)).toBe(false)
+        expect(invalidOrder).toBeLessThan(1)
+      })
+    })
+
+    it('order가 음수이면 잘못된 상태여야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        const invalidOrder = -1
+        expect(invalidOrder).toBeLessThan(1)
+      })
+    })
+
+    it('order가 approvalLine 길이보다 크면 더 이상 에스컬레이션이 없어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const role = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // Given: 단일 승인라인
+        const approvalLine = [createRoleApprovalLineItem(role)]
+
+        // order=1일 때: approvalLine.length(1) > order(1) = false
+        const order = 1
+        const hasNextLevel = approvalLine.length > order
+        expect(hasNextLevel).toBe(false)
+      })
+    })
+  })
+
+  describe('타입스탬프 설정', () => {
+    it('승인 완료 시 terminatedAt이 반드시 설정되어야 한다', 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: Pending approval
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+        expect(approval.terminatedAt).toBeFalsy() // null or undefined
+
+        // When: 승인
+        approval.judgment = ActivityApprovalJudgment.Approved
+        approval.approver = approver
+        approval.terminatedAt = new Date()
+        const approved = await tx.save('ActivityApproval', approval) as any
+
+        // Then
+        expect(approved.terminatedAt).toBeDefined()
+        expect(approved.terminatedAt).toBeInstanceOf(Date)
+      })
+    })
+
+    it('반려 시 terminatedAt이 반드시 설정되어야 한다', 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: Pending approval
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // When: 반려
+        approval.judgment = ActivityApprovalJudgment.Rejected
+        approval.approver = approver
+        approval.comment = 'Rejected reason'
+        approval.terminatedAt = new Date()
+        const rejected = await tx.save('ActivityApproval', approval) as any
+
+        // Then
+        expect(rejected.terminatedAt).toBeDefined()
+        expect(rejected.terminatedAt).toBeInstanceOf(Date)
+      })
+    })
+  })
+
+  describe('Domain 격리', () => {
+    it('다른 Domain의 Role로 approval을 생성할 수 없어야 한다 (개념적)', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: 두 개의 다른 Domain
+        const domain1 = await domainFactory.create({ name: 'Domain 1' }, tx)
+        const domain2 = await domainFactory.create({ name: 'Domain 2' }, tx)
+
+        // Given: 각 도메인의 역할
+        const role1 = await roleFactory.create({ name: 'Role in Domain 1', domain: domain1 }, tx)
+        const role2 = await roleFactory.create({ name: 'Role in Domain 2', domain: domain2 }, tx)
+
+        // Then: 역할은 각 도메인에 속함
+        expect(role1.domain?.id).toBe(domain1.id)
+        expect(role2.domain?.id).toBe(domain2.id)
+
+        // 실제 구현에서는 Domain 격리 검증이 필요
+        expect(role1.domain?.id).not.toBe(domain2.id)
+        expect(role2.domain?.id).not.toBe(domain1.id)
+      })
+    })
+  })
+
+  describe('Round 증가 규칙', () => {
+    it('Rejected 후 재시작 시 round가 증가해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: Round 1 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started, round: 1 },
+          instance,
+          user,
+          tx
+        )
+
+        // When: 반려됨
+        thread.state = ActivityThreadStatus.Rejected
+        const rejected = await tx.save('ActivityThread', thread) as any
+
+        // When: 재시작
+        rejected.state = ActivityThreadStatus.Started
+        rejected.round = rejected.round + 1
+        const restarted = await tx.save('ActivityThread', rejected) as any
+
+        // Then: Round 증가
+        expect(restarted.round).toBe(2)
+      })
+    })
+
+    it('동일 round에서 approval의 round도 일치해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // Given: Round 2 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted, round: 2 },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Approval 생성
+        const approval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: thread.round, // 스레드 round와 일치
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          approverRole: approverRole,
+          creator: user,
+          updater: user
+        }) as any
+
+        // Then: Round 일치
+        expect(approval.round).toBe(thread.round)
+        expect(approval.round).toBe(2)
+      })
+    })
+  })
+
+  describe('ActivityApprovalJudgment 값 검증', () => {
+    it('Pending은 빈 문자열이어야 한다', () => {
+      expect(ActivityApprovalJudgment.Pending).toBe('')
+    })
+
+    it('유효한 judgment 값만 허용되어야 한다', () => {
+      const validJudgments = [
+        ActivityApprovalJudgment.Pending,
+        ActivityApprovalJudgment.Rejected,
+        ActivityApprovalJudgment.Escalated,
+        ActivityApprovalJudgment.Delegated,
+        ActivityApprovalJudgment.Approved,
+        ActivityApprovalJudgment.Aborted
+      ]
+
+      expect(validJudgments).toContain('')
+      expect(validJudgments).toContain('rejected')
+      expect(validJudgments).toContain('escalated')
+      expect(validJudgments).toContain('delegated')
+      expect(validJudgments).toContain('approved')
+      expect(validJudgments).toContain('aborted')
+
+      expect(validJudgments).not.toContain('invalid')
+      expect(validJudgments).not.toContain('Approved') // 대소문자 구분
+    })
+  })
+
+  describe('OOC Resolve 시나리오 (버그 수정 주요 케이스)', () => {
+    it('OOC Resolve에서 ROLE 타입 outlierApprovalLine이 정상 작동해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const oocApproverRole = await roleFactory.create({ name: 'OOC Approver', domain }, tx)
+        const resolver = await userFactory.create({ name: 'Resolver' }, tx)
+        const approver = await userFactory.createWithRole({ name: 'Approver' }, oocApproverRole, tx)
+
+        // Given: OOC Resolve Activity with ROLE-based outlierApprovalLine
+        const outlierApprovalLine = [createRoleApprovalLineItem(oocApproverRole)]
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          outlierApprovalLine,
+          {
+            name: '[OOC 조치]',
+            state: ActivityInstanceStatus.Started
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        expect(instance.approvalLine?.[0].type).toBe('Role')
+        expect(instance.approvalLine?.[0].value).toBe(oocApproverRole.id)
+
+        // Given: Resolver가 작업 완료 후 Submit
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Submitted },
+          instance,
+          resolver,
+          tx
+        )
+
+        // When: ROLE 기반 approval 생성 (버그 수정 후 정상 작동)
+        // 수정 전: if (approverRoleId) throw - roleId가 있으면 항상 에러
+        // 수정 후: if (!approverRoleId) throw - roleId가 없을 때만 에러
+        const approvalLineItem = outlierApprovalLine[0]
+        const approverRoleId = approvalLineItem.value
+
+        // 버그 수정 확인: roleId가 있으므로 정상 처리되어야 함
+        expect(approverRoleId).toBeDefined()
+        expect(approverRoleId).toBe(oocApproverRole.id)
+
+        const approval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          approverRole: oocApproverRole,
+          transaction: 'submit',
+          creator: resolver,
+          updater: resolver
+        }) as any
+
+        expect(approval).toBeDefined()
+        expect(approval.approverRole?.id).toBe(oocApproverRole.id)
+
+        // When: 해당 역할 소유자가 승인
+        approval.judgment = ActivityApprovalJudgment.Approved
+        approval.approver = approver
+        approval.terminatedAt = new Date()
+        const approved = await tx.save('ActivityApproval', approval) as any
+
+        // Then: OOC Resolve 승인 완료
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approved.approver?.id).toBe(approver.id)
+        expect(approved.approverRole?.id).toBe(oocApproverRole.id)
+      })
+    })
+  })
+})