From 130f2a269d02e458b2ba23b04c77975fceffabaf Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Wed, 13 Nov 2024 00:18:11 +0900 Subject: [PATCH 01/10] =?UTF-8?q?chore:=20entity=20=EB=B6=88=ED=95=84?= =?UTF-8?q?=EC=9A=94=ED=95=9C=20=EC=BD=94=EB=93=9C=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../corecord/dev/domain/record/converter/RecordConverter.java | 2 -- src/main/java/corecord/dev/domain/record/entity/Record.java | 4 ++-- .../dev/domain/record/repository/RecordRepository.java | 3 +-- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java b/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java index f9ce472..2992e99 100644 --- a/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java +++ b/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java @@ -14,7 +14,6 @@ public class RecordConverter { public static Record toMemoRecordEntity(String title, String content, User user, Folder folder) { return Record.builder() - .type(RecordType.MEMO) .title(title) .user(user) .content(content) @@ -25,7 +24,6 @@ public static Record toMemoRecordEntity(String title, String content, User user, public static Record toChatRecordEntity(String title, String content, User user, Folder folder, ChatRoom chatRoom) { return Record.builder() - .type(RecordType.CHAT) .title(title) .user(user) .content(content) diff --git a/src/main/java/corecord/dev/domain/record/entity/Record.java b/src/main/java/corecord/dev/domain/record/entity/Record.java index 598b1df..16ccb27 100644 --- a/src/main/java/corecord/dev/domain/record/entity/Record.java +++ b/src/main/java/corecord/dev/domain/record/entity/Record.java @@ -32,11 +32,11 @@ public class Record extends BaseEntity { @Column(nullable = false, length = 500) private String content; - @ManyToOne + @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "user_id", nullable = false) private User user; - @OneToOne + @OneToOne(fetch = FetchType.LAZY) @JoinColumn(name = "chat_room_id", nullable = true) private ChatRoom chatRoom; diff --git a/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java b/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java index 919ff4c..08b0cf4 100644 --- a/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java +++ b/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java @@ -24,8 +24,7 @@ public interface RecordRepository extends JpaRepository { "JOIN FETCH a.abilityList al " + "WHERE r.user = :user " + "AND (:last_record_id = 0 OR r.recordId < :last_record_id) " + // 제일 마지막에 읽은 데이터 이후부터 가져옴 - "AND r.folder is not null AND r.folder = :folder "+ // 임시 저장 기록 제외 - "ORDER BY r.createdAt desc ") // 최근 생성 순 정렬 + "AND r.folder is not null AND r.folder = :folder") // 임시 저장 기록 제외 List findRecordsByFolder( @Param(value = "folder") Folder folder, @Param(value = "user") User user, From cb5f03f1c4d72a78feffd63cd1f8690ce0d45e78 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Sat, 16 Nov 2024 16:03:23 +0900 Subject: [PATCH 02/10] =?UTF-8?q?test:=20memo=20record=20=EC=83=9D?= =?UTF-8?q?=EC=84=B1=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dev/domain/folder/entity/Folder.java | 2 +- .../repository/MemoRecordRepositoryTest.java | 88 +++++++++++++++++++ .../memo/service/MemoRecordServiceTest.java | 4 + 3 files changed, 93 insertions(+), 1 deletion(-) create mode 100644 src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java create mode 100644 src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java diff --git a/src/main/java/corecord/dev/domain/folder/entity/Folder.java b/src/main/java/corecord/dev/domain/folder/entity/Folder.java index 02c257c..6c26557 100644 --- a/src/main/java/corecord/dev/domain/folder/entity/Folder.java +++ b/src/main/java/corecord/dev/domain/folder/entity/Folder.java @@ -29,7 +29,7 @@ public class Folder extends BaseEntity { @OneToMany(mappedBy = "folder", cascade = CascadeType.ALL, orphanRemoval = true) private List records; - @ManyToOne + @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "user_id", nullable = false) private User user; diff --git a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java new file mode 100644 index 0000000..bce14c8 --- /dev/null +++ b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java @@ -0,0 +1,88 @@ +package corecord.dev.record.memo.repository; + +import corecord.dev.domain.folder.entity.Folder; +import corecord.dev.domain.record.constant.RecordType; +import corecord.dev.domain.record.entity.Record; +import corecord.dev.domain.record.repository.RecordRepository; +import corecord.dev.domain.user.entity.Status; +import corecord.dev.domain.user.entity.User; +import jakarta.persistence.EntityManager; +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.orm.jpa.DataJpaTest; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +public class MemoRecordRepositoryTest { + @Autowired + EntityManager entityManager; + + @Autowired + RecordRepository recordRepository; + + private final Long lastRecordId = 0L; + private final Pageable pageable = PageRequest.of(0, 5); + private final String testTitle = "Test Title"; + private final String testContent = "Test Content"; + + + @Test + void findRecordByFolder() { + // Given + User user = createUser("Test User"); + entityManager.persist(user); + + Folder folder = createFolder("Test Folder", user); + entityManager.persist(folder); + + Record record1 = createRecord("Test Record1", testContent, user, folder); + entityManager.persist(record1); + Record record2 = createRecord("Test Record2", testContent, user, folder); + entityManager.persist(record2); + + // When + List result = recordRepository.findRecordsByFolder(folder, user, lastRecordId, pageable); + + // Then + assertThat(result.size()).isEqualTo(2); + assertThat(result.get(0).getRecordId()).isEqualTo(record1.getRecordId()); + assertThat(result.get(0).getFolder().getFolderId()).isEqualTo(folder.getFolderId()); + assertThat(result.get(1).getRecordId()).isEqualTo(record2.getRecordId()); + assertThat(result.get(1).getFolder().getFolderId()).isEqualTo(folder.getFolderId()); + } + + private User createUser(String nickName) { + return User.builder() + .providerId("Test Provider") + .nickName(nickName) + .status(Status.GRADUATE_STUDENT) + .folders(new ArrayList<>()) + .build(); + } + + private Record createRecord(String title, String content, User user, Folder folder) { + return Record.builder() + .title(title) + .content(content) + .user(user) + .type(RecordType.MEMO) + .folder(folder) + .build(); + } + + private Folder createFolder(String title, User user) { + return Folder.builder() + .title(title) + .user(user) + .build(); + } + +} diff --git a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java new file mode 100644 index 0000000..edcde05 --- /dev/null +++ b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java @@ -0,0 +1,4 @@ +package corecord.dev.record.memo.service; + +public class MemoRecordServiceTest { +} From 284cfa6543943b090e8a938639e934aad7cbf60e Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Mon, 18 Nov 2024 15:10:13 +0900 Subject: [PATCH 03/10] =?UTF-8?q?test:=20memo=20ver.=20record=20repository?= =?UTF-8?q?=20test=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../repository/MemoRecordRepositoryTest.java | 125 ++++++++++++++++-- 1 file changed, 112 insertions(+), 13 deletions(-) diff --git a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java index bce14c8..a2501d3 100644 --- a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java +++ b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java @@ -1,25 +1,38 @@ package corecord.dev.record.memo.repository; +import corecord.dev.domain.ability.entity.Ability; +import corecord.dev.domain.ability.entity.Keyword; +import corecord.dev.domain.ability.repository.AbilityRepository; +import corecord.dev.domain.analysis.entity.Analysis; +import corecord.dev.domain.analysis.repository.AnalysisRepository; import corecord.dev.domain.folder.entity.Folder; +import corecord.dev.domain.folder.repository.FolderRepository; import corecord.dev.domain.record.constant.RecordType; import corecord.dev.domain.record.entity.Record; import corecord.dev.domain.record.repository.RecordRepository; import corecord.dev.domain.user.entity.Status; import corecord.dev.domain.user.entity.User; +import corecord.dev.domain.user.repository.UserRepository; import jakarta.persistence.EntityManager; +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.orm.jpa.DataJpaTest; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; +import org.springframework.transaction.annotation.Transactional; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; @DataJpaTest +@Transactional @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) public class MemoRecordRepositoryTest { @Autowired @@ -28,25 +41,32 @@ public class MemoRecordRepositoryTest { @Autowired RecordRepository recordRepository; + @Autowired + UserRepository userRepository; + + @Autowired + FolderRepository folderRepository; + + @Autowired + AnalysisRepository analysisRepository; + + @Autowired + AbilityRepository abilityRepository; + private final Long lastRecordId = 0L; private final Pageable pageable = PageRequest.of(0, 5); - private final String testTitle = "Test Title"; private final String testContent = "Test Content"; @Test + @DisplayName("폴더별 경험 기록 리스트 조회 테스트") void findRecordByFolder() { // Given User user = createUser("Test User"); - entityManager.persist(user); - Folder folder = createFolder("Test Folder", user); - entityManager.persist(folder); - Record record1 = createRecord("Test Record1", testContent, user, folder); - entityManager.persist(record1); - Record record2 = createRecord("Test Record2", testContent, user, folder); - entityManager.persist(record2); + Record record1 = createRecord("Test Record1", user, folder); + Record record2 = createRecord("Test Record2", user, folder); // When List result = recordRepository.findRecordsByFolder(folder, user, lastRecordId, pageable); @@ -59,30 +79,109 @@ void findRecordByFolder() { assertThat(result.get(1).getFolder().getFolderId()).isEqualTo(folder.getFolderId()); } + @Test + @DisplayName("경험 기록이 존재하지 않는 폴더에 대한 리스트 조회 테스트") + void findRecordByFolderWhenNoRecordsExist() { + // Given + User user = createUser("Test User"); + Folder folder = createFolder("Test Folder", user); + + // When + List result = recordRepository.findRecordsByFolder(folder, user, lastRecordId, pageable); + + // Then + assertEquals(result.size(), 0); + } + + @Test + @DisplayName("메모 경험 기록 조회 테스트") + void findMemoRecordDetail() { + // Given + User user = createUser("Test User"); + Folder folder = createFolder("Test folder", user); + Record record = createRecord("Test Record", user, folder); + + // When + Optional result = recordRepository.findRecordById(record.getRecordId()); + + // Then + assertTrue(result.isPresent()); + assertThat(result.get().getTitle()).isEqualTo("Test Record"); + assertThat(result.get().getRecordId()).isEqualTo(record.getRecordId()); + } + + @Test + @DisplayName("키워드별 경험 기록 조회 테스트") + void findMemoRecordListByKeywordTest() { + // Given + User user = createUser("Test User"); + Folder folder = createFolder("Test folder", user); + + Record record1 = createRecord("Test Record1", user, folder); + Record record2 = createRecord("Test Record2", user, folder); + + // When + List result = recordRepository.findRecordsByKeyword(Keyword.COLLABORATION, user, lastRecordId, pageable); + + // Then + assertEquals(result.size(), 2); + assertEquals(result.get(0).getTitle(), record1.getTitle()); + assertEquals(result.get(1).getTitle(), record2.getTitle()); + } + private User createUser(String nickName) { - return User.builder() + User user = User.builder() .providerId("Test Provider") .nickName(nickName) .status(Status.GRADUATE_STUDENT) .folders(new ArrayList<>()) .build(); + userRepository.save(user); + return user; } - private Record createRecord(String title, String content, User user, Folder folder) { - return Record.builder() + private Record createRecord(String title, User user, Folder folder) { + Record record = Record.builder() .title(title) - .content(content) + .content(testContent) .user(user) .type(RecordType.MEMO) .folder(folder) .build(); + recordRepository.save(record); + createAnalysis(record, user); + return record; } private Folder createFolder(String title, User user) { - return Folder.builder() + Folder folder = Folder.builder() .title(title) .user(user) .build(); + folderRepository.save(folder); + return folder; + } + + private Analysis createAnalysis(Record record, User user) { + Analysis analysis = Analysis.builder() + .content(testContent) + .comment(testContent) + .record(record) + .build(); + analysisRepository.save(analysis); + createAbility(user, analysis, Keyword.COLLABORATION); + return analysis; + } + + private Ability createAbility(User user, Analysis analysis, Keyword keyword) { + Ability ability = Ability.builder() + .keyword(keyword) + .content(testContent) + .user(user) + .analysis(analysis) + .build(); + abilityRepository.save(ability); + return ability; } } From ec8bbfb3bd20e31fb318340765934b2a8d5c048f Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Mon, 18 Nov 2024 18:48:14 +0900 Subject: [PATCH 04/10] =?UTF-8?q?test:=20memo=20ver.=20record=20service=20?= =?UTF-8?q?test=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../corecord/dev/common/base/BaseEntity.java | 3 +- .../record/dto/request/RecordRequest.java | 5 +- .../repository/MemoRecordRepositoryTest.java | 13 +- .../memo/service/MemoRecordServiceTest.java | 239 ++++++++++++++++++ 4 files changed, 249 insertions(+), 11 deletions(-) diff --git a/src/main/java/corecord/dev/common/base/BaseEntity.java b/src/main/java/corecord/dev/common/base/BaseEntity.java index 052e4a9..c664e4e 100644 --- a/src/main/java/corecord/dev/common/base/BaseEntity.java +++ b/src/main/java/corecord/dev/common/base/BaseEntity.java @@ -4,6 +4,7 @@ import jakarta.persistence.EntityListeners; import jakarta.persistence.MappedSuperclass; import lombok.Getter; +import lombok.Setter; import org.springframework.data.annotation.CreatedDate; import org.springframework.data.annotation.LastModifiedDate; import org.springframework.data.jpa.domain.support.AuditingEntityListener; @@ -12,7 +13,7 @@ import java.time.format.DateTimeFormatter; @EntityListeners(AuditingEntityListener.class) -@Getter +@Getter @Setter @MappedSuperclass public class BaseEntity { @CreatedDate diff --git a/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java b/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java index 3fd648d..efe4b90 100644 --- a/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java +++ b/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java @@ -2,10 +2,11 @@ import corecord.dev.domain.record.constant.RecordType; import jakarta.validation.constraints.NotBlank; +import lombok.Builder; import lombok.Data; public class RecordRequest { - @Data + @Data @Builder public static class RecordDto { @NotBlank(message = "제목을 입력해주세요.") private String title; @@ -18,7 +19,7 @@ public static class RecordDto { private Long chatRoomId; } - @Data + @Data @Builder public static class TmpMemoRecordDto { @NotBlank(message = "임시 저장할 기록의 제목을 입력해주세요.") private String title; diff --git a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java index a2501d3..03c7835 100644 --- a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java +++ b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java @@ -13,7 +13,6 @@ import corecord.dev.domain.user.entity.Status; import corecord.dev.domain.user.entity.User; import corecord.dev.domain.user.repository.UserRepository; -import jakarta.persistence.EntityManager; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -35,23 +34,21 @@ @Transactional @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) public class MemoRecordRepositoryTest { - @Autowired - EntityManager entityManager; @Autowired - RecordRepository recordRepository; + private RecordRepository recordRepository; @Autowired - UserRepository userRepository; + private UserRepository userRepository; @Autowired - FolderRepository folderRepository; + private FolderRepository folderRepository; @Autowired - AnalysisRepository analysisRepository; + private AnalysisRepository analysisRepository; @Autowired - AbilityRepository abilityRepository; + private AbilityRepository abilityRepository; private final Long lastRecordId = 0L; private final Pageable pageable = PageRequest.of(0, 5); diff --git a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java index edcde05..3e427b4 100644 --- a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java +++ b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java @@ -1,4 +1,243 @@ package corecord.dev.record.memo.service; +import corecord.dev.domain.analysis.entity.Analysis; +import corecord.dev.domain.analysis.service.AnalysisService; +import corecord.dev.domain.folder.entity.Folder; +import corecord.dev.domain.folder.repository.FolderRepository; +import corecord.dev.domain.record.constant.RecordType; +import corecord.dev.domain.record.dto.request.RecordRequest; +import corecord.dev.domain.record.dto.response.RecordResponse; +import corecord.dev.domain.record.entity.Record; +import corecord.dev.domain.record.exception.enums.RecordErrorStatus; +import corecord.dev.domain.record.exception.model.RecordException; +import corecord.dev.domain.record.repository.RecordRepository; +import corecord.dev.domain.record.service.RecordService; +import corecord.dev.domain.user.entity.Status; +import corecord.dev.domain.user.entity.User; +import corecord.dev.domain.user.repository.UserRepository; +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 java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + + +@ExtendWith(MockitoExtension.class) public class MemoRecordServiceTest { + + @Mock + private UserRepository userRepository; + + @Mock + private FolderRepository folderRepository; + + @Mock + private RecordRepository recordRepository; + + @Mock + private AnalysisService analysisService; + + @InjectMocks + private RecordService recordService; + + private User user; + private Folder folder; + + private String testTitle = "Test Record"; + private String testContent = "Test content"; + + @BeforeEach + void setUp() { + user = createMockUser(); + folder = createMockFolder(user); + } + @Test + @DisplayName("메모 경험 기록 생성 테스트") + void createMemoRecordTest() { + // Given + Record record = createMockRecord(testTitle, user, folder); + + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(folderRepository.findById(1L)).thenReturn(Optional.of(folder)); + when(analysisService.createAnalysis(any(Record.class), any(User.class))) + .thenReturn(createMockAnalysis(record)); + when(recordRepository.save(any(Record.class))).thenAnswer(invocation -> { + Record savedRecord = invocation.getArgument(0); + savedRecord.setCreatedAt(LocalDateTime.now()); + return savedRecord; + }); + + // When + RecordRequest.RecordDto request = RecordRequest.RecordDto.builder() + .title(testTitle) + .content(testContent) + .folderId(1L) + .recordType(RecordType.MEMO) + .build(); + + RecordResponse.MemoRecordDto response = recordService.createMemoRecord(1L, request); + + // Then + verify(userRepository).findById(1L); + verify(folderRepository).findById(1L); + verify(recordRepository).save(any(Record.class)); + + assertEquals(response.getFolder(), folder.getTitle()); + assertEquals(response.getTitle(), testTitle); + assertEquals(response.getContent(), testContent); + } + + @Test + @DisplayName("경험 기록 제목이 긴 경우 예외 발생") + void createMemoRecordWithLongContent() { + // Given + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(folderRepository.findById(1L)).thenReturn(Optional.of(folder)); + + // When & Then + RecordRequest.RecordDto request = RecordRequest.RecordDto.builder() + .title("Too Long Record Title") + .content(testContent) + .folderId(1L) + .recordType(RecordType.MEMO) + .build(); + + RecordException exception = assertThrows(RecordException.class, + () -> recordService.createMemoRecord(1L, request)); + assertEquals(exception.getRecordErrorStatus(), RecordErrorStatus.OVERFLOW_MEMO_RECORD_TITLE); + } + + @Test + @DisplayName("임시 메모 경험 기록 저장 테스트") + void createTmpMemoRecordTest() { + // Given + Record tmpRecord = createMockRecord(testContent, user, null); + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(recordRepository.save(any(Record.class))).thenReturn(tmpRecord); + + // When + RecordRequest.TmpMemoRecordDto request = RecordRequest.TmpMemoRecordDto.builder() + .title(testTitle) + .content(testContent) + .build(); + + recordService.createTmpMemoRecord(1L, request); + + // Then + verify(userRepository, times(1)).findById(1L); + verify(recordRepository, times(1)).save(any(Record.class)); + assertEquals(user.getTmpMemo(), tmpRecord.getRecordId()); + } + + @Test + @DisplayName("중복 임시 메모 경험 기록 저장 시 예외 발생 테스트") + void createTmpMemoRecordDuplicateTest() { + // Given + user.updateTmpMemo(1L); // 이미 임시 메모 경험 기록을 저장 + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + + // When & Then + RecordRequest.TmpMemoRecordDto request = RecordRequest.TmpMemoRecordDto.builder() + .title(testTitle) + .content(testContent) + .build(); + + RecordException exception = assertThrows(RecordException.class, + () -> recordService.createTmpMemoRecord(1L, request)); + assertEquals(exception.getRecordErrorStatus(), RecordErrorStatus.ALREADY_TMP_MEMO); + + verify(userRepository, times(1)).findById(1L); + verify(recordRepository, times(0)).save(any(Record.class)); + } + + @Test + @DisplayName("임시 메모 경험 기록이 있는 경우 조회 테스트") + void getTmpMemoRecordTest() { + // Given + Record tmpRecord = createMockRecord(testContent, user, null); + user.updateTmpMemo(1L); + + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(recordRepository.findById(1L)).thenReturn(Optional.of(tmpRecord)); + + // When + RecordResponse.TmpMemoRecordDto response = recordService.getTmpMemoRecord(1L); + + // Then + verify(userRepository, times(1)).findById(1L); + verify(recordRepository, times(1)).findById(1L); + verify(recordRepository, times(1)).delete(tmpRecord); + + assertNull(user.getTmpMemo()); + assertTrue(response.getIsExist()); + assertEquals(response.getTitle(), testTitle); + assertEquals(response.getContent(), testContent); + } + + @Test + @DisplayName("임시 메모 경험 기록이 없는 경우 조회 테스트") + void getTmpMemoRecordWithoutRecordTest() { + // Given + user.updateTmpMemo(null); + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + + // When + RecordResponse.TmpMemoRecordDto response = recordService.getTmpMemoRecord(1L); + + // Then + verify(userRepository, times(1)).findById(1L); + + assertFalse(response.getIsExist()); + assertNull(response.getTitle()); + assertNull(response.getContent()); + } + + private User createMockUser() { + return User.builder() + .userId(1L) + .providerId("Test Provider") + .nickName("Test User") + .status(Status.GRADUATE_STUDENT) + .folders(new ArrayList<>()) + .build(); + } + + private Folder createMockFolder(User user) { + return Folder.builder() + .folderId(1L) + .title("Test Folder") + .user(user) + .build(); + } + + private Record createMockRecord(String content, User user, Folder folder) { + return Record.builder() + .recordId(1L) + .title(testTitle) + .content(content) + .user(user) + .type(RecordType.MEMO) + .folder(folder) + .build(); + } + + private Analysis createMockAnalysis(Record record) { + return Analysis.builder() + .analysisId(1L) + .content(testContent) + .comment("Test Comment") + .record(record) + .build(); + } + } From 968ca9672af7b261f27935c1186a48842cf3f5e7 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Wed, 13 Nov 2024 00:18:11 +0900 Subject: [PATCH 05/10] =?UTF-8?q?chore:=20entity=20=EB=B6=88=ED=95=84?= =?UTF-8?q?=EC=9A=94=ED=95=9C=20=EC=BD=94=EB=93=9C=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../corecord/dev/domain/record/converter/RecordConverter.java | 2 -- src/main/java/corecord/dev/domain/record/entity/Record.java | 4 ++-- .../dev/domain/record/repository/RecordRepository.java | 3 +-- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java b/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java index f9ce472..2992e99 100644 --- a/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java +++ b/src/main/java/corecord/dev/domain/record/converter/RecordConverter.java @@ -14,7 +14,6 @@ public class RecordConverter { public static Record toMemoRecordEntity(String title, String content, User user, Folder folder) { return Record.builder() - .type(RecordType.MEMO) .title(title) .user(user) .content(content) @@ -25,7 +24,6 @@ public static Record toMemoRecordEntity(String title, String content, User user, public static Record toChatRecordEntity(String title, String content, User user, Folder folder, ChatRoom chatRoom) { return Record.builder() - .type(RecordType.CHAT) .title(title) .user(user) .content(content) diff --git a/src/main/java/corecord/dev/domain/record/entity/Record.java b/src/main/java/corecord/dev/domain/record/entity/Record.java index 001c8e8..b45d7d0 100644 --- a/src/main/java/corecord/dev/domain/record/entity/Record.java +++ b/src/main/java/corecord/dev/domain/record/entity/Record.java @@ -32,11 +32,11 @@ public class Record extends BaseEntity { @Column(nullable = false, length = 500) private String content; - @ManyToOne + @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "user_id", nullable = false) private User user; - @OneToOne + @OneToOne(fetch = FetchType.LAZY) @JoinColumn(name = "chat_room_id", nullable = true) private ChatRoom chatRoom; diff --git a/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java b/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java index 919ff4c..08b0cf4 100644 --- a/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java +++ b/src/main/java/corecord/dev/domain/record/repository/RecordRepository.java @@ -24,8 +24,7 @@ public interface RecordRepository extends JpaRepository { "JOIN FETCH a.abilityList al " + "WHERE r.user = :user " + "AND (:last_record_id = 0 OR r.recordId < :last_record_id) " + // 제일 마지막에 읽은 데이터 이후부터 가져옴 - "AND r.folder is not null AND r.folder = :folder "+ // 임시 저장 기록 제외 - "ORDER BY r.createdAt desc ") // 최근 생성 순 정렬 + "AND r.folder is not null AND r.folder = :folder") // 임시 저장 기록 제외 List findRecordsByFolder( @Param(value = "folder") Folder folder, @Param(value = "user") User user, From b92047bdaf9fb7fc117e50df2a87c8c6926408d2 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Sat, 16 Nov 2024 16:03:23 +0900 Subject: [PATCH 06/10] =?UTF-8?q?test:=20memo=20record=20=EC=83=9D?= =?UTF-8?q?=EC=84=B1=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dev/domain/folder/entity/Folder.java | 2 +- .../repository/MemoRecordRepositoryTest.java | 88 +++++++++++++++++++ .../memo/service/MemoRecordServiceTest.java | 4 + 3 files changed, 93 insertions(+), 1 deletion(-) create mode 100644 src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java create mode 100644 src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java diff --git a/src/main/java/corecord/dev/domain/folder/entity/Folder.java b/src/main/java/corecord/dev/domain/folder/entity/Folder.java index 02c257c..6c26557 100644 --- a/src/main/java/corecord/dev/domain/folder/entity/Folder.java +++ b/src/main/java/corecord/dev/domain/folder/entity/Folder.java @@ -29,7 +29,7 @@ public class Folder extends BaseEntity { @OneToMany(mappedBy = "folder", cascade = CascadeType.ALL, orphanRemoval = true) private List records; - @ManyToOne + @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "user_id", nullable = false) private User user; diff --git a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java new file mode 100644 index 0000000..bce14c8 --- /dev/null +++ b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java @@ -0,0 +1,88 @@ +package corecord.dev.record.memo.repository; + +import corecord.dev.domain.folder.entity.Folder; +import corecord.dev.domain.record.constant.RecordType; +import corecord.dev.domain.record.entity.Record; +import corecord.dev.domain.record.repository.RecordRepository; +import corecord.dev.domain.user.entity.Status; +import corecord.dev.domain.user.entity.User; +import jakarta.persistence.EntityManager; +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.orm.jpa.DataJpaTest; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +public class MemoRecordRepositoryTest { + @Autowired + EntityManager entityManager; + + @Autowired + RecordRepository recordRepository; + + private final Long lastRecordId = 0L; + private final Pageable pageable = PageRequest.of(0, 5); + private final String testTitle = "Test Title"; + private final String testContent = "Test Content"; + + + @Test + void findRecordByFolder() { + // Given + User user = createUser("Test User"); + entityManager.persist(user); + + Folder folder = createFolder("Test Folder", user); + entityManager.persist(folder); + + Record record1 = createRecord("Test Record1", testContent, user, folder); + entityManager.persist(record1); + Record record2 = createRecord("Test Record2", testContent, user, folder); + entityManager.persist(record2); + + // When + List result = recordRepository.findRecordsByFolder(folder, user, lastRecordId, pageable); + + // Then + assertThat(result.size()).isEqualTo(2); + assertThat(result.get(0).getRecordId()).isEqualTo(record1.getRecordId()); + assertThat(result.get(0).getFolder().getFolderId()).isEqualTo(folder.getFolderId()); + assertThat(result.get(1).getRecordId()).isEqualTo(record2.getRecordId()); + assertThat(result.get(1).getFolder().getFolderId()).isEqualTo(folder.getFolderId()); + } + + private User createUser(String nickName) { + return User.builder() + .providerId("Test Provider") + .nickName(nickName) + .status(Status.GRADUATE_STUDENT) + .folders(new ArrayList<>()) + .build(); + } + + private Record createRecord(String title, String content, User user, Folder folder) { + return Record.builder() + .title(title) + .content(content) + .user(user) + .type(RecordType.MEMO) + .folder(folder) + .build(); + } + + private Folder createFolder(String title, User user) { + return Folder.builder() + .title(title) + .user(user) + .build(); + } + +} diff --git a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java new file mode 100644 index 0000000..edcde05 --- /dev/null +++ b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java @@ -0,0 +1,4 @@ +package corecord.dev.record.memo.service; + +public class MemoRecordServiceTest { +} From c5385cf93e003022b3fb527fb604cbc937acb0b3 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Mon, 18 Nov 2024 15:10:13 +0900 Subject: [PATCH 07/10] =?UTF-8?q?test:=20memo=20ver.=20record=20repository?= =?UTF-8?q?=20test=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../repository/MemoRecordRepositoryTest.java | 125 ++++++++++++++++-- 1 file changed, 112 insertions(+), 13 deletions(-) diff --git a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java index bce14c8..a2501d3 100644 --- a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java +++ b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java @@ -1,25 +1,38 @@ package corecord.dev.record.memo.repository; +import corecord.dev.domain.ability.entity.Ability; +import corecord.dev.domain.ability.entity.Keyword; +import corecord.dev.domain.ability.repository.AbilityRepository; +import corecord.dev.domain.analysis.entity.Analysis; +import corecord.dev.domain.analysis.repository.AnalysisRepository; import corecord.dev.domain.folder.entity.Folder; +import corecord.dev.domain.folder.repository.FolderRepository; import corecord.dev.domain.record.constant.RecordType; import corecord.dev.domain.record.entity.Record; import corecord.dev.domain.record.repository.RecordRepository; import corecord.dev.domain.user.entity.Status; import corecord.dev.domain.user.entity.User; +import corecord.dev.domain.user.repository.UserRepository; import jakarta.persistence.EntityManager; +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.orm.jpa.DataJpaTest; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; +import org.springframework.transaction.annotation.Transactional; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; @DataJpaTest +@Transactional @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) public class MemoRecordRepositoryTest { @Autowired @@ -28,25 +41,32 @@ public class MemoRecordRepositoryTest { @Autowired RecordRepository recordRepository; + @Autowired + UserRepository userRepository; + + @Autowired + FolderRepository folderRepository; + + @Autowired + AnalysisRepository analysisRepository; + + @Autowired + AbilityRepository abilityRepository; + private final Long lastRecordId = 0L; private final Pageable pageable = PageRequest.of(0, 5); - private final String testTitle = "Test Title"; private final String testContent = "Test Content"; @Test + @DisplayName("폴더별 경험 기록 리스트 조회 테스트") void findRecordByFolder() { // Given User user = createUser("Test User"); - entityManager.persist(user); - Folder folder = createFolder("Test Folder", user); - entityManager.persist(folder); - Record record1 = createRecord("Test Record1", testContent, user, folder); - entityManager.persist(record1); - Record record2 = createRecord("Test Record2", testContent, user, folder); - entityManager.persist(record2); + Record record1 = createRecord("Test Record1", user, folder); + Record record2 = createRecord("Test Record2", user, folder); // When List result = recordRepository.findRecordsByFolder(folder, user, lastRecordId, pageable); @@ -59,30 +79,109 @@ void findRecordByFolder() { assertThat(result.get(1).getFolder().getFolderId()).isEqualTo(folder.getFolderId()); } + @Test + @DisplayName("경험 기록이 존재하지 않는 폴더에 대한 리스트 조회 테스트") + void findRecordByFolderWhenNoRecordsExist() { + // Given + User user = createUser("Test User"); + Folder folder = createFolder("Test Folder", user); + + // When + List result = recordRepository.findRecordsByFolder(folder, user, lastRecordId, pageable); + + // Then + assertEquals(result.size(), 0); + } + + @Test + @DisplayName("메모 경험 기록 조회 테스트") + void findMemoRecordDetail() { + // Given + User user = createUser("Test User"); + Folder folder = createFolder("Test folder", user); + Record record = createRecord("Test Record", user, folder); + + // When + Optional result = recordRepository.findRecordById(record.getRecordId()); + + // Then + assertTrue(result.isPresent()); + assertThat(result.get().getTitle()).isEqualTo("Test Record"); + assertThat(result.get().getRecordId()).isEqualTo(record.getRecordId()); + } + + @Test + @DisplayName("키워드별 경험 기록 조회 테스트") + void findMemoRecordListByKeywordTest() { + // Given + User user = createUser("Test User"); + Folder folder = createFolder("Test folder", user); + + Record record1 = createRecord("Test Record1", user, folder); + Record record2 = createRecord("Test Record2", user, folder); + + // When + List result = recordRepository.findRecordsByKeyword(Keyword.COLLABORATION, user, lastRecordId, pageable); + + // Then + assertEquals(result.size(), 2); + assertEquals(result.get(0).getTitle(), record1.getTitle()); + assertEquals(result.get(1).getTitle(), record2.getTitle()); + } + private User createUser(String nickName) { - return User.builder() + User user = User.builder() .providerId("Test Provider") .nickName(nickName) .status(Status.GRADUATE_STUDENT) .folders(new ArrayList<>()) .build(); + userRepository.save(user); + return user; } - private Record createRecord(String title, String content, User user, Folder folder) { - return Record.builder() + private Record createRecord(String title, User user, Folder folder) { + Record record = Record.builder() .title(title) - .content(content) + .content(testContent) .user(user) .type(RecordType.MEMO) .folder(folder) .build(); + recordRepository.save(record); + createAnalysis(record, user); + return record; } private Folder createFolder(String title, User user) { - return Folder.builder() + Folder folder = Folder.builder() .title(title) .user(user) .build(); + folderRepository.save(folder); + return folder; + } + + private Analysis createAnalysis(Record record, User user) { + Analysis analysis = Analysis.builder() + .content(testContent) + .comment(testContent) + .record(record) + .build(); + analysisRepository.save(analysis); + createAbility(user, analysis, Keyword.COLLABORATION); + return analysis; + } + + private Ability createAbility(User user, Analysis analysis, Keyword keyword) { + Ability ability = Ability.builder() + .keyword(keyword) + .content(testContent) + .user(user) + .analysis(analysis) + .build(); + abilityRepository.save(ability); + return ability; } } From 371872d0cbb40cd9be5cf4fbac3b0081d8191180 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Mon, 18 Nov 2024 18:48:14 +0900 Subject: [PATCH 08/10] =?UTF-8?q?test:=20memo=20ver.=20record=20service=20?= =?UTF-8?q?test=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../corecord/dev/common/base/BaseEntity.java | 3 +- .../record/dto/request/RecordRequest.java | 5 +- .../repository/MemoRecordRepositoryTest.java | 13 +- .../memo/service/MemoRecordServiceTest.java | 239 ++++++++++++++++++ 4 files changed, 249 insertions(+), 11 deletions(-) diff --git a/src/main/java/corecord/dev/common/base/BaseEntity.java b/src/main/java/corecord/dev/common/base/BaseEntity.java index 052e4a9..c664e4e 100644 --- a/src/main/java/corecord/dev/common/base/BaseEntity.java +++ b/src/main/java/corecord/dev/common/base/BaseEntity.java @@ -4,6 +4,7 @@ import jakarta.persistence.EntityListeners; import jakarta.persistence.MappedSuperclass; import lombok.Getter; +import lombok.Setter; import org.springframework.data.annotation.CreatedDate; import org.springframework.data.annotation.LastModifiedDate; import org.springframework.data.jpa.domain.support.AuditingEntityListener; @@ -12,7 +13,7 @@ import java.time.format.DateTimeFormatter; @EntityListeners(AuditingEntityListener.class) -@Getter +@Getter @Setter @MappedSuperclass public class BaseEntity { @CreatedDate diff --git a/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java b/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java index 04ee549..57357f3 100644 --- a/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java +++ b/src/main/java/corecord/dev/domain/record/dto/request/RecordRequest.java @@ -2,11 +2,12 @@ import corecord.dev.domain.record.constant.RecordType; import jakarta.validation.constraints.NotBlank; +import lombok.Builder; import jakarta.validation.constraints.NotNull; import lombok.Data; public class RecordRequest { - @Data + @Data @Builder public static class RecordDto { @NotBlank(message = "제목을 입력해주세요.") private String title; @@ -19,7 +20,7 @@ public static class RecordDto { private Long chatRoomId; } - @Data + @Data @Builder public static class TmpMemoRecordDto { @NotBlank(message = "임시 저장할 기록의 제목을 입력해주세요.") private String title; diff --git a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java index a2501d3..03c7835 100644 --- a/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java +++ b/src/test/java/corecord/dev/record/memo/repository/MemoRecordRepositoryTest.java @@ -13,7 +13,6 @@ import corecord.dev.domain.user.entity.Status; import corecord.dev.domain.user.entity.User; import corecord.dev.domain.user.repository.UserRepository; -import jakarta.persistence.EntityManager; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -35,23 +34,21 @@ @Transactional @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) public class MemoRecordRepositoryTest { - @Autowired - EntityManager entityManager; @Autowired - RecordRepository recordRepository; + private RecordRepository recordRepository; @Autowired - UserRepository userRepository; + private UserRepository userRepository; @Autowired - FolderRepository folderRepository; + private FolderRepository folderRepository; @Autowired - AnalysisRepository analysisRepository; + private AnalysisRepository analysisRepository; @Autowired - AbilityRepository abilityRepository; + private AbilityRepository abilityRepository; private final Long lastRecordId = 0L; private final Pageable pageable = PageRequest.of(0, 5); diff --git a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java index edcde05..3e427b4 100644 --- a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java +++ b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java @@ -1,4 +1,243 @@ package corecord.dev.record.memo.service; +import corecord.dev.domain.analysis.entity.Analysis; +import corecord.dev.domain.analysis.service.AnalysisService; +import corecord.dev.domain.folder.entity.Folder; +import corecord.dev.domain.folder.repository.FolderRepository; +import corecord.dev.domain.record.constant.RecordType; +import corecord.dev.domain.record.dto.request.RecordRequest; +import corecord.dev.domain.record.dto.response.RecordResponse; +import corecord.dev.domain.record.entity.Record; +import corecord.dev.domain.record.exception.enums.RecordErrorStatus; +import corecord.dev.domain.record.exception.model.RecordException; +import corecord.dev.domain.record.repository.RecordRepository; +import corecord.dev.domain.record.service.RecordService; +import corecord.dev.domain.user.entity.Status; +import corecord.dev.domain.user.entity.User; +import corecord.dev.domain.user.repository.UserRepository; +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 java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + + +@ExtendWith(MockitoExtension.class) public class MemoRecordServiceTest { + + @Mock + private UserRepository userRepository; + + @Mock + private FolderRepository folderRepository; + + @Mock + private RecordRepository recordRepository; + + @Mock + private AnalysisService analysisService; + + @InjectMocks + private RecordService recordService; + + private User user; + private Folder folder; + + private String testTitle = "Test Record"; + private String testContent = "Test content"; + + @BeforeEach + void setUp() { + user = createMockUser(); + folder = createMockFolder(user); + } + @Test + @DisplayName("메모 경험 기록 생성 테스트") + void createMemoRecordTest() { + // Given + Record record = createMockRecord(testTitle, user, folder); + + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(folderRepository.findById(1L)).thenReturn(Optional.of(folder)); + when(analysisService.createAnalysis(any(Record.class), any(User.class))) + .thenReturn(createMockAnalysis(record)); + when(recordRepository.save(any(Record.class))).thenAnswer(invocation -> { + Record savedRecord = invocation.getArgument(0); + savedRecord.setCreatedAt(LocalDateTime.now()); + return savedRecord; + }); + + // When + RecordRequest.RecordDto request = RecordRequest.RecordDto.builder() + .title(testTitle) + .content(testContent) + .folderId(1L) + .recordType(RecordType.MEMO) + .build(); + + RecordResponse.MemoRecordDto response = recordService.createMemoRecord(1L, request); + + // Then + verify(userRepository).findById(1L); + verify(folderRepository).findById(1L); + verify(recordRepository).save(any(Record.class)); + + assertEquals(response.getFolder(), folder.getTitle()); + assertEquals(response.getTitle(), testTitle); + assertEquals(response.getContent(), testContent); + } + + @Test + @DisplayName("경험 기록 제목이 긴 경우 예외 발생") + void createMemoRecordWithLongContent() { + // Given + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(folderRepository.findById(1L)).thenReturn(Optional.of(folder)); + + // When & Then + RecordRequest.RecordDto request = RecordRequest.RecordDto.builder() + .title("Too Long Record Title") + .content(testContent) + .folderId(1L) + .recordType(RecordType.MEMO) + .build(); + + RecordException exception = assertThrows(RecordException.class, + () -> recordService.createMemoRecord(1L, request)); + assertEquals(exception.getRecordErrorStatus(), RecordErrorStatus.OVERFLOW_MEMO_RECORD_TITLE); + } + + @Test + @DisplayName("임시 메모 경험 기록 저장 테스트") + void createTmpMemoRecordTest() { + // Given + Record tmpRecord = createMockRecord(testContent, user, null); + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(recordRepository.save(any(Record.class))).thenReturn(tmpRecord); + + // When + RecordRequest.TmpMemoRecordDto request = RecordRequest.TmpMemoRecordDto.builder() + .title(testTitle) + .content(testContent) + .build(); + + recordService.createTmpMemoRecord(1L, request); + + // Then + verify(userRepository, times(1)).findById(1L); + verify(recordRepository, times(1)).save(any(Record.class)); + assertEquals(user.getTmpMemo(), tmpRecord.getRecordId()); + } + + @Test + @DisplayName("중복 임시 메모 경험 기록 저장 시 예외 발생 테스트") + void createTmpMemoRecordDuplicateTest() { + // Given + user.updateTmpMemo(1L); // 이미 임시 메모 경험 기록을 저장 + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + + // When & Then + RecordRequest.TmpMemoRecordDto request = RecordRequest.TmpMemoRecordDto.builder() + .title(testTitle) + .content(testContent) + .build(); + + RecordException exception = assertThrows(RecordException.class, + () -> recordService.createTmpMemoRecord(1L, request)); + assertEquals(exception.getRecordErrorStatus(), RecordErrorStatus.ALREADY_TMP_MEMO); + + verify(userRepository, times(1)).findById(1L); + verify(recordRepository, times(0)).save(any(Record.class)); + } + + @Test + @DisplayName("임시 메모 경험 기록이 있는 경우 조회 테스트") + void getTmpMemoRecordTest() { + // Given + Record tmpRecord = createMockRecord(testContent, user, null); + user.updateTmpMemo(1L); + + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(recordRepository.findById(1L)).thenReturn(Optional.of(tmpRecord)); + + // When + RecordResponse.TmpMemoRecordDto response = recordService.getTmpMemoRecord(1L); + + // Then + verify(userRepository, times(1)).findById(1L); + verify(recordRepository, times(1)).findById(1L); + verify(recordRepository, times(1)).delete(tmpRecord); + + assertNull(user.getTmpMemo()); + assertTrue(response.getIsExist()); + assertEquals(response.getTitle(), testTitle); + assertEquals(response.getContent(), testContent); + } + + @Test + @DisplayName("임시 메모 경험 기록이 없는 경우 조회 테스트") + void getTmpMemoRecordWithoutRecordTest() { + // Given + user.updateTmpMemo(null); + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + + // When + RecordResponse.TmpMemoRecordDto response = recordService.getTmpMemoRecord(1L); + + // Then + verify(userRepository, times(1)).findById(1L); + + assertFalse(response.getIsExist()); + assertNull(response.getTitle()); + assertNull(response.getContent()); + } + + private User createMockUser() { + return User.builder() + .userId(1L) + .providerId("Test Provider") + .nickName("Test User") + .status(Status.GRADUATE_STUDENT) + .folders(new ArrayList<>()) + .build(); + } + + private Folder createMockFolder(User user) { + return Folder.builder() + .folderId(1L) + .title("Test Folder") + .user(user) + .build(); + } + + private Record createMockRecord(String content, User user, Folder folder) { + return Record.builder() + .recordId(1L) + .title(testTitle) + .content(content) + .user(user) + .type(RecordType.MEMO) + .folder(folder) + .build(); + } + + private Analysis createMockAnalysis(Record record) { + return Analysis.builder() + .analysisId(1L) + .content(testContent) + .comment("Test Comment") + .record(record) + .build(); + } + } From 27eb24b3c5c44b9abc876df104f2078f9a2efcb2 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Mon, 18 Nov 2024 19:13:59 +0900 Subject: [PATCH 09/10] =?UTF-8?q?chore:=20=EA=B2=BD=ED=97=98=20=EA=B8=B0?= =?UTF-8?q?=EB=A1=9D=20=EB=82=B4=EC=9A=A9=20=EC=B5=9C=EC=86=8C=20=EA=B8=80?= =?UTF-8?q?=EC=9E=90=EC=88=98=20=EC=A0=9C=ED=95=9C=20=EB=B0=98=EC=98=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../exception/enums/RecordErrorStatus.java | 1 + .../domain/record/service/RecordService.java | 3 ++ .../memo/service/MemoRecordServiceTest.java | 34 +++++++++++++++---- 3 files changed, 31 insertions(+), 7 deletions(-) diff --git a/src/main/java/corecord/dev/domain/record/exception/enums/RecordErrorStatus.java b/src/main/java/corecord/dev/domain/record/exception/enums/RecordErrorStatus.java index 5b9bdd9..5c6032b 100644 --- a/src/main/java/corecord/dev/domain/record/exception/enums/RecordErrorStatus.java +++ b/src/main/java/corecord/dev/domain/record/exception/enums/RecordErrorStatus.java @@ -10,6 +10,7 @@ public enum RecordErrorStatus implements BaseErrorStatus { OVERFLOW_MEMO_RECORD_TITLE(HttpStatus.BAD_REQUEST, "E0400_OVERFLOW_TITLE", "메모 제목은 50자 이내여야 합니다."), OVERFLOW_MEMO_RECORD_CONTENT(HttpStatus.BAD_REQUEST, "E0400_OVERFLOW_CONTENT", "메모 내용은 500자 이내여야 합니다."), + NOT_ENOUGH_MEMO_RECORD_CONTENT(HttpStatus.BAD_REQUEST, "E0400_NOT_ENOUGH_CONTENT", "메모 내용은 30자 이상이어야 합니다."), USER_RECORD_UNAUTHORIZED(HttpStatus.UNAUTHORIZED, "E401_RECORD_UNAUTHORIZED", "유저가 경험 기록에 대한 권한이 없습니다."), RECORD_NOT_FOUND(HttpStatus.NOT_FOUND, "E0404_RECORD", "존재하지 않는 경험 기록입니다."), ALREADY_TMP_MEMO(HttpStatus.BAD_REQUEST, "E0400_TMP_MEMO", "유저가 이미 임시 저장된 메모를 가지고 있습니다.") diff --git a/src/main/java/corecord/dev/domain/record/service/RecordService.java b/src/main/java/corecord/dev/domain/record/service/RecordService.java index 0b47cad..3a48e7b 100644 --- a/src/main/java/corecord/dev/domain/record/service/RecordService.java +++ b/src/main/java/corecord/dev/domain/record/service/RecordService.java @@ -217,6 +217,9 @@ private void validTextLength(String title, String content) { if (title != null && title.length() > 50) throw new RecordException(RecordErrorStatus.OVERFLOW_MEMO_RECORD_TITLE); + if (content != null && content.length() < 30) + throw new RecordException(RecordErrorStatus.NOT_ENOUGH_MEMO_RECORD_CONTENT); + if (content != null && content.length() > 500) { throw new RecordException(RecordErrorStatus.OVERFLOW_MEMO_RECORD_CONTENT); } diff --git a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java index 3e427b4..6cbfddd 100644 --- a/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java +++ b/src/test/java/corecord/dev/record/memo/service/MemoRecordServiceTest.java @@ -54,7 +54,7 @@ public class MemoRecordServiceTest { private Folder folder; private String testTitle = "Test Record"; - private String testContent = "Test content"; + private String testContent = "Test".repeat(10); @BeforeEach void setUp() { @@ -65,7 +65,7 @@ void setUp() { @DisplayName("메모 경험 기록 생성 테스트") void createMemoRecordTest() { // Given - Record record = createMockRecord(testTitle, user, folder); + Record record = createMockRecord(user, folder); when(userRepository.findById(1L)).thenReturn(Optional.of(user)); when(folderRepository.findById(1L)).thenReturn(Optional.of(folder)); @@ -106,7 +106,7 @@ void createMemoRecordWithLongContent() { // When & Then RecordRequest.RecordDto request = RecordRequest.RecordDto.builder() - .title("Too Long Record Title") + .title("a".repeat(51)) .content(testContent) .folderId(1L) .recordType(RecordType.MEMO) @@ -117,11 +117,31 @@ void createMemoRecordWithLongContent() { assertEquals(exception.getRecordErrorStatus(), RecordErrorStatus.OVERFLOW_MEMO_RECORD_TITLE); } + @Test + @DisplayName("경험 기록 내용 글자수가 충분하지 않은 경우 예외 발생") + void createMemoRecordWithNotEnoughContent() { + // Given + when(userRepository.findById(1L)).thenReturn(Optional.of(user)); + when(folderRepository.findById(1L)).thenReturn(Optional.of(folder)); + + // When & Then + RecordRequest.RecordDto request = RecordRequest.RecordDto.builder() + .title(testTitle) + .content("Test") + .folderId(1L) + .recordType(RecordType.MEMO) + .build(); + + RecordException exception = assertThrows(RecordException.class, + () -> recordService.createMemoRecord(1L, request)); + assertEquals(exception.getRecordErrorStatus(), RecordErrorStatus.NOT_ENOUGH_MEMO_RECORD_CONTENT); + } + @Test @DisplayName("임시 메모 경험 기록 저장 테스트") void createTmpMemoRecordTest() { // Given - Record tmpRecord = createMockRecord(testContent, user, null); + Record tmpRecord = createMockRecord(user, null); when(userRepository.findById(1L)).thenReturn(Optional.of(user)); when(recordRepository.save(any(Record.class))).thenReturn(tmpRecord); @@ -164,7 +184,7 @@ void createTmpMemoRecordDuplicateTest() { @DisplayName("임시 메모 경험 기록이 있는 경우 조회 테스트") void getTmpMemoRecordTest() { // Given - Record tmpRecord = createMockRecord(testContent, user, null); + Record tmpRecord = createMockRecord(user, null); user.updateTmpMemo(1L); when(userRepository.findById(1L)).thenReturn(Optional.of(user)); @@ -220,11 +240,11 @@ private Folder createMockFolder(User user) { .build(); } - private Record createMockRecord(String content, User user, Folder folder) { + private Record createMockRecord(User user, Folder folder) { return Record.builder() .recordId(1L) .title(testTitle) - .content(content) + .content(testContent) .user(user) .type(RecordType.MEMO) .folder(folder) From 7a1b47dc63b94a866dbf786947ba129212c7b8e7 Mon Sep 17 00:00:00 2001 From: daeun084 <030804jk@naver.com> Date: Mon, 18 Nov 2024 22:19:51 +0900 Subject: [PATCH 10/10] chore: webClient logging off --- src/main/resources/application.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml index 92e7016..6a318e0 100644 --- a/src/main/resources/application.yml +++ b/src/main/resources/application.yml @@ -13,4 +13,5 @@ spring: logging: level: - org.springframework.web: DEBUG \ No newline at end of file + org.springframework.web: DEBUG + org.springframework.web.client.DefaultRestClient: OFF \ No newline at end of file