diff --git a/src/test/java/com/back/domain/studyroom/controller/RoomAvatarControllerTest.java b/src/test/java/com/back/domain/studyroom/controller/RoomAvatarControllerTest.java new file mode 100644 index 00000000..a69549b1 --- /dev/null +++ b/src/test/java/com/back/domain/studyroom/controller/RoomAvatarControllerTest.java @@ -0,0 +1,239 @@ +package com.back.domain.studyroom.controller; + +import com.back.domain.studyroom.dto.AvatarResponse; +import com.back.domain.studyroom.dto.UpdateAvatarRequest; +import com.back.domain.studyroom.entity.Avatar; +import com.back.domain.studyroom.service.AvatarService; +import com.back.global.common.dto.RsData; +import com.back.global.security.user.CurrentUser; +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; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +@DisplayName("RoomAvatarController 테스트") +class RoomAvatarControllerTest { + + @Mock + private AvatarService avatarService; + + @Mock + private CurrentUser currentUser; + + @InjectMocks + private RoomAvatarController roomAvatarController; + + private List avatarResponses; + + @BeforeEach + void setUp() { + avatarResponses = List.of( + new AvatarResponse(1L, "검은 고양이", "/images/avatars/cat-black.png", + "귀여운 검은 고양이", true, "CAT"), + new AvatarResponse(2L, "하얀 고양이", "/images/avatars/cat-white.png", + "우아한 하얀 고양이", true, "CAT"), + new AvatarResponse(3L, "노란 고양이", "/images/avatars/cat-orange.png", + "발랄한 노란 고양이", true, "CAT") + ); + } + + @Test + @DisplayName("아바타 목록 조회 API - 성공") + void getAvatars_Success() { + // given + given(avatarService.getAvailableAvatars()).willReturn(avatarResponses); + + // when + ResponseEntity>> response = + roomAvatarController.getAvatars(1L); + + // then + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isNotNull(); + assertThat(response.getBody().isSuccess()).isTrue(); + assertThat(response.getBody().getMessage()).isEqualTo("아바타 목록 조회 완료"); + assertThat(response.getBody().getData()).hasSize(3); + assertThat(response.getBody().getData()) + .extracting(AvatarResponse::getName) + .containsExactly("검은 고양이", "하얀 고양이", "노란 고양이"); + + verify(avatarService, times(1)).getAvailableAvatars(); + } + + @Test + @DisplayName("아바타 목록 조회 API - 빈 리스트 반환") + void getAvatars_EmptyList() { + // given + given(avatarService.getAvailableAvatars()).willReturn(List.of()); + + // when + ResponseEntity>> response = + roomAvatarController.getAvatars(1L); + + // then + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isNotNull(); + assertThat(response.getBody().getData()).isEmpty(); + } + + @Test + @DisplayName("아바타 변경 API - 성공 (VISITOR)") + void updateMyAvatar_Visitor_Success() { + // given + given(currentUser.getUserId()).willReturn(100L); + + UpdateAvatarRequest request = new UpdateAvatarRequest(2L); + + doNothing().when(avatarService).updateRoomAvatar(1L, 100L, 2L); + + // when + ResponseEntity> response = + roomAvatarController.updateMyAvatar(1L, request); + + // then + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isNotNull(); + assertThat(response.getBody().isSuccess()).isTrue(); + assertThat(response.getBody().getMessage()).isEqualTo("아바타가 변경되었습니다"); + + verify(currentUser, times(1)).getUserId(); + verify(avatarService, times(1)).updateRoomAvatar(1L, 100L, 2L); + } + + @Test + @DisplayName("아바타 변경 API - 성공 (MEMBER)") + void updateMyAvatar_Member_Success() { + // given + given(currentUser.getUserId()).willReturn(100L); + + UpdateAvatarRequest request = new UpdateAvatarRequest(3L); + + doNothing().when(avatarService).updateRoomAvatar(1L, 100L, 3L); + + // when + ResponseEntity> response = + roomAvatarController.updateMyAvatar(1L, request); + + // then + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + assertThat(response.getBody()).isNotNull(); + assertThat(response.getBody().isSuccess()).isTrue(); + + verify(avatarService, times(1)).updateRoomAvatar(1L, 100L, 3L); + } + + @Test + @DisplayName("아바타 변경 API - 다른 방에서는 다른 아바타 설정 가능") + void updateMyAvatar_DifferentRooms() { + // given + given(currentUser.getUserId()).willReturn(100L); + + UpdateAvatarRequest request1 = new UpdateAvatarRequest(1L); + UpdateAvatarRequest request2 = new UpdateAvatarRequest(3L); + + // when + roomAvatarController.updateMyAvatar(1L, request1); // 방1에서 아바타 1 + roomAvatarController.updateMyAvatar(2L, request2); // 방2에서 아바타 3 + + // then + verify(avatarService, times(1)).updateRoomAvatar(1L, 100L, 1L); + verify(avatarService, times(1)).updateRoomAvatar(2L, 100L, 3L); + } + + @Test + @DisplayName("아바타 변경 API - 같은 아바타로 여러 번 변경 가능") + void updateMyAvatar_SameAvatarMultipleTimes() { + // given + given(currentUser.getUserId()).willReturn(100L); + + UpdateAvatarRequest request = new UpdateAvatarRequest(2L); + + // when + roomAvatarController.updateMyAvatar(1L, request); + roomAvatarController.updateMyAvatar(1L, request); + + // then + verify(avatarService, times(2)).updateRoomAvatar(1L, 100L, 2L); + } + + @Test + @DisplayName("아바타 변경 API - 여러 사용자가 동시에 변경 가능") + void updateMyAvatar_MultipleUsers() { + // given + UpdateAvatarRequest request1 = new UpdateAvatarRequest(1L); + UpdateAvatarRequest request2 = new UpdateAvatarRequest(2L); + + // when + given(currentUser.getUserId()).willReturn(100L); + roomAvatarController.updateMyAvatar(1L, request1); + + given(currentUser.getUserId()).willReturn(200L); + roomAvatarController.updateMyAvatar(1L, request2); + + // then + verify(avatarService, times(1)).updateRoomAvatar(1L, 100L, 1L); + verify(avatarService, times(1)).updateRoomAvatar(1L, 200L, 2L); + } + + @Test + @DisplayName("아바타 목록 조회 - 카테고리 정보 포함") + void getAvatars_IncludesCategory() { + // given + given(avatarService.getAvailableAvatars()).willReturn(avatarResponses); + + // when + ResponseEntity>> response = + roomAvatarController.getAvatars(1L); + + // then + assertThat(response.getBody().getData()) + .allMatch(avatar -> avatar.getCategory() != null); + assertThat(response.getBody().getData()) + .allMatch(avatar -> avatar.getCategory().equals("CAT")); + } + + @Test + @DisplayName("아바타 목록 조회 - isDefault 정보 포함") + void getAvatars_IncludesIsDefault() { + // given + given(avatarService.getAvailableAvatars()).willReturn(avatarResponses); + + // when + ResponseEntity>> response = + roomAvatarController.getAvatars(1L); + + // then + assertThat(response.getBody().getData()) + .allMatch(AvatarResponse::isDefault); + } + + @Test + @DisplayName("아바타 변경 API - 요청 검증 (avatarId 필수)") + void updateMyAvatar_RequestValidation() { + // given + given(currentUser.getUserId()).willReturn(100L); + + // avatarId가 있는 정상 요청 + UpdateAvatarRequest validRequest = new UpdateAvatarRequest(1L); + + // when + ResponseEntity> response = + roomAvatarController.updateMyAvatar(1L, validRequest); + + // then + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); + verify(avatarService, times(1)).updateRoomAvatar(1L, 100L, 1L); + } +} diff --git a/src/test/java/com/back/domain/studyroom/repository/AvatarRepositoryTest.java b/src/test/java/com/back/domain/studyroom/repository/AvatarRepositoryTest.java new file mode 100644 index 00000000..5a76b8a3 --- /dev/null +++ b/src/test/java/com/back/domain/studyroom/repository/AvatarRepositoryTest.java @@ -0,0 +1,183 @@ +package com.back.domain.studyroom.repository; + +import com.back.domain.studyroom.entity.Avatar; +import com.back.global.config.QueryDslTestConfig; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; +import org.springframework.context.annotation.Import; +import org.springframework.test.context.ActiveProfiles; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +@DataJpaTest +@ActiveProfiles("test") +@AutoConfigureTestDatabase(replace = Replace.NONE) +@Import(QueryDslTestConfig.class) +@DisplayName("AvatarRepository 테스트") +class AvatarRepositoryTest { + + @Autowired + private TestEntityManager testEntityManager; + + @Autowired + private AvatarRepository avatarRepository; + + private Avatar avatar1; + private Avatar avatar2; + private Avatar avatar3; + private Avatar avatar4; + + @BeforeEach + void setUp() { + // 기본 아바타 (랜덤 배정용) + avatar1 = Avatar.builder() + .name("검은 고양이") + .imageUrl("/images/avatars/cat-black.png") + .description("귀여운 검은 고양이") + .isDefault(true) + .sortOrder(1) + .category("CAT") + .build(); + testEntityManager.persist(avatar1); + + avatar2 = Avatar.builder() + .name("하얀 고양이") + .imageUrl("/images/avatars/cat-white.png") + .description("우아한 하얀 고양이") + .isDefault(true) + .sortOrder(2) + .category("CAT") + .build(); + testEntityManager.persist(avatar2); + + avatar3 = Avatar.builder() + .name("노란 고양이") + .imageUrl("/images/avatars/cat-orange.png") + .description("발랄한 노란 고양이") + .isDefault(true) + .sortOrder(3) + .category("CAT") + .build(); + testEntityManager.persist(avatar3); + + // 특별 아바타 (구매 필요 등) + avatar4 = Avatar.builder() + .name("골든 리트리버") + .imageUrl("/images/avatars/dog-golden.png") + .description("친근한 골든 리트리버") + .isDefault(false) // 기본 아바타 아님 + .sortOrder(4) + .category("DOG") + .build(); + testEntityManager.persist(avatar4); + + testEntityManager.flush(); + testEntityManager.clear(); + } + + @Test + @DisplayName("정렬 순서대로 모든 아바타 조회") + void findAllByOrderBySortOrderAsc() { + // when + List avatars = avatarRepository.findAllByOrderBySortOrderAsc(); + + // then + assertThat(avatars).hasSize(4); + assertThat(avatars.get(0).getName()).isEqualTo("검은 고양이"); + assertThat(avatars.get(1).getName()).isEqualTo("하얀 고양이"); + assertThat(avatars.get(2).getName()).isEqualTo("노란 고양이"); + assertThat(avatars.get(3).getName()).isEqualTo("골든 리트리버"); + } + + @Test + @DisplayName("기본 아바타만 조회 (랜덤 배정용)") + void findByIsDefaultTrueOrderBySortOrderAsc() { + // when + List defaultAvatars = avatarRepository.findByIsDefaultTrueOrderBySortOrderAsc(); + + // then + assertThat(defaultAvatars).hasSize(3); + assertThat(defaultAvatars) + .extracting(Avatar::getName) + .containsExactly("검은 고양이", "하얀 고양이", "노란 고양이"); + + assertThat(defaultAvatars) + .allMatch(Avatar::isDefault); + } + + @Test + @DisplayName("카테고리별 아바타 조회") + void findByCategoryOrderBySortOrderAsc() { + // when + List catAvatars = avatarRepository.findByCategoryOrderBySortOrderAsc("CAT"); + List dogAvatars = avatarRepository.findByCategoryOrderBySortOrderAsc("DOG"); + + // then + assertThat(catAvatars).hasSize(3); + assertThat(catAvatars) + .extracting(Avatar::getCategory) + .containsOnly("CAT"); + + assertThat(dogAvatars).hasSize(1); + assertThat(dogAvatars.get(0).getName()).isEqualTo("골든 리트리버"); + } + + @Test + @DisplayName("존재하지 않는 카테고리 조회 - 빈 리스트 반환") + void findByCategory_NotFound() { + // when + List result = avatarRepository.findByCategoryOrderBySortOrderAsc("BIRD"); + + // then + assertThat(result).isEmpty(); + } + + @Test + @DisplayName("아바타 저장 및 조회") + void saveAndFindById() { + // given + Avatar newAvatar = Avatar.builder() + .name("회색 늑대") + .imageUrl("/images/avatars/wolf-grey.png") + .description("멋진 회색 늑대") + .isDefault(false) + .sortOrder(5) + .category("WOLF") + .build(); + + // when + testEntityManager.persist(newAvatar); + testEntityManager.flush(); + testEntityManager.clear(); + + Avatar found = avatarRepository.findById(newAvatar.getId()).orElse(null); + + // then + assertThat(found).isNotNull(); + assertThat(found.getName()).isEqualTo("회색 늑대"); + assertThat(found.getImageUrl()).isEqualTo("/images/avatars/wolf-grey.png"); + assertThat(found.getCategory()).isEqualTo("WOLF"); + assertThat(found.isDefault()).isFalse(); + } + + @Test + @DisplayName("정렬 순서 확인") + void checkSortOrder() { + // when + List avatars = avatarRepository.findAllByOrderBySortOrderAsc(); + + // then + for (int i = 0; i < avatars.size() - 1; i++) { + assertThat(avatars.get(i).getSortOrder()) + .isLessThan(avatars.get(i + 1).getSortOrder()); + } + } +} diff --git a/src/test/java/com/back/domain/studyroom/repository/RoomMemberAvatarRepositoryTest.java b/src/test/java/com/back/domain/studyroom/repository/RoomMemberAvatarRepositoryTest.java new file mode 100644 index 00000000..eef04396 --- /dev/null +++ b/src/test/java/com/back/domain/studyroom/repository/RoomMemberAvatarRepositoryTest.java @@ -0,0 +1,323 @@ +package com.back.domain.studyroom.repository; + +import com.back.domain.studyroom.entity.*; +import com.back.domain.user.entity.Role; +import com.back.domain.user.entity.User; +import com.back.domain.user.entity.UserProfile; +import com.back.domain.user.entity.UserStatus; +import com.back.global.config.QueryDslTestConfig; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; +import org.springframework.context.annotation.Import; +import org.springframework.test.context.ActiveProfiles; + +import java.util.List; +import java.util.Optional; +import java.util.Set; + +import static org.assertj.core.api.Assertions.assertThat; + +@DataJpaTest +@ActiveProfiles("test") +@AutoConfigureTestDatabase(replace = Replace.NONE) +@Import(QueryDslTestConfig.class) +@DisplayName("RoomMemberAvatarRepository 테스트") +class RoomMemberAvatarRepositoryTest { + + @Autowired + private TestEntityManager testEntityManager; + + @Autowired + private RoomMemberAvatarRepository roomMemberAvatarRepository; + + @Autowired + private AvatarRepository avatarRepository; + + private Room testRoom1; + private Room testRoom2; + private User user1; + private User user2; + private User user3; + private Avatar avatar1; + private Avatar avatar2; + private Avatar avatar3; + + @BeforeEach + void setUp() { + // 사용자 생성 + user1 = createUser("user1", "user1@test.com", "유저1"); + user2 = createUser("user2", "user2@test.com", "유저2"); + user3 = createUser("user3", "user3@test.com", "유저3"); + + // 방 생성 + testRoom1 = Room.create( + "테스트 방 1", + "테스트 설명", + false, + null, + 10, + user1, + null, + true, + null + ); + testEntityManager.persist(testRoom1); + + testRoom2 = Room.create( + "테스트 방 2", + "테스트 설명", + false, + null, + 10, + user1, + null, + true, + null + ); + testEntityManager.persist(testRoom2); + + // 아바타 생성 + avatar1 = createAvatar("검은 고양이", 1); + avatar2 = createAvatar("하얀 고양이", 2); + avatar3 = createAvatar("노란 고양이", 3); + + testEntityManager.flush(); + testEntityManager.clear(); + } + + private User createUser(String username, String email, String nickname) { + User user = User.builder() + .username(username) + .email(email) + .password("password123") + .role(Role.USER) + .userStatus(UserStatus.ACTIVE) + .build(); + + UserProfile profile = new UserProfile(); + profile.setNickname(nickname); + user.setUserProfile(profile); + + testEntityManager.persist(user); + return user; + } + + private Avatar createAvatar(String name, int sortOrder) { + Avatar avatar = Avatar.builder() + .name(name) + .imageUrl("/images/avatars/" + name + ".png") + .description(name) + .isDefault(true) + .sortOrder(sortOrder) + .category("CAT") + .build(); + testEntityManager.persist(avatar); + return avatar; + } + + @Test + @DisplayName("방별 아바타 설정 저장 및 조회") + void saveAndFindByRoomIdAndUserId() { + // given + RoomMemberAvatar roomAvatar = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user1) + .selectedAvatar(avatar1) + .build(); + + // when + testEntityManager.persist(roomAvatar); + testEntityManager.flush(); + testEntityManager.clear(); + + Optional found = roomMemberAvatarRepository + .findByRoomIdAndUserId(testRoom1.getId(), user1.getId()); + + // then + assertThat(found).isPresent(); + assertThat(found.get().getSelectedAvatar().getName()).isEqualTo("검은 고양이"); + assertThat(found.get().getRoom().getId()).isEqualTo(testRoom1.getId()); + assertThat(found.get().getUser().getId()).isEqualTo(user1.getId()); + } + + @Test + @DisplayName("같은 방에서 여러 사용자의 아바타 일괄 조회 (N+1 방지)") + void findByRoomIdAndUserIdIn() { + // given + RoomMemberAvatar avatar1Setting = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user1) + .selectedAvatar(avatar1) + .build(); + testEntityManager.persist(avatar1Setting); + + RoomMemberAvatar avatar2Setting = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user2) + .selectedAvatar(avatar2) + .build(); + testEntityManager.persist(avatar2Setting); + + RoomMemberAvatar avatar3Setting = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user3) + .selectedAvatar(avatar3) + .build(); + testEntityManager.persist(avatar3Setting); + + testEntityManager.flush(); + testEntityManager.clear(); + + // when + Set userIds = Set.of(user1.getId(), user2.getId(), user3.getId()); + List results = roomMemberAvatarRepository + .findByRoomIdAndUserIdIn(testRoom1.getId(), userIds); + + // then + assertThat(results).hasSize(3); + assertThat(results) + .extracting(rma -> rma.getSelectedAvatar().getName()) + .containsExactlyInAnyOrder("검은 고양이", "하얀 고양이", "노란 고양이"); + } + + @Test + @DisplayName("존재하지 않는 사용자 조회 - 빈 리스트 반환") + void findByRoomIdAndUserIdIn_NotFound() { + // when + Set userIds = Set.of(999L, 1000L); + List results = roomMemberAvatarRepository + .findByRoomIdAndUserIdIn(testRoom1.getId(), userIds); + + // then + assertThat(results).isEmpty(); + } + + @Test + @DisplayName("아바타 변경 (업데이트)") + void updateSelectedAvatar() { + // given + RoomMemberAvatar roomAvatar = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user1) + .selectedAvatar(avatar1) + .build(); + testEntityManager.persist(roomAvatar); + testEntityManager.flush(); + testEntityManager.clear(); + + // when + RoomMemberAvatar found = roomMemberAvatarRepository + .findByRoomIdAndUserId(testRoom1.getId(), user1.getId()) + .orElseThrow(); + found.setSelectedAvatar(avatar2); + testEntityManager.persist(found); + testEntityManager.flush(); + testEntityManager.clear(); + + // then + RoomMemberAvatar updated = roomMemberAvatarRepository + .findByRoomIdAndUserId(testRoom1.getId(), user1.getId()) + .orElseThrow(); + + assertThat(updated.getSelectedAvatar().getName()).isEqualTo("하얀 고양이"); + } + + @Test + @DisplayName("사용자가 여러 방에서 각기 다른 아바타 설정") + void userCanHaveDifferentAvatarsInDifferentRooms() { + // given + RoomMemberAvatar room1Avatar = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user1) + .selectedAvatar(avatar1) + .build(); + testEntityManager.persist(room1Avatar); + + RoomMemberAvatar room2Avatar = RoomMemberAvatar.builder() + .room(testRoom2) + .user(user1) + .selectedAvatar(avatar3) + .build(); + testEntityManager.persist(room2Avatar); + + testEntityManager.flush(); + testEntityManager.clear(); + + // when + RoomMemberAvatar found1 = roomMemberAvatarRepository + .findByRoomIdAndUserId(testRoom1.getId(), user1.getId()) + .orElseThrow(); + + RoomMemberAvatar found2 = roomMemberAvatarRepository + .findByRoomIdAndUserId(testRoom2.getId(), user1.getId()) + .orElseThrow(); + + // then + assertThat(found1.getSelectedAvatar().getName()).isEqualTo("검은 고양이"); + assertThat(found2.getSelectedAvatar().getName()).isEqualTo("노란 고양이"); + } + + @Test + @DisplayName("아바타 설정 삭제") + void deleteRoomMemberAvatar() { + // given + RoomMemberAvatar roomAvatar = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user1) + .selectedAvatar(avatar1) + .build(); + testEntityManager.persist(roomAvatar); + testEntityManager.flush(); + + // when + roomMemberAvatarRepository.delete(roomAvatar); + testEntityManager.flush(); + testEntityManager.clear(); + + // then + Optional found = roomMemberAvatarRepository + .findByRoomIdAndUserId(testRoom1.getId(), user1.getId()); + + assertThat(found).isEmpty(); + } + + @Test + @DisplayName("Fetch Join으로 아바타 정보 한 번에 조회 (N+1 방지)") + void fetchJoinTest() { + // given + RoomMemberAvatar avatar1Setting = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user1) + .selectedAvatar(avatar1) + .build(); + testEntityManager.persist(avatar1Setting); + + RoomMemberAvatar avatar2Setting = RoomMemberAvatar.builder() + .room(testRoom1) + .user(user2) + .selectedAvatar(avatar2) + .build(); + testEntityManager.persist(avatar2Setting); + + testEntityManager.flush(); + testEntityManager.clear(); + + // when + Set userIds = Set.of(user1.getId(), user2.getId()); + List results = roomMemberAvatarRepository + .findByRoomIdAndUserIdIn(testRoom1.getId(), userIds); + + // then + assertThat(results).hasSize(2); + results.forEach(rma -> { + assertThat(rma.getSelectedAvatar()).isNotNull(); + assertThat(rma.getSelectedAvatar().getName()).isNotBlank(); + }); + } +}