Spring Booot Test 작성 및 실행하기

 

Spring Boot Test 작성 및 실행하기

 

Spring Boot Test를 작성하고 실행하는 방법에 대해 정리한 내용입니다.

 

 

 

1. Spring Boot Test

---

Spring Boot에서는 애플리케이션을 테스트할 때 도움이 되는 테스트 스타터를 제공합니다. 스타터는 크게 spring-boot-test와 spring-boot-test-autoconfigure 두가지 모듈로 구성됩니다.

 

spring-boot-test는 테스트를 위한 핵심 기능을 지원하고 spring-boot-test-autoconfigure는 테스트를 위한 자동 구성을 지원합니다. 일반적으로 Spring Boot 테스트 모듈과 JUnit, Jupiter, AssertJ, Hamcrest 및 다른 유용한 라이브러리들이 포함되어 있는 spring-boot-starter-test를 이용하여 테스트를 실행합니다.

Core Features

 

 

2. Spring Boot Test 어노테이션

---

Spring Boot에서는 테스트 목적에 따라 다양한 어노테이션을 제공합니다. 일반적으로 통합 테스트와 단위 테스트로 구분되는데 이에 따라 주로 사용되는 어노테이션을 구분하면 다음과 같습니다.

 

• 통합 테스트
  @SpringBootTest
• 단위 테스트
  @WebMvcTest
  @DataJpaTest
  @RestClientTest
  @JsonTest

Spring Boot의 테스트 어노테이션은 JUnit에 내장된 테스트 메서드를 사용하기 편리하게 가공한 것입니다. 각 어노테이션의 용도에 따라 적합한 상황에 사용해주면 됩니다.

 

 

 

2.1. @SpringBootTest

 

@SpringBootTest 어노테이션은 Spring Boot 에서 통합 테스트를 할 때 사용하는 기본적인 어노테이션입니다. Spring Boot 프로젝트를 생성하면 메인 클래스와 함께 기본으로 제공됩니다. 애플리케이션이 실행될 때의 설정을 임의로 바꾸어 테스트를 진행하거나 여러 단위의 테스트를 하나로 통합하여 수행할 때 적합합니다. 

 

@SpringBootTest 어노테이션은 실제 구동되는 애플리케이션과 동일하게 context를 로드하여 테스트하기 때문에 원하는 테스트를 모두 수행할 수 있습니다. 하지만 애플리케이션에 설정된 Bean을 모두 로드하는 특징이 있어서 애플리케이션 규모가 커질수록 느려지게 됩니다.

 

다음은 Spring Boot 프로젝트를 생성할 때 기본으로 제공되는 테스트 클래스입니다. 클래스명은 프로젝트명 뒤에 'Tests'를 붙인 형태로 생성됩니다. 테스트 클래스를 실행하면 애플리케이션의 context를 로드하여 테스트가 실행됩니다.

package com.freestrokes;

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootStudyApplicationTests {

	@Test
	public void contextLoads() {
	}

}

 

테스트 클래스에 사용된 어노테이션에 대한 설명은 다음과 같습니다.

 

• @RunWith
  어노테이션에 정의된 Runner 클래스를 사용.
  @SpringBootTest 어노테이션을 사용을 위해 필요.
  JUnit 실행에 필요한 SpringJUnit4ClassRunner 클래스를 상속 받아 @RunWith(SpringRunner.class) 형태로 사용
• @SpringBootTest
  Spring Boot 애플리케이션을 테스트할 때 필요한 의존성을 제공

 

앞서 알아본 예제에 아래 내용을 추가해서 @SpringBootTest 어노테이션에서 파라미터를 사용하는 방법에 대해 알아보겠습니다.

package com.freestrokes;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;

@RunWith(SpringRunner.class)
@SpringBootTest(
	value = "value=test",
	properties = {"property.value=propertyTest"},
	classes = {SpringBootStudyApplication.class},
	webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT
)
public class SpringBootStudyApplicationTests {

	@Value("${value}")
	private String value;

	@Value("${property.value}")
	private String propertyValue;

	@Test
	public void contextLoads() {
		assertThat(value, is("test"));
		assertThat(propertyValue, is("propertyTest"));
	}

}

 

@SpringBootTest 어노테이션의 파라미터로 value와 properties는 함께 사용할 수 없기 때문에 실행할 때는 하나만 사용해줘야 합니다. @SpringBootTest 어노테이션에 사용된 파라미터에 대한 설명은 다음과 같습니다.

 

• value
  테스트 실행전에 사용할 프로퍼티를 추가.
  기존에 프로퍼티가 있는 경우엔 오버라이드 됨.
• properties
  테스트 실행전에 {"key=value"} 형식으로 프로퍼티를 추가.
• classes
  테스트 실행시 애플리케이션 context에 로드할 클래스를 지정.
  따로 지정하지 않을 경우엔 @SpringBootTest 어노테이션이 사용된 해당 클래스를 로드.
• webEnvironment
  애플리케이션이 실행될 때의 웹 환경을 설정.
  기본값은 Mock 서블릿을 로드.
  (위의 예제에서는 랜덤 포트값을 로드하도록 설정)

 

다음은 @SpringBootTest 어노테이션에 대한 추가적인 내용입니다.

 

• @SpringBootTest의  검색 알고리즘 
  @SpringBootApplication 또는 @SpringBootConfiguration 어노테이션을 검색하여 찾음.
  @SpringBootTest에서는 해당 어노테이션 중 하나를 반드시 필요로 함.
• 개발, QA, 운영 등의 Profile 환경마다 각각 다른 DataSource를 사용하는 경우
  @ActiveProfiles("local") 같은 형식의 프로파일 환경값을 어노테이션으로 추가하여 구분.
• @Transactional 어노테이션
  추가해주면 테스트를 마친 후에 데이터가 Rollback 됨.
  해당 테스트가 서버의 다른 쓰레드에서 실행중인 경우엔 WebEnvironment의 RANDOM_PORT 또는 DEFINED_PORT를 사용하여 테스트를 실행해도 Rollback되지 않음.

 

 

2.2. @WebMvcTest

---

@WebMvcTest 어노테이션은 웹에서의 요청과 응답에 대한 테스트할 때 사용합니다. Security 또는 Filter까지 자동으로 테스트하며 수동으로 추가/삭제가 가능한 특징이 있습니다.

 

@WebMvcTest 어노테이션을 사용하여 테스트하면 MVC 관련 설정들(@Controller, @ControllerAdvice, @JsonComponent, Filter, WebMvcConfigurer, HandlerMethodArgumentResolver)만 로드하기 때문에 @SpringBootTest 어노테이션을 사용했을 때보다 가볍고 빠르게 테스트를 진행할 수 있습니다.

 

아래와 같이 MVC 구조로 패키지를 만들고 각각의 클래스와 인터페이스를 생성해줍니다.

src
└── main
     └── java
          └── com
               ├── controller
               │    └── BookController.java
               ├── domain
               │    └── Book.java
               └── service
                    └── BookService.java

 

 

Book.java 클래스는 아래와 같이 작성해줍니다. 

import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.time.LocalDateTime;

@NoArgsConstructor
@Getter
public class Book {

    private Integer idx;
    private String title;
    private LocalDateTime publishedAt;

    @Builder
    public Book(
        String title,
        LocalDateTime publishedAt
    ) {
        this.title = title;
        this.publishedAt = publishedAt;
    }

}

 

위와 같이 lombok을 이용하여 관련 어노테이션을 사용하기 위해서는 build.gradle에 다음과 같이 설정을 추가해주어야 합니다.

compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'

 

BookService.java 인터페이스는 아래와 같이 작성해줍니다. BookService 인터페이스에서는 Book 타입의 리스트를 넘기는 메서드를 생성해줍니다. BookService 인터페이스는 @Service 어노테이션과 함께 구현되어야 하지만 아래의 BookControllerTest.java에서 @MockBean을 사용하여 실제 객체처럼 동작하도록 합니다.

import com.springboot.springboot.domain.Book;
import java.util.List;

public interface BookService {
    List<Book> getBookList();
}

 

 

BookController.java 클래스는 아래와 같이 작성해줍니다. BookController에서는 /books url에 대한 GET request로 받아 BookService에서 getBookList()를 호출하여 bookList를 반환하도록 합니다.

import com.springboot.springboot.service.BookService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class BookController {

    @Autowired
    private BookService bookService;

    @GetMapping("/books")
    public String getBookList(Model model) {
        model.addAttribute("bookList", bookService.getBookList());
        return "book";
    }
}

 

 

마지막으로 테스트를 위해 BookControllerTest.java 클래스를 아래와 같이 작성해줍니다.

import com.freestrokes.controller.BookController;
import com.freestrokes.domain.Book;
import com.freestrokes.service.BookService;
import org.junit.Test;
import org.junit.runner.RunWith;
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.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;

import java.time.LocalDateTime;
import java.util.Collections;

import static org.hamcrest.Matchers.contains;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@RunWith(SpringRunner.class)
@WebMvcTest(BookController.class)
public class BookControllerTest {

    @Autowired
    private MockMvc mvc;

    @MockBean
    private BookService bookService;

    @Test
    public void bookMvcTest() throws Exception {
        Book book = new Book("Spring Boot Book", LocalDateTime.now());
        
        given(bookService.getBookList()).willReturn(Collections.singletonList(book));
        
        mvc.perform(
            get("/books"))
            .andExpect(status().isOk())
            .andExpect(view().name("book"))
            .andExpect(model().attributeExists("bookList"))
            .andExpect(model().attribute("bookList", contains(book))
        );
    }
}

 

 

BookControllerTest 클래스에 대한 설명은 다음과 같습니다.

 

• @WebMvcTest(BookController.class)
  @WebMvcTest 어노테이션에 사용하기 위한 특정 Controller를 명시.
• org.springframework.test.web.servlet.MockMvc
  Controller 테스트시 모든 의존성을 로드하지 않고 해당 Controller의 관련 Bean만 로드.
  HTTP 서버를 실행하지 않고 테스트 가능.
• @MockBean
  Controller 내부의 의존성인 BookService를 실제 객체가 아닌 Mock 객체로 대체.
  Mock 객체를 만들고 given()을 사용하여 getBookList() 메서드의 실행에 대한 반환값을 미리 정의.

테스트에 사용한 MockMvc의 메서드에 대한 설명은 다음과 같습니다.

 

• andExpect(status.isOk())
  HTTP 상태값 확인 (200)
• andExpect(view().name("book"))
  view 이름이 book인지 확인.
• andExpect(model().attributeExists("bookList"))
  model에 bookList 프로퍼티가 존재하는지 확인.
• andExpect(model().attributeExsits("bookList", contains(book)))
  model의 bookList 프로퍼티에 book 객체가 포함되어 있는지 확인.

 

 

2.3. @DataJpaTest

---

@DataJpaTest 어노테이션은 JPA 테스트를 할 때 사용합니다. JPA와 관련된 설정만 로드하며 DataSource의 설정이나 JPA를 이용한 데이터의 생성, 수정, 삭제 등의 테스트가 가능합니다. 내장형 데이터베이스를 이용하여 데이터베이스가 없어도 테스트가 가능하고 테스트가 끝날 때마다 데이터를 자동으로 롤백하여 실제 데이터 변경에 대한 부담없이 테스트를 진행할 수 있습니다.

 

@DataJpaTest 어노테이션은 기본적으로 In-Memory Embedded Database를 사용하며 @Entity 클래스를 스캔하여 스프링 데이터 JPA 저장소(Spring Data JPA Repositories)를 구성합니다. 또한 EntityManager를 테스트 용도로 대체하기 위해 만들어진 TestEntityManager를 사용하여 persist, flush, find 등의 기본적인 JPA 테스트를 진행할 수 있습니다.

 

JPA 사용을 위해서 build.gradle의 dependencies에 아래의 의존성을 추가해줍니다.

compile('org.springframework.boot:spring-boot-starter-data-jpa')

 

 

다음으로 앞서 작성한 Book.java 클래스를 아래와 같이 수정해줍니다. JPA 테스트를 수행할 수 있게 관련 어노테이션을 추가해줍니다.

import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.time.LocalDateTime;

@NoArgsConstructor
@Getter
@Entity
@Table
public class Book {

    @Id
    @GeneratedValue
    private Integer idx;

    @Column
    private String title;

    @Column
    private LocalDateTime publishedAt;

    @Builder
    public Book(
        String title,
        LocalDateTime publishedAt
    ) {
        this.title = title;
        this.publishedAt = publishedAt;
    }

}

 

JPA Repository로 사용할 BookRepository.java 인터페이스도 다음과 같이 작성해줍니다. repository 패키지를 생성해서 하위에 추가해줍니다.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

public interface BookRepository extends JpaRepository<Book, Integer> {
}

 

마지막으로 JPA 관련 설정들을 테스트하기 위한 BookJpaTest.java 클래스를 작성해줍니다. @Test 어노테이션이 매핑된 각각의 메서드를 실행하면 JPA 테스트 결과를 확인할 수 있습니다.

import com.freestrokes.domain.Book;
import com.freestrokes.repository.BookRepository;

import org.hamcrest.collection.IsEmptyCollection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.test.context.junit4.SpringRunner;

import java.time.LocalDateTime;
import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;

@RunWith(SpringRunner.class)
@DataJpaTest
public class BookJpaTest {

    private final static String JPA_TEST_TITLE = "Spring Boot Jpa Test";

    @Autowired
    private TestEntityManager testEntityManager;

    @Autowired
    private BookRepository bookRepository;

    @Test
    public void saveBook() {
        Book book = Book.builder().title(JPA_TEST_TITLE).publishedAt(LocalDateTime.now()).build();
        testEntityManager.persist(book);
        assertThat(bookRepository.getOne(book.getIdx()), is(book));
    }

    @Test
    public void saveAndFindBookList() {
        Book book1 = Book.builder().title(JPA_TEST_TITLE + "1").publishedAt(LocalDateTime.now()).build();
        testEntityManager.persist(book1);
        Book book2 = Book.builder().title(JPA_TEST_TITLE + "2").publishedAt(LocalDateTime.now()).build();
        testEntityManager.persist(book2);
        Book book3 = Book.builder().title(JPA_TEST_TITLE + "3").publishedAt(LocalDateTime.now()).build();
        testEntityManager.persist(book3);

        List<Book> bookList = bookRepository.findAll();
        assertThat(bookList, hasSize(3));
        assertThat(bookList, contains(book1, book2, book3));
    }

    @Test
    public void saveAndDeleteBookList() {
        Book book1 = Book.builder().title(JPA_TEST_TITLE + "1").publishedAt(LocalDateTime.now()).build();
        testEntityManager.persist(book1);
        Book book2 = Book.builder().title(JPA_TEST_TITLE + "2").publishedAt(LocalDateTime.now()).build();
        testEntityManager.persist(book2);

        bookRepository.deleteAll();
        assertThat(bookRepository.findAll(), IsEmptyCollection.empty());
    }
}

 

BookJpaTest 클래스에 대한 설명은 다음과 같습니다.

 

• saveBook()
  testEntityManager로 persist() 메서드의 정상 동작을 확인.
• saveAndFindBookList()
  도메인 객체를 저장하고 리스트를 조회하여 개수와 각 객체의 포함 여부를 확인.
• saveAndDeleteBookList()
  도메인 객체를 저장하고 삭제한 뒤에 모두 삭제 되었는지 확인.

 

 

2.4. @RestClientTest

---

@RestClientTest 어노테이션은 REST와 관련된 테스트를 할 때 사용합니다. REST 통신을 테스트하고 데이터 타입으로 사용되는 JSON 타입이 정상적인 response로 반환되는지 테스트할 수 있습니다. 

 

아래와 같이 클래스들과 테스트에 사용할 JSON 파일을 생성해줍니다.

src
├── main
│    └── java
│         └── com
│              ├──controller
│              │   └── BookRestController.java
│              ├──domain
│              │   └── Book.java
│              └──service
│                  └── BookRestService.java
└── test
     ├── java
     └── resources
          └── test.json

 

테스트에 사용할 test.json 파일은 아래와 같이 작성해줍니다.

{
  "idx": null,
  "title": "테스트",
  "publishedAt": null
}

 

BookRestService.java 클래스는 다음과 같이 작성해줍니다.

import com.freestrokes.domain.Book;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class BookRestService {

    private final RestTemplate restTemplate;

    public BookRestService(RestTemplateBuilder restTemplateBuilder) {
        this.restTemplate = restTemplateBuilder.rootUri("/rest/test").build();
    }

    public Book getRestBookList() {
        return this.restTemplate.getForObject("/rest/test", Book.class);
    }
    
}

 

BookRestService 클래스 대한 설명은 다음과 같습니다.

 

• BookRestService(RestTemplateBuilder restTemplateBuilder)
  RestTemplateBuilder는 RestTemplate을 핸들링하는 빌더 객체.
  connectionTimeout, readTimeOut과 같은 RestTemplate과 관련된 여러 설정을 제공.
  REST 테스트를 할 rootUri를 설정.
• getRestBookList()
  RestTemplate의 GET 방식으로 통신하는 getForObject() 메서드를 사용하여 uri에 request를보냄.
  response는 Book 객체 타입으로 받아오도록 설정.

 

BookRestController.java 클래스는 다음과 같이 작성해줍니다. @RestController 어노테이션을 사용하여 REST 형식의 데이터를 반환하도록 해줍니다. getRestBooklist() 메서드는 Book 객체를 리턴하지만 @RestController 어노테이션을 사용하면 JSON 형식의 String 데이터로 반환됩니다.

import com.freestrokes.domain.Book;
import com.freestrokes.service.BookRestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BookRestController {

    @Autowired
    private BookRestService bookRestService;

    @GetMapping(
        path = "/rest/test",
        produces = MediaType.APPLICATION_JSON_VALUE
    )
    public Book getRestBookList() {
        return bookRestService.getRestBookList();
    }
    
}

 

마지막으로 테스트를 위해 BookRestTest.java 클래스를 작성해줍니다.

import com.freestrokes.domain.Book;
import com.freestrokes.service.BookRestService;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.HttpServerErrorException;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withServerError;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;

@RunWith(SpringRunner.class)
@RestClientTest(BookRestService.class)
public class BookRestTest {

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Autowired
    private BookRestService bookRestService;

    @Autowired
    private MockRestServiceServer mockRestServiceServer;

    @Test
    public void restTest() {
        this.mockRestServiceServer
            .expect(requestTo("/rest/test"))
            .andRespond(withSuccess(new ClassPathResource("/test.json", getClass()), MediaType.APPLICATION_JSON));

        Book book = this.bookRestService.getRestBookList();
        assertThat(book.getTitle()).isEqualTo("테스트");
    }

    @Test
    public void restErrorTest() {
        this.mockRestServiceServer
            .expect(requestTo("/rest/test"))
            .andRespond(withServerError());

        this.thrown.expect(HttpServerErrorException.class);
        this.bookRestService.getRestBookList();
    }

}

 

BookRestTest 클래스 대한 설명은 다음과 같습니다.

 

• @RestClientTest(BookRestService.class)
  테스트 대상이 되는 빈 클래스를 주입.
• @Rule
  지정된 필드값은 하나의 테스트가 끝날 때마다 지정한 값으로 초기화 됨.
  @Before, @After 어노테이션에 상관없이 동작.
  테스트에서 자체적인 규칙을 정의하여 재사용할 때 유용.
• MockRestServiceServer
  클라이언트와 서버 사이의 REST 테스트를 위한 객체.
  Mock 객체를 사용했던 것처럼 테스트가 이루어지도록 함.
• restTest()
  요청에 대한 응답을 테스트하는 메서드.
  getRestBookList() 메서드를 호출하여 JSON String으로 반환된 값이 test.json에 작성된 값과 일치하는지 확인.
• restErrorTest()
  요청에 대한 에러를 테스트하는 메서드.
  ExcepectedException 객체의 expect() 메서드로 지정한 에러를 발생.

 

 

2.5. @JsonTest

---

@JsonTest 어노테이션은 JSON의 직렬화와 역직렬화를 테스트를 할 때 사용합니다. Gson 또는 Jackson 라이브러리의 테스터를 사용하여 테스트를 수행합니다.

 

다음과 같이 BookJsonTest.java 클래스를 작성해줍니다.

import com.freestrokes.domain.Book;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.json.JsonTest;
import org.springframework.boot.test.json.JacksonTester;
import org.springframework.test.context.junit4.SpringRunner;

import static org.assertj.core.api.Assertions.assertThat;

@RunWith(SpringRunner.class)
@JsonTest
public class BookJsonTest {

    @Autowired
    private JacksonTester<Book> json;

    @Test
    public void jsonTest() throws Exception {
        Book book = Book.builder()
            .title("테스트")
            .build();

        String content = "{\"title\":\"테스트\"}";

        assertThat(this.json.parseObject(content).getTitle()).isEqualTo(book.getTitle());
        assertThat(this.json.parseObject(content).getPublishedAt()).isNull();

        assertThat(this.json.write(book)).isEqualToJson("/test.json");
        assertThat(this.json.write(book)).hasJsonPathStringValue("title");
        assertThat(this.json.write(book)).extractingJsonPathStringValue("title").isEqualTo("테스트");
    }
    
}

 

BookRestTest 클래스 대한 설명은 다음과 같습니다.

 

• assertThat(this.json.parseObject(content).getTitle()).isEqualTo(book.getTitle())
  content 문자열을 객체로 변환하여 Book 객체의 title과 일치하는지 확인.
• assertThat(this.json.parseObject(content).getPublishedAt()).isNull()
  content 문자열을 객체로 변환하여 publishedAt이 null인지 확인.
• assertThat(this.json.write(book)).isEqualToJson("/test.json")
  Book 객체를 문자열로 변환하여 test.json 파일의 내용과 일치하는지 확인. 
• assertThat(this.json.write(book)).hasJsonPathStringValue("title")
  Book 객체를 문자열로 변환하여 title 값이 있는지 확인.
• assertThat(this.json.write(book)).extractingJsonPathStringValue("title").isEqualTo("테스트")
  Book 객체를 문자열로 변환하여 title 값이 일치하는지 확인.

 

이상으로 Spring Boot Test를 작성하고 실행하는 방법에 대해 알아봤습니다.

 

 

※ References

 

• 김영재 지음, 『처음 배우는 스프링 부트 2』, 한빛미디어 (2019), p73 ~ p.91 CHAPTER 3 스프링 부트 테스트
• gracelove91.tistory.com, gradle 사용시 lombok cannot find symbol 에러, https://gracelove91.tistory.com/13
• goddaehee.tistory.com, [스프링부트 (9)] SpringBoot Test(2) - @SpringBootTest로 통합테스트 하기, https://goddaehee.tistory.com/211
• goddaehee.tistory.com, [스프링부트 (10)] SpringBoot Test(3) - 단위 테스트(@WebMvcTest, @DataJpaTest, @RestClientTest 등), https://goddaehee.tistory.com/212