import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.HashSet;
import java.util.Set;

public class MiscTest {

  // HashSet 기능 테스트
  @Test
  public void testHashSetContainsNonDuplicatedValue() {
    // Given
    Integer value = Integer.valueOf(1);
    Set<Integer> set = new HashSet<>();

    // When
    set.add(value);
    set.add(value);
    set.add(value);

    // Then
    Assertions.assertEquals(1, set.size());
    Assertions.assertTrue(set.contains(value));
  }
}

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.*;

import java.util.HashSet;
import java.util.Set;

@Slf4j
public class MiscTest {

  // 테스트 클래스 인스턴스를 초기화할 때 가장 먼저 실행되며 한 번만 실행됨
  @BeforeAll
  public static void setup() {
    log.info("BeforeAll: before all tests in the current test class.");
  }

  // 테스트 클래스의 모든 테스트 메서드가 실행을 마치면 마지막으로 한 번만 실행됨
  @AfterAll
  public static void destroy() {
    log.info("AfterAll: after all tests in the current test class.");
  }

  // 모든 테스트 메서드가 실행되기 전 각각 한 번씩 실행됨
  @BeforeEach
  public void init() {
    log.info("BeforeEach: before each @Test.");
  }

  // HashSet 기능 테스트
  @Test
  public void testHashSetContainsNonDuplicatedValue() {
    log.info("Test: testHashSetContainsNonDuplicatedValue()");

    // Given
    Integer value = Integer.valueOf(1);
    Set<Integer> set = new HashSet<>();

    // When
    set.add(value);
    set.add(value);
    set.add(value);

    // Then
    Assertions.assertEquals(1, set.size());
    Assertions.assertTrue(set.contains(value));
  }

  @Test
  public void testDummy() {
    log.info("Test: testDummy()");
    Assertions.assertTrue(Boolean.TRUE);
  }

  // 모든 테스트 메서드가 실행되고 난 후 각각 한 번씩 실행됨
  @AfterEach
  public void cleanup() {
    log.info("AfterEach: after each @Test");
  }
}

public static <T extends Throwable> T assertThrows(Class<T> expectedType, Executable executable) {
  return AssertThrows.assertThrows(expectedType, executable);
}

@FunctionalInterface
@API(
  status = Status.STABLE,
  since = "5.0"
)
public interface Executable {
  void execute() throws Throwable;
}

Assertions.assertThrows(
    IOException.class, 
        () -> IOUtils.copy(inputStream, outputStream)
);

package com.assu.study.chap07.service;

import com.assu.study.chap07.controller.HotelRequest;
import com.assu.study.chap07.controller.HotelResponse;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

import java.util.List;

@SpringBootTest // 스프링 프레임워크의 기능과 함께 대상 클래스 테스트, Junit4는 @Runwith(SpringRunner.class) 설정 필요, Junit5 는 @Runwith 생략 가능
public class HotelDisplayServiceTest {

  private final HotelDisplayService hotelDisplayService;
  private final ApplicationContext applicationContext;

  // 테스트 클래스에 테스트 대상 스프링 빈을 생성자 주입 방식으로 사용 시 반드시 생성자에 @Autowired 정의해야 함
  // (필드 주입 방식을 사용하여 스프링 빈 주입도 가능하긴 함)
  @Autowired
  public HotelDisplayServiceTest(HotelDisplayService hotelDisplayService, ApplicationContext applicationContext) {
    this.hotelDisplayService = hotelDisplayService;

    // 스프링 프레임워크에서 제공하는 모든 스프링 빈을 주입받아 사용할 수 있음
    this.applicationContext = applicationContext;
  }

  @Test
  public void testReturnOneHotelWhenRequestIsHotelName() {
    // Given
    HotelRequest hotelRequest = new HotelRequest("Assu Hotel");

    // When
    // 주입받은 hotelDisplayService 스프링 빈 객체의 메서드를 테스트할 수 있음
    List<HotelResponse> hotelResponses = hotelDisplayService.getHotelsByName(hotelRequest);

    // Then
    Assertions.assertNotNull(hotelResponses);
    Assertions.assertEquals(1, hotelResponses.size());
  }

  @Test
  public void testApplicationContext() {
    // 주입받은 applicationContext 의 getBean() 메서드를 사용하여 DisplayService 타입의 스프링 빈을 받아옴
    DisplayService displayService = applicationContext.getBean(DisplayService.class);

    Assertions.assertNotNull(displayService);
    Assertions.assertTrue(displayService instanceof HotelDisplayService);
  }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.test.context;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.core.annotation.AliasFor;
import org.springframework.test.context.BootstrapWith;
import org.springframework.test.context.junit.jupiter.SpringExtension;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@BootstrapWith(SpringBootTestContextBootstrapper.class)
@ExtendWith({SpringExtension.class})
public @interface SpringBootTest {
  @AliasFor("properties")
  String[] value() default {};

  @AliasFor("value")
  String[] properties() default {};

  String[] args() default {};

  Class<?>[] classes() default {};

  WebEnvironment webEnvironment() default SpringBootTest.WebEnvironment.MOCK;

  ...
  
  public static enum WebEnvironment {
    MOCK(false),
    RANDOM_PORT(true),
    DEFINED_PORT(true),
    NONE(false);
    ...
  }
}

@AliasFor("properties")
String[] value() default {};

@AliasFor("value")
String[] properties() default {};

String[] args() default {};

Class<?>[] classes() default {};

WebEnvironment webEnvironment() default SpringBootTest.WebEnvironment.MOCK;

// key-value 속성만 교체하는 방법
@SpringBootTest(properties = {"search.host=127.0.0.1", "search.port=99999"})

// 테스트 케이스에만 사용하는 프로퍼티 파일을 설정하는 방법
@SpringBootTest(properties = {"spring.config.location=classpath:application-test.properties"})

@GetMapping("/hotel/room/{id}")
public void getHotelRoomById(@PathVariable Long id) {
  hotelRoomDisplayService.getHotelRoomById(id);
}

package com.assu.study.chap07.service;

import com.assu.study.chap07.controller.HotelRoomResponse;
import com.assu.study.chap07.domain.HotelRoomEntity;
import com.assu.study.chap07.repository.HotelRoomRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class HotelRoomDisplayService {
  private final HotelRoomRepository hotelRoomRepository;
  private final ThreadPoolTaskExecutor threadPoolTaskExecutor;

  public HotelRoomDisplayService(HotelRoomRepository hotelRoomRepository, ThreadPoolTaskExecutor threadPoolTaskExecutor) {
    this.hotelRoomRepository = hotelRoomRepository;
    this.threadPoolTaskExecutor = threadPoolTaskExecutor;
  }

  public HotelRoomResponse getHotelRoomById(Long id) {
    HotelRoomEntity hotelRoomEntity = hotelRoomRepository.findById(id);
    threadPoolTaskExecutor.execute(() -> log.warn("entity: {}", hotelRoomEntity.toString()));

    return HotelRoomResponse.from(hotelRoomEntity);
  }
}

package com.assu.study.chap07.repository;

import com.assu.study.chap07.domain.HotelRoomEntity;
import org.springframework.stereotype.Repository;

@Repository
public class HotelRoomRepository {
  public HotelRoomEntity findById(Long id) {
    return new HotelRoomEntity(id, "EAST-111", 9, 2, 1);
  }
}

package com.assu.study.chap07.domain;

import lombok.Getter;
import lombok.ToString;

@Getter
@ToString
public class HotelRoomEntity {
  private final Long id;
  private final String code;
  private final Integer floor;
  private final Integer bedCount;
  private final Integer bathCount;

  public HotelRoomEntity(Long id, String code, Integer floor, Integer bedCount, Integer bathCount) {
    this.id = id;
    this.code = code;
    this.floor = floor;
    this.bedCount = bedCount;
    this.bathCount = bathCount;
  }
}

package com.assu.study.chap07.controller;

import com.assu.study.chap07.domain.HotelRoomEntity;
import lombok.Getter;

// DTO
@Getter
public class HotelRoomResponse {
  private final Long id;
  private final String code;
  private final Integer floor;
  private final Integer bedCount;
  private final Integer bathCount;

  private HotelRoomResponse(Long id, String code, Integer floor, Integer bedCount, Integer bathCount) {
    this.id = id;
    this.code = code;
    this.floor = floor;
    this.bedCount = bedCount;
    this.bathCount = bathCount;
  }

  public static HotelRoomResponse from(HotelRoomEntity hotelRoomEntity) {
    return new HotelRoomResponse(hotelRoomEntity.getId(),
        hotelRoomEntity.getCode(),
        hotelRoomEntity.getFloor(),
        hotelRoomEntity.getBedCount(),
        hotelRoomEntity.getBathCount()
    );
  }
}

package com.assu.study.chap07.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration  // ThreadPoolConfig 자바 설정 클래스는 애플리케이션이 실행될 때 클래스 내부에 정의된 스프링 빈들이 생성됨
public class ThreadPoolConfig {

  // 스프링 빈 이름은 threadPoolTaskExecutor 이고, ThreadPoolTaskExecutor 클래스 타입
  @Bean(destroyMethod = "shutdown")
  public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
    ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
    // 스레드 풀의 개수는 최대 10개까지 늘어남
    threadPoolTaskExecutor.setMaxPoolSize(10);
    // 스레드 풀의 이름은 AsyncExecutor- 로 시작함
    threadPoolTaskExecutor.setThreadNamePrefix("AsyncExecutor-");
    // 컨테이너가 모든 속성값을 적용한 후 initialize() 호출
    threadPoolTaskExecutor.afterPropertiesSet();

    return threadPoolTaskExecutor;
  }
}

package com.assu.study.chap07.config;

import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@TestConfiguration  // ThreadPoolConfigTest 자바 설정 클래스는 테스트가 실행될 때 클래스 내부에 정의된 스프링 빈들이 생성됨
public class ThreadPoolConfigTest {

  // 기존의 threadPoolTaskExecutor 스프링 빈을 재정의하려고 타입과 이름이 같은 스프링 빈 정의
  @Bean(destroyMethod = "shutdown")
  public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
    ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
    // 스레드 풀의 개수는 최대 1개까지 늘어남
    threadPoolTaskExecutor.setMaxPoolSize(1);
    // 스레드 풀의 이름은 TestExecutor- 로 시작함
    threadPoolTaskExecutor.setThreadNamePrefix("TestExecutor-");
    // 컨테이너가 모든 속성값을 적용한 후 initialize() 호출
    threadPoolTaskExecutor.afterPropertiesSet();

    return threadPoolTaskExecutor;
  }
}

package com.assu.study.chap07.service;

import com.assu.study.chap07.controller.HotelRoomResponse;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class HotelRoomDisplayServiceTest00 {

  @Autowired  // 필드 주입 방식
  private HotelRoomDisplayService hotelRoomDisplayService;

  @Test
  void testOriginalGetHotelRoomById() {
    HotelRoomResponse hotelRoomResponse = hotelRoomDisplayService.getHotelRoomById(1L);

    Assertions.assertNotNull(hotelRoomResponse);
    Assertions.assertEquals(1L, hotelRoomResponse.getId());
  }
}

package com.assu.study.chap07.service;

import com.assu.study.chap07.config.ThreadPoolConfigTest;
import com.assu.study.chap07.controller.HotelRoomResponse;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;

@SpringBootTest
// @Import 나 @ContextConfiguration 을 사용하여 명시적으로 테스트 자바 설정 클래스 로딩
//@Import(value = {ThreadPoolConfigTest.class})
@ContextConfiguration(classes = ThreadPoolConfigTest.class)
// 테스트 환경에 맞게 커스터마이징된 프로퍼티 파일 로딩 (application-test.properties 에는 스프링 빈을 재정의할 수 있는 설정값을 포함하고 있음)
@TestPropertySource(locations = "classpath:application-test.properties")
class HotelRoomDisplayServiceTest01 {

  @Autowired  // 필드 주입 방식
  private HotelRoomDisplayService hotelRoomDisplayService;

  @Test
  void testGetHotelRoomById() {
    HotelRoomResponse hotelRoomResponse = hotelRoomDisplayService.getHotelRoomById(1L);

    Assertions.assertNotNull(hotelRoomResponse);
    Assertions.assertEquals(1L, hotelRoomResponse.getId());
  }
}

@MockBean
private HotelRoomRepository hotelRoomRepository;

package com.assu.study.chap07.service;

import com.assu.study.chap07.controller.HotelRoomResponse;
import com.assu.study.chap07.domain.HotelRoomEntity;
import com.assu.study.chap07.repository.HotelRoomRepository;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;

@SpringBootTest
class HotelRoomDisplayServiceTest02 {

  @Autowired  // 필드 주입 방식
  private HotelRoomDisplayService hotelRoomDisplayService;

  // Mock 객체 생성
  // 테스트 프레임워크가 만든 HotelRoomRepository Mock 객체가 ApplicationContext 에 포함되고,
  // 해당 Mock 객체는 ApplicationContext 로 HotelRoomDisplayService 에 주입됨
  @MockBean
  private HotelRoomRepository hotelRoomRepository;

  @Test
  void testGetHotelRoomById() {
    // Mock 객체의 행동 설정
    // findById() 메서드가 호출되면 아이디가 10L 인 HotelRoomEntity 객체 리턴
    // findById() 메서드에 '어떤 인자' 를 의미하는 any() 를 설정했으므로 인수값에 상관없이
    // willReturn() 메서드에 인자로 설정된 HotelRoomEntity 객체를 무조건 리턴
    given(this.hotelRoomRepository.findById(any()))
        .willReturn(new HotelRoomEntity(10L, "test", 1, 2, 3));


    HotelRoomResponse hotelRoomResponse = hotelRoomDisplayService.getHotelRoomById(1L);

    Assertions.assertNotNull(hotelRoomResponse);
    Assertions.assertEquals(10L, hotelRoomResponse.getId());
  }
}

given(this.hotelRoomRepository.findById(any()))
        .willReturn(new HotelRoomEntity(10L, "test", 1, 2, 3));

public interface Answer<T> {
  T answer(InvocationOnMock var1) throws Throwable;
}

@Test
void testWillAnswer() {
  given(this.hotelRoomRepository.findById(any()))
      // 스텁 메서드가 응답하는 클래스의 타입(HotelRoomEntity)을 제네릭으로 입력
      // 즉, hotelRoomRepository.findById() 메서드가 응답하는 클래스 타입은 HotelRoomEntity
      .willAnswer(new Answer<HotelRoomEntity>() {
        @Override
        // InvocationOnMock 은 Mock 메서드의 인자, 메서드명, Mock 객체 정보를 포함하여, 이 정보들을 참조할 수 있는 메서드 제공
        public HotelRoomEntity answer(InvocationOnMock invocationOnMock) throws Throwable {
          // 런타임 시점에서 Mock 메서드의 인자 정보 획득
          Long id = invocationOnMock.getArgument(0);
          if (id != null && id > 10) {
            return new HotelRoomEntity(id, "CODE", 3, 3, 3);
          } else {
            return new HotelRoomEntity(10L, "test", 1, 2, 3);
          }
        }
      });

  HotelRoomResponse hotelRoomResponse = hotelRoomDisplayService.getHotelRoomById(1L);

  Assertions.assertNotNull(hotelRoomResponse);
  Assertions.assertEquals(10L, hotelRoomResponse.getId());
}

package com.assu.study.chap07.controller;

import com.assu.study.chap07.service.HotelDisplayService;
import com.assu.study.chap07.service.HotelRoomDisplayService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@Slf4j
public class HotelController {
  private final HotelDisplayService hotelDisplayService;
  private final HotelRoomDisplayService hotelRoomDisplayService;

  public HotelController(HotelDisplayService hotelDisplayService, HotelRoomDisplayService hotelRoomDisplayService) {
    this.hotelDisplayService = hotelDisplayService;
    this.hotelRoomDisplayService = hotelRoomDisplayService;
  }

  @PostMapping("/hotels/name")
  // List<HotelResponse> 객체를 리턴하며, @RestController 가 JSON 으로 변경함, List 객체이므로 마셜링되면 JSON Array 형태로 변환됨
  public ResponseEntity<List<HotelResponse>> getHotelByName(
      @RequestBody HotelRequest hotelRequest) { // POST 요청의 Content-type 헤더값은 application/json 이고, Body 는 JSON 형식의 데이터
    List<HotelResponse> hotelResponse = hotelDisplayService.getHotelsByName(hotelRequest);
    return ResponseEntity.ok(hotelResponse);
  }
}

mockMvc.perform(
  post("/hotels/{id}", 11)  // HTTP POST 메서드를 사용하여 요청
  .contentType(MediaType.APPLICATION_JSON)  // 요청 메시지의 Content-type 헤더에 'application/json' 헤더값 설정
  .accept(MediaType.APPLICATION_JSON) // Accept 헤더에 'application/json' 설정
  .content(jsonString)  // 요청 메시지 body 에 문자열값 설정, 인자로 String 이 아닌 byte[] 도 받을 수 있기 때문에 파일 업로드 테스트도 가능
  .header("x-channel-name", "web")  // 요청 메시지의 헤더 영역과 헤더값 설정
);

mockMvc.perform(
  get("/hotles/{id}", 11)
  .queryParam("type", "5Star")
);

mockMvc.perform(
  put("/hotels/{id}", 11)
);

mockMvc.perform(
  delete("/hotels/{id}", 11)
);

package com.assu.study.chap07.controller;

import com.assu.study.chap07.util.JsonUtil;
import org.hamcrest.Matchers;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

// MockMvcBuilders 클래스를 사용하여 MockMvc 객체 생성도 가능하지만, 스프링 부트에서 제공하는 @AutoConfigureMockMvc 를 정의하면 MockMvc 객체를 스프링 빈으로 주입받을 수 있음
// @SpringBootTest 애너테이션을 사용하여 스프링 MVC 기능 테스트 시 함께 사용함
@AutoConfigureMockMvc
// WebEnvironment.MOCK 을 설정하여 실제 서블릿 컨테이너를 실행하지 않고 Mock 서블릿 컨테이너를 사용하여 테스트 진행
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
class ApiControllerTest00 {

  // @AutoConfigureMockMvc 로 생성된 MockMvc 스프링 빈 주입받음
  @Autowired
  private MockMvc mockMvc;

  @Test
  public void testGetHotelByName() throws Exception {
    HotelRequest hotelRequest = new HotelRequest("Assu Hotel.");
    String jsonRequest = JsonUtil.objectMapper.writeValueAsString(hotelRequest);

    mockMvc.perform(post("/hotels/name")
            .content(jsonRequest)
            .contentType(MediaType.APPLICATION_JSON)
        )
        .andExpect(status().isOk()) // 응답 메시지가 200 인지 검증
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(content().string("[{\"hotelId\":1000,\"hotelName\":\"Assu Hotel~\",\"address\":\"Seoul Gangnam\",\"phoneNumber\":\"+821112222\"}]"))
        .andExpect(content().json("[{\"hotelId\":1000,\"hotelName\":\"Assu Hotel~\",\"address\":\"Seoul Gangnam\",\"phoneNumber\":\"+821112222\"}]"))
        .andExpect(jsonPath("$[0].hotelId", Matchers.is(1000)))
        .andExpect(jsonPath("$[0].hotelName", Matchers.is("Assu Hotel~")))
        .andDo(MockMvcResultHandlers.print(System.out));
  }
}

package com.assu.study.chap07.util;

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonUtil {
  public static final ObjectMapper objectMapper = new ObjectMapper();
}

package com.assu.study.chap07.controller;

import com.assu.study.chap07.service.HotelDisplayService;
import com.assu.study.chap07.util.JsonUtil;
import org.hamcrest.Matchers;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;

import java.util.List;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

// @WebMvcTest 의 controllers 속성을 사용하지 않으면 애플리케이션에 포함된 모든 컨트롤러 클래스 스캔
@WebMvcTest(controllers = HotelController.class)
public class ApiControllerTest01 {
  @Autowired
  private MockMvc mockMvc;

  // Mock 객체 생성
  @MockBean
  private HotelDisplayService hotelDisplayService;

  // Mockito 의 given() 과 willAnswer() 를 사용하여 적절한 값을 응답하도록 설정
  @BeforeEach
  public void init() {
    given(hotelDisplayService.getHotelsByName(any()))
        .willAnswer(new Answer<List<HotelResponse>>() {
          @Override
          public List<HotelResponse> answer(InvocationOnMock invocationOnMock) throws Throwable {
            HotelRequest hotelRequest = invocationOnMock.getArgument(0);
            return List.of(new HotelResponse(1L, hotelRequest.getHotelName(), "unknown", "111-222-3333"));
          }
        });
  }

  @Test
  public void testGetHotelByName() throws Exception {
    HotelRequest hotelRequest = new HotelRequest("Assu Hotel.");
    String jsonRequest = JsonUtil.objectMapper.writeValueAsString(hotelRequest);

    mockMvc.perform(post("/hotels/name")
            .content(jsonRequest)
            .contentType(MediaType.APPLICATION_JSON)
        )
        .andExpect(status().isOk()) // 응답 메시지가 200 인지 검증
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$[0].hotelId", Matchers.is(1)))
        .andExpect(jsonPath("$[0].hotelName", Matchers.is("Assu Hotel.")))
        .andDo(MockMvcResultHandlers.print(System.out));
  }
}