[FEAT] 온보딩 및 프로필 태그 선택 개수 정책 변경

src/main/java/org/sopt/buddys/domain/user/code/UserErrorCode.java

@@ -16,7 +16,7 @@ public enum UserErrorCode implements ErrorCode {
   ONBOARDING_ALREADY_COMPLETED("USER-E005", HttpStatus.BAD_REQUEST, "이미 온보딩을 완료한 사용자입니다."),
   TAG_NOT_FOUND("USER-E006", HttpStatus.NOT_FOUND, "존재하지 않는 태그가 포함되어 있습니다."),
   EXCHANGE_INFO_INCOMPLETE("USER-E007", HttpStatus.BAD_REQUEST, "교환학생 국가, 대학교, 기간은 모두 입력하거나 모두 비워야 합니다."),
-  INVALID_TAG_SELECTION_COUNT("USER-E008", HttpStatus.BAD_REQUEST, "활동과 관심사 태그는 각각 1~3개, 여행 스타일 태그는 1~5개 선택해야 합니다."),
+  INVALID_TAG_SELECTION_COUNT("USER-E008", HttpStatus.BAD_REQUEST, "활동 태그는 1~3개, 관심사와 여행 스타일 태그는 각각 1~2개 선택해야 합니다."),
   DUPLICATE_TAG("USER-E009", HttpStatus.BAD_REQUEST, "중복된 태그가 포함되어 있습니다."),
   RESERVED_NICKNAME("USER-E010", HttpStatus.BAD_REQUEST, "사용할 수 없는 닉네임입니다."),
   INVALID_PROFILE_IMAGE_URL("USER-E011", HttpStatus.BAD_REQUEST, "사용할 수 없는 프로필 이미지 URL입니다.");

src/main/java/org/sopt/buddys/domain/user/controller/swagger/CompleteOnboardingSwagger.java

@@ -108,6 +108,17 @@
                         }
                         """
                 ),
+                @ExampleObject(
+                    name = "태그 선택 개수 오류",
+                    value = """
+                        {
+                          "success": false,
+                          "code": "USER-E008",
+                          "message": "활동 태그는 1~3개, 관심사와 여행 스타일 태그는 각각 1~2개 선택해야 합니다.",
+                          "data": null
+                        }
+                        """
+                ),
                 @ExampleObject(
                     name = "예약된 닉네임",
                     value = """

src/main/java/org/sopt/buddys/domain/user/controller/swagger/UpdateProfileSwagger.java

@@ -82,7 +82,7 @@
                         {
                           "success": false,
                           "code": "USER-E008",
-                          "message": "활동과 관심사 태그는 각각 1~3개, 여행 스타일 태그는 1~5개 선택해야 합니다.",
+                          "message": "활동 태그는 1~3개, 관심사와 여행 스타일 태그는 각각 1~2개 선택해야 합니다.",
                           "data": null
                         }
                         """

src/main/java/org/sopt/buddys/domain/user/dto/request/OnboardingRequest.java

@@ -35,11 +35,11 @@ public record OnboardingRequest(
     @Schema(description = "활동 태그 ID 목록. 1~3개", example = "[1, 2, 3]")
     @NotEmpty @Size(min = 1, max = 3) List<Long> activityTagIds,
 
-    @Schema(description = "관심사 태그 ID 목록. 1~3개", example = "[13, 26]")
-    @NotEmpty @Size(min = 1, max = 3) List<Long> interestTagIds,
+    @Schema(description = "관심사 태그 ID 목록. 1~2개", example = "[13, 26]")
+    @NotEmpty @Size(min = 1, max = 2) List<Long> interestTagIds,
 
-    @Schema(description = "여행 스타일 태그 ID 목록. 1~5개", example = "[27, 30]")
-    @NotEmpty @Size(min = 1, max = 5) List<Long> travelStyleTagIds,
+    @Schema(description = "여행 스타일 태그 ID 목록. 1~2개", example = "[27, 30]")
+    @NotEmpty @Size(min = 1, max = 2) List<Long> travelStyleTagIds,
 
     @Schema(description = "닉네임. 최대 14자", example = "버디즈")
     @NotBlank @Size(max = 14) String nickname,

src/main/java/org/sopt/buddys/domain/user/dto/request/UpdateProfileRequest.java

@@ -60,13 +60,13 @@ public record UpdateProfileRequest(
                 description = """
             드래그앤드롭으로 정렬한 전체 선택 태그 ID 목록입니다.
             카테고리와 무관하게 상위 3개가 대표 태그로 노출됩니다.
-            서버에서 활동 1~3개, 관심사 1~3개, 여행 스타일 1~5개인지 검증합니다.
+            서버에서 활동 1~3개, 관심사 1~2개, 여행 스타일 1~2개인지 검증합니다.
             """,
-                example = "[27, 1, 15, 3, 18, 30, 34]",
+                example = "[27, 1, 15, 3, 18, 30, 2]",
                 requiredMode = Schema.RequiredMode.REQUIRED
         )
         @NotEmpty
-        @Size(min = 3, max = 11)
+        @Size(min = 3, max = 7)
         List<@NotNull Long> orderedTagIds
 ) {
 

src/main/java/org/sopt/buddys/domain/user/service/UserOnboardingService.java

@@ -72,6 +72,7 @@ public User completeOnboarding(Long userId, OnboardingCommand request) {
     validateTagType(tagsById, request.activityTagIds(), TagType.ACTIVITY);
     validateTagType(tagsById, request.interestTagIds(), TagType.INTEREST);
     validateTagType(tagsById, request.travelStyleTagIds(), TagType.TRAVEL_STYLE);
+    UserTagSelectionValidator.validate(tagsById.values());
 
     try {
       user.completeOnboarding(

src/main/java/org/sopt/buddys/domain/user/service/UserProfileEditService.java

@@ -10,7 +10,6 @@
 import org.hibernate.exception.ConstraintViolationException;
 import org.sopt.buddys.domain.auth.code.AuthErrorCode;
 import org.sopt.buddys.domain.tag.entity.Tag;
-import org.sopt.buddys.domain.tag.entity.TagType;
 import org.sopt.buddys.domain.tag.repository.TagRepository;
 import org.sopt.buddys.domain.user.code.UserErrorCode;
 import org.sopt.buddys.domain.user.dto.response.ProfileEditResponse;
@@ -30,12 +29,6 @@
 public class UserProfileEditService {
 
   private static final String NICKNAME_UNIQUE_CONSTRAINT = "uk_user_nickname";
-  private static final int MIN_ACTIVITY_TAG_COUNT = 1;
-  private static final int MAX_ACTIVITY_TAG_COUNT = 3;
-  private static final int MIN_INTEREST_TAG_COUNT = 1;
-  private static final int MAX_INTEREST_TAG_COUNT = 3;
-  private static final int MIN_TRAVEL_STYLE_TAG_COUNT = 1;
-  private static final int MAX_TRAVEL_STYLE_TAG_COUNT = 5;
 
   private final UserRepository userRepository;
   private final UserTagRepository userTagRepository;
@@ -106,27 +99,10 @@ private Map<Long, Tag> getAndValidateTags(List<Long> orderedTagIds) {
       throw new BaseException(UserErrorCode.TAG_NOT_FOUND);
     }
 
-    validateTagCounts(tagsById);
+    UserTagSelectionValidator.validate(tagsById.values());
     return tagsById;
   }
 
-  private void validateTagCounts(Map<Long, Tag> tagsById) {
-    Map<TagType, Long> tagCounts = tagsById.values().stream()
-        .collect(Collectors.groupingBy(Tag::getTagType, Collectors.counting()));
-    if (!isBetween(tagCounts.getOrDefault(TagType.ACTIVITY, 0L),
-        MIN_ACTIVITY_TAG_COUNT, MAX_ACTIVITY_TAG_COUNT)
-        || !isBetween(tagCounts.getOrDefault(TagType.INTEREST, 0L),
-        MIN_INTEREST_TAG_COUNT, MAX_INTEREST_TAG_COUNT)
-        || !isBetween(tagCounts.getOrDefault(TagType.TRAVEL_STYLE, 0L),
-        MIN_TRAVEL_STYLE_TAG_COUNT, MAX_TRAVEL_STYLE_TAG_COUNT)) {
-      throw new BaseException(UserErrorCode.INVALID_TAG_SELECTION_COUNT);
-    }
-  }
-
-  private boolean isBetween(long value, int minimum, int maximum) {
-    return value >= minimum && value <= maximum;
-  }
-
   private boolean isNicknameConflict(DataIntegrityViolationException exception) {
     Throwable cause = exception;
     while (cause != null) {

src/main/java/org/sopt/buddys/domain/user/service/UserTagSelectionValidator.java

@@ -0,0 +1,39 @@
+package org.sopt.buddys.domain.user.service;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.sopt.buddys.domain.tag.entity.Tag;
+import org.sopt.buddys.domain.tag.entity.TagType;
+import org.sopt.buddys.domain.user.code.UserErrorCode;
+import org.sopt.buddys.global.exception.BaseException;
+
+public final class UserTagSelectionValidator {
+
+  private static final int MIN_ACTIVITY_TAG_COUNT = 1;
+  private static final int MAX_ACTIVITY_TAG_COUNT = 3;
+  private static final int MIN_INTEREST_TAG_COUNT = 1;
+  private static final int MAX_INTEREST_TAG_COUNT = 2;
+  private static final int MIN_TRAVEL_STYLE_TAG_COUNT = 1;
+  private static final int MAX_TRAVEL_STYLE_TAG_COUNT = 2;
+
+  private UserTagSelectionValidator() {
+  }
+
+  public static void validate(Collection<Tag> tags) {
+    Map<TagType, Long> tagCounts = tags.stream()
+        .collect(Collectors.groupingBy(Tag::getTagType, Collectors.counting()));
+    if (!isBetween(tagCounts.getOrDefault(TagType.ACTIVITY, 0L),
+        MIN_ACTIVITY_TAG_COUNT, MAX_ACTIVITY_TAG_COUNT)
+        || !isBetween(tagCounts.getOrDefault(TagType.INTEREST, 0L),
+        MIN_INTEREST_TAG_COUNT, MAX_INTEREST_TAG_COUNT)
+        || !isBetween(tagCounts.getOrDefault(TagType.TRAVEL_STYLE, 0L),
+        MIN_TRAVEL_STYLE_TAG_COUNT, MAX_TRAVEL_STYLE_TAG_COUNT)) {
+      throw new BaseException(UserErrorCode.INVALID_TAG_SELECTION_COUNT);
+    }
+  }
+
+  private static boolean isBetween(long value, int minimum, int maximum) {
+    return value >= minimum && value <= maximum;
+  }
+}

src/test/java/org/sopt/buddys/domain/user/service/UserOnboardingServiceTest.java

@@ -16,10 +16,15 @@
 import java.time.YearMonth;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
 import org.hibernate.exception.ConstraintViolationException;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
@@ -47,6 +52,9 @@ public class UserOnboardingServiceTest {
   private static final Long USER_ID = 1L;
   private static final Long COUNTRY_ID = 31L;
   private static final Long CITY_ID = 20692L;
+  private static final long ACTIVITY_TAG_START_ID = 1L;
+  private static final long INTEREST_TAG_START_ID = 13L;
+  private static final long TRAVEL_STYLE_TAG_START_ID = 27L;
 
   @InjectMocks
   private UserOnboardingService userOnboardingService;
@@ -297,6 +305,36 @@ void completeOnboarding_tagTypeMismatch_throwsException() {
         );
   }
 
+  @DisplayName("카테고리별 최대 선택 개수를 하나라도 초과하면 INVALID_TAG_SELECTION_COUNT 예외가 발생한다")
+  @ParameterizedTest(name = "활동 {0}개, 관심사 {1}개, 여행 스타일 {2}개")
+  @MethodSource("tagSelectionCountsExceedingLimit")
+  void completeOnboarding_tagSelectionCountExceeded_throwsException(
+      int activityCount, int interestCount, int travelStyleCount
+  ) {
+    // given
+    Country interestCountry = mockCountry(COUNTRY_ID);
+    City interestCity = mockCity(interestCountry);
+    List<Tag> activityTags = mockTags(ACTIVITY_TAG_START_ID, activityCount, TagType.ACTIVITY);
+    List<Tag> interestTags = mockTags(INTEREST_TAG_START_ID, interestCount, TagType.INTEREST);
+    List<Tag> travelStyleTags = mockTags(TRAVEL_STYLE_TAG_START_ID, travelStyleCount, TagType.TRAVEL_STYLE);
+    OnboardingCommand request = createRequestWithTagIds(
+        tagIdsOf(activityTags), tagIdsOf(interestTags), tagIdsOf(travelStyleTags));
+
+    given(userRepository.findActiveByIdForUpdate(USER_ID)).willReturn(Optional.of(createUser()));
+    given(userTagRepository.existsByUserId(USER_ID)).willReturn(false);
+    given(cityRepository.findById(CITY_ID)).willReturn(Optional.of(interestCity));
+    given(tagRepository.findAllById(any())).willReturn(
+        Stream.of(activityTags, interestTags, travelStyleTags).flatMap(List::stream).toList());
+
+    // when, then
+    assertThatThrownBy(() -> userOnboardingService.completeOnboarding(USER_ID, request))
+        .isInstanceOfSatisfying(BaseException.class, exception ->
+            assertThat(exception.getErrorCode()).isEqualTo(UserErrorCode.INVALID_TAG_SELECTION_COUNT)
+        );
+    then(userRepository).should(never()).flush();
+    then(userTagRepository).should(never()).saveAll(any());
+  }
+
   @DisplayName("닉네임이 중복되면 DUPLICATE_NICKNAME 예외로 변환한다")
   @Test
   void completeOnboarding_duplicateNickname_throwsException() {
@@ -458,6 +496,13 @@ void completeOnboarding_otherTagSaveConstraintViolation_rethrowsOriginalExceptio
         .isSameAs(otherViolation);
   }
 
+  private static Stream<Arguments> tagSelectionCountsExceedingLimit() {
+    return Stream.of(
+        Arguments.of(1, 3, 1),
+        Arguments.of(1, 1, 3)
+    );
+  }
+
   private User createUser() {
     return User.builder()
         .email("test@test.com")
@@ -509,6 +554,39 @@ private OnboardingCommand createRequestWithNickname(String nickname) {
     );
   }
 
+  private List<Tag> mockTags(long startId, int count, TagType tagType) {
+    return LongStream.range(startId, startId + count)
+        .mapToObj(id -> mockTag(id, tagType))
+        .toList();
+  }
+
+  private List<Long> tagIdsOf(List<Tag> tags) {
+    return tags.stream().map(Tag::getId).toList();
+  }
+
+  private OnboardingCommand createRequestWithTagIds(
+      List<Long> activityTagIds,
+      List<Long> interestTagIds,
+      List<Long> travelStyleTagIds
+  ) {
+    return new OnboardingCommand(
+        COUNTRY_ID,
+        CITY_ID,
+        null,
+        null,
+        null,
+        null,
+        activityTagIds,
+        interestTagIds,
+        travelStyleTagIds,
+        "해령",
+        Gender.FEMALE,
+        LocalDate.of(2000, 4, 2),
+        "같이 여행 다녀요!",
+        "https://example.com/profile.png"
+    );
+  }
+
   private OnboardingCommand createRequestWithExchangeCountry(
       Long exchangeCountryId,
       YearMonth exchangeStartDate,

src/test/java/org/sopt/buddys/domain/user/service/UserProfileEditServiceTest.java

@@ -12,9 +12,14 @@
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
@@ -35,6 +40,10 @@
 @ExtendWith(MockitoExtension.class)
 class UserProfileEditServiceTest {
 
+  private static final long ACTIVITY_TAG_START_ID = 1L;
+  private static final long INTEREST_TAG_START_ID = 13L;
+  private static final long TRAVEL_STYLE_TAG_START_ID = 27L;
+
   @InjectMocks
   private UserProfileEditService userProfileEditService;
 
@@ -208,6 +217,37 @@ void updateProfile_withoutActivityTag_rejectsBeforeMutation() {
     verify(userTagRepository, never()).deleteAllByUserId(userId);
   }
 
+  @DisplayName("전체 개수와 무관하게 카테고리별 최대 선택 개수를 하나라도 초과하면 프로필을 수정하지 않는다")
+  @ParameterizedTest(name = "활동 {0}개, 관심사 {1}개, 여행 스타일 {2}개")
+  @MethodSource("tagSelectionCountsExceedingLimit")
+  void updateProfile_withTagSelectionCountExceeded_rejectsBeforeMutation(
+      int activityCount, int interestCount, int travelStyleCount
+  ) {
+    // given
+    Long userId = 1L;
+    User user = createUser(userId);
+    List<Tag> tags = Stream.of(
+            createTags(ACTIVITY_TAG_START_ID, activityCount, TagType.ACTIVITY),
+            createTags(INTEREST_TAG_START_ID, interestCount, TagType.INTEREST),
+            createTags(TRAVEL_STYLE_TAG_START_ID, travelStyleCount, TagType.TRAVEL_STYLE))
+        .flatMap(List::stream)
+        .toList();
+    List<Long> orderedTagIds = tags.stream().map(Tag::getId).toList();
+    UpdateProfileCommand command = createCommandWithTagIds(orderedTagIds);
+
+    given(userRepository.findActiveByIdForUpdate(userId)).willReturn(Optional.of(user));
+    given(tagRepository.findAllById(orderedTagIds)).willReturn(tags);
+
+    // when & then
+    assertThatThrownBy(() -> userProfileEditService.updateProfile(userId, command))
+        .isInstanceOf(BaseException.class)
+        .satisfies(exception -> assertThat(((BaseException) exception).getErrorCode())
+            .isEqualTo(UserErrorCode.INVALID_TAG_SELECTION_COUNT));
+    assertThat(user.getNickname()).isEqualTo("기존닉네임");
+    verify(userRepository, never()).flush();
+    verify(userTagRepository, never()).deleteAllByUserId(userId);
+  }
+
   @DisplayName("orderedTagIds에 중복 태그가 있으면 프로필을 수정하지 않는다")
   @Test
   void updateProfile_withDuplicateTagIds_rejectsBeforeMutation() {
@@ -252,6 +292,13 @@ void isNicknameAvailable_excludesCurrentUser() {
     assertThat(available).isTrue();
   }
 
+  private static Stream<Arguments> tagSelectionCountsExceedingLimit() {
+    return Stream.of(
+        Arguments.of(1, 3, 1),
+        Arguments.of(1, 1, 3)
+    );
+  }
+
   private User createUser(Long id) {
     return User.builder()
         .id(id)
@@ -266,6 +313,23 @@ private User createUser(Long id) {
         .build();
   }
 
+  private UpdateProfileCommand createCommandWithTagIds(List<Long> orderedTagIds) {
+    return new UpdateProfileCommand(
+        "새닉네임",
+        Gender.MALE,
+        LocalDate.of(2001, 2, 3),
+        null,
+        null,
+        orderedTagIds
+    );
+  }
+
+  private List<Tag> createTags(long startId, int count, TagType tagType) {
+    return LongStream.range(startId, startId + count)
+        .mapToObj(id -> createTag(id, "태그" + id, tagType))
+        .toList();
+  }
+
   private Tag createTag(Long id, String name, TagType tagType) {
     Tag tag = mock(Tag.class);
     given(tag.getId()).willReturn(id);