CLAP-440 작업 상태 변경 알림 중복 전송 에러 해결

src/main/java/clap/server/application/service/task/ApprovalTaskService.java

@@ -25,6 +25,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -61,11 +62,8 @@ public ApprovalTaskResponse approvalTaskByReviewer(Long reviewerId, Long taskId,
         TaskHistory taskHistory = TaskHistory.createTaskHistory(TaskHistoryType.PROCESSOR_ASSIGNED, task, null, processor, null);
         commandTaskHistoryPort.save(taskHistory);
 
-        List<Member> receivers = Stream.of(task.getRequester(), processor)
-                .distinct()
-                .collect(Collectors.toList());
         String processorName = processor.getNickname();
-        publishNotification(receivers, task, processorName);
+        publishNotification(task, processorName);
 
         return TaskResponseMapper.toApprovalTaskResponse(taskService.upsert(task));
     }
@@ -78,7 +76,14 @@ public FindApprovalFormResponse findApprovalForm(Long managerId, Long taskId) {
         return TaskResponseMapper.toFindApprovalFormResponse(task);
     }
 
-    private void publishNotification(List<Member> receivers, Task task, String processorName) {
+    private void publishNotification(Task task, String processorName) {
+        List<Member> receivers = new ArrayList<>();
+        receivers.add(task.getRequester());
+
+        if (!task.getRequester().getMemberId().equals(task.getProcessor().getMemberId())) {
+            receivers.add(task.getProcessor());
+        }
+
         receivers.forEach(receiver -> {
             boolean isManager = receiver.getMemberInfo().getRole() == MemberRole.ROLE_MANAGER;
             sendNotificationService.sendPushNotification(receiver, NotificationType.PROCESSOR_ASSIGNED,

src/main/java/clap/server/application/service/task/UpdateTaskOrderAndStstusService.java

@@ -24,6 +24,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Slf4j
@@ -83,7 +84,7 @@ public void updateTaskOrderAndStatus(Long processorId, UpdateTaskOrderRequest re
 
         TaskHistory taskHistory = TaskHistory.createTaskHistory(TaskHistoryType.STATUS_SWITCHED, updatedTask, targetStatus.getDescription(), null,null);
         commandTaskHistoryPort.save(taskHistory);
-        publishNotification(targetTask, NotificationType.STATUS_SWITCHED, updatedTask.getDescription());
+        publishNotification(targetTask);
     }
 
     /**
@@ -139,14 +140,14 @@ public void validateRequest(TaskStatus targetStatus) {
         }
     }
 
-    private void publishNotification(Task task, NotificationType notificationType, String message) {
-        List<Member> receivers = List.of(task.getRequester(), task.getProcessor());
+    private void publishNotification(Task task) {
+        List<Member> receivers = List.of(task.getRequester());
         receivers.forEach(receiver -> {
             boolean isManager = receiver.getMemberInfo().getRole() == MemberRole.ROLE_MANAGER;
-            sendNotificationService.sendPushNotification(receiver, notificationType, task, message, null, null, isManager);
+            sendNotificationService.sendPushNotification(receiver, NotificationType.STATUS_SWITCHED, task, task.getTaskStatus().getDescription(), null, null, isManager);
         });
-        sendNotificationService.sendAgitNotification(notificationType,
-                task, message, null);
+        sendNotificationService.sendAgitNotification(NotificationType.STATUS_SWITCHED,
+                task, task.getTaskStatus().getDescription(), null);
     }
 
 }

src/test/java/clap/server/domain/policy/task/TaskOrderCalculationPolicyTest.java

@@ -2,7 +2,6 @@
 
 import clap.server.domain.model.task.Task;
 import clap.server.exception.DomainException;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -12,7 +11,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
 
 @ExtendWith(MockitoExtension.class)
 class TaskOrderCalculationPolicyTest {
@@ -28,65 +27,101 @@ class TaskOrderCalculationPolicyTest {
     @Mock
     private Task nextTask;
 
-    @BeforeEach
-    void setUp() {
-        lenient().when(prevTask.getProcessorOrder()).thenReturn(1000L);
-        lenient().when(nextTask.getProcessorOrder()).thenReturn(3000L);
-    }
-
     @Test
     @DisplayName("맨 위에 새로운 Task 추가 - 이전 Task가 없는 경우")
     void calculateOrderForTop_WhenPrevTaskIsNull() {
+        // Arrange (준비)
+        when(nextTask.getProcessorOrder()).thenReturn(3000L);
+
+        // Act (실행)
         long order = policy.calculateOrderForTop(null, nextTask);
+
+        // Assert (검증)
         assertEquals(3000L - DEFAULT_PROCESSOR_ORDER_GAP, order);
     }
 
     @Test
     @DisplayName("맨 위에 새로운 Task 추가 - 이전 Task가 존재하는 경우")
     void calculateOrderForTop_WhenPrevTaskExists() {
+        // Arrange
+        when(prevTask.getProcessorOrder()).thenReturn(1000L);
+        when(nextTask.getProcessorOrder()).thenReturn(3000L);
+
+        // Act
         long order = policy.calculateOrderForTop(prevTask, nextTask);
+
+        // Assert
         assertEquals(2000L, order);
     }
 
     @Test
     @DisplayName("맨 아래에 새로운 Task 추가 - 다음 Task가 없는 경우")
     void calculateOrderForBottom_WhenNextTaskIsNull() {
+        // Arrange
+        when(prevTask.getProcessorOrder()).thenReturn(1000L);
+
+        // Act
         long order = policy.calculateOrderForBottom(prevTask, null);
+
+        // Assert
         assertEquals(1000L + DEFAULT_PROCESSOR_ORDER_GAP, order);
     }
 
     @Test
     @DisplayName("맨 아래에 새로운 Task 추가 - 다음 Task가 존재하는 경우")
     void calculateOrderForBottom_WhenNextTaskExists() {
+        // Arrange
+        when(prevTask.getProcessorOrder()).thenReturn(1000L);
+        when(nextTask.getProcessorOrder()).thenReturn(3000L);
+
+        // Act
         long order = policy.calculateOrderForBottom(prevTask, nextTask);
+
+        // Assert
         assertEquals(2000L, order);
     }
 
     @Test
     @DisplayName("새로운 순서를 계산 - 유효한 범위 내에서 계산")
     void calculateNewProcessorOrder_WhenValid() {
-        long order = policy.calculateNewProcessorOrder(1000L, 3000L);
+        // Arrange
+        long prevOrder = 1000L;
+        long nextOrder = 3000L;
+
+        // Act
+        long order = policy.calculateNewProcessorOrder(prevOrder, nextOrder);
+
+        // Assert
         assertEquals(2000L, order);
     }
 
     @Test
     @DisplayName("새로운 순서를 계산 - 간격이 너무 좁을 경우 예외 발생")
     void calculateNewProcessorOrder_WhenOrderGapIsTooSmall() {
-        assertThrows(DomainException.class, () ->
-                policy.calculateNewProcessorOrder(1000L, 1001L));
+        // Arrange
+        long prevOrder = 1000L;
+        long nextOrder = 1001L;
+
+        // Act & Assert
+        assertThrows(DomainException.class, () -> policy.calculateNewProcessorOrder(prevOrder, nextOrder));
     }
 
     @Test
     @DisplayName("새로운 순서를 계산 - prevTaskOrder 또는 nextTaskOrder가 null일 경우 기본값 반환")
     void calculateNewProcessorOrder_WhenNullValues() {
-        long order1 = policy.calculateNewProcessorOrder(null, 3000L);
+        // Arrange
+        Long prevOrder = null;
+        Long nextOrder = 3000L;
+
+        // Act
+        long order1 = policy.calculateNewProcessorOrder(prevOrder, nextOrder);
         long order2 = policy.calculateNewProcessorOrder(1000L, null);
 
+        // Assert
         assertEquals(DEFAULT_PROCESSOR_ORDER_GAP, order1);
         assertEquals(DEFAULT_PROCESSOR_ORDER_GAP, order2);
     }
 }
 
 
 
-