fix: 필터링 API 파싱 오류 수정 #604

.github/workflows/backend-ci-cd-dev.yml

@@ -1,9 +1,7 @@
 name: Backend CI/CD dev
 
 on:
-  push:
-    paths: [ 'backend/**', '.github/**' ]
-    branches: [ "develop-be", "develop" ]
+  workflow_dispatch:
 
 jobs:
   ci:

.github/workflows/backend-ci-cd-multi-prod.yml → .github/workflows/backend-ci-cd-multi-dev.yml

@@ -1,4 +1,4 @@
-name: Backend CI/CD multi prod
+name: Backend CI/CD multi dev
 
 on:
   push:

backend/src/main/java/com/staccato/auth/service/dto/request/LoginRequest.java

@@ -17,7 +17,7 @@ public record LoginRequest(
         String nickname
 ) {
     public LoginRequest {
-        if (!Objects.isNull(nickname)) {
+        if (Objects.nonNull(nickname)) {
             nickname = nickname.trim();
         }
     }

backend/src/main/java/com/staccato/memory/service/MemoryFilter.java

@@ -28,6 +28,7 @@ public static List<MemoryFilter> findAllByName(List<String> filters) {
                 .map(name -> MemoryFilter.findByName(name.trim()))
                 .filter(Optional::isPresent)
                 .map(Optional::get)
+                .distinct()
                 .toList();
     }
 

backend/src/main/java/com/staccato/memory/service/dto/request/MemoryReadRequest.java

@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import com.staccato.memory.service.MemoryFilter;
 import com.staccato.memory.service.MemorySort;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -16,12 +17,19 @@ public record MemoryReadRequest(
     private static final String DELIMITER = ",";
 
     public List<MemoryFilter> getFilters() {
-        List<String> filters = Arrays.stream(this.filters.split(DELIMITER))
+        List<String> filters = parseFilters().stream()
                 .map(String::trim)
                 .toList();
         return MemoryFilter.findAllByName(filters);
     }
 
+    private List<String> parseFilters() {
+        if (Objects.isNull(filters)) {
+            return List.of();
+        }
+        return Arrays.stream(filters.split(DELIMITER)).toList();
+    }
+
     public MemorySort getSort() {
         return MemorySort.findByName(sort);
     }

backend/src/test/java/com/staccato/memory/service/MemoryFilterTest.java

@@ -36,7 +36,7 @@ void findByNameWithValidFilter() {
         );
     }
 
-    @DisplayName("필터링명이 주어졌을 때 유효한 MemoryFilter 목록 민 반환한다.")
+    @DisplayName("필터링명이 주어졌을 때 유효한 MemoryFilter 목록만 반환한다.")
     @Test
     void findAllByNameIfOnlyValid() {
         // when
@@ -49,6 +49,19 @@ void findAllByNameIfOnlyValid() {
         );
     }
 
+    @DisplayName("필터링명이 중복으로 주어졌을 때 중복 없이 MemoryFilter 목록을 반환한다.")
+    @Test
+    void findAllByNameDistinct() {
+        // when
+        List<MemoryFilter> result = MemoryFilter.findAllByName(List.of("TERM", "term"));
+
+        // then
+        assertAll(
+                () -> assertThat(result).hasSize(1),
+                () -> assertThat(result.get(0)).isEqualTo(MemoryFilter.TERM)
+        );
+    }
+
     @DisplayName("유효하지 않거나 null인 정렬명이 주어졌을 때 빈 값을 반환한다.")
     @Test
     void findByNameWithInvalid() {

backend/src/test/java/com/staccato/memory/service/MemorySortTest.java

@@ -5,6 +5,7 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.NullSource;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -26,13 +27,21 @@ public class MemorySortTest extends ServiceSliceTest {
     private MemoryRepository memoryRepository;
 
     @DisplayName("정렬명이 주어졌을 때 대소문자 구분 없이 MemorySort을 반환한다.")
-    @Test
-    void findByNameWithValidSort() {
+    @ParameterizedTest
+    @CsvSource({
+            "UPDATED, UPDATED",
+            "NEWEST, NEWEST",
+            "OLDEST, OLDEST",
+            "updated, UPDATED",
+            "newest, NEWEST",
+            "oldest, OLDEST"
+    })
+    void findByNameWithValidSort(String name, MemorySort sort) {
         // when
-        MemorySort result = MemorySort.findByName("newest");
+        MemorySort result = MemorySort.findByName(name);
 
         // then
-        assertThat(result).isEqualTo(MemorySort.NEWEST);
+        assertThat(result).isEqualTo(sort);
     }
 
     @DisplayName("유효하지 않거나 null인 정렬명이 주어졌을 때 기본값인 UPDATED를 반환한다.")

backend/src/test/java/com/staccato/memory/service/dto/request/MemoryReadRequestTest.java

@@ -0,0 +1,54 @@
+package com.staccato.memory.service.dto.request;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import com.staccato.memory.service.MemoryFilter;
+import com.staccato.memory.service.MemorySort;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class MemoryReadRequestTest {
+    @DisplayName("필터가 주어졌을 때 올바른 필터 목록을 반환한다")
+    @Test
+    void getFiltersWithValidFilters() {
+        // given
+        MemoryReadRequest request = new MemoryReadRequest("TERM, term", "NEWEST");
+
+        // when
+        List<MemoryFilter> filters = request.getFilters();
+
+        // then
+        assertThat(filters).hasSize(1).containsOnly(MemoryFilter.TERM);
+    }
+
+    @DisplayName("필터가 주어지지 않았을 때 빈 필터 목록을 반환한다")
+    @ParameterizedTest
+    @NullAndEmptySource
+    void getFiltersWithNullOrEmptyFilters(String filters) {
+        // given
+        MemoryReadRequest request = new MemoryReadRequest(filters, "NEWEST");
+
+        // when
+        List<MemoryFilter> result = request.getFilters();
+
+        // then
+        assertThat(result).isEmpty();
+    }
+
+    @DisplayName("정렬이 주어지지 않았을 때 기본 정렬 기준을 반환한다")
+    @ParameterizedTest
+    @NullAndEmptySource
+    void getSortWithNullOrEmptyFilters(String sort) {
+        // given
+        MemoryReadRequest request = new MemoryReadRequest(null, sort);
+
+        // when
+        MemorySort result = request.getSort();
+
+        // then
+        assertThat(result).isEqualTo(MemorySort.UPDATED);
+    }
+}