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

package/spec/unit/controllers/activity-instance-issue.spec.ts

@@ -0,0 +1,360 @@
+/**
+ * ActivityInstance Issue Controller Tests
+ * ActivityInstance 발행 컨트롤러 테스트
+ */
+
+import { TestDatabase } from '../../../../../test/test-database'
+import { withTestTransaction } from '../../../../../test/test-context'
+import {
+  domainFactory,
+  userFactory,
+  roleFactory,
+  activityFactory,
+  activityInstanceFactory,
+  activityThreadFactory
+} from '../../../../../test/factories'
+import { ActivityInstanceStatus, ActivityThreadStatus } from '../../../../../test/entities/schemas'
+
+describe('ActivityInstance Issue Controller', () => {
+  let testDb: TestDatabase
+
+  beforeAll(async () => {
+    testDb = TestDatabase.getInstance()
+  })
+
+  describe('Instance 발행 기본 동작', () => {
+    it('Activity에서 Instance를 발행할 수 있어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: Activity 생성
+        const activity = await activityFactory.createWithDomain(
+          {
+            name: 'Test Activity',
+            description: 'Test Description',
+            priority: 3,
+            standardTime: 3600 // 1시간
+          },
+          domain,
+          tx
+        )
+
+        // When: Instance 발행 시뮬레이션
+        const issuedAt = new Date()
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            name: activity.name,
+            description: activity.description,
+            priority: activity.priority,
+            state: ActivityInstanceStatus.Issued,
+            input: { taskId: 'task-123' }
+          },
+          activity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance).toBeDefined()
+        expect(instance.state).toBe(ActivityInstanceStatus.Issued)
+        expect(instance.name).toBe('Test Activity')
+        expect(instance.priority).toBe(3)
+        expect(instance.activity?.id).toBe(activity.id)
+      })
+    })
+
+    it('assigneeRole이 설정되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const assigneeRole = await roleFactory.create({ name: 'Worker', domain }, tx)
+        const activity = await activityFactory.createWithDomain({}, domain, tx)
+
+        // When
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            assigneeRole
+          },
+          activity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance.assigneeRole?.id).toBe(assigneeRole.id)
+      })
+    })
+
+    it('dueAt이 standardTime 기반으로 계산되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const standardTime = 7200 // 2시간
+        const activity = await activityFactory.createWithDomain(
+          { standardTime },
+          domain,
+          tx
+        )
+        const issuedAt = new Date()
+
+        // When: dueAt 계산
+        const expectedDueAt = new Date(issuedAt.getTime() + standardTime * 1000)
+
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            dueAt: expectedDueAt
+          },
+          activity,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance.dueAt).toEqual(expectedDueAt)
+      })
+    })
+  })
+
+  describe('Thread 생성 규칙', () => {
+    it('assignees가 지정되면 해당 사용자에게 Thread가 할당되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const assignee = await userFactory.create({ name: 'Assigned User' }, tx)
+        const instance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Issued },
+          undefined,
+          domain,
+          tx
+        )
+
+        // When: Thread 생성
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          { state: ActivityThreadStatus.Assigned },
+          instance,
+          assignee,
+          tx
+        )
+
+        // Then
+        expect(thread.assignee?.id).toBe(assignee.id)
+        expect(thread.state).toBe(ActivityThreadStatus.Assigned)
+      })
+    })
+
+    it('assigneeRole만 있고 assignees가 없으면 Unassigned Thread가 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const assigneeRole = await roleFactory.create({ name: 'Worker', domain }, tx)
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            assigneeRole,
+            threadsMin: 1
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        // When: Unassigned Thread 생성
+        const thread = await tx.save('ActivityThread', {
+          state: ActivityThreadStatus.Unassigned,
+          round: 1,
+          activityInstance: instance,
+          domain
+        }) as any
+
+        // Then
+        expect(thread.state).toBe(ActivityThreadStatus.Unassigned)
+        expect(thread.assignee).toBeUndefined()
+      })
+    })
+
+    it('threadsMin이 0이면 assigneeRole의 모든 사용자에게 Thread가 생성되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: Role에 여러 사용자
+        const role = await roleFactory.create({ name: 'Worker', domain }, tx)
+        const user1 = await userFactory.create({ name: 'Worker 1', roles: [role] }, tx)
+        const user2 = await userFactory.create({ name: 'Worker 2', roles: [role] }, tx)
+
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            assigneeRole: role,
+            threadsMin: 0 // 모든 사용자
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        // When: 모든 Role 사용자에게 Thread 생성 시뮬레이션
+        const threads = await Promise.all([
+          activityThreadFactory.createWithInstanceAndAssignee(
+            { state: ActivityThreadStatus.Assigned },
+            instance,
+            user1,
+            tx
+          ),
+          activityThreadFactory.createWithInstanceAndAssignee(
+            { state: ActivityThreadStatus.Assigned },
+            instance,
+            user2,
+            tx
+          )
+        ])
+
+        // Then
+        expect(threads.length).toBe(2)
+        expect(threads[0].assignee?.id).toBe(user1.id)
+        expect(threads[1].assignee?.id).toBe(user2.id)
+      })
+    })
+  })
+
+  describe('Draft -> Issue 전이', () => {
+    it('Draft 상태에서만 Issue가 가능해야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: Draft 상태의 Instance
+        const draftInstance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Draft },
+          undefined,
+          domain,
+          tx
+        )
+
+        // When: Issue 시뮬레이션
+        draftInstance.state = ActivityInstanceStatus.Issued
+        const issued = await tx.save('ActivityInstance', draftInstance)
+
+        // Then
+        expect(issued.state).toBe(ActivityInstanceStatus.Issued)
+      })
+    })
+
+    it('이미 Issue된 Instance는 다시 Issue할 수 없어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given: 이미 Issued 상태의 Instance
+        const issuedInstance = await activityInstanceFactory.createWithActivity(
+          { state: ActivityInstanceStatus.Issued },
+          undefined,
+          domain,
+          tx
+        )
+
+        // Then: 이미 Issued 상태
+        expect(issuedInstance.state).toBe(ActivityInstanceStatus.Issued)
+        // 실제 컨트롤러에서는 이 경우 에러 발생
+      })
+    })
+  })
+
+  describe('Post 타입 발행 (startingType=post)', () => {
+    it('post 타입이면 발행과 동시에 Started 상태가 되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain, user } = context.state
+
+        // Given: startingType=post인 Activity 시뮬레이션
+        // When: post 방식 발행 시뮬레이션
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Started, // post는 바로 Started
+            input: { dataId: 'data-123' },
+            output: { result: 'submitted' }
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        // post 방식은 Thread도 바로 생성됨
+        const thread = await activityThreadFactory.createWithInstanceAndAssignee(
+          {
+            state: ActivityThreadStatus.Started,
+            startedAt: new Date()
+          },
+          instance,
+          user,
+          tx
+        )
+
+        // Then
+        expect(instance.state).toBe(ActivityInstanceStatus.Started)
+        expect(thread.state).toBe(ActivityThreadStatus.Started)
+      })
+    })
+  })
+
+  describe('approvalLine 설정', () => {
+    it('Activity의 approvalLine이 Instance에 복사되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const approverRole = await roleFactory.create({ name: 'Approver', domain }, tx)
+        const approvalLine = [
+          { type: 'Role', value: approverRole.id, approver: { id: approverRole.id, name: approverRole.name } }
+        ]
+
+        // When
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            approvalLine
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance.approvalLine).toBeDefined()
+        expect(instance.approvalLine?.length).toBe(1)
+        expect(instance.approvalLine?.[0].type).toBe('Role')
+      })
+    })
+  })
+
+  describe('input/output 처리', () => {
+    it('input이 Instance에 저장되어야 한다', async () => {
+      await withTestTransaction(async (context) => {
+        const { tx, domain } = context.state
+
+        // Given
+        const input = {
+          dataOocId: 'ooc-123',
+          instruction: 'Fix the temperature'
+        }
+
+        // When
+        const instance = await activityInstanceFactory.createWithActivity(
+          {
+            state: ActivityInstanceStatus.Issued,
+            input
+          },
+          undefined,
+          domain,
+          tx
+        )
+
+        // Then
+        expect(instance.input).toEqual(input)
+        expect(instance.input?.dataOocId).toBe('ooc-123')
+      })
+    })
+  })
+})