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

package/spec/integration/approval-role-based.spec.ts

@@ -0,0 +1,389 @@
+/**
+ * Role-Based Approval Workflow Integration Tests
+ * 역할 기반 승인 워크플로우 통합 테스트
+ */
+
+import { TestDatabase } from '../../../../test/test-database'
+import { withTestTransaction } from '../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  activityFactory,
+  activityInstanceFactory,
+  activityThreadFactory,
+  activityApprovalFactory
+} from '../../../../test/factories'
+
+import {
+  ActivityInstanceStatus,
+  ActivityThreadStatus,
+  ActivityApprovalJudgment
+} from '../../../../test/entities/schemas'
+
+import {
+  createRoleApprovalLineItem,
+  simulateApproval,
+  simulateRejection,
+  simulateEscalation
+} from '../../../../test/helpers/workflow-helpers'
+
+describe('Role-Based Approval Workflow Integration Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('ROLE 타입 Approval Line 설정', () => {
+    it('approvalLine에 Role 타입이 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver Role', domain }, tx)
+
+        // Given: Role 타입 approval line
+        const approvalLine = [createRoleApprovalLineItem(approverRole)]
+
+        // When: ActivityInstance 생성
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Issued },
+          undefined,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance.approvalLine).toBeDefined()
+        expect(instance.approvalLine?.length).toBe(1)
+        expect(instance.approvalLine?.[0].type).toBe('Role')
+        expect(instance.approvalLine?.[0].value).toBe(approverRole.id)
+      })
+    })
+
+    it('Role 타입 ActivityApproval 생성 시 approverRole이 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver Role', domain }, tx)
+
+        // When: Role 기반 approval 생성
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // Then
+        expect(approval.approverRole?.id).toBe(approverRole.id)
+        expect(approval.approver).toBeUndefined()
+      })
+    })
+
+    it('Role 타입 approval 생성 시 approver는 설정되지 않아야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+
+        // When
+        const approval = await activityApprovalFactory.createWithRole(
+          {},
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // Then: approver는 undefined, approverRole만 설정됨
+        expect(approval.approver).toBeUndefined()
+        expect(approval.approverRole).toBeDefined()
+        expect(approval.approverRole?.id).toBe(approverRole.id)
+      })
+    })
+  })
+
+  describe('Role 기반 승인 권한 검증', () => {
+    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)
+
+        // Given: Role을 가진 사용자
+        const userWithRole = await userFactory.createWithRole({}, approverRole, tx)
+
+        // Given: Role 기반 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // When: 승인 시뮬레이션
+        const approved = await simulateApproval(
+          approval,
+          userWithRole,
+          'Approved by role member',
+          { tx, domain, user: userWithRole }
+        )
+
+        // Then
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approved.approver?.id).toBe(userWithRole.id)
+      })
+    })
+
+    it('첫 번째 승인자가 Role 기반 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)
+        const userWithRole = await userFactory.createWithRole({}, approverRole, tx)
+
+        // Given: approver가 없는 Role 기반 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+        expect(approval.approver).toBeUndefined()
+
+        // When: 승인 실행 시
+        const approved = await simulateApproval(
+          approval,
+          userWithRole,
+          undefined,
+          { tx, domain, user: userWithRole }
+        )
+
+        // Then: 승인한 사용자가 approver로 할당됨
+        expect(approved.approver?.id).toBe(userWithRole.id)
+      })
+    })
+  })
+
+  describe('다단계 Role 기반 승인', () => {
+    it('여러 레벨의 Role 기반 approval line이 처리되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: 2개의 approver roles
+        const firstApproverRole = await roleFactory.create({ name: 'First Approver', domain }, tx)
+        const secondApproverRole = await roleFactory.create({ name: 'Second Approver', domain }, tx)
+
+        const firstApprover = await userFactory.createWithRole({}, firstApproverRole, tx)
+        const secondApprover = await userFactory.createWithRole({}, secondApproverRole, tx)
+
+        // Given: 2단계 approval line
+        const approvalLine = [
+          createRoleApprovalLineItem(firstApproverRole),
+          createRoleApprovalLineItem(secondApproverRole)
+        ]
+
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        // When: 첫 번째 레벨 approval 생성 및 승인
+        const firstApproval = await activityApprovalFactory.createWithRole(
+          { order: 1, judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          firstApproverRole,
+          tx
+        )
+
+        const escalated = await simulateEscalation(
+          firstApproval,
+          firstApprover,
+          'Escalating to next level',
+          { tx, domain, user: firstApprover }
+        )
+
+        // Then: 에스컬레이션됨
+        expect(escalated.judgment).toBe(ActivityApprovalJudgment.Escalated)
+
+        // When: 두 번째 레벨 approval 생성 및 승인
+        const secondApproval = await activityApprovalFactory.createWithRole(
+          { order: 2, judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          secondApproverRole,
+          tx
+        )
+
+        const approved = await simulateApproval(
+          secondApproval,
+          secondApprover,
+          'Final approval',
+          { tx, domain, user: secondApprover }
+        )
+
+        // Then: 최종 승인
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approved.approver?.id).toBe(secondApprover.id)
+      })
+    })
+
+    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 approver = await userFactory.createWithRole({}, approverRole, tx)
+
+        // Given: Role 기반 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          { order: 1, judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // When: 반려
+        const rejected = await simulateRejection(
+          approval,
+          approver,
+          'Needs revision',
+          { tx, domain, user: approver }
+        )
+
+        // Then
+        expect(rejected.judgment).toBe(ActivityApprovalJudgment.Rejected)
+        expect(rejected.comment).toBe('Needs revision')
+      })
+    })
+  })
+
+  describe('OOC Resolve에서 Role 기반 승인', () => {
+    it('OOC Resolve Activity에 outlierApprovalLine(Role 타입)이 적용되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'OOC Approver', domain }, tx)
+
+        // Given: OOC Resolve Activity with Role-based approval line
+        const resolveActivity = await activityFactory.createOocResolveActivity(domain, tx)
+        const outlierApprovalLine = [createRoleApprovalLineItem(approverRole)]
+
+        // When: Instance 생성
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            approvalLine: outlierApprovalLine
+          },
+          resolveActivity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance.approvalLine?.length).toBe(1)
+        expect(instance.approvalLine?.[0].type).toBe('Role')
+      })
+    })
+
+    it('OOC Resolve 승인 시 Role을 가진 사용자만 승인 가능해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'OOC Approver', domain }, tx)
+        const userWithRole = await userFactory.createWithRole({}, approverRole, tx)
+
+        // Given: Role 기반 approval
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // When: Role을 가진 사용자가 승인
+        const approved = await simulateApproval(
+          approval,
+          userWithRole,
+          'OOC Corrective action approved',
+          { tx, domain, user: userWithRole }
+        )
+
+        // Then
+        expect(approved.judgment).toBe(ActivityApprovalJudgment.Approved)
+        expect(approved.terminatedAt).toBeDefined()
+      })
+    })
+  })
+
+  describe('ActivityApprovalJudgment Enum', () => {
+    it('Pending은 빈 문자열이어야 한다', () => {
+      expect(ActivityApprovalJudgment.Pending).toBe('')
+    })
+
+    it('모든 judgment 값이 정의되어야 한다', () => {
+      expect(ActivityApprovalJudgment.Rejected).toBe('rejected')
+      expect(ActivityApprovalJudgment.Escalated).toBe('escalated')
+      expect(ActivityApprovalJudgment.Delegated).toBe('delegated')
+      expect(ActivityApprovalJudgment.Approved).toBe('approved')
+      expect(ActivityApprovalJudgment.Aborted).toBe('aborted')
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('Role에 사용자가 없어도 approval이 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+
+        // Given: 사용자가 없는 Role
+        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은 생성됨 (나중에 Role에 사용자가 추가될 수 있음)
+        expect(approval).toBeDefined()
+        expect(approval.approverRole?.id).toBe(emptyRole.id)
+      })
+    })
+
+    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
+        const approval = await activityApprovalFactory.createWithRole(
+          { judgment: ActivityApprovalJudgment.Pending },
+          undefined,
+          approverRole,
+          tx
+        )
+
+        // When
+        const approved = await simulateApproval(
+          approval,
+          approver,
+          undefined,
+          { tx, domain, user: approver }
+        )
+
+        // Then
+        expect(approved.terminatedAt).toBeDefined()
+        expect(approved.terminatedAt).toBeInstanceOf(Date)
+      })
+    })
+  })
+})