From a9b227f3f2a910b4d9a121c775b218c4383116f3 Mon Sep 17 00:00:00 2001
From: joowojr <joowojr@gmail.com>
Date: Sat, 15 Feb 2025 22:51:28 +0900
Subject: [PATCH] =?UTF-8?q?CLAP-439=20Test:=20GWT=EC=97=90=EC=84=9C=20AAA?=
 =?UTF-8?q?=20=ED=8C=A8=ED=84=B4=EC=9C=BC=EB=A1=9C=20=ED=85=8C=EC=8A=A4?=
 =?UTF-8?q?=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EA=B0=9C=EC=84=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#574
---
 .../task/TaskOrderCalculationPolicyTest.java  | 61 +++++++++++++++----
 1 file changed, 48 insertions(+), 13 deletions(-)

diff --git a/src/test/java/clap/server/domain/policy/task/TaskOrderCalculationPolicyTest.java b/src/test/java/clap/server/domain/policy/task/TaskOrderCalculationPolicyTest.java
index f813d41f..e209ed47 100644
--- a/src/test/java/clap/server/domain/policy/task/TaskOrderCalculationPolicyTest.java
+++ b/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,60 +27,97 @@ 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);
     }
@@ -89,4 +125,3 @@ void calculateNewProcessorOrder_WhenNullValues() {
 
 
 
-