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

✅ update test file

Browse Source
This commit is contained in:
shinmj
2021-10-28 10:52:11 +09:00
parent f0fe0ed6ff
commit c03f875162
20 changed files with 1057 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

517
backend/reserve-check-service/src/test/java/org/egovframe/cloud/reservechecksevice/api/ReserveApiControllerTest.java
View File

@@ -1,17 +1,530 @@
package org.egovframe.cloud.reservechecksevice.api;
import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;
import java.time.LocalDateTime;
import org.egovframe.cloud.common.domain.Role;
import org.egovframe.cloud.common.exception.dto.ErrorCode;
import org.egovframe.cloud.common.exception.dto.ErrorResponse;
import org.egovframe.cloud.reservechecksevice.api.reserve.dto.ReserveCancelRequestDto;
import org.egovframe.cloud.reservechecksevice.api.reserve.dto.ReserveListResponseDto;
import org.egovframe.cloud.reservechecksevice.api.reserve.dto.ReserveSaveRequestDto;
import org.egovframe.cloud.reservechecksevice.api.reserve.dto.ReserveUpdateRequestDto;
import org.egovframe.cloud.reservechecksevice.client.ReserveItemServiceClient;
import org.egovframe.cloud.reservechecksevice.client.UserServiceClient;
import org.egovframe.cloud.reservechecksevice.client.dto.ReserveItemRelationResponseDto;
import org.egovframe.cloud.reservechecksevice.client.dto.ReserveItemResponseDto;
import org.egovframe.cloud.reservechecksevice.client.dto.UserResponseDto;
import org.egovframe.cloud.reservechecksevice.domain.location.Location;
import org.egovframe.cloud.reservechecksevice.domain.reserve.Reserve;
import org.egovframe.cloud.reservechecksevice.domain.reserve.ReserveItem;
import org.egovframe.cloud.reservechecksevice.domain.reserve.ReserveRepository;
import org.egovframe.cloud.reservechecksevice.domain.reserve.ReserveStatus;
import org.egovframe.cloud.reservechecksevice.util.RestResponsePage;
import org.egovframe.cloud.reservechecksevice.util.WithCustomMockUser;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.BDDMockito;
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.mock.mockito.MockBean;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.web.reactive.server.WebTestClient;
import reactor.core.publisher.Mono;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@EnableConfigurationProperties
@TestPropertySource(properties = {"spring.config.location=classpath:application-test.yml"})
@ActiveProfiles(profiles = "test")
class ReserveApiControllerTest {
public class ReserveApiControllerTest {
@Autowired
private ReserveRepository reserveRepository;
@MockBean
private ReserveItemServiceClient reserveItemServiceClient;
@MockBean
private UserServiceClient userServiceClient;
}
@Autowired
private WebTestClient webTestClient;
private static final String API_URL = "/api/v1/reserves";
private UserResponseDto user;
private Location location;
private ReserveItem reserveItem;
private Reserve reserve;
@BeforeEach
public void setup() {
user = UserResponseDto.builder()
.roleId(Role.ADMIN.getKey())
.userId("user")
.build();
location = Location.builder()
.locationId(1L)
.locationName("location")
.build();
reserveItem = ReserveItem.builder()
.reserveItemId(1L)
.reserveItemName("test")
.locationId(location.getLocationId())
.location(location)
.categoryId("place")
.inventoryQty(100)
.totalQty(100)
.reserveMethodId("internet")
.reserveMeansId("realtime")
.requestStartDate(LocalDateTime.of(2021, 1, 1, 1, 1))
.requestEndDate(LocalDateTime.of(2021, 12, 31, 23, 59))
.operationStartDate(LocalDateTime.of(2021, 1, 1, 1, 1))
.operationEndDate(LocalDateTime.of(2021, 12, 31, 23, 59))
.build();
reserve = Reserve.builder()
.reserveId("1")
.reserveItemId(reserveItem.getReserveItemId())
.reserveQty(50)
.reservePurposeContent("test")
.reserveStatusId("request")
.reserveStartDate(LocalDateTime.of(2021, 9, 9, 1, 1))
.reserveEndDate(LocalDateTime.of(2021, 9, 20, 1, 1))
.userId(user.getUserId())
.userEmail("user@email.com")
.userContactNo("contact")
.build();
reserve.setReserveItem(reserveItem);
reserve.setUser(user);
}
@AfterEach
public void tearDown() {
reserveRepository.deleteAll().block();
}
@Test
public void 예약신청관리_목록_조회_성공() throws Exception {
//given
BDDMockito.when(userServiceClient.findByUserId(ArgumentMatchers.anyString()))
.thenReturn(Mono.just(user));
BDDMockito.when(reserveItemServiceClient.findByIdWithRelations(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemRelationResponseDto.builder().entity(reserveItem).build()));
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
//when
webTestClient.get()
.uri(API_URL + "?page=0&size=5")
.exchange()
.expectStatus().isOk()
.expectBody(new ParameterizedTypeReference<RestResponsePage<ReserveListResponseDto>>() {
})
.value(page -> {
//then
assertThat(page.getTotalElements()).isEqualTo(1L);
assertThat(page.getContent().get(0).getReserveId()).isEqualTo(reserve.getReserveId());
page.getContent().stream().forEach(System.out::println);
});
}
@Test
@WithCustomMockUser(userId = "admin", role = Role.ADMIN)
public void 관리자_취소_성공() throws Exception {
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
webTestClient.put()
.uri(API_URL + "/cancel/{reserveId}", saved.getReserveId())
.bodyValue(ReserveCancelRequestDto.builder().reasonCancelContent("reason for cancellation").build())
.exchange()
.expectStatus().isNoContent();
Reserve updated = reserveRepository.findById(saved.getReserveId()).block();
assertThat(updated.getReserveStatusId()).isEqualTo("cancel");
assertThat(updated.getReasonCancelContent()).isEqualTo("reason for cancellation");
}
@Test
@WithCustomMockUser(userId = "user", role = Role.USER)
public void 사용자_취소_성공() {
//given
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
//when
webTestClient.put()
.uri(API_URL + "/cancel/{reserveId}", saved.getReserveId())
.bodyValue(ReserveCancelRequestDto.builder().reasonCancelContent("reason for cancellation").build())
.exchange()
.expectStatus().isNoContent()
;
Reserve updated = reserveRepository.findById(saved.getReserveId()).block();
assertThat(updated.getReserveStatusId()).isEqualTo("cancel");
assertThat(updated.getReasonCancelContent()).isEqualTo("reason for cancellation");
}
@Test
@WithCustomMockUser(userId = "test", role = Role.USER)
public void 다른사용자_예약_취소_실패() throws Exception {
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
webTestClient.put()
.uri(API_URL + "/cancel/{reserveId}", saved.getReserveId())
.bodyValue(ReserveCancelRequestDto.builder().reasonCancelContent("reason for cancellation").build())
.exchange()
.expectStatus().isBadRequest()
.expectBody(ErrorResponse.class)
.value(response -> {
assertThat(response.getMessage()).isEqualTo("해당 예약은 취소할 수 없습니다.");
assertThat(response.getCode()).isEqualTo(ErrorCode.BUSINESS_CUSTOM_MESSAGE.getCode());
});
}
@Test
@WithCustomMockUser(userId = "user", role = Role.USER)
public void 예약상태_완료_취소_실패() throws Exception {
Reserve done = reserve.updateStatus(ReserveStatus.DONE.getKey());
Reserve saved = reserveRepository.insert(done).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
webTestClient.put()
.uri(API_URL + "/cancel/{reserveId}", saved.getReserveId())
.bodyValue(ReserveCancelRequestDto.builder().reasonCancelContent("reason for cancellation").build())
.exchange()
.expectBody(ErrorResponse.class)
.value(response -> {
assertThat(response.getMessage()).isEqualTo("해당 예약은 이미 실행되어 취소할 수 없습니다.");
assertThat(response.getCode()).isEqualTo(ErrorCode.BUSINESS_CUSTOM_MESSAGE.getCode());
});
;
}
@Test
@WithCustomMockUser(userId = "user", role = Role.USER)
public void 관리자가_아닌_경우_승인_실패() throws Exception {
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
webTestClient.put()
.uri(API_URL + "/approve/{reserveId}", saved.getReserveId())
.exchange()
.expectStatus().isBadRequest()
.expectBody(ErrorResponse.class)
.value(response -> {
assertThat(response.getMessage()).isEqualTo("관리자만 승인할 수 있습니다.");
});
}
@Test
@WithCustomMockUser(userId = "admin", role = Role.ADMIN)
public void 예약승인_성공() throws Exception {
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
webTestClient.put()
.uri(API_URL + "/approve/{reserveId}", saved.getReserveId())
.exchange()
.expectStatus().isNoContent();
Reserve updated = reserveRepository.findById(saved.getReserveId()).block();
assertThat(updated.getReserveStatusId()).isEqualTo("approve");
}
@Test
@WithCustomMockUser(userId = "admin", role = Role.ADMIN)
public void 예약승인_실패_재고부족() throws Exception {
ReserveItem failReserveItem = ReserveItem.builder()
.reserveItemId(1L)
.reserveItemName("test")
.locationId(location.getLocationId())
.location(location)
.categoryId("equipment")
.totalQty(20)
.inventoryQty(10)
.reserveMethodId("internet")
.reserveMeansId("realtime")
.isPeriod(false)
.requestStartDate(LocalDateTime.of(2021, 1, 1, 1, 1))
.requestEndDate(LocalDateTime.of(2021, 12, 31, 23, 59))
.operationStartDate(LocalDateTime.of(2021, 1, 1, 1, 1))
.operationEndDate(LocalDateTime.of(2021, 12, 31, 23, 59))
.build();
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(failReserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(false));
webTestClient.put()
.uri(API_URL + "/approve/{reserveId}", saved.getReserveId())
.exchange()
.expectStatus().isBadRequest()
.expectBody(ErrorResponse.class)
.value(response -> {
assertThat(response.getMessage()).isEqualTo("해당 날짜에 예약할 수 있는 재고수량이 없습니다.");
});
}
@Test
@WithCustomMockUser(userId = "admin", role = Role.ADMIN)
public void 관리자_예약정보_수정_성공() throws Exception {
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
ReserveUpdateRequestDto updateRequestDto =
ReserveUpdateRequestDto.builder()
.reserveItemId(saved.getReserveItemId())
.categoryId(saved.getReserveItem().getCategoryId())
.reservePurposeContent("purpose")
.reserveQty(10)
.reserveStartDate(saved.getReserveStartDate())
.reserveEndDate(saved.getReserveEndDate())
.attachmentCode(saved.getAttachmentCode())
.userId(saved.getUserId())
.userContactNo("contact update")
.userEmail(saved.getUserEmail())
.build();
webTestClient.put()
.uri(API_URL + "/{reserveId}", saved.getReserveId())
.bodyValue(updateRequestDto)
.exchange()
.expectStatus().isNoContent()
;
Reserve updated = reserveRepository.findById(saved.getReserveId()).block();
assertThat(updated.getReservePurposeContent()).isEqualTo("purpose");
assertThat(updated.getReserveQty()).isEqualTo(10);
assertThat(updated.getUserContactNo()).isEqualTo("contact update");
}
@Test
@WithCustomMockUser(userId = "test", role = Role.USER)
public void 다른사용자_예약정보_수정_실패() throws Exception {
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
ReserveUpdateRequestDto updateRequestDto =
ReserveUpdateRequestDto.builder()
.reserveItemId(saved.getReserveItemId())
.categoryId(saved.getReserveItem().getCategoryId())
.reservePurposeContent("purpose")
.reserveQty(10)
.reserveStartDate(saved.getReserveStartDate())
.reserveEndDate(saved.getReserveEndDate())
.attachmentCode(saved.getAttachmentCode())
.userId(saved.getUserId())
.userContactNo("contact update")
.userEmail(saved.getUserEmail())
.build();
webTestClient.put()
.uri(API_URL + "/{reserveId}", saved.getReserveId())
.bodyValue(updateRequestDto)
.exchange()
.expectStatus().isBadRequest()
.expectBody(ErrorResponse.class)
.value(response -> {
assertThat(response.getMessage()).isEqualTo("해당 예약은 수정할 수 없습니다.");
});
}
@Test
@WithCustomMockUser(userId = "user", role = Role.USER)
public void 사용자_예약정보_수정_성공() throws Exception {
Reserve saved = reserveRepository.insert(reserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
ReserveUpdateRequestDto updateRequestDto =
ReserveUpdateRequestDto.builder()
.reserveItemId(saved.getReserveItemId())
.categoryId(saved.getReserveItem().getCategoryId())
.reservePurposeContent("purpose")
.reserveQty(10)
.reserveStartDate(saved.getReserveStartDate())
.reserveEndDate(saved.getReserveEndDate())
.attachmentCode(saved.getAttachmentCode())
.userId(saved.getUserId())
.userContactNo("contact update")
.userEmail(saved.getUserEmail())
.build();
webTestClient.put()
.uri(API_URL + "/{reserveId}", saved.getReserveId())
.bodyValue(updateRequestDto)
.exchange()
.expectStatus().isNoContent()
;
Reserve updated = reserveRepository.findById(saved.getReserveId()).block();
assertThat(updated.getReservePurposeContent()).isEqualTo("purpose");
assertThat(updated.getReserveQty()).isEqualTo(10);
assertThat(updated.getUserContactNo()).isEqualTo("contact update");
}
@Test
@WithCustomMockUser(userId = "user", role = Role.USER)
public void 사용자_상태승인인예약정보_수정_실패() throws Exception {
Reserve failedReserve = reserve.withReserveStatusId(ReserveStatus.APPROVE.getKey());
Reserve saved = reserveRepository.insert(failedReserve).block();
assertNotNull(saved);
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(false));
ReserveUpdateRequestDto updateRequestDto =
ReserveUpdateRequestDto.builder()
.reserveItemId(saved.getReserveItemId())
.categoryId(saved.getReserveItem().getCategoryId())
.reservePurposeContent("purpose")
.reserveQty(10)
.reserveStartDate(saved.getReserveStartDate())
.reserveEndDate(saved.getReserveEndDate())
.attachmentCode(saved.getAttachmentCode())
.userId(saved.getUserId())
.userContactNo("contact update")
.userEmail(saved.getUserEmail())
.build();
webTestClient.put()
.uri(API_URL + "/{reserveId}", saved.getReserveId())
.bodyValue(updateRequestDto)
.exchange()
.expectStatus().isBadRequest()
.expectBody(ErrorResponse.class)
.value(response -> {
assertThat(response.getMessage()).isEqualTo("예약 신청 상태인 경우에만 수정 가능합니다.");
});
}
@Test
public void 관리자_예약_성공() throws Exception {
BDDMockito.when(reserveItemServiceClient.findById(ArgumentMatchers.anyLong()))
.thenReturn(Mono.just(ReserveItemResponseDto.builder().reserveItem(reserveItem).build()));
BDDMockito.when(reserveItemServiceClient.updateInventory(ArgumentMatchers.anyLong(), ArgumentMatchers.anyInt()))
.thenReturn(Mono.just(true));
ReserveSaveRequestDto saveRequestDto =
ReserveSaveRequestDto.builder()
.reserveItemId(reserve.getReserveItemId())
.categoryId(reserve.getReserveItem().getCategoryId())
.reservePurposeContent(reserve.getReservePurposeContent())
.reserveQty(reserve.getReserveQty())
.reserveStartDate(reserve.getReserveStartDate())
.reserveEndDate(reserve.getReserveEndDate())
.attachmentCode(reserve.getAttachmentCode())
.userId(reserve.getUserId())
.userContactNo(reserve.getUserContactNo())
.userEmail(reserve.getUserEmail())
.build();
webTestClient.post()
.uri(API_URL)
.bodyValue(saveRequestDto)
.exchange()
.expectStatus().isCreated();
Reserve saved = reserveRepository.findById(reserve.getReserveId()).block();
System.out.println(saved);
}
@Test
public void 예약신청_valid_실패() throws Exception {
ReserveItem validReserveItem = ReserveItem.builder()
.reserveItemId(1L)
.reserveItemName("test")
.locationId(location.getLocationId())
.location(location)
.categoryId("equipment")
.totalQty(100)
.inventoryQty(10)
.operationStartDate(LocalDateTime.of(2021, 10, 1, 1, 1))
.operationEndDate(LocalDateTime.of(2021, 10, 31, 23, 59))
.build();
reserve.setReserveItem(validReserveItem);
ReserveSaveRequestDto saveRequestDto =
ReserveSaveRequestDto.builder()
.reserveItemId(reserve.getReserveItemId())
.categoryId(reserve.getReserveItem().getCategoryId())
.reservePurposeContent(reserve.getReservePurposeContent())
.reserveQty(null)
.reserveStartDate(LocalDateTime.of(2021, 11, 1, 1, 1))
.reserveEndDate(reserve.getReserveEndDate())
.attachmentCode(reserve.getAttachmentCode())
.userId(reserve.getUserId())
.userContactNo(reserve.getUserContactNo())
.userEmail(reserve.getUserEmail())
.build();
webTestClient.post()
.uri(API_URL)
.bodyValue(saveRequestDto)
.exchange()
.expectStatus().isBadRequest()
;
}
}

11
backend/reserve-check-service/src/test/java/org/egovframe/cloud/reservechecksevice/config/R2dbcConfig.java
View File

@@ -1,9 +1,5 @@
package org.egovframe.cloud.reservechecksevice.config;
import io.r2dbc.h2.H2ConnectionConfiguration;
import io.r2dbc.h2.H2ConnectionFactory;
import io.r2dbc.h2.H2ConnectionOption;
import io.r2dbc.spi.ConnectionFactory;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
@@ -13,6 +9,11 @@ import org.springframework.r2dbc.connection.init.CompositeDatabasePopulator;
import org.springframework.r2dbc.connection.init.ConnectionFactoryInitializer;
import org.springframework.r2dbc.connection.init.ResourceDatabasePopulator;
import io.r2dbc.h2.H2ConnectionConfiguration;
import io.r2dbc.h2.H2ConnectionFactory;
import io.r2dbc.h2.H2ConnectionOption;
import io.r2dbc.spi.ConnectionFactory;
@Profile("test")
@TestConfiguration
@EnableR2dbcRepositories
@@ -20,7 +21,7 @@ public class R2dbcConfig {
@Bean
public H2ConnectionFactory connectionFactory() {
return new H2ConnectionFactory(H2ConnectionConfiguration.builder()
.tcp("localhost", "~/querydsl")
.inMemory("testdb")
.property(H2ConnectionOption.DB_CLOSE_DELAY, "-1")
.username("sa")
.build());

11
backend/reserve-check-service/src/test/java/org/egovframe/cloud/reservechecksevice/util/RestResponsePage.java
View File

@@ -1,14 +1,15 @@
package org.egovframe.cloud.reservechecksevice.util;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.JsonNode;
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 java.util.Collections;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.JsonNode;
/**
* org.egovframe.cloud.boardservice.util.RestResponsePage

6
backend/reserve-check-service/src/test/java/org/egovframe/cloud/reservechecksevice/util/WithCustomMockUser.java
View File

@@ -1,11 +1,11 @@
package org.egovframe.cloud.reservechecksevice.util;
import org.egovframe.cloud.common.domain.Role;
import org.springframework.security.test.context.support.WithSecurityContext;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import org.egovframe.cloud.common.domain.Role;
import org.springframework.security.test.context.support.WithSecurityContext;
@Retention(RetentionPolicy.RUNTIME)
@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory.class)
public @interface WithCustomMockUser {

6
backend/reserve-check-service/src/test/java/org/egovframe/cloud/reservechecksevice/util/WithMockCustomUserSecurityContextFactory.java
View File

@@ -1,14 +1,14 @@
package org.egovframe.cloud.reservechecksevice.util;
import java.util.ArrayList;
import java.util.List;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.test.context.support.WithSecurityContextFactory;
import java.util.ArrayList;
import java.util.List;
public class WithMockCustomUserSecurityContextFactory implements WithSecurityContextFactory<WithCustomMockUser> {
@Override

14
backend/reserve-check-service/src/test/resources/application-test.yml
View File

@@ -2,20 +2,6 @@ spring:
application:
name: reserve-check-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:
hibernate:
generate-ddl: true
ddl-auto: create-drop
properties:
hibernate:
format_sql: true
default_batch_fetch_size: 1000
show-sql: true
h2:
console:
enabled: true

70
backend/reserve-check-service/src/test/resources/schema-h2.sql
View File

@@ -1,72 +1,17 @@
-- location Table Create SQL
CREATE TABLE IF NOT EXISTS location
(
location_id BIGINT NOT NULL AUTO_INCREMENT COMMENT '지역 id',
location_name VARCHAR(200) NULL COMMENT '지역 이름',
sort_seq SMALLINT(3) NULL COMMENT '정렬 순서',
use_at TINYINT(1) NULL DEFAULT 1 COMMENT '사용 여부',
created_by VARCHAR(255) NULL COMMENT '생성자',
create_date DATETIME NULL COMMENT '생성일',
last_modified_by VARCHAR(255) NULL COMMENT '수정자',
modified_date DATETIME NULL COMMENT '수정일',
PRIMARY KEY (location_id)
) ;
-- reserve_item Table Create SQL
CREATE TABLE IF NOT EXISTS reserve_item
(
reserve_item_id BIGINT NOT NULL AUTO_INCREMENT COMMENT '예약 물품 id',
reserve_item_name VARCHAR(200) NULL COMMENT '예약 물품 이름',
location_id BIGINT NULL COMMENT '지역 id',
category_id VARCHAR(20) NULL COMMENT '예약유형 - 공통코드 reserve-category',
total_qty BIGINT(18) NULL COMMENT '총 재고/수용인원 수',
inventory_qty BIGINT(18) NULL COMMENT '현재 남은 재고/수용인원 수',
operation_start_date DATETIME NULL COMMENT '운영 시작 일',
operation_end_date DATETIME NULL COMMENT '운영 종료 일',
reserve_method_id VARCHAR(20) NULL COMMENT '예약 방법 - 공통코드 reserve-method',
reserve_means_id VARCHAR(20) NULL COMMENT '예약 구분 (인터넷 예약 시) - 공통코드 reserve-means',
request_start_date DATETIME NULL COMMENT '예약 신청 시작 일시',
request_end_date DATETIME NULL COMMENT '예약 신청 종료 일시',
period_at TINYINT(1) NULL DEFAULT 0 COMMENT '기간 지정 가능 여부 - true: 지정 가능, false: 지정 불가',
period_max_count SMALLINT(3) NULL COMMENT '최대 예약 가능 일 수',
external_url VARCHAR(500) NULL COMMENT '외부링크',
selection_means_id VARCHAR(20) NULL COMMENT '선별 방법 - 공통코드 reserve-selection-means',
free_at TINYINT(1) NULL DEFAULT 1 COMMENT '유/무료 - true: 무료, false: 유료',
usage_cost DECIMAL(18, 0) NULL COMMENT '이용 요금',
use_at TINYINT(1) NULL DEFAULT 1 COMMENT '사용 여부',
purpose_content VARCHAR(4000) NULL COMMENT '용도',
item_addr VARCHAR(500) NULL COMMENT '주소',
target_id VARCHAR(20) NULL COMMENT '이용 대상 - 공통코드 reserve-target',
excluded_content VARCHAR(2000) NULL COMMENT '사용허가 제외대상',
homepage_url VARCHAR(500) NULL COMMENT '홈페이지 url',
contact_no VARCHAR(50) NULL COMMENT '문의처',
manager_dept_name VARCHAR(200) NULL COMMENT '담당자 소속',
manager_name VARCHAR(200) NULL COMMENT '담당자 이름',
manager_contact_no VARCHAR(50) NULL COMMENT '담당자 연락처',
create_date DATETIME NULL COMMENT '생성일',
created_by VARCHAR(255) NULL COMMENT '생성자',
modified_date DATETIME NULL COMMENT '수정일',
last_modified_by VARCHAR(255) NULL COMMENT '수정자',
PRIMARY KEY (reserve_item_id),
CONSTRAINT FK_reserve_item_location_id FOREIGN KEY (location_id)
REFERENCES location (location_id) ON DELETE RESTRICT ON UPDATE RESTRICT
) ;
-- reserve Table Create SQL
CREATE TABLE IF NOT EXISTS reserve
CREATE TABLE IF NOT EXISTS reserve
(
reserve_id BIGINT NOT NULL AUTO_INCREMENT COMMENT '예약 id',
reserve_id VARCHAR(255) NOT NULL COMMENT '예약 id',
reserve_item_id BIGINT NULL COMMENT '예약 물품 id',
location_id BIGINT NULL COMMENT '예약 물품-지역 id',
category_id VARCHAR(255) NULL COMMENT '예약 물품-유형 id',
reserve_qty BIGINT(18) NULL COMMENT '예약 신청인원/수량',
reserve_purpose_content VARCHAR(4000) NULL COMMENT '예약신청 목적',
attachment_code VARCHAR(255) NULL COMMENT '첨부파일 코드',
reserve_start_date DATETIME NULL COMMENT '예약 신청 시작일',
reserve_end_date DATETIME NULL COMMENT '예약 신청 종료일',
reserve_status_id VARCHAR(20) NULL COMMENT '예약상태 - 공통코드(reserve-status)',
reason_cancel_content VARCHAR(4000) NULL COMMENT '예약 취소 사유',
user_id VARCHAR(255) NULL COMMENT '예약자 id',
user_contact_no VARCHAR(50) NULL COMMENT '예약자 연락처',
user_email_addr VARCHAR(500) NULL COMMENT '예약자 이메일',
@@ -74,8 +19,5 @@ CREATE TABLE IF NOT EXISTS reserve
created_by VARCHAR(255) NULL COMMENT '생성자',
modified_date DATETIME NULL COMMENT '수정일',
last_modified_by VARCHAR(255) NULL COMMENT '수정자',
PRIMARY KEY (reserve_id),
CONSTRAINT FK_reserve_reserve_item_id FOREIGN KEY (reserve_item_id)
REFERENCES reserve_item (reserve_item_id) ON DELETE RESTRICT ON UPDATE RESTRICT
PRIMARY KEY (reserve_id)
) ;