diff --git a/src/main/java/com/Alchive/backend/config/result/ResultCode.java b/src/main/java/com/Alchive/backend/config/result/ResultCode.java index ab14c1f..ce59f90 100644 --- a/src/main/java/com/Alchive/backend/config/result/ResultCode.java +++ b/src/main/java/com/Alchive/backend/config/result/ResultCode.java @@ -32,6 +32,7 @@ public enum ResultCode { BOARD_NOT_EXIST("B004", "존재하지 않는 게시물"), BOARD_MEMO_UPDATE_SUCCESS("B005", "게시물 메모 수정 성공"), BOARD_DELETE_SUCCESS("B006", "게시물 삭제 성공"), + BOARD_ALREADY_EXIST("B007", "존재하는 게시물"), // SNS SNS_INFO_SUCCESS("N001", "소셜 조회 성공"), diff --git a/src/main/java/com/Alchive/backend/controller/BoardController.java b/src/main/java/com/Alchive/backend/controller/BoardController.java index edddf71..02eb0f5 100644 --- a/src/main/java/com/Alchive/backend/controller/BoardController.java +++ b/src/main/java/com/Alchive/backend/controller/BoardController.java @@ -36,11 +36,7 @@ public class BoardController { @PostMapping("/saved") public ResponseEntity isBoardSaved(@AuthenticationPrincipal User user, @RequestBody @Valid ProblemNumberRequest problemNumberRequest) { BoardDetailResponseDTO board = boardService.isBoardSaved(user, problemNumberRequest); - if (board != null) { - return ResponseEntity.ok(ResultResponse.of(BOARD_INFO_SUCCESS, board)); - } else { - return ResponseEntity.ok(ResultResponse.of(BOARD_NOT_EXIST, null)); - } + return ResponseEntity.ok(ResultResponse.of(boardService.boardSavedStatus(board), board)); } @Operation(summary = "게시물 목록 조회", description = "게시물 목록을 조회하는 메서드입니다. ") @@ -55,7 +51,6 @@ public ResponseEntity getBoardList(@RequestParam(value = "offset @PostMapping("") public ResponseEntity createBoard(@AuthenticationPrincipal User user, @RequestBody @Valid BoardCreateRequest boardCreateRequest) { BoardResponseDTO board = boardService.createBoard(user, boardCreateRequest); -// slackService.sendMessageCreateBoard(boardCreateRequest, board); return ResponseEntity.ok(ResultResponse.of(BOARD_CREATE_SUCCESS, board)); } @@ -73,17 +68,17 @@ public ResponseEntity updateBoard(@AuthenticationPrincipal User return ResponseEntity.ok(ResultResponse.of(BOARD_MEMO_UPDATE_SUCCESS, board)); } - @Operation(summary = "게시물 삭제", description = "게시물을 삭제하는 메서드입니다. ") - @DeleteMapping("/{boardId}") - public ResponseEntity deleteBoard(@AuthenticationPrincipal User user, @PathVariable Long boardId) { - boardService.deleteBoard(user, boardId); - return ResponseEntity.ok(ResultResponse.of(BOARD_DELETE_SUCCESS)); - } - @Operation(summary = "게시물 메모 업데이트", description = "게시물 메모를 수정하는 메서드입니다. ") @PatchMapping("/memo/{boardId}") public ResponseEntity updateBoardMemo(@AuthenticationPrincipal User user, @PathVariable Long boardId, @RequestBody BoardMemoUpdateRequest updateRequest) { BoardResponseDTO board = boardService.updateBoardMemo(user, boardId, updateRequest); return ResponseEntity.ok(ResultResponse.of(BOARD_MEMO_UPDATE_SUCCESS, board)); } + + @Operation(summary = "게시물 삭제", description = "게시물을 삭제하는 메서드입니다. ") + @DeleteMapping("/{boardId}") + public ResponseEntity deleteBoard(@AuthenticationPrincipal User user, @PathVariable Long boardId) { + boardService.deleteBoard(user, boardId); + return ResponseEntity.ok(ResultResponse.of(BOARD_DELETE_SUCCESS)); + } } \ No newline at end of file diff --git a/src/main/java/com/Alchive/backend/service/BoardService.java b/src/main/java/com/Alchive/backend/service/BoardService.java index 48bd9d5..a1552a1 100644 --- a/src/main/java/com/Alchive/backend/service/BoardService.java +++ b/src/main/java/com/Alchive/backend/service/BoardService.java @@ -2,6 +2,8 @@ import com.Alchive.backend.config.error.exception.board.NotFoundBoardException; import com.Alchive.backend.config.error.exception.problem.NotFoundProblemException; +import com.Alchive.backend.config.result.ResultCode; +import com.Alchive.backend.config.result.ResultResponse; import com.Alchive.backend.domain.algorithm.Algorithm; import com.Alchive.backend.domain.algorithmProblem.AlgorithmProblem; import com.Alchive.backend.domain.board.Board; @@ -37,62 +39,44 @@ public class BoardService { private final SolutionRepository solutionRepository; private final UserService userService; - private BoardDetailResponseDTO toBoardDetailResponseDTO(Board board) { - BoardResponseDTO boardResponseDTO = new BoardResponseDTO(board); - - // 문제 정보 - Long problemId = board.getProblem().getId(); - Problem problem = problemRepository.findById(problemId) - .orElseThrow(NotFoundProblemException::new); - ProblemResponseDTO problemResponseDTO = new ProblemResponseDTO(problem, getProblemAlgorithms(problemId)); - - // 풀이 정보 - List solutions = getSolutions(board.getId()); - - // DTO로 묶어서 반환 - return new BoardDetailResponseDTO(boardResponseDTO, problemResponseDTO, solutions); - } - - // Board 저장 여부 구현 public BoardDetailResponseDTO isBoardSaved(User user, ProblemNumberRequest problemNumberRequest) { Optional board = boardRepository.findByProblem_PlatformAndProblem_NumberAndUser_Id(problemNumberRequest.getPlatform(), problemNumberRequest.getProblemNumber(), user.getId()); return board.map(this::toBoardDetailResponseDTO).orElse(null); } + public ResultCode boardSavedStatus(BoardDetailResponseDTO board) { + if (board != null) { + return ResultCode.BOARD_ALREADY_EXIST; + } + return ResultCode.BOARD_NOT_EXIST; + } + public Page> getBoardList(int offset, int limit) { Pageable pageable = PageRequest.of(offset, limit); Page boardPage = boardRepository.findAll(pageable); - // Board를 BoardDetailResponseDTO로 변환 List boardList = boardPage.getContent().stream() .map(this::toBoardDetailResponseDTO) .toList(); - // 변환된 리스트를 새로운 Page 객체로 감싸서 반환 return new PageImpl<>(List.of(boardList), pageable, boardPage.getTotalElements()); } - // 게시물 메서드 + public BoardDetailResponseDTO getBoardDetail(Long boardId) { + Board board = boardRepository.findById(boardId) + .orElseThrow(NotFoundBoardException::new); + return toBoardDetailResponseDTO(board); + } + @Transactional public BoardResponseDTO createBoard(User user, BoardCreateRequest boardCreateRequest) { ProblemCreateRequest problemCreateRequest = boardCreateRequest.getProblemCreateRequest(); - // 문제 정보 저장 여부 확인 - if (!problemRepository.existsByNumberAndPlatform(problemCreateRequest.getNumber(), problemCreateRequest.getPlatform())) { - // 문제가 저장되지 않은 경우 - createProblem(problemCreateRequest); - } + createProblem(problemCreateRequest); Problem problem = problemRepository.findByNumberAndPlatform(problemCreateRequest.getNumber(), problemCreateRequest.getPlatform()); Board board = Board.of(problem, user, boardCreateRequest); return new BoardResponseDTO(boardRepository.save(board)); } - public BoardDetailResponseDTO getBoardDetail(Long boardId) { - // 게시물 정보 - Board board = boardRepository.findById(boardId) - .orElseThrow(NotFoundBoardException::new); - return toBoardDetailResponseDTO(board); - } - @Transactional public BoardResponseDTO updateBoard(User user, Long boardId, BoardUpdateRequest updateRequest) { Board board = boardRepository.findById(boardId) @@ -102,55 +86,74 @@ public BoardResponseDTO updateBoard(User user, Long boardId, BoardUpdateRequest } @Transactional - public void deleteBoard(User user, Long boardId) { + public BoardResponseDTO updateBoardMemo(User user, Long boardId, BoardMemoUpdateRequest updateRequest) { Board board = boardRepository.findById(boardId) .orElseThrow(NotFoundBoardException::new); userService.validateUser(user.getId(), board.getUser().getId()); - boardRepository.delete(board); + return new BoardResponseDTO(board.updateMemo(updateRequest.getMemo())); } @Transactional - public BoardResponseDTO updateBoardMemo(User user, Long boardId, BoardMemoUpdateRequest updateRequest) { + public void deleteBoard(User user, Long boardId) { Board board = boardRepository.findById(boardId) .orElseThrow(NotFoundBoardException::new); userService.validateUser(user.getId(), board.getUser().getId()); - return new BoardResponseDTO(board.updateMemo(updateRequest.getMemo())); + boardRepository.delete(board); } - // 문제 메서드 - @Transactional - public void createProblem(ProblemCreateRequest problemCreateRequest) { - Problem problem = problemRepository.save(Problem.of(problemCreateRequest)); - List algorithms = problemCreateRequest.getAlgorithms(); + private BoardDetailResponseDTO toBoardDetailResponseDTO(Board board) { + BoardResponseDTO boardResponseDTO = new BoardResponseDTO(board); + ProblemResponseDTO problemResponseDTO = getBoardProblem(board); + List solutions = getBoardSolutions(board.getId()); - for (String algorithmName : algorithms) { - // 알고리즘 저장 여부 확인 - if (!algorithmRepository.existsByName(algorithmName)) { - // 알고리즘이 저장되지 않은 경우 - createAlgorithm(algorithmName); - } - Algorithm algorithm = algorithmRepository.findByName(algorithmName); - // Algorithm - Problem 연결 - AlgorithmProblem algorithmProblem = AlgorithmProblem.of(algorithm, problem); - algorithmProblemRepository.save(algorithmProblem); - } + return new BoardDetailResponseDTO(boardResponseDTO, problemResponseDTO, solutions); + } + + private ProblemResponseDTO getBoardProblem(Board board) { + Long problemId = board.getProblem().getId(); + Problem problem = problemRepository.findById(problemId) + .orElseThrow(NotFoundProblemException::new); + return new ProblemResponseDTO(problem, getProblemAlgorithms(problemId)); + } + + public List getBoardSolutions(Long boardId) { + List solutions = solutionRepository.findAllByBoard_Id(boardId); + return solutions.stream() + .map(SolutionResponseDTO::new) + .toList(); } public List getProblemAlgorithms(Long problemId) { return algorithmProblemRepository.findAlgorithmNamesByProblemId(problemId); } - // 알고리즘 메서드 @Transactional - public void createAlgorithm(String name) { - Algorithm newAlgorithm = Algorithm.of(name); + public void createProblem(ProblemCreateRequest problemCreateRequest) { + if (problemRepository.existsByNumberAndPlatform(problemCreateRequest.getNumber(), problemCreateRequest.getPlatform())) { + return; + } + Problem problem = problemRepository.save(Problem.of(problemCreateRequest)); + connectProblemAlgorithm(problem, problemCreateRequest.getAlgorithms()); + } + + private void connectProblemAlgorithm(Problem problem, List algorithms) { + for (String algorithmName : algorithms) { + createAlgorithm(algorithmName); + createAlgorithmProblem(algorithmName, problem); + } + } + + private void createAlgorithm(String algorithmName) { + if (algorithmRepository.existsByName(algorithmName)) { + return; + } + Algorithm newAlgorithm = Algorithm.of(algorithmName); algorithmRepository.save(newAlgorithm); } - public List getSolutions(Long boardId) { - List solutions = solutionRepository.findAllByBoard_Id(boardId); - return solutions.stream() - .map(SolutionResponseDTO::new) - .toList(); + private void createAlgorithmProblem(String algorithmName, Problem problem) { + Algorithm algorithm = algorithmRepository.findByName(algorithmName); + AlgorithmProblem algorithmProblem = AlgorithmProblem.of(algorithm, problem); + algorithmProblemRepository.save(algorithmProblem); } } diff --git a/src/test/java/com/Alchive/backend/controller/BoardControllerTest.java b/src/test/java/com/Alchive/backend/controller/BoardControllerTest.java new file mode 100644 index 0000000..a8ffd57 --- /dev/null +++ b/src/test/java/com/Alchive/backend/controller/BoardControllerTest.java @@ -0,0 +1,89 @@ +package com.Alchive.backend.controller; + +import com.Alchive.backend.config.result.ResultResponse; +import com.Alchive.backend.domain.board.Board; +import com.Alchive.backend.domain.board.BoardStatus; +import com.Alchive.backend.domain.problem.Problem; +import com.Alchive.backend.domain.problem.ProblemDifficulty; +import com.Alchive.backend.domain.problem.ProblemPlatform; +import com.Alchive.backend.domain.user.User; +import com.Alchive.backend.dto.request.ProblemNumberRequest; +import com.Alchive.backend.dto.response.BoardDetailResponseDTO; +import com.Alchive.backend.dto.response.BoardResponseDTO; +import com.Alchive.backend.dto.response.ProblemResponseDTO; +import com.Alchive.backend.service.BoardService; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.http.ResponseEntity; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static com.Alchive.backend.config.result.ResultCode.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.nullable; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class BoardControllerTest { + @InjectMocks + private BoardController sut; + @Mock + private BoardService boardService; + private Board board; + private Problem problem; + private User user; + private List algorithms = Arrays.asList("BFS", "DFS"); + + private long problemId = 1L; + private int problemNumber = 1; + private String problemTitle = "testProblem"; + private String problemContent = "this is test problem's content"; + private String problemUrl = "https://test/problem/1"; + private ProblemDifficulty problemDifficulty = ProblemDifficulty.LEVEL0; + private ProblemPlatform problemPlatform = ProblemPlatform.BAEKJOON; + private long userId = 1L; + private String userEmail = "testUser@test.com"; + private String userName = "testUsername"; + private long boardId = 1L; + private String boardMemo = "test problem's memo"; + private BoardStatus boardStatus = BoardStatus.CORRECT; + private String boardDescription = "test problem's description"; + @BeforeEach + + public void setUp() { + problem = new Problem(problemId, problemNumber, problemTitle, problemContent, problemUrl, problemDifficulty, problemPlatform); + user = new User(userId, userEmail, userName); + board = new Board(boardId, problem, user, boardMemo, boardStatus, boardDescription); + } + + @DisplayName("게시물 저장 여부 조회 - 이미 존재하는 문제") + @Test + public void existBoard() { + BoardDetailResponseDTO response = new BoardDetailResponseDTO(new BoardResponseDTO(board), new ProblemResponseDTO(problem, algorithms), new ArrayList<>()); + when(boardService.isBoardSaved(any(User.class), any(ProblemNumberRequest.class))).thenReturn(response); + when(boardService.boardSavedStatus(response)).thenReturn(BOARD_ALREADY_EXIST); + + ResponseEntity result = sut.isBoardSaved(user, new ProblemNumberRequest(problemPlatform, problemNumber)); + + Assertions.assertEquals(BOARD_ALREADY_EXIST.getMessage(), result.getBody().getMessage()); + } + + @DisplayName("게시물 저장 여부 조회 - 존재하지 않는 문제") + @Test + public void newBoard() { + when(boardService.isBoardSaved(any(User.class), any(ProblemNumberRequest.class))).thenReturn(null); + when(boardService.boardSavedStatus(nullable(BoardDetailResponseDTO.class))).thenReturn(BOARD_NOT_EXIST); + + ResponseEntity result = sut.isBoardSaved(user, new ProblemNumberRequest(problemPlatform, problemNumber)); + + Assertions.assertEquals(BOARD_NOT_EXIST.getMessage(), result.getBody().getMessage()); + } +} diff --git a/src/test/java/com/Alchive/backend/service/BoardServiceTest.java b/src/test/java/com/Alchive/backend/service/BoardServiceTest.java new file mode 100644 index 0000000..ebc97a2 --- /dev/null +++ b/src/test/java/com/Alchive/backend/service/BoardServiceTest.java @@ -0,0 +1,185 @@ +package com.Alchive.backend.service; + +import com.Alchive.backend.config.error.exception.token.UnmatchedUserIdException; +import com.Alchive.backend.domain.algorithm.Algorithm; +import com.Alchive.backend.domain.algorithmProblem.AlgorithmProblem; +import com.Alchive.backend.domain.board.Board; +import com.Alchive.backend.domain.board.BoardStatus; +import com.Alchive.backend.domain.problem.Problem; +import com.Alchive.backend.domain.problem.ProblemDifficulty; +import com.Alchive.backend.domain.problem.ProblemPlatform; +import com.Alchive.backend.domain.user.User; +import com.Alchive.backend.dto.request.BoardCreateRequest; +import com.Alchive.backend.dto.request.BoardMemoUpdateRequest; +import com.Alchive.backend.dto.request.ProblemCreateRequest; +import com.Alchive.backend.dto.request.ProblemNumberRequest; +import com.Alchive.backend.dto.response.BoardDetailResponseDTO; +import com.Alchive.backend.dto.response.BoardResponseDTO; +import com.Alchive.backend.repository.*; +import org.junit.jupiter.api.Assertions; +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.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +public class BoardServiceTest { + @InjectMocks + private BoardService sut; + @Mock + private BoardRepository boardRepository; + @Mock + private ProblemRepository problemRepository; + @Mock + private AlgorithmRepository algorithmRepository; + @Mock + private AlgorithmProblemRepository algorithmProblemRepository; + @Mock + private SolutionRepository solutionRepository; + @Mock + private UserService userService; + + private Board board; + private Problem problem; + private User user; + private List algorithms = Arrays.asList("BFS", "DFS"); + + private long problemId = 1L; + private int problemNumber = 1; + private String problemTitle = "testProblem"; + private String problemContent = "this is test problem's content"; + private String problemUrl = "https://test/problem/1"; + private ProblemDifficulty problemDifficulty = ProblemDifficulty.LEVEL0; + private ProblemPlatform problemPlatform = ProblemPlatform.BAEKJOON; + private long userId = 1L; + private String userEmail = "testUser@test.com"; + private String userName = "testUsername"; + private long boardId = 1L; + private String boardMemo = "test problem's memo"; + private BoardStatus boardStatus = BoardStatus.CORRECT; + private String boardDescription = "test problem's description"; + @BeforeEach + + public void setUp() { + problem = new Problem(problemId, problemNumber, problemTitle, problemContent, problemUrl, problemDifficulty, problemPlatform); + user = new User(userId, userEmail, userName); + board = new Board(boardId, problem, user, boardMemo, boardStatus, boardDescription); + } + +// @DisplayName("게시물, 문제, 풀이 묶어서 반환 - 성공") +// @Test +// public void toBoardSolutionDtoSuccess() { +// when(problemRepository.findById(problemId)).thenReturn(Optional.ofNullable(problem)); +// when(algorithmProblemRepository.findAlgorithmNamesByProblemId(problemId)).thenReturn(algorithms); +// when(solutionRepository.findAllByBoard_Id(boardId)).thenReturn(new ArrayList<>()); +// } + + @DisplayName("문제 저장 여부 - 참") + @Test + public void isBoardSavedTrue() { + when(boardRepository.findByProblem_PlatformAndProblem_NumberAndUser_Id(problemPlatform, problemNumber, userId)).thenReturn(Optional.ofNullable(board)); + + when(problemRepository.findById(problemId)).thenReturn(Optional.ofNullable(problem)); + when(algorithmProblemRepository.findAlgorithmNamesByProblemId(problemId)).thenReturn(algorithms); + when(solutionRepository.findAllByBoard_Id(boardId)).thenReturn(new ArrayList<>()); + ProblemNumberRequest request = new ProblemNumberRequest(problemPlatform, problemNumber); + + BoardDetailResponseDTO result = sut.isBoardSaved(user, request); + + Assertions.assertEquals(boardMemo, result.getBoard().getMemo()); + Assertions.assertEquals(0, result.getSolutions().size()); + Assertions.assertEquals(2, result.getProblem().getAlgorithms().size()); + } + + @DisplayName("문제 저장 여부 - 거짓") + @Test + public void isBoardSavedFalse() { + when(boardRepository.findByProblem_PlatformAndProblem_NumberAndUser_Id(problemPlatform, problemNumber, userId)).thenReturn(Optional.empty()); + ProblemNumberRequest request = new ProblemNumberRequest(problemPlatform, problemNumber); + + BoardDetailResponseDTO result = sut.isBoardSaved(user, request); + + Assertions.assertEquals(null, result); + } + + @DisplayName("게시물 저장 - 이미 존재하는 문제") + @Test + public void createBoardWithExistProblem() { + when(problemRepository.existsByNumberAndPlatform(problemNumber, problemPlatform)).thenReturn(true); + when(problemRepository.findByNumberAndPlatform(problemNumber, problemPlatform)).thenReturn(problem); + when(boardRepository.save(any(Board.class))).thenReturn(board); + ProblemCreateRequest request1 = new ProblemCreateRequest(problemNumber, problemTitle, problemContent, problemUrl, problemDifficulty, problemPlatform, algorithms); + BoardCreateRequest request = new BoardCreateRequest(request1, boardMemo, boardDescription, boardStatus); + + BoardResponseDTO result = sut.createBoard(user, request); + + Assertions.assertEquals(boardMemo, result.getMemo()); + Assertions.assertEquals(boardStatus, result.getStatus()); + Assertions.assertEquals(boardDescription, result.getDescription()); + } + + @DisplayName("게시물 저장 - 새로운 문제") + @Test + public void createBoardWithNewProblem() { + when(problemRepository.existsByNumberAndPlatform(problemNumber, problemPlatform)).thenReturn(false); + when(problemRepository.save(any(Problem.class))).thenReturn(problem); + when(algorithmRepository.existsByName(anyString())).thenReturn(true); + when(algorithmRepository.findByName(anyString())).thenReturn(new Algorithm(1L, "BFS")); + when(problemRepository.findByNumberAndPlatform(problemNumber, problemPlatform)).thenReturn(problem); + when(boardRepository.save(any(Board.class))).thenReturn(board); + ProblemCreateRequest request1 = new ProblemCreateRequest(problemNumber, problemTitle, problemContent, problemUrl, problemDifficulty, problemPlatform, algorithms); + BoardCreateRequest request = new BoardCreateRequest(request1, boardMemo, boardDescription, boardStatus); + + sut.createBoard(user, request); + } + + @DisplayName("문제 생성 - 성공") + @Test + public void createProblemSuccess() { + when(problemRepository.existsByNumberAndPlatform(anyInt(), any(ProblemPlatform.class))).thenReturn(false); + when(problemRepository.save(any(Problem.class))).thenReturn(problem); + when(algorithmRepository.existsByName(anyString())).thenReturn(true); + when(algorithmRepository.findByName(any(String.class))).thenReturn(Algorithm.of("algorithm")); + AlgorithmProblem algorithmProblem = new AlgorithmProblem(1L, Algorithm.of("algorithm"), problem); + when(algorithmProblemRepository.save(any(AlgorithmProblem.class))).thenReturn(algorithmProblem); + + ProblemCreateRequest request = new ProblemCreateRequest(problemNumber, problemTitle, problemContent, problemUrl, problemDifficulty, problemPlatform, algorithms); + + sut.createProblem(request); + } + + + + @DisplayName("게시물 수정 - 작성자가 수정") + @Test + public void updateBoardByAuthor() { + when(boardRepository.findById(boardId)).thenReturn(Optional.ofNullable(board)); + doNothing().when(userService).validateUser(any(Long.class), any(Long.class)); + String newMemo = "new Memo"; + BoardMemoUpdateRequest request = new BoardMemoUpdateRequest(newMemo); + + sut.updateBoardMemo(user, boardId, request); + } + + @DisplayName("게시물 수정 - 작성자가 아닌 사람이 수정") + @Test + public void updateBoardByNonAuthor() { + when(boardRepository.findById(boardId)).thenReturn(Optional.ofNullable(board)); + doCallRealMethod().when(userService).validateUser(anyLong(), anyLong()); + User newUser = new User(2L, "newUser@test.com", "newUser"); + BoardMemoUpdateRequest request = new BoardMemoUpdateRequest("new Memo"); + + Assertions.assertThrows(UnmatchedUserIdException.class, () -> sut.updateBoardMemo(newUser, boardId, request)); + } +}