Merge pull request #136 from kakao-tech-campus-2nd-step3/Develop

[Master] 테스트코드 수정

src/main/java/team18/team18_be/recruitment/controller/RecruitmentController.java

@@ -21,7 +21,6 @@
 import team18.team18_be.recruitment.dto.response.RecruitmentAllResponse;
 import team18.team18_be.recruitment.dto.response.RecruitmentResponse;
 import team18.team18_be.recruitment.dto.response.RecruitmentResponseForCompany;
-import team18.team18_be.recruitment.dto.response.RecruitmentSummationResponse;
 import team18.team18_be.recruitment.service.RecruitmentService;
 
 @Tag(name = "구인글 관련 Controller")

src/main/java/team18/team18_be/recruitment/entity/Recruitment.java

@@ -7,6 +7,7 @@
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.OneToOne;
+import jakarta.validation.constraints.NotNull;
 import java.util.Date;
 import lombok.Getter;
 import lombok.Setter;
@@ -20,28 +21,48 @@ public class Recruitment {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long recruitmentId;
+  @NotNull
   private String koreanTitle;
+  @NotNull
   private String vietnameseTitle;
+  @NotNull
   private String companySize;
+  @NotNull
   private String area;
+  @NotNull
   private Long salary;
+  @NotNull
   private String workDuration;
+  @NotNull
   private String workDays;
+  @NotNull
   private String workType;
+  @NotNull
   private String workHours;
+  @NotNull
   private String requestedCareer;
+  @NotNull
   private String majorBusiness;
+  @NotNull
   private String eligibilityCriteria;
+  @NotNull
   private String preferredConditions;
+  @NotNull
   private String employerName;
+  @NotNull
   private String companyName;
+  @NotNull
   private Boolean hiring;
+  @NotNull
   private Date uploadDate;
 
   @ManyToOne
   @JoinColumn(name = "companyId")
+  @NotNull
   private Company company;
+
   @OneToOne
+  @NotNull
   private RecruitmentContent recruitmentContent;
 
   public Recruitment(String koreanTitle, String vietnameseTitle, String companySize, String area,

src/main/java/team18/team18_be/recruitment/entity/RecruitmentContent.java

@@ -6,18 +6,22 @@
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.Lob;
+import jakarta.validation.constraints.NotNull;
 
 @Entity
 public class RecruitmentContent {
 
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
+  @NotNull
   private Long resumeContentId;
   @Lob
   @Column(columnDefinition = "TEXT")
+  @NotNull
   private String koreanDetailedDescription;
   @Lob
   @Column(columnDefinition = "TEXT")
+  @NotNull
   private String vietnameseDetailedDescription;
 
   public RecruitmentContent(String koreanDetailedDescription,

src/main/java/team18/team18_be/recruitment/service/RecruitmentService.java

@@ -41,7 +41,7 @@ public RecruitmentService(RecruitmentRepository recruitmentRepository,
     this.recruitmentMapper = recruitmentMapper;
   }
 
-  public void saveRecruitment(RecruitmentRequest recruitmentRequest)
+  public Long saveRecruitment(RecruitmentRequest recruitmentRequest)
       throws JsonProcessingException {
     String koreanTitle = recruitmentRequest.title();
     String vietnameseTitle = openAiService.translateKoreanToVietnamese(koreanTitle);
@@ -51,12 +51,12 @@ public void saveRecruitment(RecruitmentRequest recruitmentRequest)
         koreanDetailedDescription);
     RecruitmentContent recruitmentContent = recruitmentContentRepository.save(
         new RecruitmentContent(koreanDetailedDescription, vietnameseDetailedDescription));
-    recruitmentRepository.save(
+   return recruitmentRepository.save(
         recruitmentMapper.toRecruitment(koreanTitle, vietnameseTitle, recruitmentRequest,
             recruitmentContent, companyRepository.findById(recruitmentRequest.companyId())
                 .orElseThrow(() -> new NoSuchElementException("해당하는 회사가 존재하지 않습니다.")), true,
             new Date()
-        ));
+        )).getRecruitmentId();
 
   }
 

src/main/java/team18/team18_be/resume/entity/Resume.java

@@ -8,6 +8,7 @@
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.Lob;
 import jakarta.persistence.ManyToOne;
+import jakarta.validation.constraints.NotNull;
 import lombok.Getter;
 import lombok.Setter;
 import team18.team18_be.auth.entity.User;
@@ -20,17 +21,24 @@ public class Resume {
   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   private Long resumeId;
+  @NotNull
   private String applicantName;
+  @NotNull
   private String address;
+  @NotNull
   private String phoneNumber;
+  @NotNull
   private String career;
+  @NotNull
   private String korean;
   @Lob
   @Column(columnDefinition = "TEXT")
+  @NotNull
   private String selfIntroduction;
 
   @ManyToOne
   @JoinColumn(name = "userId")
+  @NotNull
   private User user;
 
   public Resume(String applicantName, String address, String phoneNumber, String career,

src/main/java/team18/team18_be/resume/service/ResumeService.java

@@ -31,8 +31,8 @@ public ResumeService(ResumeRepository resumeRepository,
     this.applicationFormRepository = applicationFormRepository;
   }
 
-  public void saveResume(ResumeRequest resumeRequest, User user) {
-    resumeRepository.save(resumeMapper.toResume(resumeRequest, user));
+  public Long saveResume(ResumeRequest resumeRequest, User user) {
+    return resumeRepository.save(resumeMapper.toResume(resumeRequest, user)).getResumeId();
   }
 
   public ResumeResponse findResumeByEmployee(User user) {

src/test/java/team18/team18_be/recruitment/RecruitmentServiceTest.java

@@ -5,6 +5,7 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import jakarta.transaction.Transactional;
 import java.util.List;
+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;
@@ -15,6 +16,7 @@
 import team18.team18_be.auth.entity.User;
 import team18.team18_be.auth.repository.AuthRepository;
 import team18.team18_be.recruitment.dto.request.RecruitmentRequest;
+import team18.team18_be.recruitment.dto.response.RecruitmentAllResponse;
 import team18.team18_be.recruitment.dto.response.RecruitmentSummationResponse;
 import team18.team18_be.recruitment.entity.Recruitment;
 import team18.team18_be.recruitment.repository.RecruitmentRepository;
@@ -23,11 +25,18 @@
 import team18.team18_be.userInformation.repository.CompanyRepository;
 
 @SpringBootTest(classes = Team18BeApplication.class)
-@Transactional
 public class RecruitmentServiceTest {
 
   static final String NAME = "name";
   static final String EMAIL = "email";
+
+  public static Long companyId;
+  public static Long firstRecruitmentId;
+  public static Long secondRecruitmentId;
+  public static Long thirdRecruitmentId;
+
+
+
   @Autowired
   RecruitmentRepository recruitmentRepository;
   @Autowired
@@ -37,92 +46,63 @@ public class RecruitmentServiceTest {
   @Autowired
   AuthRepository authRepository;
 
-  @Test
-  @Transactional
-  @DisplayName("구인글 저장")
-  public void saveRecruitmentTest() throws JsonProcessingException {
+  @BeforeEach
+  public void setup() throws JsonProcessingException {
     User user = new User(NAME, EMAIL, "first");
-    Company company = new Company("MyCompany", "Tech", "MyBrand", 1000000L, "image", user);
-    companyRepository.save(company);
-
-    recruitmentService.saveRecruitment(
-        new RecruitmentRequest("맛있는 밥상에서 아르바이트를 모집합니다.", "50명 이상의 직원", "서울, 대한민국",
-            70000000L, "정규직", "주 5일", "상근", "오전 10시부터 오후 7시까지",
-            "경력 5년 이상", "한식 레스토랑", "요리 관련 전공 또는 경력",
-            "팀워크 및 리더십 경험", "박정호", "맛있는 한상", 1L));
-    Recruitment recruitment = recruitmentRepository.findById(1L).get();
-    assertThat(recruitment.getArea()).isEqualTo("서울, 대한민국");
-  }
-
-  @Test
-  @Transactional
-  @DisplayName("구인글 전체조회")
-  public void findAllRecruitmentTest() throws JsonProcessingException {
-    User user = new User(NAME, EMAIL, "first");
-    Company company = new Company("MyCompany", "Tech", "MyBrand", 1000000L, "image", user);
-    companyRepository.save(company);
     authRepository.save(user);
+    Company company = new Company("MyCompany", "Tech", "MyBrand", 1000000L, "image", user);
+    companyId = companyRepository.save(company).getId();
 
-    recruitmentService.saveRecruitment(new RecruitmentRequest(
+    firstRecruitmentId = recruitmentService.saveRecruitment(new RecruitmentRequest(
         "초보자를 위한 요리사 모집", "30명 이상의 직원", "제주, 대한민국",
         25000000L, "계약직", "주 6일", "파트타임", "오전 7시부터 오후 3시까지",
         "경력 1년 이상", "지역 맛집", "요리 관련 자격증 소지자 우대",
-        "팀워크와 성실함", "정하윤", "제주 맛집", 1L));
+        "팀워크와 성실함", "정하윤", "제주 맛집", companyId));
 
-    recruitmentService.saveRecruitment(new RecruitmentRequest(
+    secondRecruitmentId = recruitmentService.saveRecruitment(new RecruitmentRequest(
         "프리랜서 웹 개발자 모집", "10명 이하의 직원", "서울, 대한민국",
         100000000L, "프리랜서", "주 3일", "원격 근무", "유연한 근무 시간",
         "경력 7년 이상", "스타트업", "풀스택 개발 경험 필수",
-        "문제 해결 능력 및 주도성", "김재훈", "테크이노베이션", 1L));
+        "문제 해결 능력 및 주도성", "김재훈", "테크이노베이션", companyId));
 
-    recruitmentService.saveRecruitment(new RecruitmentRequest(
+    thirdRecruitmentId = recruitmentService.saveRecruitment(new RecruitmentRequest(
         "해외 영업 전문가 모집", "200명 이상의 직원", "부산, 대한민국",
         120000000L, "정규직", "주 5일", "상근", "오전 8시부터 오후 5시까지",
         "경력 10년 이상", "무역 회사", "국제 무역 및 영업 관련 전공",
-        "영어 능통 및 협상 기술", "이민호", "글로벌 트레이드", 1L));
+        "영어 능통 및 협상 기술", "이민호", "글로벌 트레이드", companyId));
+  }
 
+  @Test
+  @Transactional
+  @DisplayName("구인글 저장")
+  public void saveRecruitmentTest() {
+    Recruitment recruitment = recruitmentRepository.findById(firstRecruitmentId).get();
+    assertThat(recruitment.getArea()).isEqualTo("제주, 대한민국");
+  }
+
+  @Test
+  @Transactional
+  @DisplayName("구인글 전체조회")
+  public void findAllRecruitmentTest(){
     Pageable pageable = PageRequest.of(0, 5);
 
-    List<RecruitmentSummationResponse> recruitmentSummationResponseList = recruitmentService.getAllRecruitment(
+    RecruitmentAllResponse recruitmentAllResponse = recruitmentService.getAllRecruitment(
         pageable);
-    assertThat(recruitmentSummationResponseList.size()).isEqualTo(3);
+    assertThat(recruitmentAllResponse.content().size()).isEqualTo(3);
   }
 
   @Test
   @Transactional
   @DisplayName("구인글 급여 순서대로 전체조회")
   public void findAllRecruitmentBySalaryTest() throws JsonProcessingException {
-    User user = new User(NAME, EMAIL, "first");
-    Company company = new Company("MyCompany", "Tech", "MyBrand", 1000000L, "image", user);
-    companyRepository.save(company);
-    authRepository.save(user);
-
-    recruitmentService.saveRecruitment(new RecruitmentRequest(
-        "초보자를 위한 요리사 모집", "30명 이상의 직원", "제주, 대한민국",
-        25000000L, "계약직", "주 6일", "파트타임", "오전 7시부터 오후 3시까지",
-        "경력 1년 이상", "지역 맛집", "요리 관련 자격증 소지자 우대",
-        "팀워크와 성실함", "정하윤", "제주 맛집", 1L));
-
-    recruitmentService.saveRecruitment(new RecruitmentRequest(
-        "프리랜서 웹 개발자 모집", "10명 이하의 직원", "서울, 대한민국",
-        100000000L, "프리랜서", "주 3일", "원격 근무", "유연한 근무 시간",
-        "경력 7년 이상", "스타트업", "풀스택 개발 경험 필수",
-        "문제 해결 능력 및 주도성", "김재훈", "테크이노베이션", 1L));
-
-    recruitmentService.saveRecruitment(new RecruitmentRequest(
-        "해외 영업 전문가 모집", "200명 이상의 직원", "부산, 대한민국",
-        120000000L, "정규직", "주 5일", "상근", "오전 8시부터 오후 5시까지",
-        "경력 10년 이상", "무역 회사", "국제 무역 및 영업 관련 전공",
-        "영어 능통 및 협상 기술", "이민호", "글로벌 트레이드", 1L));
-
     Pageable pageable = PageRequest.of(0, 5);
 
-    List<RecruitmentSummationResponse> recruitmentSummationResponseList = recruitmentService.getAllRecruitmentAndSortBySalary(
+    RecruitmentAllResponse recruitmentAllResponse = recruitmentService.getAllRecruitmentAndSortBySalary(
         pageable);
 
-    assertThat(recruitmentSummationResponseList.get(0).recruitmentId()).isEqualTo(3L);
-    assertThat(recruitmentSummationResponseList.get(1).recruitmentId()).isEqualTo(2L);
-    assertThat(recruitmentSummationResponseList.get(2).recruitmentId()).isEqualTo(1L);
+    assertThat(recruitmentAllResponse.content().get(0).recruitmentId()).isEqualTo(thirdRecruitmentId);
+    assertThat(recruitmentAllResponse.content().get(1).recruitmentId()).isEqualTo(secondRecruitmentId);
+    assertThat(recruitmentAllResponse.content().get(2).recruitmentId()).isEqualTo(firstRecruitmentId);
   }
 
 }