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

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

@@ -0,0 +1,481 @@
+/**
+ * ROLE Approval Submit Logic Tests
+ * ROLE 타입 승인라인 Submit 로직 검증 테스트
+ *
+ * 수정된 버그:
+ * - submit.ts:60 - if (approverRoleId) → if (!approverRoleId)
+ */
+
+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,
+  createUserApprovalLineItem,
+  createMultiLevelApprovalLine
+} from '../../../../test/helpers/workflow-helpers'
+
+describe('ROLE Approval Submit Logic Tests', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('단일 ROLE 타입 승인라인 Submit', () => {
+    it('ROLE 타입 승인라인이 있는 스레드를 submit하면 ActivityApproval이 생성되어야 한다', 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 Role', domain }, tx)
+
+        // Given: ROLE 타입 승인라인을 가진 ActivityInstance
+        const approvalLine = [createRoleApprovalLineItem(approverRole)]
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        // Given: Started 상태의 스레드
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 시뮬레이션 - ActivityApproval 생성
+        const approval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: thread.round,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          transaction: 'submit',
+          approverRole: approverRole,
+          creator: user,
+          updater: user
+        }) as any
+
+        // Then: ActivityApproval이 approverRole과 함께 생성됨
+        expect(approval).toBeDefined()
+        expect(approval.approverRole?.id).toBe(approverRole.id)
+        expect(approval.approver).toBeUndefined()
+        expect(approval.judgment).toBe(ActivityApprovalJudgment.Pending)
+        expect(approval.order).toBe(1)
+      })
+    })
+
+    it('ROLE 타입 approval의 value(roleId)가 반드시 존재해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const approverRole = await roleFactory.create({ name: 'Valid Role', domain }, tx)
+
+        // Given: 유효한 ROLE 승인라인
+        const approvalLineItem = createRoleApprovalLineItem(approverRole)
+
+        // Then: value(roleId)가 존재해야 함
+        expect(approvalLineItem.value).toBeDefined()
+        expect(approvalLineItem.value).toBe(approverRole.id)
+        expect(approvalLineItem.type).toBe('Role')
+
+        // 버그 수정 확인: value가 있으면 정상 처리되어야 함
+        // 수정 전: if (approverRoleId) throw - 항상 에러
+        // 수정 후: if (!approverRoleId) throw - roleId 없을 때만 에러
+        const hasValidRoleId = !!approvalLineItem.value
+        expect(hasValidRoleId).toBe(true)
+      })
+    })
+
+    it('ROLE 타입 승인라인의 value가 없으면 오류가 발생해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: value가 없는 잘못된 ROLE 승인라인
+        const invalidApprovalLineItem = {
+          type: 'Role',
+          value: undefined, // roleId가 없음
+          approver: { id: undefined, name: 'Invalid' }
+        }
+
+        // Then: value가 없으면 에러 조건 충족
+        const approverRoleId = invalidApprovalLineItem.value
+        const shouldThrowError = !approverRoleId
+        expect(shouldThrowError).toBe(true)
+      })
+    })
+
+    it('빈 문자열 roleId도 오류로 처리되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+
+        // Given: 빈 문자열 value
+        const invalidApprovalLineItem = {
+          type: 'Role',
+          value: '', // 빈 문자열
+          approver: { id: '', name: 'Invalid' }
+        }
+
+        // Then: 빈 문자열도 falsy이므로 오류 조건 충족
+        const approverRoleId = invalidApprovalLineItem.value
+        const shouldThrowError = !approverRoleId
+        expect(shouldThrowError).toBe(true)
+      })
+    })
+  })
+
+  describe('User 타입 vs ROLE 타입 승인라인 비교', () => {
+    it('User 타입 승인라인은 approver가 직접 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+        const approverUser = await userFactory.create({ name: 'Approver' }, tx)
+
+        // Given: User 타입 승인라인
+        const approvalLineItem = createUserApprovalLineItem(approverUser)
+        expect(approvalLineItem.type).toBe('Employee')
+
+        // When: ActivityApproval 생성
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          [approvalLineItem],
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        const approval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          transaction: 'submit',
+          approver: approverUser,
+          creator: user,
+          updater: user
+        }) as any
+
+        // Then: approver가 설정되고 approverRole은 없음
+        expect(approval.approver?.id).toBe(approverUser.id)
+        expect(approval.approverRole).toBeUndefined()
+      })
+    })
+
+    it('ROLE 타입 승인라인은 approverRole이 설정되고 approver는 나중에 할당된다', 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 Role', domain }, tx)
+
+        // Given: ROLE 타입 승인라인
+        const approvalLineItem = createRoleApprovalLineItem(approverRole)
+        expect(approvalLineItem.type).toBe('Role')
+
+        // When: ActivityApproval 생성 (submit 시점)
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          [approvalLineItem],
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        const approval = await tx.save('ActivityApproval', {
+          domain,
+          activityThread: thread,
+          round: 1,
+          order: 1,
+          judgment: ActivityApprovalJudgment.Pending,
+          transaction: 'submit',
+          approverRole: approverRole,
+          creator: user,
+          updater: user
+        }) as any
+
+        // Then: approverRole이 설정되고 approver는 없음
+        expect(approval.approverRole?.id).toBe(approverRole.id)
+        expect(approval.approver).toBeUndefined()
+
+        // When: 역할 소유자가 승인 시 approver 할당
+        const roleOwner = await userFactory.createWithRole({}, approverRole, tx)
+        approval.approver = roleOwner
+        approval.judgment = ActivityApprovalJudgment.Approved
+        approval.terminatedAt = new Date()
+
+        const approved = await tx.save('ActivityApproval', approval) as any
+
+        // Then: 이제 approver도 설정됨
+        expect(approved.approver?.id).toBe(roleOwner.id)
+        expect(approved.approverRole?.id).toBe(approverRole.id)
+      })
+    })
+  })
+
+  describe('Submit 후 스레드 상태 전이', () => {
+    it('승인라인이 있으면 스레드는 Submitted 상태가 되어야 한다', 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: ROLE 승인라인을 가진 Instance
+        const approvalLine = [createRoleApprovalLineItem(approverRole)]
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+
+        // Given: Started 상태 스레드
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 후 상태 변경
+        thread.state = ActivityThreadStatus.Submitted
+        const submitted = await tx.save('ActivityThread', thread) as any
+
+        // Then
+        expect(submitted.state).toBe(ActivityThreadStatus.Submitted)
+      })
+    })
+
+    it('승인라인이 없으면 스레드는 Ended 상태가 되어야 한다', 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
+        )
+
+        // Given: Started 상태 스레드
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Started },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 후 상태 변경 (승인라인 없음)
+        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('Submit 전 상태 검증', () => {
+    it('Assigned 상태에서도 Submit이 가능해야 한다 (암묵적 시작)', 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: Assigned 상태 스레드
+        const approvalLine = [createRoleApprovalLineItem(approverRole)]
+        const instance = await activityInstanceFactory.createWithApprovalLine(
+          approvalLine,
+          { state: ActivityInstanceStatus.Assigned },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Assigned },
+          instance,
+          user,
+          tx
+        )
+
+        // Then: Assigned와 Started 둘 다 submit 가능한 상태
+        const canSubmit =
+          thread.state === ActivityThreadStatus.Assigned ||
+          thread.state === ActivityThreadStatus.Started
+        expect(canSubmit).toBe(true)
+      })
+    })
+
+    it('Ended 상태에서는 Submit이 불가능해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: Ended 상태 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Ended },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          {
+            state: ActivityThreadStatus.Ended,
+            terminatedAt: new Date()
+          },
+          instance,
+          user,
+          tx
+        )
+
+        // Then: Submit 불가능
+        const canSubmit =
+          thread.state === ActivityThreadStatus.Assigned ||
+          thread.state === ActivityThreadStatus.Started
+        expect(canSubmit).toBe(false)
+      })
+    })
+
+    it('Aborted 상태에서는 Submit이 불가능해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: Aborted 상태 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Aborted },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          {
+            state: ActivityThreadStatus.Aborted,
+            terminatedAt: new Date()
+          },
+          instance,
+          user,
+          tx
+        )
+
+        // Then: Submit 불가능
+        const canSubmit =
+          thread.state === ActivityThreadStatus.Assigned ||
+          thread.state === ActivityThreadStatus.Started
+        expect(canSubmit).toBe(false)
+      })
+    })
+  })
+
+  describe('startedAt 자동 설정', () => {
+    it('Submit 시 startedAt이 없으면 자동 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: startedAt이 없는 Assigned 스레드
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Assigned },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Assigned },
+          instance,
+          user,
+          tx
+        )
+        expect(thread.startedAt).toBeFalsy() // null or undefined
+
+        // When: Submit 시 startedAt 설정
+        if (!thread.startedAt) {
+          thread.startedAt = new Date()
+        }
+        const updated = await tx.save('ActivityThread', thread) as any
+
+        // Then
+        expect(updated.startedAt).toBeDefined()
+        expect(updated.startedAt).toBeInstanceOf(Date)
+      })
+    })
+
+    it('Submit 시 startedAt이 이미 있으면 유지되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx } = context.state
+        const domain = await domainFactory.create({}, tx)
+        const user = await userFactory.create({}, tx)
+
+        // Given: startedAt이 이미 있는 Started 스레드
+        const originalStartedAt = new Date('2024-01-01T00:00:00Z')
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Started },
+          undefined,
+          domain,
+          tx
+        )
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          {
+            state: ActivityThreadStatus.Started,
+            startedAt: originalStartedAt
+          },
+          instance,
+          user,
+          tx
+        )
+
+        // When: Submit 시 startedAt 확인
+        if (!thread.startedAt) {
+          thread.startedAt = new Date()
+        }
+
+        // Then: 기존 startedAt 유지
+        expect(thread.startedAt).toEqual(originalStartedAt)
+      })
+    })
+  })
+})