diff --git a/src/main/java/com/example/solidconnection/university/controller/UniversityController.java b/src/main/java/com/example/solidconnection/university/controller/UniversityController.java index 2bab9da1a..1acfcb931 100644 --- a/src/main/java/com/example/solidconnection/university/controller/UniversityController.java +++ b/src/main/java/com/example/solidconnection/university/controller/UniversityController.java @@ -7,8 +7,9 @@ import com.example.solidconnection.university.dto.UniversityDetailResponse; import com.example.solidconnection.university.dto.UniversityInfoForApplyPreviewResponse; import com.example.solidconnection.university.dto.UniversityRecommendsResponse; +import com.example.solidconnection.university.service.UniversityLikeService; +import com.example.solidconnection.university.service.UniversityQueryService; import com.example.solidconnection.university.service.UniversityRecommendService; -import com.example.solidconnection.university.service.UniversityService; import lombok.RequiredArgsConstructor; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.GetMapping; @@ -26,7 +27,8 @@ @RestController public class UniversityController { - private final UniversityService universityService; + private final UniversityQueryService universityQueryService; + private final UniversityLikeService universityLikeService; private final UniversityRecommendService universityRecommendService; private final SiteUserService siteUserService; @@ -52,7 +54,7 @@ public ResponseEntity> getMyWishUniv public ResponseEntity getIsLiked( Principal principal, @PathVariable Long universityInfoForApplyId) { - IsLikeResponse isLiked = universityService.getIsLiked(principal.getName(), universityInfoForApplyId); + IsLikeResponse isLiked = universityLikeService.getIsLiked(principal.getName(), universityInfoForApplyId); return ResponseEntity.ok(isLiked); } @@ -60,7 +62,7 @@ public ResponseEntity getIsLiked( public ResponseEntity addWishUniversity( Principal principal, @PathVariable Long universityInfoForApplyId) { - LikeResultResponse likeResultResponse = universityService.likeUniversity(principal.getName(), universityInfoForApplyId); + LikeResultResponse likeResultResponse = universityLikeService.likeUniversity(principal.getName(), universityInfoForApplyId); return ResponseEntity .ok(likeResultResponse); } @@ -68,7 +70,7 @@ public ResponseEntity addWishUniversity( @GetMapping("/detail/{universityInfoForApplyId}") public ResponseEntity getUniversityDetails( @PathVariable Long universityInfoForApplyId) { - UniversityDetailResponse universityDetailResponse = universityService.getUniversityDetail(universityInfoForApplyId); + UniversityDetailResponse universityDetailResponse = universityQueryService.getUniversityDetail(universityInfoForApplyId); return ResponseEntity.ok(universityDetailResponse); } @@ -80,7 +82,7 @@ public ResponseEntity> searchUnivers @RequestParam(required = false, defaultValue = "") LanguageTestType testType, @RequestParam(required = false, defaultValue = "") String testScore) { List universityInfoForApplyPreviewResponse - = universityService.searchUniversity(region, keyword, testType, testScore).universityInfoForApplyPreviewResponses(); + = universityQueryService.searchUniversity(region, keyword, testType, testScore).universityInfoForApplyPreviewResponses(); return ResponseEntity.ok(universityInfoForApplyPreviewResponse); } } diff --git a/src/main/java/com/example/solidconnection/university/service/UniversityLikeService.java b/src/main/java/com/example/solidconnection/university/service/UniversityLikeService.java new file mode 100644 index 000000000..4b15e5b8d --- /dev/null +++ b/src/main/java/com/example/solidconnection/university/service/UniversityLikeService.java @@ -0,0 +1,65 @@ +package com.example.solidconnection.university.service; + +import com.example.solidconnection.siteuser.domain.SiteUser; +import com.example.solidconnection.siteuser.repository.LikedUniversityRepository; +import com.example.solidconnection.siteuser.repository.SiteUserRepository; +import com.example.solidconnection.university.domain.LikedUniversity; +import com.example.solidconnection.university.domain.UniversityInfoForApply; +import com.example.solidconnection.university.dto.IsLikeResponse; +import com.example.solidconnection.university.dto.LikeResultResponse; +import com.example.solidconnection.university.repository.UniversityInfoForApplyRepository; +import lombok.RequiredArgsConstructor; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.Optional; + +@RequiredArgsConstructor +@Service +public class UniversityLikeService { + + public static final String LIKE_SUCCESS_MESSAGE = "LIKE_SUCCESS"; + public static final String LIKE_CANCELED_MESSAGE = "LIKE_CANCELED"; + + private final UniversityInfoForApplyRepository universityInfoForApplyRepository; + private final LikedUniversityRepository likedUniversityRepository; + private final SiteUserRepository siteUserRepository; + + @Value("${university.term}") + public String term; + + /* + * 대학교를 '좋아요' 한다. + * - 이미 좋아요가 눌러져있다면, 좋아요를 취소한다. + * */ + @Transactional + public LikeResultResponse likeUniversity(String email, Long universityInfoForApplyId) { + SiteUser siteUser = siteUserRepository.getByEmail(email); + UniversityInfoForApply universityInfoForApply = universityInfoForApplyRepository.getUniversityInfoForApplyById(universityInfoForApplyId); + + Optional alreadyLikedUniversity = likedUniversityRepository.findBySiteUserAndUniversityInfoForApply(siteUser, universityInfoForApply); + if (alreadyLikedUniversity.isPresent()) { + likedUniversityRepository.delete(alreadyLikedUniversity.get()); + return new LikeResultResponse(LIKE_CANCELED_MESSAGE); + } + + LikedUniversity likedUniversity = LikedUniversity.builder() + .universityInfoForApply(universityInfoForApply) + .siteUser(siteUser) + .build(); + likedUniversityRepository.save(likedUniversity); + return new LikeResultResponse(LIKE_SUCCESS_MESSAGE); + } + + /* + * '좋아요'한 대학교인지 확인한다. + * */ + @Transactional(readOnly = true) + public IsLikeResponse getIsLiked(String email, Long universityInfoForApplyId) { + SiteUser siteUser = siteUserRepository.getByEmail(email); + UniversityInfoForApply universityInfoForApply = universityInfoForApplyRepository.getUniversityInfoForApplyById(universityInfoForApplyId); + boolean isLike = likedUniversityRepository.findBySiteUserAndUniversityInfoForApply(siteUser, universityInfoForApply).isPresent(); + return new IsLikeResponse(isLike); + } +} diff --git a/src/main/java/com/example/solidconnection/university/service/UniversityService.java b/src/main/java/com/example/solidconnection/university/service/UniversityQueryService.java similarity index 55% rename from src/main/java/com/example/solidconnection/university/service/UniversityService.java rename to src/main/java/com/example/solidconnection/university/service/UniversityQueryService.java index 708374e96..f93f3ffae 100644 --- a/src/main/java/com/example/solidconnection/university/service/UniversityService.java +++ b/src/main/java/com/example/solidconnection/university/service/UniversityQueryService.java @@ -1,15 +1,9 @@ package com.example.solidconnection.university.service; import com.example.solidconnection.cache.annotation.ThunderingHerdCaching; -import com.example.solidconnection.siteuser.domain.SiteUser; -import com.example.solidconnection.siteuser.repository.LikedUniversityRepository; -import com.example.solidconnection.siteuser.repository.SiteUserRepository; import com.example.solidconnection.type.LanguageTestType; -import com.example.solidconnection.university.domain.LikedUniversity; import com.example.solidconnection.university.domain.University; import com.example.solidconnection.university.domain.UniversityInfoForApply; -import com.example.solidconnection.university.dto.IsLikeResponse; -import com.example.solidconnection.university.dto.LikeResultResponse; import com.example.solidconnection.university.dto.UniversityDetailResponse; import com.example.solidconnection.university.dto.UniversityInfoForApplyPreviewResponse; import com.example.solidconnection.university.dto.UniversityInfoForApplyPreviewResponses; @@ -21,19 +15,13 @@ import org.springframework.transaction.annotation.Transactional; import java.util.List; -import java.util.Optional; @RequiredArgsConstructor @Service -public class UniversityService { - - public static final String LIKE_SUCCESS_MESSAGE = "LIKE_SUCCESS"; - public static final String LIKE_CANCELED_MESSAGE = "LIKE_CANCELED"; +public class UniversityQueryService { private final UniversityInfoForApplyRepository universityInfoForApplyRepository; - private final LikedUniversityRepository likedUniversityRepository; private final UniversityFilterRepositoryImpl universityFilterRepository; - private final SiteUserRepository siteUserRepository; @Value("${university.term}") public String term; @@ -70,38 +58,4 @@ public UniversityInfoForApplyPreviewResponses searchUniversity( .map(UniversityInfoForApplyPreviewResponse::from) .toList()); } - - /* - * 대학교를 '좋아요' 한다. - * - 이미 좋아요가 눌러져있다면, 좋아요를 취소한다. - * */ - @Transactional - public LikeResultResponse likeUniversity(String email, Long universityInfoForApplyId) { - SiteUser siteUser = siteUserRepository.getByEmail(email); - UniversityInfoForApply universityInfoForApply = universityInfoForApplyRepository.getUniversityInfoForApplyById(universityInfoForApplyId); - - Optional alreadyLikedUniversity = likedUniversityRepository.findBySiteUserAndUniversityInfoForApply(siteUser, universityInfoForApply); - if (alreadyLikedUniversity.isPresent()) { - likedUniversityRepository.delete(alreadyLikedUniversity.get()); - return new LikeResultResponse(LIKE_CANCELED_MESSAGE); - } - - LikedUniversity likedUniversity = LikedUniversity.builder() - .universityInfoForApply(universityInfoForApply) - .siteUser(siteUser) - .build(); - likedUniversityRepository.save(likedUniversity); - return new LikeResultResponse(LIKE_SUCCESS_MESSAGE); - } - - /* - * '좋아요'한 대학교인지 확인한다. - * */ - @Transactional(readOnly = true) - public IsLikeResponse getIsLiked(String email, Long universityInfoForApplyId) { - SiteUser siteUser = siteUserRepository.getByEmail(email); - UniversityInfoForApply universityInfoForApply = universityInfoForApplyRepository.getUniversityInfoForApplyById(universityInfoForApplyId); - boolean isLike = likedUniversityRepository.findBySiteUserAndUniversityInfoForApply(siteUser, universityInfoForApply).isPresent(); - return new IsLikeResponse(isLike); - } } diff --git a/src/test/java/com/example/solidconnection/e2e/UniversityLikeTest.java b/src/test/java/com/example/solidconnection/e2e/UniversityLikeTest.java index 37f922e4e..fb78cdffb 100644 --- a/src/test/java/com/example/solidconnection/e2e/UniversityLikeTest.java +++ b/src/test/java/com/example/solidconnection/e2e/UniversityLikeTest.java @@ -25,8 +25,8 @@ import static com.example.solidconnection.e2e.DynamicFixture.createLikedUniversity; import static com.example.solidconnection.e2e.DynamicFixture.createSiteUserByEmail; import static com.example.solidconnection.e2e.DynamicFixture.createUniversityForApply; -import static com.example.solidconnection.university.service.UniversityService.LIKE_CANCELED_MESSAGE; -import static com.example.solidconnection.university.service.UniversityService.LIKE_SUCCESS_MESSAGE; +import static com.example.solidconnection.university.service.UniversityLikeService.LIKE_CANCELED_MESSAGE; +import static com.example.solidconnection.university.service.UniversityLikeService.LIKE_SUCCESS_MESSAGE; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.*; diff --git a/src/test/java/com/example/solidconnection/university/service/UniversityDataSetUpIntegrationTest.java b/src/test/java/com/example/solidconnection/university/service/UniversityDataSetUpIntegrationTest.java new file mode 100644 index 000000000..91518a09e --- /dev/null +++ b/src/test/java/com/example/solidconnection/university/service/UniversityDataSetUpIntegrationTest.java @@ -0,0 +1,288 @@ +package com.example.solidconnection.university.service; + +import com.example.solidconnection.entity.Country; +import com.example.solidconnection.entity.Region; +import com.example.solidconnection.repositories.CountryRepository; +import com.example.solidconnection.repositories.RegionRepository; +import com.example.solidconnection.support.DatabaseClearExtension; +import com.example.solidconnection.support.TestContainerSpringBootTest; +import com.example.solidconnection.type.LanguageTestType; +import com.example.solidconnection.university.domain.LanguageRequirement; +import com.example.solidconnection.university.domain.University; +import com.example.solidconnection.university.domain.UniversityInfoForApply; +import com.example.solidconnection.university.repository.LanguageRequirementRepository; +import com.example.solidconnection.university.repository.UniversityInfoForApplyRepository; +import com.example.solidconnection.university.repository.UniversityRepository; +import io.restassured.RestAssured; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.test.web.server.LocalServerPort; + +import java.util.HashSet; + +import static com.example.solidconnection.type.SemesterAvailableForDispatch.ONE_SEMESTER; +import static com.example.solidconnection.type.TuitionFeeType.HOME_UNIVERSITY_PAYMENT; + +@ExtendWith(DatabaseClearExtension.class) +@TestContainerSpringBootTest +abstract class UniversityDataSetUpIntegrationTest { + + public static Region 영미권; + public static Region 유럽; + public static Region 아시아; + public static Country 미국; + public static Country 캐나다; + public static Country 덴마크; + public static Country 오스트리아; + public static Country 일본; + + public static University 영미권_미국_괌대학; + public static University 영미권_미국_네바다주립대학_라스베이거스; + public static University 영미권_캐나다_메모리얼대학_세인트존스; + public static University 유럽_덴마크_서던덴마크대학교; + public static University 유럽_덴마크_코펜하겐IT대학; + public static University 유럽_오스트리아_그라츠대학; + public static University 유럽_오스트리아_그라츠공과대학; + public static University 유럽_오스트리아_린츠_카톨릭대학; + public static University 아시아_일본_메이지대학; + + public static UniversityInfoForApply 괌대학_A_지원_정보; + public static UniversityInfoForApply 괌대학_B_지원_정보; + public static UniversityInfoForApply 네바다주립대학_라스베이거스_지원_정보; + public static UniversityInfoForApply 메모리얼대학_세인트존스_A_지원_정보; + public static UniversityInfoForApply 서던덴마크대학교_지원_정보; + public static UniversityInfoForApply 코펜하겐IT대학_지원_정보; + public static UniversityInfoForApply 그라츠대학_지원_정보; + public static UniversityInfoForApply 그라츠공과대학_지원_정보; + public static UniversityInfoForApply 린츠_카톨릭대학_지원_정보; + public static UniversityInfoForApply 메이지대학_지원_정보; + + @Value("${university.term}") + public String term; + + @LocalServerPort + private int port; + + @Autowired + private RegionRepository regionRepository; + + @Autowired + private CountryRepository countryRepository; + + @Autowired + private UniversityRepository universityRepository; + + @Autowired + private UniversityInfoForApplyRepository universityInfoForApplyRepository; + + @Autowired + private LanguageRequirementRepository languageRequirementRepository; + + @BeforeEach + public void setUpBasicData() { + RestAssured.port = port; + + 영미권 = regionRepository.save(new Region("AMERICAS", "영미권")); + 유럽 = regionRepository.save(new Region("EUROPE", "유럽")); + 아시아 = regionRepository.save(new Region("ASIA", "아시아")); + + 미국 = countryRepository.save(new Country("US", "미국", 영미권)); + 캐나다 = countryRepository.save(new Country("CA", "캐나다", 영미권)); + 덴마크 = countryRepository.save(new Country("DK", "덴마크", 유럽)); + 오스트리아 = countryRepository.save(new Country("AT", "오스트리아", 유럽)); + 일본 = countryRepository.save(new Country("JP", "일본", 아시아)); + + 영미권_미국_괌대학 = universityRepository.save(new University( + null, "괌대학", "University of Guam", "university_of_guam", + "https://www.uog.edu/admissions/international-students", + "https://www.uog.edu/admissions/course-schedule", + "https://www.uog.edu/life-at-uog/residence-halls/", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_guam/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_guam/1.png", + null, 미국, 영미권 + )); + + 영미권_미국_네바다주립대학_라스베이거스 = universityRepository.save(new University( + null, "네바다주립대학 라스베이거스", "University of Nevada, Las Vegas", "university_of_nevada_las_vegas", + "https://www.unlv.edu/engineering/eip", + "https://www.unlv.edu/engineering/academic-programs", + "https://www.unlv.edu/housing", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_nevada_las_vegas/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_nevada_las_vegas/1.png", + null, 미국, 영미권 + )); + + 영미권_캐나다_메모리얼대학_세인트존스 = universityRepository.save(new University( + null, "메모리얼 대학 세인트존스", "Memorial University of Newfoundland St. John's", "memorial_university_of_newfoundland_st_johns", + "https://mun.ca/goabroad/visiting-students-inbound/", + "https://www.unlv.edu/engineering/academic-programs", + "https://www.mun.ca/residences/", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/memorial_university_of_newfoundland_st_johns/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/memorial_university_of_newfoundland_st_johns/1.png", + null, 캐나다, 영미권 + )); + + 유럽_덴마크_서던덴마크대학교 = universityRepository.save(new University( + null, "서던덴마크대학교", "University of Southern Denmark", "university_of_southern_denmark", + "https://www.sdu.dk/en", + "https://www.sdu.dk/en", + "https://www.sdu.dk/en/uddannelse/information_for_international_students/studenthousing", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_southern_denmark/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_southern_denmark/1.png", + null, 덴마크, 유럽 + )); + + 유럽_덴마크_코펜하겐IT대학 = universityRepository.save(new University( + null, "코펜하겐 IT대학", "IT University of Copenhagen", "it_university_of_copenhagen", + "https://en.itu.dk/", null, + "https://en.itu.dk/Programmes/Student-Life/Practical-information-for-international-students", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/it_university_of_copenhagen/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/it_university_of_copenhagen/1.png", + null, 덴마크, 유럽 + )); + + 유럽_오스트리아_그라츠대학 = universityRepository.save(new University( + null, "그라츠 대학", "University of Graz", "university_of_graz", + "https://www.uni-graz.at/en/", + "https://static.uni-graz.at/fileadmin/veranstaltungen/orientation/documents/incstud_application-courses.pdf", + "https://orientation.uni-graz.at/de/planning-the-arrival/accommodation/", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_graz/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/university_of_graz/1.png", + null, 오스트리아, 유럽 + )); + + 유럽_오스트리아_그라츠공과대학 = universityRepository.save(new University( + null, "그라츠공과대학", "Graz University of Technology", "graz_university_of_technology", + "https://www.tugraz.at/en/home", null, + "https://www.tugraz.at/en/studying-and-teaching/studying-internationally/incoming-students-exchange-at-tu-graz/your-stay-at-tu-graz/preparation#c75033", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/graz_university_of_technology/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/graz_university_of_technology/1.png", + null, 오스트리아, 유럽 + )); + + 유럽_오스트리아_린츠_카톨릭대학 = universityRepository.save(new University( + null, "린츠 카톨릭 대학교", "Catholic Private University Linz", "catholic_private_university_linz", + "https://ku-linz.at/en", null, + "https://ku-linz.at/en/ku_international/incomings/kulis", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/catholic_private_university_linz/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/catholic_private_university_linz/1.png", + null, 오스트리아, 유럽 + )); + + 아시아_일본_메이지대학 = universityRepository.save(new University( + null, "메이지대학", "Meiji University", "meiji_university", + "https://www.meiji.ac.jp/cip/english/admissions/co7mm90000000461-att/co7mm900000004fa.pdf", null, + "https://www.meiji.ac.jp/cip/english/admissions/co7mm90000000461-att/co7mm900000004fa.pdf", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/meiji_university/logo.png", + "https://solid-connection.s3.ap-northeast-2.amazonaws.com/original/meiji_university/1.png", + null, 일본, 아시아 + )); + + 괌대학_A_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "괌대학(A형)", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 영미권_미국_괌대학 + )); + + 괌대학_B_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "괌대학(B형)", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 영미권_미국_괌대학 + )); + + 네바다주립대학_라스베이거스_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "네바다주립대학 라스베이거스(B형)", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 영미권_미국_네바다주립대학_라스베이거스 + )); + + 메모리얼대학_세인트존스_A_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "메모리얼 대학 세인트존스(A형)", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 영미권_캐나다_메모리얼대학_세인트존스 + )); + + 서던덴마크대학교_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "서던덴마크대학교", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 유럽_덴마크_서던덴마크대학교 + )); + + 코펜하겐IT대학_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "코펜하겐 IT대학", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 유럽_덴마크_코펜하겐IT대학 + )); + + 그라츠대학_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "그라츠 대학", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 유럽_오스트리아_그라츠대학 + )); + + 그라츠공과대학_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "그라츠공과대학", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 유럽_오스트리아_그라츠공과대학 + )); + + 린츠_카톨릭대학_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "린츠 카톨릭 대학교", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 유럽_오스트리아_린츠_카톨릭대학 + )); + + 메이지대학_지원_정보 = universityInfoForApplyRepository.save(new UniversityInfoForApply( + null, term, "메이지대학", 1, HOME_UNIVERSITY_PAYMENT, ONE_SEMESTER, + "1", "detailsForLanguage", "gpaRequirement", + "gpaRequirementCriteria", "detailsForApply", "detailsForMajor", + "detailsForAccommodation", "detailsForEnglishCourse", "details", + new HashSet<>(), 아시아_일본_메이지대학 + )); + + saveLanguageTestRequirement(괌대학_A_지원_정보, LanguageTestType.TOEFL_IBT, "80"); + saveLanguageTestRequirement(괌대학_A_지원_정보, LanguageTestType.TOEIC, "800"); + saveLanguageTestRequirement(괌대학_B_지원_정보, LanguageTestType.TOEFL_IBT, "70"); + saveLanguageTestRequirement(괌대학_B_지원_정보, LanguageTestType.TOEIC, "900"); + saveLanguageTestRequirement(네바다주립대학_라스베이거스_지원_정보, LanguageTestType.TOEIC, "800"); + saveLanguageTestRequirement(메모리얼대학_세인트존스_A_지원_정보, LanguageTestType.TOEIC, "800"); + saveLanguageTestRequirement(서던덴마크대학교_지원_정보, LanguageTestType.TOEFL_IBT, "70"); + saveLanguageTestRequirement(코펜하겐IT대학_지원_정보, LanguageTestType.TOEFL_IBT, "80"); + saveLanguageTestRequirement(그라츠대학_지원_정보, LanguageTestType.TOEFL_IBT, "80"); + saveLanguageTestRequirement(그라츠공과대학_지원_정보, LanguageTestType.TOEIC, "800"); + saveLanguageTestRequirement(린츠_카톨릭대학_지원_정보, LanguageTestType.TOEIC, "800"); + saveLanguageTestRequirement(메이지대학_지원_정보, LanguageTestType.JLPT, "N2"); + } + + private void saveLanguageTestRequirement( + UniversityInfoForApply universityInfoForApply, LanguageTestType testType, String minScore) { + LanguageRequirement languageRequirement = new LanguageRequirement( + null, + testType, + minScore, + universityInfoForApply); + universityInfoForApply.addLanguageRequirements(languageRequirement); + universityInfoForApplyRepository.save(universityInfoForApply); + languageRequirementRepository.save(languageRequirement); + } +} diff --git a/src/test/java/com/example/solidconnection/university/service/UniversityLikeServiceTest.java b/src/test/java/com/example/solidconnection/university/service/UniversityLikeServiceTest.java new file mode 100644 index 000000000..50adf6839 --- /dev/null +++ b/src/test/java/com/example/solidconnection/university/service/UniversityLikeServiceTest.java @@ -0,0 +1,136 @@ +package com.example.solidconnection.university.service; + +import com.example.solidconnection.custom.exception.CustomException; +import com.example.solidconnection.siteuser.domain.SiteUser; +import com.example.solidconnection.siteuser.repository.LikedUniversityRepository; +import com.example.solidconnection.siteuser.repository.SiteUserRepository; +import com.example.solidconnection.type.Gender; +import com.example.solidconnection.type.PreparationStatus; +import com.example.solidconnection.type.Role; +import com.example.solidconnection.university.domain.LikedUniversity; +import com.example.solidconnection.university.domain.UniversityInfoForApply; +import com.example.solidconnection.university.dto.IsLikeResponse; +import com.example.solidconnection.university.dto.LikeResultResponse; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +import static com.example.solidconnection.custom.exception.ErrorCode.UNIVERSITY_INFO_FOR_APPLY_NOT_FOUND; +import static com.example.solidconnection.university.service.UniversityLikeService.LIKE_CANCELED_MESSAGE; +import static com.example.solidconnection.university.service.UniversityLikeService.LIKE_SUCCESS_MESSAGE; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode; + +@DisplayName("대학교 좋아요 서비스 테스트") +class UniversityLikeServiceTest extends UniversityDataSetUpIntegrationTest { + + @Autowired + private UniversityLikeService universityLikeService; + + @Autowired + private LikedUniversityRepository likedUniversityRepository; + + @Autowired + private SiteUserRepository siteUserRepository; + + @Test + void 대학_좋아요를_등록한다() { + // given + SiteUser testUser = createSiteUser(); + + // when + LikeResultResponse response = universityLikeService.likeUniversity( + testUser.getEmail(), 괌대학_A_지원_정보.getId()); + + // then + assertThat(response.result()).isEqualTo(LIKE_SUCCESS_MESSAGE); + assertThat(likedUniversityRepository.findBySiteUserAndUniversityInfoForApply( + testUser, 괌대학_A_지원_정보)).isPresent(); + } + + @Test + void 대학_좋아요를_취소한다() { + // given + SiteUser testUser = createSiteUser(); + saveLikedUniversity(testUser, 괌대학_A_지원_정보); + + // when + LikeResultResponse response = universityLikeService.likeUniversity( + testUser.getEmail(), 괌대학_A_지원_정보.getId()); + + // then + assertThat(response.result()).isEqualTo(LIKE_CANCELED_MESSAGE); + assertThat(likedUniversityRepository.findBySiteUserAndUniversityInfoForApply( + testUser, 괌대학_A_지원_정보)).isEmpty(); + } + + @Test + void 존재하지_않는_대학_좋아요_시도하면_예외를_반환한다() { + // given + SiteUser testUser = createSiteUser(); + Long invalidUniversityId = 9999L; + + // when & then + assertThatCode(() -> universityLikeService.likeUniversity(testUser.getEmail(), invalidUniversityId)) + .isInstanceOf(CustomException.class) + .hasMessage(UNIVERSITY_INFO_FOR_APPLY_NOT_FOUND.getMessage()); + } + + @Test + void 좋아요한_대학인지_확인한다() { + // given + SiteUser testUser = createSiteUser(); + saveLikedUniversity(testUser, 괌대학_A_지원_정보); + + // when + IsLikeResponse response = universityLikeService.getIsLiked(testUser.getEmail(), 괌대학_A_지원_정보.getId()); + + // then + assertThat(response.isLike()).isTrue(); + } + + @Test + void 좋아요하지_않은_대학인지_확인한다() { + // given + SiteUser testUser = createSiteUser(); + + // when + IsLikeResponse response = universityLikeService.getIsLiked(testUser.getEmail(), 괌대학_A_지원_정보.getId()); + + // then + assertThat(response.isLike()).isFalse(); + } + + @Test + void 존재하지_않는_대학의_좋아요_여부_조회시_예외를_반환한다() { + // given + SiteUser testUser = createSiteUser(); + Long invalidUniversityId = 9999L; + + // when & then + assertThatCode(() -> universityLikeService.getIsLiked(testUser.getEmail(), invalidUniversityId)) + .isInstanceOf(CustomException.class) + .hasMessage(UNIVERSITY_INFO_FOR_APPLY_NOT_FOUND.getMessage()); + } + + private SiteUser createSiteUser() { + SiteUser siteUser = new SiteUser( + "test@example.com", + "nickname", + "profileImageUrl", + "1999-01-01", + PreparationStatus.CONSIDERING, + Role.MENTEE, + Gender.MALE + ); + return siteUserRepository.save(siteUser); + } + + private void saveLikedUniversity(SiteUser siteUser, UniversityInfoForApply universityInfoForApply) { + LikedUniversity likedUniversity = LikedUniversity.builder() + .siteUser(siteUser) + .universityInfoForApply(universityInfoForApply) + .build(); + likedUniversityRepository.save(likedUniversity); + } +} diff --git a/src/test/java/com/example/solidconnection/university/service/UniversityQueryServiceTest.java b/src/test/java/com/example/solidconnection/university/service/UniversityQueryServiceTest.java new file mode 100644 index 000000000..54c235452 --- /dev/null +++ b/src/test/java/com/example/solidconnection/university/service/UniversityQueryServiceTest.java @@ -0,0 +1,205 @@ +package com.example.solidconnection.university.service; + +import com.example.solidconnection.custom.exception.CustomException; +import com.example.solidconnection.type.LanguageTestType; +import com.example.solidconnection.university.dto.UniversityDetailResponse; +import com.example.solidconnection.university.dto.LanguageRequirementResponse; +import com.example.solidconnection.university.dto.UniversityInfoForApplyPreviewResponse; +import com.example.solidconnection.university.dto.UniversityInfoForApplyPreviewResponses; +import com.example.solidconnection.university.repository.UniversityInfoForApplyRepository; +import com.example.solidconnection.university.repository.custom.UniversityFilterRepository; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.mock.mockito.SpyBean; + +import java.util.List; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType; +import static com.example.solidconnection.custom.exception.ErrorCode.UNIVERSITY_INFO_FOR_APPLY_NOT_FOUND; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.BDDMockito.then; +import static org.mockito.Mockito.times; + +@DisplayName("대학교 조회 서비스 테스트") +class UniversityQueryServiceTest extends UniversityDataSetUpIntegrationTest { + + @Autowired + private UniversityQueryService universityQueryService; + + @SpyBean + private UniversityFilterRepository universityFilterRepository; + + @SpyBean + private UniversityInfoForApplyRepository universityInfoForApplyRepository; + + @Test + void 대학_상세정보를_정상_조회한다() { + // given + Long universityId = 괌대학_A_지원_정보.getId(); + + // when + UniversityDetailResponse response = universityQueryService.getUniversityDetail(universityId); + + // then + Assertions.assertAll( + () -> assertThat(response.id()).isEqualTo(괌대학_A_지원_정보.getId()), + () -> assertThat(response.term()).isEqualTo(괌대학_A_지원_정보.getTerm()), + () -> assertThat(response.koreanName()).isEqualTo(괌대학_A_지원_정보.getKoreanName()), + () -> assertThat(response.englishName()).isEqualTo(영미권_미국_괌대학.getEnglishName()), + () -> assertThat(response.formatName()).isEqualTo(영미권_미국_괌대학.getFormatName()), + () -> assertThat(response.region()).isEqualTo(영미권.getKoreanName()), + () -> assertThat(response.country()).isEqualTo(미국.getKoreanName()), + () -> assertThat(response.homepageUrl()).isEqualTo(영미권_미국_괌대학.getHomepageUrl()), + () -> assertThat(response.logoImageUrl()).isEqualTo(영미권_미국_괌대학.getLogoImageUrl()), + () -> assertThat(response.backgroundImageUrl()).isEqualTo(영미권_미국_괌대학.getBackgroundImageUrl()), + () -> assertThat(response.detailsForLocal()).isEqualTo(영미권_미국_괌대학.getDetailsForLocal()), + () -> assertThat(response.studentCapacity()).isEqualTo(괌대학_A_지원_정보.getStudentCapacity()), + () -> assertThat(response.tuitionFeeType()).isEqualTo(괌대학_A_지원_정보.getTuitionFeeType().getKoreanName()), + () -> assertThat(response.semesterAvailableForDispatch()).isEqualTo(괌대학_A_지원_정보.getSemesterAvailableForDispatch().getKoreanName()), + () -> assertThat(response.languageRequirements()).containsOnlyOnceElementsOf( + 괌대학_A_지원_정보.getLanguageRequirements().stream() + .map(LanguageRequirementResponse::from) + .toList()), + () -> assertThat(response.detailsForLanguage()).isEqualTo(괌대학_A_지원_정보.getDetailsForLanguage()), + () -> assertThat(response.gpaRequirement()).isEqualTo(괌대학_A_지원_정보.getGpaRequirement()), + () -> assertThat(response.gpaRequirementCriteria()).isEqualTo(괌대학_A_지원_정보.getGpaRequirementCriteria()), + () -> assertThat(response.semesterRequirement()).isEqualTo(괌대학_A_지원_정보.getSemesterRequirement()), + () -> assertThat(response.detailsForApply()).isEqualTo(괌대학_A_지원_정보.getDetailsForApply()), + () -> assertThat(response.detailsForMajor()).isEqualTo(괌대학_A_지원_정보.getDetailsForMajor()), + () -> assertThat(response.detailsForAccommodation()).isEqualTo(괌대학_A_지원_정보.getDetailsForAccommodation()), + () -> assertThat(response.detailsForEnglishCourse()).isEqualTo(괌대학_A_지원_정보.getDetailsForEnglishCourse()), + () -> assertThat(response.details()).isEqualTo(괌대학_A_지원_정보.getDetails()), + () -> assertThat(response.accommodationUrl()).isEqualTo(괌대학_A_지원_정보.getUniversity().getAccommodationUrl()), + () -> assertThat(response.englishCourseUrl()).isEqualTo(괌대학_A_지원_정보.getUniversity().getEnglishCourseUrl()) + ); + } + + @Test + void 대학_상세정보_조회시_캐시가_적용된다() { + // given + Long universityId = 괌대학_A_지원_정보.getId(); + + // when + UniversityDetailResponse firstResponse = universityQueryService.getUniversityDetail(universityId); + UniversityDetailResponse secondResponse = universityQueryService.getUniversityDetail(universityId); + + // then + assertThat(firstResponse).isEqualTo(secondResponse); + then(universityInfoForApplyRepository).should(times(1)).getUniversityInfoForApplyById(universityId); + } + + @Test + void 존재하지_않는_대학_상세정보_조회시_예외_응답을_반환한다() { + // given + Long invalidUniversityInfoForApplyId = 9999L; + + // when & then + assertThatExceptionOfType(RuntimeException.class) + .isThrownBy(() -> universityQueryService.getUniversityDetail(invalidUniversityInfoForApplyId)) + .havingRootCause() + .isInstanceOf(CustomException.class) + .withMessage(UNIVERSITY_INFO_FOR_APPLY_NOT_FOUND.getMessage()); + } + + @Test + void 전체_대학을_조회한다() { + // when + UniversityInfoForApplyPreviewResponses response = universityQueryService.searchUniversity( + null, List.of(), null, null); + + // then + assertThat(response.universityInfoForApplyPreviewResponses()) + .containsExactlyInAnyOrder( + UniversityInfoForApplyPreviewResponse.from(괌대학_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(괌대학_B_지원_정보), + UniversityInfoForApplyPreviewResponse.from(네바다주립대학_라스베이거스_지원_정보), + UniversityInfoForApplyPreviewResponse.from(메모리얼대학_세인트존스_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(서던덴마크대학교_지원_정보), + UniversityInfoForApplyPreviewResponse.from(코펜하겐IT대학_지원_정보), + UniversityInfoForApplyPreviewResponse.from(그라츠대학_지원_정보), + UniversityInfoForApplyPreviewResponse.from(그라츠공과대학_지원_정보), + UniversityInfoForApplyPreviewResponse.from(린츠_카톨릭대학_지원_정보), + UniversityInfoForApplyPreviewResponse.from(메이지대학_지원_정보) + ); + } + + @Test + void 대학_조회시_캐시가_적용된다() { + // given + String regionCode = 영미권.getCode(); + List keywords = List.of("괌"); + LanguageTestType testType = LanguageTestType.TOEFL_IBT; + String testScore = "70"; + String term = "2024-1"; + + // when + UniversityInfoForApplyPreviewResponses firstResponse = + universityQueryService.searchUniversity(regionCode, keywords, testType, testScore); + UniversityInfoForApplyPreviewResponses secondResponse = + universityQueryService.searchUniversity(regionCode, keywords, testType, testScore); + + // then + assertThat(firstResponse).isEqualTo(secondResponse); + then(universityFilterRepository).should(times(1)) + .findByRegionCodeAndKeywordsAndLanguageTestTypeAndTestScoreAndTerm( + regionCode, keywords, testType, testScore, term); + } + + @Test + void 지역으로_대학을_필터링한다() { + // when + UniversityInfoForApplyPreviewResponses response = universityQueryService.searchUniversity( + 영미권.getCode(), List.of(), null, null); + + // then + assertThat(response.universityInfoForApplyPreviewResponses()) + .containsExactlyInAnyOrder( + UniversityInfoForApplyPreviewResponse.from(괌대학_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(괌대학_B_지원_정보), + UniversityInfoForApplyPreviewResponse.from(네바다주립대학_라스베이거스_지원_정보), + UniversityInfoForApplyPreviewResponse.from(메모리얼대학_세인트존스_A_지원_정보) + ); + } + + @Test + void 키워드로_대학을_필터링한다() { + // when + UniversityInfoForApplyPreviewResponses response = universityQueryService.searchUniversity( + null, List.of("라", "일본"), null, null); + + // then + assertThat(response.universityInfoForApplyPreviewResponses()) + .containsExactlyInAnyOrder( + UniversityInfoForApplyPreviewResponse.from(네바다주립대학_라스베이거스_지원_정보), + UniversityInfoForApplyPreviewResponse.from(그라츠대학_지원_정보), + UniversityInfoForApplyPreviewResponse.from(그라츠공과대학_지원_정보), + UniversityInfoForApplyPreviewResponse.from(메이지대학_지원_정보) + ); + } + + @Test + void 어학시험_조건으로_대학을_필터링한다() { + // when + UniversityInfoForApplyPreviewResponses response = universityQueryService.searchUniversity( + null, List.of(), LanguageTestType.TOEFL_IBT, "70"); + + // then + assertThat(response.universityInfoForApplyPreviewResponses()) + .containsExactlyInAnyOrder( + UniversityInfoForApplyPreviewResponse.from(괌대학_B_지원_정보), + UniversityInfoForApplyPreviewResponse.from(서던덴마크대학교_지원_정보) + ); + } + + @Test + void 모든_조건으로_대학을_필터링한다() { + // when + UniversityInfoForApplyPreviewResponses response = universityQueryService.searchUniversity( + "EUROPE", List.of(), LanguageTestType.TOEFL_IBT, "70"); + + // then + assertThat(response.universityInfoForApplyPreviewResponses()).containsExactly(UniversityInfoForApplyPreviewResponse.from(서던덴마크대학교_지원_정보)); + } +} diff --git a/src/test/java/com/example/solidconnection/university/service/UniversityRecommendServiceTest.java b/src/test/java/com/example/solidconnection/university/service/UniversityRecommendServiceTest.java new file mode 100644 index 000000000..1fee99033 --- /dev/null +++ b/src/test/java/com/example/solidconnection/university/service/UniversityRecommendServiceTest.java @@ -0,0 +1,153 @@ +package com.example.solidconnection.university.service; + +import com.example.solidconnection.entity.InterestedCountry; +import com.example.solidconnection.entity.InterestedRegion; +import com.example.solidconnection.repositories.InterestedCountyRepository; +import com.example.solidconnection.repositories.InterestedRegionRepository; +import com.example.solidconnection.siteuser.domain.SiteUser; +import com.example.solidconnection.siteuser.repository.SiteUserRepository; +import com.example.solidconnection.type.Gender; +import com.example.solidconnection.type.PreparationStatus; +import com.example.solidconnection.type.Role; +import com.example.solidconnection.university.dto.UniversityInfoForApplyPreviewResponse; +import com.example.solidconnection.university.dto.UniversityRecommendsResponse; +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 java.util.List; + +import static com.example.solidconnection.university.service.UniversityRecommendService.RECOMMEND_UNIVERSITY_NUM; +import static org.assertj.core.api.Assertions.assertThat; + +@DisplayName("대학교 추천 서비스 테스트") +class UniversityRecommendServiceTest extends UniversityDataSetUpIntegrationTest { + + @Autowired + private UniversityRecommendService universityRecommendService; + + @Autowired + private SiteUserRepository siteUserRepository; + + @Autowired + private InterestedRegionRepository interestedRegionRepository; + + @Autowired + private InterestedCountyRepository interestedCountyRepository; + + @Autowired + private GeneralRecommendUniversities generalRecommendUniversities; + + @BeforeEach + void setUp() { + generalRecommendUniversities.init(); + } + + @Test + void 관심_지역_설정한_사용자의_맞춤_추천_대학을_조회한다() { + // given + SiteUser testUser = createSiteUser(); + interestedRegionRepository.save(new InterestedRegion(testUser, 영미권)); + + // when + UniversityRecommendsResponse response = universityRecommendService.getPersonalRecommends(testUser.getEmail()); + + // then + assertThat(response.recommendedUniversities()) + .hasSize(RECOMMEND_UNIVERSITY_NUM) + .containsAll(List.of( + UniversityInfoForApplyPreviewResponse.from(괌대학_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(괌대학_B_지원_정보), + UniversityInfoForApplyPreviewResponse.from(메모리얼대학_세인트존스_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(네바다주립대학_라스베이거스_지원_정보) + )); + } + + @Test + void 관심_국가_설정한_사용자의_맞춤_추천_대학을_조회한다() { + // given + SiteUser testUser = createSiteUser(); + interestedCountyRepository.save(new InterestedCountry(testUser, 덴마크)); + + // when + UniversityRecommendsResponse response = universityRecommendService.getPersonalRecommends(testUser.getEmail()); + + // then + assertThat(response.recommendedUniversities()) + .hasSize(RECOMMEND_UNIVERSITY_NUM) + .containsAll(List.of( + UniversityInfoForApplyPreviewResponse.from(서던덴마크대학교_지원_정보), + UniversityInfoForApplyPreviewResponse.from(코펜하겐IT대학_지원_정보) + )); + } + + @Test + void 관심_지역과_국가_모두_설정한_사용자의_맞춤_추천_대학을_조회한다() { + // given + SiteUser testUser = createSiteUser(); + interestedRegionRepository.save(new InterestedRegion(testUser, 영미권)); + interestedCountyRepository.save(new InterestedCountry(testUser, 덴마크)); + + // when + UniversityRecommendsResponse response = universityRecommendService.getPersonalRecommends(testUser.getEmail()); + + // then + assertThat(response.recommendedUniversities()) + .hasSize(RECOMMEND_UNIVERSITY_NUM) + .containsExactlyInAnyOrder( + UniversityInfoForApplyPreviewResponse.from(괌대학_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(괌대학_B_지원_정보), + UniversityInfoForApplyPreviewResponse.from(메모리얼대학_세인트존스_A_지원_정보), + UniversityInfoForApplyPreviewResponse.from(네바다주립대학_라스베이거스_지원_정보), + UniversityInfoForApplyPreviewResponse.from(서던덴마크대학교_지원_정보), + UniversityInfoForApplyPreviewResponse.from(코펜하겐IT대학_지원_정보) + ); + } + + @Test + void 관심사_미설정_사용자는_일반_추천_대학을_조회한다() { + // given + SiteUser testUser = createSiteUser(); + + // when + UniversityRecommendsResponse response = universityRecommendService.getPersonalRecommends(testUser.getEmail()); + + // then + assertThat(response.recommendedUniversities()) + .hasSize(RECOMMEND_UNIVERSITY_NUM) + .containsExactlyInAnyOrderElementsOf( + generalRecommendUniversities.getRecommendUniversities().stream() + .map(UniversityInfoForApplyPreviewResponse::from) + .toList() + ); + } + + @Test + void 일반_추천_대학을_조회한다() { + // when + UniversityRecommendsResponse response = universityRecommendService.getGeneralRecommends(); + + // then + assertThat(response.recommendedUniversities()) + .hasSize(RECOMMEND_UNIVERSITY_NUM) + .containsExactlyInAnyOrderElementsOf( + generalRecommendUniversities.getRecommendUniversities().stream() + .map(UniversityInfoForApplyPreviewResponse::from) + .toList() + ); + } + + private SiteUser createSiteUser() { + SiteUser siteUser = new SiteUser( + "test@example.com", + "nickname", + "profileImageUrl", + "1999-01-01", + PreparationStatus.CONSIDERING, + Role.MENTEE, + Gender.MALE + ); + return siteUserRepository.save(siteUser); + } +}