refactor: Board controller, service 계층 리팩토링/테스트 코드 추가

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_EXSIST("B007", "존재하는 게시물"),
 
     // SNS
     SNS_INFO_SUCCESS("N001", "소셜 조회 성공"),

src/main/java/com/Alchive/backend/controller/BoardController.java

@@ -36,11 +36,7 @@ public class BoardController {
     @PostMapping("/saved")
     public ResponseEntity<ResultResponse> 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<ResultResponse> getBoardList(@RequestParam(value = "offset
     @PostMapping("")
     public ResponseEntity<ResultResponse> 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<ResultResponse> updateBoard(@AuthenticationPrincipal User
         return ResponseEntity.ok(ResultResponse.of(BOARD_MEMO_UPDATE_SUCCESS, board));
     }
 
-    @Operation(summary = "게시물 삭제", description = "게시물을 삭제하는 메서드입니다. ")
-    @DeleteMapping("/{boardId}")
-    public ResponseEntity<ResultResponse> 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<ResultResponse> 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<ResultResponse> deleteBoard(@AuthenticationPrincipal User user, @PathVariable Long boardId) {
+        boardService.deleteBoard(user, boardId);
+        return ResponseEntity.ok(ResultResponse.of(BOARD_DELETE_SUCCESS));
+    }
 }

src/main/java/com/Alchive/backend/service/BoardService.java

@@ -2,6 +2,7 @@
 
 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.domain.algorithm.Algorithm;
 import com.Alchive.backend.domain.algorithmProblem.AlgorithmProblem;
 import com.Alchive.backend.domain.board.Board;
@@ -37,62 +38,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<SolutionResponseDTO> solutions = getSolutions(board.getId());
-
-        // DTO로 묶어서 반환
-        return new BoardDetailResponseDTO(boardResponseDTO, problemResponseDTO, solutions);
-    }
-
-    // Board 저장 여부 구현
     public BoardDetailResponseDTO isBoardSaved(User user, ProblemNumberRequest problemNumberRequest) {
         Optional<Board> 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_EXSIST;
+        }
+        return ResultCode.BOARD_NOT_EXIST;
+    }
+
     public Page<List<BoardDetailResponseDTO>> getBoardList(int offset, int limit) {
         Pageable pageable = PageRequest.of(offset, limit);
         Page<Board> boardPage = boardRepository.findAll(pageable);
 
-        // Board를 BoardDetailResponseDTO로 변환
         List<BoardDetailResponseDTO> 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 +85,75 @@ 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);
+    }
+
+    private BoardDetailResponseDTO toBoardDetailResponseDTO(Board board) {
+        BoardResponseDTO boardResponseDTO = new BoardResponseDTO(board);
+        ProblemResponseDTO problemResponseDTO = getBoardProblem(board);
+        List<SolutionResponseDTO> solutions = getBoardSolutions(board.getId());
+
+        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<SolutionResponseDTO> getBoardSolutions(Long boardId) {
+        List<Solution> solutions = solutionRepository.findAllByBoard_Id(boardId);
+        return solutions.stream()
+                .map(SolutionResponseDTO::new)
+                .toList();
+    }
+
+    public List<String> getProblemAlgorithms(Long problemId) {
+        return algorithmProblemRepository.findAlgorithmNamesByProblemId(problemId);
     }
 
-    // 문제 메서드
     @Transactional
     public void createProblem(ProblemCreateRequest problemCreateRequest) {
+        if (problemRepository.existsByNumberAndPlatform(problemCreateRequest.getNumber(), problemCreateRequest.getPlatform())) {
+            return;
+        }
         Problem problem = problemRepository.save(Problem.of(problemCreateRequest));
-        List<String> algorithms = problemCreateRequest.getAlgorithms();
+        connectProblemAlgorithm(problem, problemCreateRequest.getAlgorithms());
+    }
 
+    private void connectProblemAlgorithm(Problem problem, List<String> algorithms) {
         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);
+            createAlgorithm(algorithmName);
+            createAlgorithmProblem(algorithmName, problem);
         }
     }
 
-    public List<String> getProblemAlgorithms(Long problemId) {
-        return algorithmProblemRepository.findAlgorithmNamesByProblemId(problemId);
-    }
-
-    // 알고리즘 메서드
     @Transactional
-    public void createAlgorithm(String name) {
-        Algorithm newAlgorithm = Algorithm.of(name);
+    public void createAlgorithm(String algorithmName) {
+        if (algorithmRepository.existsByName(algorithmName)) {
+            return;
+        }
+        Algorithm newAlgorithm = Algorithm.of(algorithmName);
         algorithmRepository.save(newAlgorithm);
     }
 
-    public List<SolutionResponseDTO> getSolutions(Long boardId) {
-        List<Solution> 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);
     }
 }

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<String> 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 = "[email protected]";
+    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_EXSIST);
+
+        ResponseEntity<ResultResponse> result = sut.isBoardSaved(user, new ProblemNumberRequest(problemPlatform, problemNumber));
+
+        Assertions.assertEquals(BOARD_ALREADY_EXSIST.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<ResultResponse> result = sut.isBoardSaved(user, new ProblemNumberRequest(problemPlatform, problemNumber));
+
+        Assertions.assertEquals(BOARD_NOT_EXIST.getMessage(), result.getBody().getMessage());
+    }
+}