officer/egovframe-msa-edu
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
jooho
2021-10-20 17:12:00 +09:00
parent 0c884beff8
commit 8caa4bbc5a
487 changed files with 44198 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

440
backend/board-service/src/test/java/org/egovframe/cloud/boardservice/api/board/BoardApiControllerTest.java Normal file
View File

@@ -0,0 +1,440 @@
package org.egovframe.cloud.boardservice.api.board;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.assertj.core.api.Condition;
import org.egovframe.cloud.boardservice.api.board.dto.BoardListResponseDto;
import org.egovframe.cloud.boardservice.api.board.dto.BoardResponseDto;
import org.egovframe.cloud.boardservice.domain.board.Board;
import org.egovframe.cloud.boardservice.domain.board.BoardRepository;
import org.egovframe.cloud.boardservice.util.RestResponsePage;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import lombok.extern.slf4j.Slf4j;
/**
* org.egovframe.cloud.boardservice.api.board.BoardApiControllerTest
* <p>
* 게시판 Rest API 컨트롤러 테스트 클래스
*
* @author 표준프레임워크센터 jooho
* @version 1.0
* @since 2021/07/26
*
* <pre>
* << 개정이력(Modification Information) >>
*
* 수정일 수정자 수정내용
* ---------- -------- ---------------------------
* 2021/07/26 jooho 최초 생성
* </pre>
*/
@Slf4j
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@EnableConfigurationProperties
@TestPropertySource(properties = {"spring.config.location=classpath:application-test.yml"})
@ActiveProfiles(profiles = "test")
public class BoardApiControllerTest {
/**
* test rest template
*/
@Autowired
TestRestTemplate restTemplate;
/**
* 게시판 레파지토리 인터페이스
*/
@Autowired
BoardRepository boardRepository;
/**
* 게시판 API 경로
*/
private static final String URL = "/api/v1/boards";
/**
* 테스트 데이터 등록 횟수
*/
private final Integer GIVEN_DATA_COUNT = 10;
/**
* 테스트 데이터
*/
private final String BOARD_NAME_PREFIX = "게시판 명";
private final String SKIN_TYPE_CODE_PREFIX = "000";
private final Integer BOARD_NO = GIVEN_DATA_COUNT + 1;
private final String INSERT_BOARD_NAME = BOARD_NAME_PREFIX + "_" + BOARD_NO;
private final String INSERT_SKIN_TYPE_CODE = SKIN_TYPE_CODE_PREFIX + "_" + BOARD_NO;
private final Integer INSERT_TITLE_DISPLAY_LENGTH = 50;
private final Integer INSERT_POST_DISPLAY_COUNT = 10;
private final Integer INSERT_PAGE_DISPLAY_COUNT = 10;
private final Integer INSERT_NEW_DISPLAY_COUNT = 3;
private final Boolean INSERT_EDITOR_USE_AT = true;
private final Boolean INSERT_UPLOAD_USE_AT = true;
private final Boolean INSERT_USER_WRITE_AT = true;
private final Boolean INSERT_COMMENT_USE_AT = true;
private final Integer INSERT_UPLOAD_FILE_COUNT = 5;
private final BigDecimal INSERT_UPLOAD_LIMIT_SIZE = new BigDecimal("104857600");
private final String UPDATE_BOARD_NAME = BOARD_NAME_PREFIX + "_" + (BOARD_NO + 1);
private final String UPDATE_SKIN_TYPE_CODE = SKIN_TYPE_CODE_PREFIX + "_" + (BOARD_NO + 1);
private final Integer UPDATE_TITLE_DISPLAY_LENGTH = 50 + 1;
private final Integer UPDATE_POST_DISPLAY_COUNT = 10 + 1;
private final Integer UPDATE_PAGE_DISPLAY_COUNT = 10 + 1;
private final Integer UPDATE_NEW_DISPLAY_COUNT = 3 + 1;
private final Boolean UPDATE_EDITOR_USE_AT = false;
private final Boolean UPDATE_UPLOAD_USE_AT = false;
private final Boolean UPDATE_USER_WRITE_AT = false;
private final Boolean UPDATE_COMMENT_USE_AT = false;
private final Integer UPDATE_UPLOAD_FILE_COUNT = 5 + 1;
private final BigDecimal UPDATE_UPLOAD_LIMIT_SIZE = new BigDecimal("209715200");
/**
* 테스트 시작 전 수행
*/
@BeforeEach
void setUp() {
log.info("###setUp");
}
/**
* 테스트 종료 후 수행
*/
@AfterEach
void tearDown() {
log.info("###tearDown");
//게시판 삭제
boardRepository.deleteAll();
}
/**
* 게시판 페이지 목록 조회 테스트
*/
@Test
void 게시판_페이지_목록_조회() {
log.info("###게시판_페이지_목록_조회");
// given
insertBoards();
String queryString = "?keywordType=boardName&keyword=" + BOARD_NAME_PREFIX; // 검색 조건
queryString += "&page=0&size=" + GIVEN_DATA_COUNT; // 페이지 정보
// when
ResponseEntity<RestResponsePage<BoardListResponseDto>> responseEntity = restTemplate.exchange(
URL + queryString,
HttpMethod.GET,
null,
new ParameterizedTypeReference<RestResponsePage<BoardListResponseDto>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
RestResponsePage<BoardListResponseDto> page = responseEntity.getBody();
assertThat(page).isNotNull();
assertThat(page.getNumberOfElements()).isEqualTo(GIVEN_DATA_COUNT);
assertThat(page.getContent())
.isNotEmpty()
.has(new Condition<>(l -> (BOARD_NAME_PREFIX + "_10").equals(l.get(0).getBoardName()), "BoardApiControllerTest.findPage contains " + BOARD_NAME_PREFIX + "_10"))
.has(new Condition<>(l -> (BOARD_NAME_PREFIX + "_9").equals(l.get(1).getBoardName()), "BoardApiControllerTest.findPage contains " + BOARD_NAME_PREFIX + "_9"));
}
/**
* 게시판 상세 조회 테스트
*/
@Test
void 게시판_상세_조회() {
log.info("###게시판_상세_조회");
// given
Board entity = insertBoard();
final Integer boardNo = entity.getBoardNo();
String url = URL + "/" + boardNo;
// when
ResponseEntity<BoardResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<BoardResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
BoardResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
assertThat(dto.getBoardNo()).isEqualTo(boardNo);
assertThat(dto.getBoardName()).isEqualTo(INSERT_BOARD_NAME);
assertThat(dto.getSkinTypeCode()).isEqualTo(INSERT_SKIN_TYPE_CODE);
assertThat(dto.getTitleDisplayLength()).isEqualTo(INSERT_TITLE_DISPLAY_LENGTH);
assertThat(dto.getPostDisplayCount()).isEqualTo(INSERT_POST_DISPLAY_COUNT);
assertThat(dto.getPageDisplayCount()).isEqualTo(INSERT_PAGE_DISPLAY_COUNT);
assertThat(dto.getNewDisplayDayCount()).isEqualTo(INSERT_NEW_DISPLAY_COUNT);
assertThat(dto.getEditorUseAt()).isEqualTo(INSERT_EDITOR_USE_AT);
assertThat(dto.getUploadUseAt()).isEqualTo(INSERT_UPLOAD_USE_AT);
assertThat(dto.getUserWriteAt()).isEqualTo(INSERT_USER_WRITE_AT);
assertThat(dto.getCommentUseAt()).isEqualTo(INSERT_COMMENT_USE_AT);
assertThat(dto.getUploadLimitCount()).isEqualTo(INSERT_UPLOAD_FILE_COUNT);
assertThat(dto.getUploadLimitSize()).isEqualTo(INSERT_UPLOAD_LIMIT_SIZE);
deleteBoard(boardNo);
}
/**
* 게시판 등록 테스트
*/
@Test
void 게시판_등록() {
log.info("###게시판_등록");
// given
Map<String, Object> params = new HashMap<>();
params.put("boardName", INSERT_BOARD_NAME);
params.put("skinTypeCode", INSERT_SKIN_TYPE_CODE);
params.put("titleDisplayLength", INSERT_TITLE_DISPLAY_LENGTH);
params.put("postDisplayCount", INSERT_POST_DISPLAY_COUNT);
params.put("pageDisplayCount", INSERT_PAGE_DISPLAY_COUNT);
params.put("newDisplayDayCount", INSERT_NEW_DISPLAY_COUNT);
params.put("editorUseAt", INSERT_EDITOR_USE_AT);
params.put("uploadUseAt", INSERT_UPLOAD_USE_AT);
params.put("userWriteAt", INSERT_USER_WRITE_AT);
params.put("commentUseAt", INSERT_COMMENT_USE_AT);
params.put("uploadLimitCount", INSERT_UPLOAD_FILE_COUNT);
params.put("uploadLimitSize", INSERT_UPLOAD_LIMIT_SIZE);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
// when
//ResponseEntity<PostsResponseDto> responseEntity = restTemplate.postForEntity(URL, requestDto, PostsResponseDto.class);
ResponseEntity<BoardResponseDto> responseEntity = restTemplate.exchange(
URL,
HttpMethod.POST,
httpEntity,
new ParameterizedTypeReference<BoardResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
BoardResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
final Integer boardNo = dto.getBoardNo();
Optional<Board> board = selectData(boardNo);
assertThat(board).isPresent();
Board entity = board.get();
assertThat(entity.getBoardNo()).isEqualTo(boardNo);
assertThat(entity.getBoardName()).isEqualTo(INSERT_BOARD_NAME);
assertThat(entity.getSkinTypeCode()).isEqualTo(INSERT_SKIN_TYPE_CODE);
assertThat(entity.getTitleDisplayLength()).isEqualTo(INSERT_TITLE_DISPLAY_LENGTH);
assertThat(entity.getPostDisplayCount()).isEqualTo(INSERT_POST_DISPLAY_COUNT);
assertThat(entity.getPageDisplayCount()).isEqualTo(INSERT_PAGE_DISPLAY_COUNT);
assertThat(entity.getNewDisplayDayCount()).isEqualTo(INSERT_NEW_DISPLAY_COUNT);
assertThat(entity.getEditorUseAt()).isEqualTo(INSERT_EDITOR_USE_AT);
assertThat(entity.getUploadUseAt()).isEqualTo(INSERT_UPLOAD_USE_AT);
assertThat(entity.getUserWriteAt()).isEqualTo(INSERT_USER_WRITE_AT);
assertThat(entity.getCommentUseAt()).isEqualTo(INSERT_COMMENT_USE_AT);
assertThat(entity.getUploadLimitCount()).isEqualTo(INSERT_UPLOAD_FILE_COUNT);
assertThat(entity.getUploadLimitSize()).isEqualTo(INSERT_UPLOAD_LIMIT_SIZE);
deleteBoard(boardNo);
}
/**
* 게시판 수정 테스트
*/
@Test
void 게시판_수정() {
log.info("###게시판_수정");
// given
Board entity = insertBoard();
final Integer boardNo = entity.getBoardNo();
Map<String, Object> params = new HashMap<>();
params.put("boardName", UPDATE_BOARD_NAME);
params.put("skinTypeCode", UPDATE_SKIN_TYPE_CODE);
params.put("titleDisplayLength", UPDATE_TITLE_DISPLAY_LENGTH);
params.put("postDisplayCount", UPDATE_POST_DISPLAY_COUNT);
params.put("pageDisplayCount", UPDATE_PAGE_DISPLAY_COUNT);
params.put("newDisplayDayCount", UPDATE_NEW_DISPLAY_COUNT);
params.put("editorUseAt", UPDATE_EDITOR_USE_AT);
params.put("uploadUseAt", UPDATE_UPLOAD_USE_AT);
params.put("userWriteAt", UPDATE_USER_WRITE_AT);
params.put("commentUseAt", UPDATE_COMMENT_USE_AT);
params.put("uploadLimitCount", UPDATE_UPLOAD_FILE_COUNT);
params.put("uploadLimitSize", UPDATE_UPLOAD_LIMIT_SIZE);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
String url = URL + "/" + boardNo;
// when
ResponseEntity<BoardResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
new ParameterizedTypeReference<BoardResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
BoardResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
Optional<Board> board = selectData(boardNo);
assertThat(board).isPresent();
Board updatedBoard = board.get();
assertThat(updatedBoard.getBoardNo()).isEqualTo(boardNo);
assertThat(updatedBoard.getBoardName()).isEqualTo(UPDATE_BOARD_NAME);
assertThat(updatedBoard.getSkinTypeCode()).isEqualTo(UPDATE_SKIN_TYPE_CODE);
assertThat(updatedBoard.getTitleDisplayLength()).isEqualTo(UPDATE_TITLE_DISPLAY_LENGTH);
assertThat(updatedBoard.getPostDisplayCount()).isEqualTo(UPDATE_POST_DISPLAY_COUNT);
assertThat(updatedBoard.getPageDisplayCount()).isEqualTo(UPDATE_PAGE_DISPLAY_COUNT);
assertThat(updatedBoard.getNewDisplayDayCount()).isEqualTo(UPDATE_NEW_DISPLAY_COUNT);
assertThat(updatedBoard.getEditorUseAt()).isEqualTo(UPDATE_EDITOR_USE_AT);
assertThat(updatedBoard.getUploadUseAt()).isEqualTo(UPDATE_UPLOAD_USE_AT);
assertThat(updatedBoard.getUserWriteAt()).isEqualTo(UPDATE_USER_WRITE_AT);
assertThat(updatedBoard.getCommentUseAt()).isEqualTo(UPDATE_COMMENT_USE_AT);
assertThat(updatedBoard.getUploadLimitCount()).isEqualTo(UPDATE_UPLOAD_FILE_COUNT);
assertThat(updatedBoard.getUploadLimitSize()).isEqualTo(UPDATE_UPLOAD_LIMIT_SIZE);
deleteBoard(boardNo);
}
/**
* 게시판 삭제 테스트
*/
@Test
void 게시판_삭제() {
log.info("###게시판_삭제");
// given
Board entity = insertBoard();
final Integer boardNo = entity.getBoardNo();
String url = URL + "/" + boardNo;
// when
ResponseEntity<BoardResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.DELETE,
null,
BoardResponseDto.class
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
Optional<Board> board = selectData(boardNo);
assertThat(board).isNotPresent();
}
/**
* 테스트 데이터 등록
*/
private void insertBoards() {
log.info("###테스트 데이터 등록");
List<Board> list = new ArrayList<>();
for (int i = 1; i <= GIVEN_DATA_COUNT; i++) {
list.add(Board.builder()
.boardName(BOARD_NAME_PREFIX + "_" + i)
.skinTypeCode(SKIN_TYPE_CODE_PREFIX + "_" + i)
.titleDisplayLength(INSERT_TITLE_DISPLAY_LENGTH + i)
.postDisplayCount(INSERT_POST_DISPLAY_COUNT + i)
.pageDisplayCount(INSERT_PAGE_DISPLAY_COUNT + i)
.newDisplayDayCount(INSERT_NEW_DISPLAY_COUNT + i)
.editorUseAt(i % 2 == 1)
.uploadUseAt(i % 3 == 0)
.userWriteAt(i % 3 == 0)
.commentUseAt(i % 2 == 0)
.uploadLimitCount(INSERT_UPLOAD_FILE_COUNT + i)
.uploadLimitSize(INSERT_UPLOAD_LIMIT_SIZE.add(new BigDecimal(String.valueOf(i))))
.build());
}
boardRepository.saveAll(list);
}
/**
* 테스트 데이터 단건 등록
*
* @return Board 게시판 엔티티
*/
private Board insertBoard() {
log.info("###테스트 데이터 단건 등록");
return boardRepository.save(Board.builder()
.boardName(INSERT_BOARD_NAME)
.skinTypeCode(INSERT_SKIN_TYPE_CODE)
.titleDisplayLength(INSERT_TITLE_DISPLAY_LENGTH)
.postDisplayCount(INSERT_POST_DISPLAY_COUNT)
.pageDisplayCount(INSERT_PAGE_DISPLAY_COUNT)
.newDisplayDayCount(INSERT_NEW_DISPLAY_COUNT)
.editorUseAt(INSERT_EDITOR_USE_AT)
.uploadUseAt(INSERT_UPLOAD_USE_AT)
.userWriteAt(INSERT_USER_WRITE_AT)
.commentUseAt(INSERT_COMMENT_USE_AT)
.uploadLimitCount(INSERT_UPLOAD_FILE_COUNT)
.uploadLimitSize(INSERT_UPLOAD_LIMIT_SIZE)
.build());
}
/**
* 테스트 데이터 단건 삭제
*/
private void deleteBoard(Integer boardNo) {
log.info("###테스트 데이터 단건 삭제");
boardRepository.deleteById(boardNo);
}
/**
* 테스트 데이터 단건 조회
*
* @param boardNo 게시판 번호
* @return Optional<Board> 게시판 엔티티
*/
private Optional<Board> selectData(Integer boardNo) {
log.info("###테스트 데이터 단건 조회");
return boardRepository.findById(boardNo);
}
}

585
backend/board-service/src/test/java/org/egovframe/cloud/boardservice/api/comment/CommentApiControllerTest.java Normal file
View File

@@ -0,0 +1,585 @@
package org.egovframe.cloud.boardservice.api.comment;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.egovframe.cloud.boardservice.api.board.dto.BoardResponseDto;
import org.egovframe.cloud.boardservice.api.comment.dto.CommentResponseDto;
import org.egovframe.cloud.boardservice.domain.board.Board;
import org.egovframe.cloud.boardservice.domain.board.BoardRepository;
import org.egovframe.cloud.boardservice.domain.comment.Comment;
import org.egovframe.cloud.boardservice.domain.comment.CommentId;
import org.egovframe.cloud.boardservice.domain.comment.CommentRepository;
import org.egovframe.cloud.boardservice.domain.posts.Posts;
import org.egovframe.cloud.boardservice.domain.posts.PostsId;
import org.egovframe.cloud.boardservice.domain.posts.PostsRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import lombok.extern.slf4j.Slf4j;
/**
* org.egovframe.cloud.boardservice.api.posts.CommentApiControllerTest
* <p>
* 댓글 Rest API 컨트롤러 클래스
*
* @author 표준프레임워크센터 jooho
* @version 1.0
* @since 2021/08/11
*
* <pre>
* << 개정이력(Modification Information) >>
*
* 수정일 수정자 수정내용
* ---------- -------- ---------------------------
* 2021/08/11 jooho 최초 생성
* </pre>
*/
@Slf4j
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@EnableConfigurationProperties
@TestPropertySource(properties = {"spring.config.location=classpath:application-test.yml"})
@ActiveProfiles(profiles = "test")
class CommentApiControllerTest {
/**
* test rest template
*/
@Autowired
TestRestTemplate restTemplate;
/**
* 게시판 레파지토리 인터페이스
*/
@Autowired
BoardRepository boardRepository;
/**
* 게시물 레파지토리 인터페이스
*/
@Autowired
PostsRepository postsRepository;
/**
* 댓글 레파지토리 인터페이스
*/
@Autowired
CommentRepository commentRepository;
/**
* 게시판 API 경로
*/
private static final String URL = "/api/v1/comments";
/**
* 테스트 데이터 등록 횟수
*/
private final Integer GIVEN_DATA_COUNT = 10;
/**
* 테스트 데이터
*/
private Board board;
private Posts posts;
private final Integer INSERT_COMMENT_NO = 1;
private final String INSERT_COMMENT_CONTENT = "댓글 내용";
private final String UPDATE_COMMENT_CONTENT = "댓글 내용 수정";
/**
* 테스트 시작 전 수행
*/
@BeforeEach
void setUp() {
log.info("###setUp");
// 게시판 등록
board = boardRepository.save(Board.builder()
.boardName("일반게시판1")
.skinTypeCode("normal")
.titleDisplayLength(50)
.postDisplayCount(50)
.pageDisplayCount(50)
.newDisplayDayCount(50)
.editorUseAt(true)
.uploadUseAt(true)
.uploadLimitCount(50)
.uploadLimitSize(new BigDecimal("52428800"))
.userWriteAt(true)
.commentUseAt(true)
.build());
// 게시물 등록
posts = postsRepository.save(Posts.builder()
.board(board)
.postsId(PostsId.builder()
.boardNo(board.getBoardNo())
.postsNo(1)
.build())
.postsTitle("게시물 1")
.postsContent("게시물 내용 1")
.postsAnswerContent("게시물 답변 내용 1")
.attachmentCode("0000000001")
.readCount(0)
.noticeAt(false)
.deleteAt(0)
.build());
}
/**
* 테스트 종료 후 수행
*/
@AfterEach
void tearDown() {
log.info("###tearDown");
// 댓글 삭제
commentRepository.deleteAll();
// 게시물 삭제
postsRepository.deleteAll();
// 게시판 삭제
boardRepository.deleteAll();
}
/**
* 게시글의 전체 댓글 목록 조회
*/
@Test
void 게시글의_전체_댓글_목록_조회() {
log.info("###게시글의_전체_댓글_목록_조회");
// given
insertComments();
final String url = URL + "/total/" + posts.getPostsId().getBoardNo() + "/" + posts.getPostsId().getPostsNo();
// when
ResponseEntity<Map<String, Object>> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<Map<String, Object>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
Map<String, Object> data = responseEntity.getBody();
assertThat(data).isNotNull();
assertThat(data.get("numberOfElements")).isEqualTo(GIVEN_DATA_COUNT);
assertThat(data.get("totalElements")).isEqualTo(GIVEN_DATA_COUNT);
assertThat(data.get("totalPages")).isEqualTo(1);
}
/**
* 게시글의 전체 미삭제 댓글 목록 조회
*/
@Test
void 게시글의_전체_미삭제_댓글_목록_조회() {
log.info("###게시글의_전체_미삭제_댓글_목록_조회");
// given
insertComments();
final String url = URL + "/all/" + posts.getPostsId().getBoardNo() + "/" + posts.getPostsId().getPostsNo();
// when
ResponseEntity<Map<String, Object>> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<Map<String, Object>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
Map<String, Object> data = responseEntity.getBody();
assertThat(data).isNotNull();
assertThat(data.get("numberOfElements")).isEqualTo(GIVEN_DATA_COUNT / 3);
assertThat(data.get("totalElements")).isEqualTo(GIVEN_DATA_COUNT / 3);
assertThat(data.get("totalPages")).isEqualTo(1);
}
/**
* 게시글의 댓글 목록 조회
*/
@Test
void 게시글의_댓글_목록_조회() {
log.info("###게시글의_댓글_목록_조회");
// given
insertComments();
final Integer page = 0;
final Integer size = 5;
final String url = URL + "/" + posts.getPostsId().getBoardNo() + "/" + posts.getPostsId().getPostsNo() + "?page=" + page + "&size=" + size;
// when
ResponseEntity<Map<String, Object>> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<Map<String, Object>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
Map<String, Object> data = responseEntity.getBody();
assertThat(data).isNotNull();
assertThat(data.get("numberOfElements")).isEqualTo(size);
assertThat(data.get("totalElements")).isEqualTo(GIVEN_DATA_COUNT);
assertThat(data.get("totalPages")).isEqualTo(GIVEN_DATA_COUNT / size);
}
/**
* 게시글의 미삭제 댓글 목록 조회
*/
@Test
void 게시글의_미삭제_댓글_목록_조회() {
log.info("###게시글의_미삭제_댓글_목록_조회");
// given
insertComments();
final Integer page = 0;
final Integer size = 5;
final String url = URL + "/list/" + posts.getPostsId().getBoardNo() + "/" + posts.getPostsId().getPostsNo() + "?page=" + page + "&size=" + size;
// when
ResponseEntity<Map<String, Object>> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<Map<String, Object>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
Map<String, Object> data = responseEntity.getBody();
assertThat(data).isNotNull();
assertThat(data.get("numberOfElements")).isEqualTo(GIVEN_DATA_COUNT / 3);
assertThat(data.get("totalElements")).isEqualTo(GIVEN_DATA_COUNT / 3);
assertThat(data.get("totalPages")).isEqualTo(1);
}
/**
* 댓글 등록
*/
@Test
void 댓글_등록() {
log.info("###댓글_등록");
// given
Map<String, Object> params = new HashMap<>();
params.put("boardNo", posts.getPostsId().getBoardNo());
params.put("postsNo", posts.getPostsId().getPostsNo());
params.put("commentContent", INSERT_COMMENT_CONTENT);
params.put("depthSeq", 0);
params.put("parentCommentNo", null);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
// when
ResponseEntity<CommentResponseDto> responseEntity = restTemplate.exchange(
URL,
HttpMethod.POST,
httpEntity,
new ParameterizedTypeReference<CommentResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
CommentResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
final Integer boardNo = dto.getBoardNo();
final Integer postsNo = dto.getPostsNo();
final Integer commentNo = dto.getCommentNo();
Optional<Comment> comment = selectData(boardNo, postsNo, commentNo);
assertThat(comment).isPresent();
Comment entity = comment.get();
assertThat(entity.getCommentId().getPostsId().getBoardNo()).isEqualTo(boardNo);
assertThat(entity.getCommentId().getPostsId().getPostsNo()).isEqualTo(postsNo);
assertThat(entity.getCommentId().getCommentNo()).isEqualTo(commentNo);
assertThat(entity.getCommentContent()).isEqualTo(INSERT_COMMENT_CONTENT);
assertThat(entity.getParentCommentNo()).isNull();
assertThat(entity.getDeleteAt()).isZero();
}
/**
* 댓글 수정 작성자체크
*/
@Test
void 댓글_수정_작성자체크() {
log.info("###댓글_수정 작성자체크");
// given
Comment entity = insertComment();
final Integer boardNo = entity.getCommentId().getPostsId().getBoardNo();
final Integer postsNo = entity.getCommentId().getPostsId().getPostsNo();
final Integer commentNo = entity.getCommentId().getCommentNo();
Map<String, Object> params = new HashMap<>();
params.put("boardNo", boardNo);
params.put("postsNo", postsNo);
params.put("commentNo", commentNo);
params.put("commentContent", UPDATE_COMMENT_CONTENT);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
String url = URL + "/update";
// when
ResponseEntity<CommentResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
new ParameterizedTypeReference<CommentResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); // 본인글 아닌 경우 예외 발생
}
/**
* 댓글 삭제 작성자체크
*/
@Test
void 댓글_삭제_작성자체크() {
log.info("###댓글_삭제 작성자체크");
// given
Comment entity = insertComment();
final Integer boardNo = entity.getCommentId().getPostsId().getBoardNo();
final Integer postsNo = entity.getCommentId().getPostsId().getPostsNo();
final Integer commentNo = entity.getCommentId().getCommentNo();
String url = URL + "/delete/" + boardNo + "/" + postsNo + "/" + commentNo;
// when
ResponseEntity<BoardResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.DELETE,
null,
BoardResponseDto.class
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); // 관리자권한 or 본인글 아닌 경우 예외 발생
}
/**
* 댓글 수정
*/
@Test
void 댓글_수정() {
log.info("###댓글_수정");
// given
Comment entity = insertComment();
final Integer boardNo = entity.getCommentId().getPostsId().getBoardNo();
final Integer postsNo = entity.getCommentId().getPostsId().getPostsNo();
final Integer commentNo = entity.getCommentId().getCommentNo();
Map<String, Object> params = new HashMap<>();
params.put("boardNo", boardNo);
params.put("postsNo", postsNo);
params.put("commentNo", commentNo);
params.put("commentContent", UPDATE_COMMENT_CONTENT);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
// when
ResponseEntity<CommentResponseDto> responseEntity = restTemplate.exchange(
URL,
HttpMethod.PUT,
httpEntity,
new ParameterizedTypeReference<CommentResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
CommentResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
Optional<Comment> comment = selectData(boardNo, postsNo, commentNo);
assertThat(comment).isPresent();
Comment updatedComment = comment.get();
assertThat(updatedComment.getCommentId().getPostsId().getBoardNo()).isEqualTo(boardNo);
assertThat(updatedComment.getCommentId().getPostsId().getPostsNo()).isEqualTo(postsNo);
assertThat(updatedComment.getCommentId().getCommentNo()).isEqualTo(commentNo);
assertThat(updatedComment.getCommentContent()).isEqualTo(UPDATE_COMMENT_CONTENT);
}
/**
* 댓글 삭제
*/
@Test
void 댓글_삭제() {
log.info("###댓글_삭제");
// given
Comment entity = insertComment();
final Integer boardNo = entity.getCommentId().getPostsId().getBoardNo();
final Integer postsNo = entity.getCommentId().getPostsId().getPostsNo();
final Integer commentNo = entity.getCommentId().getCommentNo();
String url = URL + "/" + boardNo + "/" + postsNo + "/" + commentNo;
// when
ResponseEntity<BoardResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.DELETE,
null,
BoardResponseDto.class
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
Optional<Comment> comment = selectData(boardNo, postsNo, commentNo);
assertThat(comment).isPresent();
Comment deletedComment = comment.get();
assertThat(deletedComment.getCommentId().getPostsId().getBoardNo()).isEqualTo(boardNo);
assertThat(deletedComment.getCommentId().getPostsId().getPostsNo()).isEqualTo(postsNo);
assertThat(deletedComment.getCommentId().getCommentNo()).isEqualTo(commentNo);
assertThat(deletedComment.getDeleteAt()).isNotZero();
}
/**
* 테스트 데이터 등록
*/
private void insertComments() {
log.info("###테스트 데이터 등록");
// 댓글 등록
List<Comment> list = new ArrayList<>();
for (int i = 1; i <= GIVEN_DATA_COUNT; i++) {
list.add(Comment.builder()
.posts(posts)
.commentId(CommentId.builder()
.postsId(PostsId.builder()
.boardNo(posts.getPostsId().getBoardNo())
.postsNo(posts.getPostsId().getPostsNo())
.build())
.commentNo(i)
.build())
.commentContent(INSERT_COMMENT_CONTENT + i)
.groupNo(i)
.depthSeq(0)
.sortSeq(i)
.deleteAt(i % 3)
.build());
}
commentRepository.saveAll(list);
}
/**
* 테스트 데이터 단건 등록
*
* @return Comment 댓글 엔티티
*/
private Comment insertComment() {
log.info("###테스트 데이터 단건 등록");
return commentRepository.save(Comment.builder()
.posts(posts)
.commentId(CommentId.builder()
.postsId(PostsId.builder()
.boardNo(posts.getPostsId().getBoardNo())
.postsNo(posts.getPostsId().getPostsNo())
.build())
.commentNo(INSERT_COMMENT_NO)
.build())
.commentContent(INSERT_COMMENT_CONTENT)
.groupNo(INSERT_COMMENT_NO)
.depthSeq(0)
.sortSeq(INSERT_COMMENT_NO)
.deleteAt(0)
.build());
}
/**
* 테스트 데이터 단건 삭제
*/
/*private void deleteComment(Comment comment) {
log.info("###테스트 데이터 단건 삭제");
commentRepository.deleteById(comment.getCommentId());
}*/
/**
* 테스트 데이터 삭제
*/
/*private void deleteComments() {
log.info("###테스트 데이터 삭제");
commentRepository.deleteAll(comments);
comments.clear();
}*/
/**
* 테스트 데이터 단건 조회
*
* @param boardNo 게시판 번호
* @param postsNo 게시물 번호
* @param commentNo 댓글 번호
* @return Optional<Comment> 댓글 엔티티
*/
private Optional<Comment> selectData(Integer boardNo, Integer postsNo, Integer commentNo) {
log.info("###테스트 데이터 단건 조회");
return commentRepository.findById(CommentId.builder()
.postsId(PostsId.builder()
.boardNo(boardNo)
.postsNo(postsNo)
.build())
.commentNo(commentNo)
.build());
}
}

730
backend/board-service/src/test/java/org/egovframe/cloud/boardservice/api/posts/PostsApiControllerTest.java Normal file
View File

@@ -0,0 +1,730 @@
package org.egovframe.cloud.boardservice.api.posts;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.apache.commons.lang.StringUtils;
import org.assertj.core.api.Condition;
import org.egovframe.cloud.boardservice.api.posts.dto.PostsListResponseDto;
import org.egovframe.cloud.boardservice.api.posts.dto.PostsResponseDto;
import org.egovframe.cloud.boardservice.domain.board.Board;
import org.egovframe.cloud.boardservice.domain.board.BoardRepository;
import org.egovframe.cloud.boardservice.domain.posts.Posts;
import org.egovframe.cloud.boardservice.domain.posts.PostsId;
import org.egovframe.cloud.boardservice.domain.posts.PostsRepository;
import org.egovframe.cloud.boardservice.util.RestResponsePage;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
/**
* org.egovframe.cloud.boardservice.api.posts.PostsApiControllerTest
* <p>
* 게시물 Rest API 컨트롤러 클래스
*
* @author 표준프레임워크센터 jooho
* @version 1.0
* @since 2021/08/10
*
* <pre>
* << 개정이력(Modification Information) >>
*
* 수정일 수정자 수정내용
* ---------- -------- ---------------------------
* 2021/08/10 jooho 최초 생성
* </pre>
*/
@Slf4j
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@EnableConfigurationProperties
@TestPropertySource(properties = {"spring.config.location=classpath:application-test.yml"})
@ActiveProfiles(profiles = "test")
class PostsApiControllerTest {
/**
* test rest template
*/
@Autowired
TestRestTemplate restTemplate;
/**
* 게시판 레파지토리 인터페이스
*/
@Autowired
BoardRepository boardRepository;
/**
* 게시물 레파지토리 인터페이스
*/
@Autowired
PostsRepository postsRepository;
/**
* 게시물 API 경로
*/
private static final String URL = "/api/v1/posts";
/**
* 테스트 데이터 등록 횟수
*/
private final Integer GIVEN_DATA_COUNT = 10;
/**
* 테스트 데이터
*/
private Board board;
private List<Posts> posts = new ArrayList<>();
private final Integer INSERT_POSTS_NO = 1;
private final String INSERT_POSTS_TITLE = "게시물 제목";
private final String INSERT_POSTS_CONTENT = "게시물 내용";
private final String INSERT_POSTS_ANSWER_CONTENT = "게시물 답변 내용";
private final String INSERT_ATTACHMENT_CODE = "0000000001";
private final Integer INSERT_READ_COUNT = 0;
private final Boolean INSERT_NOTICE_AT = true;
private final String UPDATE_POSTS_TITLE = "게시물 제목 수정";
private final String UPDATE_POSTS_CONTENT = "게시물 내용 수정";
private final String UPDATE_POSTS_ANSWER_CONTENT = "게시물 답변 내용 수정";
private final String UPDATE_ATTACHMENT_CODE = "0000000002";
private final Boolean UPDATE_NOTICE_AT = false;
/**
* 테스트 시작 전 수행
*/
@BeforeEach
void setUp() {
log.info("###setUp");
// 게시판 등록
board = boardRepository.save(Board.builder()
.boardName("일반게시판1")
.skinTypeCode("normal")
.titleDisplayLength(50)
.postDisplayCount(50)
.pageDisplayCount(50)
.newDisplayDayCount(50)
.editorUseAt(true)
.uploadUseAt(true)
.uploadLimitCount(50)
.uploadLimitSize(new BigDecimal("52428800"))
.userWriteAt(false)
.commentUseAt(true)
.build());
}
/**
* 테스트 종료 후 수행
*/
@AfterEach
void tearDown() {
log.info("###tearDown");
postsRepository.deleteAll();
// 게시판 삭제
boardRepository.deleteAll();
}
/**
* 최근 게시물이 포함된 게시판 목록 조회
* @throws JsonProcessingException json exception
* @throws JsonMappingException json exception
*/
@Test
void 최근_게시물이_포함된_게시판_목록_조회() throws JsonMappingException, JsonProcessingException {
log.info("###최근_게시물이_포함된_게시판_목록_조회");
// given
insertPosts(null);
final Integer postsCount = 3;
final String url = URL + "/newest/" + board.getBoardNo() + "/" + postsCount;
// when
ResponseEntity<String> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<String>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
ObjectMapper mapper = new ObjectMapper();
JsonNode data = mapper.readTree(responseEntity.getBody());
JsonNode boardData = data.get(board.getBoardNo().toString());
assertThat(data).isNotNull();
assertThat(boardData.get("boardNo").asInt()).isEqualTo(board.getBoardNo());
assertThat(boardData.get("posts").isArray()).isTrue();
// assertThat(boardData.get("posts").size()).isEqualTo(postsCount); // h2에서 rownum을 계산하지 못해서 3건, 5건 조회될때가 있음.
}
/**
* 게시물 삭제포함 페이지 목록 조회
*/
@Test
void 게시물_삭제포함_페이지_목록_조회() {
log.info("###게시물_삭제포함_페이지_목록_조회");
// given
insertPosts(null);
String url = URL + "/" + board.getBoardNo();
String queryString = "?keywordType=postsTitle&keyword=" + INSERT_POSTS_TITLE; // 검색 조건
queryString += "&page=0&size=" + GIVEN_DATA_COUNT; // 페이지 정보
// when
ResponseEntity<RestResponsePage<PostsListResponseDto>> responseEntity = restTemplate.exchange(
url + queryString,
HttpMethod.GET,
null,
new ParameterizedTypeReference<RestResponsePage<PostsListResponseDto>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
RestResponsePage<PostsListResponseDto> page = responseEntity.getBody();
assertThat(page).isNotNull();
assertThat(page.getNumberOfElements()).isEqualTo(GIVEN_DATA_COUNT);
assertThat(page.getContent())
.isNotEmpty()
.has(new Condition<>(l -> (INSERT_POSTS_TITLE + "9").equals(l.get(0).getPostsTitle()) && l.get(0).getNoticeAt(), "PostsApiControllerTest.findPage contains [notice] " + INSERT_POSTS_TITLE + "9"))
.has(new Condition<>(l -> (INSERT_POSTS_TITLE + "6").equals(l.get(1).getPostsTitle()) && l.get(0).getNoticeAt(), "PostsApiControllerTest.findPage contains [notice] " + INSERT_POSTS_TITLE + "6"));
}
/**
* 게시물 삭제제외 페이지 목록 조회
*/
@Test
void 게시물_삭제제외_페이지_목록_조회() {
log.info("###게시물_삭제제외_페이지_목록_조회");
// given
insertPosts(null);
String url = URL + "/list/" + board.getBoardNo();
String queryString = "?keywordType=postsTitle&keyword=" + INSERT_POSTS_TITLE; // 검색 조건
queryString += "&page=0&size=" + GIVEN_DATA_COUNT; // 페이지 정보
// when
ResponseEntity<RestResponsePage<PostsListResponseDto>> responseEntity = restTemplate.exchange(
url + queryString,
HttpMethod.GET,
null,
new ParameterizedTypeReference<RestResponsePage<PostsListResponseDto>>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
RestResponsePage<PostsListResponseDto> page = responseEntity.getBody();
assertThat(page).isNotNull();
assertThat(page.getNumberOfElements()).isEqualTo(GIVEN_DATA_COUNT / 2);
assertThat(page.getContent())
.isNotEmpty()
.has(new Condition<>(l -> (INSERT_POSTS_TITLE + "6").equals(l.get(0).getPostsTitle()) && l.get(0).getNoticeAt(), "PostsApiControllerTest.findPage contains [notice] " + INSERT_POSTS_TITLE + "6"))
.has(new Condition<>(l -> (INSERT_POSTS_TITLE + "10").equals(l.get(1).getPostsTitle()) && l.get(0).getNoticeAt(), "PostsApiControllerTest.findPage contains [notice] " + INSERT_POSTS_TITLE + "10"));
}
/**
* 게시물 삭제포함 단건 조회
*/
@Test
void 게시물_삭제포함_단건_조회() {
log.info("###게시물_삭제포함_단건_조회");
// given
final Posts post = insertPost(1);
String url = URL + "/" + post.getPostsId().getBoardNo() + "/" + post.getPostsId().getPostsNo();
// when
ResponseEntity<PostsResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<PostsResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
PostsResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
assertThat(dto.getBoardNo()).isEqualTo(post.getPostsId().getBoardNo());
assertThat(dto.getPostsNo()).isEqualTo(post.getPostsId().getPostsNo());
assertThat(dto.getPostsTitle()).isEqualTo(post.getPostsTitle());
assertThat(dto.getPostsContent()).isEqualTo(post.getPostsContent());
assertThat(dto.getPostsAnswerContent()).isEqualTo(post.getPostsAnswerContent());
assertThat(dto.getAttachmentCode()).isEqualTo(post.getAttachmentCode());
assertThat(dto.getReadCount()).isEqualTo(post.getReadCount() + 1);
assertThat(dto.getNoticeAt()).isEqualTo(post.getNoticeAt());
assertThat(dto.getDeleteAt()).isEqualTo(post.getDeleteAt());
}
/**
* 게시물 삭제제외 단건 조회
*/
@Test
void 게시물_삭제제외_단건_조회() {
log.info("###게시물_삭제제외_단건_조회");
// given
final Posts post = insertPost(1);
String url = URL + "/view/" + post.getPostsId().getBoardNo() + "/" + post.getPostsId().getPostsNo();
// when
ResponseEntity<PostsResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<PostsResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); // 삭제 게시물 조회 불가
}
/**
* 게시물 등록 작성자체크
*/
@Test
void 게시물_등록_작성자체크() {
log.info("###게시물_등록_작성자체크");
// given
String url = URL + "/save/" + board.getBoardNo();
Map<String, Object> params = new HashMap<>();
params.put("postsTitle", INSERT_POSTS_TITLE);
params.put("postsContent", INSERT_POSTS_CONTENT);
params.put("postsAnswerContent", INSERT_POSTS_ANSWER_CONTENT);
params.put("attachmentCode", INSERT_ATTACHMENT_CODE);
params.put("noticeAt", INSERT_NOTICE_AT);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
// when
ResponseEntity<PostsResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.POST,
httpEntity,
new ParameterizedTypeReference<PostsResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); // 게시판에 사용자 글쓰기 허용 X
}
/**
* 게시물 수정 작성자체크
*/
@Test
void 게시물_수정_작성자체크() {
log.info("###게시물_수정 작성자체크");
// given
Posts entity = insertPost(0);
final Integer boardNo = entity.getPostsId().getBoardNo();
final Integer postsNo = entity.getPostsId().getPostsNo();
Map<String, Object> params = new HashMap<>();
params.put("postsTitle", UPDATE_POSTS_TITLE);
params.put("postsContent", UPDATE_POSTS_CONTENT);
params.put("postsAnswerContent", UPDATE_POSTS_ANSWER_CONTENT);
params.put("attachmentCode", UPDATE_ATTACHMENT_CODE);
params.put("noticeAt", UPDATE_NOTICE_AT);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
String url = URL + "/update/" + boardNo + "/" + postsNo;
// when
ResponseEntity<PostsResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
new ParameterizedTypeReference<PostsResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); // 본인글 아닌 경우 예외 발생
}
/**
* 게시물 삭제 작성자체크
*/
@Test
void 게시물_삭제_작성자체크() {
log.info("###게시물_삭제 작성자체크");
// given
Posts entity = insertPost(0);
final Integer boardNo = entity.getPostsId().getBoardNo();
final Integer postsNo = entity.getPostsId().getPostsNo();
String url = URL + "/remove/" + boardNo + "/" + postsNo;
// when
ResponseEntity<Void> responseEntity = restTemplate.exchange(
url,
HttpMethod.DELETE,
null,
new ParameterizedTypeReference<Void>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST); // 본인글 아닌 경우 예외 발생
}
/**
* 게시물 등록
*/
@Test
void 게시물_등록() {
log.info("###게시물_등록");
// given
String url = URL + "/" + board.getBoardNo();
Map<String, Object> params = new HashMap<>();
params.put("postsTitle", INSERT_POSTS_TITLE);
params.put("postsContent", INSERT_POSTS_CONTENT);
params.put("postsAnswerContent", INSERT_POSTS_ANSWER_CONTENT);
params.put("attachmentCode", INSERT_ATTACHMENT_CODE);
params.put("noticeAt", INSERT_NOTICE_AT);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
// when
ResponseEntity<PostsResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.POST,
httpEntity,
new ParameterizedTypeReference<PostsResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
PostsResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
final Integer boardNo = dto.getBoardNo();
final Integer postsNo = dto.getPostsNo();
Optional<Posts> posts = selectData(boardNo, postsNo);
assertThat(posts).isPresent();
Posts entity = posts.get();
assertThat(entity.getPostsId().getBoardNo()).isEqualTo(boardNo);
assertThat(entity.getPostsId().getPostsNo()).isEqualTo(postsNo);
assertThat(entity.getPostsTitle()).isEqualTo(INSERT_POSTS_TITLE);
assertThat(entity.getPostsContent()).isEqualTo(INSERT_POSTS_CONTENT);
assertThat(entity.getPostsAnswerContent()).isEqualTo(INSERT_POSTS_ANSWER_CONTENT);
assertThat(entity.getAttachmentCode()).isEqualTo(INSERT_ATTACHMENT_CODE);
assertThat(entity.getReadCount()).isZero();
assertThat(entity.getNoticeAt()).isEqualTo(INSERT_NOTICE_AT);
assertThat(entity.getDeleteAt()).isZero();
}
/**
* 게시물 수정
*/
@Test
void 게시물_수정() {
log.info("###게시물_수정");
// given
Posts entity = insertPost(0);
final Integer boardNo = entity.getPostsId().getBoardNo();
final Integer postsNo = entity.getPostsId().getPostsNo();
Map<String, Object> params = new HashMap<>();
params.put("postsTitle", UPDATE_POSTS_TITLE);
params.put("postsContent", UPDATE_POSTS_CONTENT);
params.put("postsAnswerContent", UPDATE_POSTS_ANSWER_CONTENT);
params.put("attachmentCode", UPDATE_ATTACHMENT_CODE);
params.put("noticeAt", UPDATE_NOTICE_AT);
HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(params);
String url = URL + "/" + boardNo + "/" + postsNo;
// when
ResponseEntity<PostsResponseDto> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
new ParameterizedTypeReference<PostsResponseDto>() {
}
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
PostsResponseDto dto = responseEntity.getBody();
assertThat(dto).isNotNull();
Optional<Posts> posts = selectData(boardNo, postsNo);
assertThat(posts).isPresent();
Posts updatedPosts = posts.get();
assertThat(updatedPosts.getPostsId().getBoardNo()).isEqualTo(boardNo);
assertThat(updatedPosts.getPostsId().getPostsNo()).isEqualTo(postsNo);
assertThat(updatedPosts.getPostsTitle()).isEqualTo(UPDATE_POSTS_TITLE);
assertThat(updatedPosts.getPostsContent()).isEqualTo(UPDATE_POSTS_CONTENT);
assertThat(updatedPosts.getPostsAnswerContent()).isEqualTo(UPDATE_POSTS_ANSWER_CONTENT);
assertThat(updatedPosts.getAttachmentCode()).isEqualTo(UPDATE_ATTACHMENT_CODE);
assertThat(updatedPosts.getNoticeAt()).isEqualTo(UPDATE_NOTICE_AT);
}
/**
* 게시물 다건 삭제
*/
@Test
void 게시물_다건_삭제() {
log.info("###게시물_다건_삭제");
// given
insertPosts(false);
List<Map<String, Object>> params = new ArrayList<>();
for (Posts post : posts) {
Map<String, Object> param = new HashMap<>();
param.put("boardNo", post.getPostsId().getBoardNo());
param.put("postsNo", post.getPostsId().getPostsNo());
params.add(param);
}
HttpEntity<List<Map<String, Object>>> httpEntity = new HttpEntity<>(params);
String url = URL + "/remove";
// when
ResponseEntity<Long> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
Long.class
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getBody()).isEqualTo(posts.size());
List<Posts> list = postsRepository.findAll();
assertThat(list).isNotNull();
assertThat(list.size()).isEqualTo(posts.size());
for (Posts post : list) {
assertThat(post).isNotNull();
assertThat(post.getDeleteAt()).isNotZero();
}
}
/**
* 게시물 다건 복원
*/
@Test
void 게시물_다건_복원() {
log.info("###게시물_다건_복원");
// given
insertPosts(true);
List<Map<String, Object>> params = new ArrayList<>();
for (Posts post : posts) {
Map<String, Object> param = new HashMap<>();
param.put("boardNo", post.getPostsId().getBoardNo());
param.put("postsNo", post.getPostsId().getPostsNo());
params.add(param);
}
HttpEntity<List<Map<String, Object>>> httpEntity = new HttpEntity<>(params);
String url = URL + "/restore";
// when
ResponseEntity<Long> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
Long.class
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getBody()).isEqualTo(posts.size());
List<Posts> list = postsRepository.findAll();
assertThat(list).isNotNull();
assertThat(list.size()).isEqualTo(posts.size());
for (Posts post : list) {
assertThat(post).isNotNull();
assertThat(post.getDeleteAt()).isZero();
}
}
/**
* 게시물 다건 완전 삭제
*/
@Test
void 게시물_다건_완전_삭제() {
log.info("###게시물_다건_완전_삭제");
// given
insertPosts(null);
List<Map<String, Object>> params = new ArrayList<>();
for (Posts post : posts) {
Map<String, Object> param = new HashMap<>();
param.put("boardNo", post.getPostsId().getBoardNo());
param.put("postsNo", post.getPostsId().getPostsNo());
params.add(param);
}
HttpEntity<List<Map<String, Object>>> httpEntity = new HttpEntity<>(params);
String url = URL + "/delete";
// when
ResponseEntity<Long> responseEntity = restTemplate.exchange(
url,
HttpMethod.PUT,
httpEntity,
Long.class
);
// then
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
List<Posts> list = postsRepository.findAll();
assertThat(list).isNotNull();
assertThat(list.size()).isZero();
}
/**
* 테스트 데이터 등록
*/
private void insertPosts(Boolean deleteAt) {
log.info("###테스트 데이터 등록");
// 게시물 등록
List<Posts> list = new ArrayList<>();
for (int i = 1; i <= GIVEN_DATA_COUNT; i++) {
list.add(Posts.builder()
.board(board)
.postsId(PostsId.builder()
.boardNo(board.getBoardNo())
.postsNo(i)
.build())
.postsTitle(INSERT_POSTS_TITLE + i)
.postsContent(INSERT_POSTS_CONTENT + i)
.postsAnswerContent(INSERT_POSTS_ANSWER_CONTENT + i)
.attachmentCode(StringUtils.leftPad(String.valueOf(i), 10, '0'))
.readCount(0)
.noticeAt(i % 3 == 0)
.deleteAt(i % 2)
.build());
}
posts = postsRepository.saveAll(list);
}
/**
* 테스트 데이터 단건 등록
*
* @return Posts 게시물 엔티티
*/
private Posts insertPost(Integer deleteAt) {
log.info("###테스트 데이터 단건 등록");
return postsRepository.save(Posts.builder()
.board(board)
.postsId(PostsId.builder()
.boardNo(board.getBoardNo())
.postsNo(INSERT_POSTS_NO)
.build())
.postsTitle(INSERT_POSTS_TITLE + 1)
.postsContent(INSERT_POSTS_CONTENT + 1)
.postsAnswerContent(INSERT_POSTS_ANSWER_CONTENT + 1)
.attachmentCode(INSERT_ATTACHMENT_CODE)
.readCount(INSERT_READ_COUNT)
.noticeAt(INSERT_NOTICE_AT)
.deleteAt(deleteAt)
.build());
}
/**
* 테스트 데이터 단건 삭제
*/
/*private void deletePost(Posts post) {
postsRepository.deleteById(post.getPostsId());
}*/
/**
* 테스트 데이터 삭제
*/
/*private void deletePosts() {
postsRepository.deleteAll(posts);
posts.clear();
}*/
/**
* 테스트 데이터 단건 조회
*
* @param boardNo 게시판 번호
* @param postsNo 게시물 번호
* @return Optional<Posts> 게시물 엔티티
*/
private Optional<Posts> selectData(Integer boardNo, Integer postsNo) {
return postsRepository.findById(PostsId.builder().boardNo(boardNo).postsNo(postsNo).build());
}
}

93
backend/board-service/src/test/java/org/egovframe/cloud/boardservice/util/RestResponsePage.java Normal file
View File

@@ -0,0 +1,93 @@
package org.egovframe.cloud.boardservice.util;
import java.util.Collections;
import java.util.List;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.JsonNode;
/**
* org.egovframe.cloud.boardservice.util.RestResponsePage
* <p>
* 페이지 API 조회 시 JSON 형식의 응답 데이터를 페이지 객체를 구현하여 마이그레이션 해주는 클래스
*
* @author 표준프레임워크센터 jooho
* @version 1.0
* @since 2021/07/08
*
* <pre>
* << 개정이력(Modification Information) >>
*
* 수정일 수정자 수정내용
* ---------- -------- ---------------------------
* 2021/07/08 jooho 최초 생성
* </pre>
*/
public class RestResponsePage<T> extends PageImpl<T> {
/**
* serialVersionUID
*/
private static final long serialVersionUID = -4377617807230211193L;
/**
* Rest 응답 페이지 생성자
*
* @param content 목록
* @param number 페이지 번호
* @param size 조회할 데이터 수
* @param totalElements 총 데이터 수
* @param pageable 페이지 정보
* @param last 마지막
* @param totalPages 총 페이지
* @param sort 정렬
* @param first 처음
* @param numberOfElements 조회된 데이터 수
*/
@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
public RestResponsePage(@JsonProperty("content") List<T> content,
@JsonProperty("number") int number,
@JsonProperty("size") int size,
@JsonProperty("totalElements") Long totalElements,
@JsonProperty("pageable") JsonNode pageable,
@JsonProperty("last") boolean last,
@JsonProperty("totalPages") int totalPages,
@JsonProperty("sort") JsonNode sort,
@JsonProperty("first") boolean first,
@JsonProperty("numberOfElements") int numberOfElements) {
super(content, PageRequest.of(number, size), totalElements);
}
/**
* Rest 응답 페이지 생성자
*
* @param content 목록
* @param pageable 페이지 정보
* @param total 총 데이터 수
*/
public RestResponsePage(List<T> content, Pageable pageable, long total) {
super(content, pageable, total);
}
/**
* Rest 응답 페이지 생성자
*
* @param content 목록
*/
public RestResponsePage(List<T> content) {
super(content);
}
/**
* Rest 응답 페이지 생성자
*/
public RestResponsePage() {
super(Collections.emptyList());
}
}

46
backend/board-service/src/test/resources/application-test.yml Normal file
View File

@@ -0,0 +1,46 @@
spring:
application:
name: board-service
datasource:
url: jdbc:h2:mem:testdb;MODE=MYSQL;DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=false
username: sa
password:
driver-class-name: org.h2.Driver
jpa:
# database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
hibernate:
generate-ddl: true
ddl-auto: create-drop
# dialect: org.hibernate.dialect.MySQL5InnoDBDialect
properties:
hibernate:
format_sql: true
default_batch_fetch_size: 1000
show-sql: true
h2:
console:
enabled: true
path: /h2
logging.level:
org.hibernate.SQL: debug
file:
directory: ${user.home}/msa-attach-volume
messages:
directory: ${file.directory}/messages
# jwt token
token:
secret: egovframe_user_token
# ftp server
ftp:
enabled: false # ftp 사용 여부, FTP 서버에 최상위 디렉토리 자동 생성 및 구현체를 결정하게 된다.
# eureka 가 포함되면 eureka server 도 등록되므로 해제한다.
eureka:
client:
register-with-eureka: false
fetch-registry: false