private void printNumber(int num){
    if(num > 10){ // #1 
        System.out.println("bigger than 10"); // #2
    } 
    System.out.println(num); // #3
}

@Test
@DisplayName("이미 반납되었을 때 반납 실패")
public void testReturnFailedWhenAlreadyReturned(){
    //given
    final List<Borrow> returnedList = returnedList();
    doReturn(returnedList).when(borrowRepository).findBorrowsByBookId(isA(Long.class));

    //when
    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,()->returnService.returnBook(1L));

    //then
    assertEquals(exception.getMessage(), "이미 반납되었습니다.");
}

class TestClass{
    @InjectMocks
    private UserService userService;
    
    @Mock
    private UserRepository userRepository;
}

doReturn(List.of(new User("honggildong"))).when(userRepository).getUsers();

@RestController
@RequiredArgsConstructor
public class BorrowController {
    private final BorrowService borrowService;
    
    ...

    @PostMapping(value = "/api/borrow", produces = "application/json; charset=utf8")
    public Borrow borrow(@RequestBody @Valid BorrowRequest borrowRequest){
       return borrowService.borrowBook(borrowRequest);
    }
    
   ...
}

@ExtendWith(MockitoExtension.class) // junit5에서 Mockito library 사용하기 위해 추가해줘야함.
class BorrowControllerTest{
   @InjectMocks // Mock 객체들을 주입
   private BorrowController borrowController;

   @Mock // Mock 객체
   private BorrowService borrowService;
   
   ...

   private MockMvc mockMvc; // MockMvc를 통해 API 요청을 할 수 있도록, Spring test에서 이를 제공.

   private Gson gson; // json 파싱을 위해 사용.

   @BeforeEach // 매 테스트가 시작되기 전 실행됨.
   public void init(){
      mockMvc = MockMvcBuilders.standaloneSetup(borrowController).build();
      gson = new Gson();
   }

   @Test
   @DisplayName("대여하기 성공") // 화면에 표시되는 문구.
   void testBorrowSuccess() throws Exception {
      //given
      final BorrowRequest borrowRequestDto = BorrowRequest.builder()
              .borrowerId(1L).borrowerName("hongildong").bookId(2L).build();
      final Borrow borrow = Borrow.builder().state(BorrowState.BORROWING).build();

      doReturn(borrow).when(borrowService).borrowBook(argThat(b -> b.getBorrowerId() == 1));

      //when
      final ResultActions resultActions = mockMvc.perform(
              MockMvcRequestBuilders.post("/api/borrow")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(gson.toJson(borrowRequestDto))
      );

      //then
      final MvcResult mvcResult = resultActions.andExpect(status().isOk()).andReturn();
      assertEquals(mvcResult.getResponse().getStatus(), 200);
      final Borrow response = gson.fromJson(mvcResult.getResponse().getContentAsString(), Borrow.class);
      assertEquals(response.getState(), BorrowState.BORROWING);
   }
   
   ...
}

@Service
@Slf4j
@RequiredArgsConstructor
public class BorrowSearchService {
    private final BorrowRepository borrowRepository;
    private final UserRepository userRepository;

    ...
    
    // below is for one user
    @Transactional
    public List<BorrowBookResponse> getMyBorrowings(Long userId){
        checkUserExist(userId);
        return borrowRepository.findBorrowbookAllByBorrower_UserIdAndState(userId, BorrowState.BORROWING);
    }

    ...

    private void checkUserExist(Long userId){
        if(!userRepository.existsById(userId)) 
            throw new IllegalArgumentException("해당 유저가 없습니다.");
    }
}

@ExtendWith(MockitoExtension.class)
class BorrowSearchServiceTest {

   @InjectMocks
   private BorrowSearchService borrowSearchService;

   @Mock
   private BorrowRepository borrowRepository;
   @Mock
   private UserRepository userRepository;
    
    ...

   @Test
   @DisplayName("유저의 현재 대여중인 목록 가져오기 실패")
   public void testGetOneUserBorrowingsFailed() {
      // given
      doReturn(false).when(userRepository).existsById(-1L);

      // when
      final IllegalArgumentException exception = assertThrows(IllegalArgumentException.class
              , () -> borrowSearchService.getMyBorrowings(-1L));

      // then
      assertEquals(exception.getMessage(), "해당 유저가 없습니다.");
   }
   ...
}

public class Borrow {

   ...
   
   @Enumerated(EnumType.STRING)
   private BorrowState state;

   @Column(name = "expired_at")
   private LocalDate expiredAt;
   
   ...

   public void expired() {
      if (state == BorrowState.RETURNED) throw new IllegalStateException("이미 반납이 완료되었습니다.");
      if (LocalDate.now().isBefore(expiredAt)) throw new IllegalStateException("아직 연체 기간이 남았습니다.");
      state = BorrowState.EXPIRED;
   }
   ...
} 

class BorrowTest {

   @Test
   @DisplayName("연체로 변경 성공")
   public void testSetExpiredSuccess() {
      //given
      Borrow borrow = Borrow.builder().state(BorrowState.BORROWIN)
              .expiredAt(LocalDate.now().minusDays(1)).build();

      //when
      borrow.expired();

      //then
      assertEquals(borrow.getState(), BorrowState.EXPIRED);
   }
   
   ...
}

@RequiredArgsConstructor
public class BorrowRepositoryImpl implements BorrowRepositoryCustom {
   private final JPAQueryFactory queryFactory;

   @Override
   public List<BorrowBookResponse> findBorrowbookAllByState(BorrowState state) {
      return find(borrow.state.eq(state));
   }
   
   ...

   private List<BorrowBookResponse> find(Predicate predicate) {
      return queryFactory
              .select(Projections.constructor(BorrowBookResponse.class,
                      borrow.id,
                      borrow.state,
                      borrow.createdAt,
                      borrow.expiredAt,
                      borrow.borrower.userId,
                      borrow.borrower.userName,
                      book
              )).from(borrow)
              .join(book).on(borrow.bookId.eq(book.book_id))
              .where(predicate)
              .fetch();
   }
}

@ExtendWith(SpringExtension.class) // junit5에서 @DataJpaTest랑 같이 사용하기 위해 필요
@DataJpaTest // JPA와 관련된 객체들만 로딩, 테스트가 끝나면 자동으로 롤백
@Import(TestConfig.class) // QueryDSL 사용에 필요한 빈을 사용하기 위해, 테스트용 Configuration import
@ActiveProfiles("test") // test db 환경인 H2를 사용하기 위한 것
class BorrowRepositoryTest {
   @Autowired
   private BorrowRepository borrowRepository;

   @Autowired
   private BookRepository bookRepository;

   @Test
   @DisplayName("상태로 대여-책 검색 성공")
   public void testFindByStateSuccess(){
      //given

      //when
      List<BorrowBookResponse> borrowBookList1 = borrowRepository
              .findBorrowbookAllByState(BorrowState.BORROWING);
      List<BorrowBookResponse> borrowBookList2 = borrowRepository
              .findBorrowbookAllByState(BorrowState.EXPIRED);
      List<BorrowBookResponse> borrowBookList3 = borrowRepository
              .findBorrowbookAllByState(BorrowState.RETURNED);

      //then
      assertEquals(borrowBookList1.size(), 2);
      assertEquals(borrowBookList2.size(), 2);
      assertEquals(borrowBookList3.size(), 2);
   }
   
   ...

   @BeforeEach // 테스트 메서드를 실행하기 전 수행
   public void setUp(){
      List<Book> bookList = bookList();
      bookRepository.saveAll(bookList);
      borrowRepository.saveAll(borrowList(bookList));
   }

   @AfterEach // 테스트 메서드가 수행하고 난 다음 수행
   public void tearDown(){
      borrowRepository.deleteAll();
      bookRepository.deleteAll();
   }

   // 책 데이터
   public List<Book> bookList(){
      return List.of(
              Book.builder().book_name("name1").build(),
              Book.builder().book_name("name2").build(),
              Book.builder().book_name("name3").build(),
              Book.builder().book_name("name4").build(),
              Book.builder().book_name("name5").build(),
              Book.builder().book_name("name6").build()
      );
   }

   // Borrow 데이터
   public List<Borrow> borrowList(List<Book> books) { 
      return List.of(
              // BORROWING 객체 2개
              Borrow.builder().bookId(books.get(0).getBook_id())
                      .state(BorrowState.BORROWING).createdAt(LocalDate.now())
                      .expiredAt(LocalDate.now().plusDays(7)).borrower(new Borrower(1L, "hong")).build(),
              Borrow.builder().bookId(books.get(1).getBook_id())
                      .state(BorrowState.BORROWING).createdAt(LocalDate.now())
                      .expiredAt(LocalDate.now().plusDays(7)).borrower(new Borrower(1L, "hong")).build(),

              // EXPIRED 객체 2개
              Borrow.builder().bookId(books.get(2).getBook_id())
                      .state(BorrowState.EXPIRED).createdAt(LocalDate.now())
                      .expiredAt(LocalDate.now().plusDays(7)).borrower(new Borrower(1L, "hong")).build(),
              Borrow.builder().bookId(books.get(3).getBook_id())
                      .state(BorrowState.EXPIRED).createdAt(LocalDate.now())
                      .expiredAt(LocalDate.now().plusDays(7)).borrower(new Borrower(2L, "kim")).build(),

              // RETURNED 객체 2개
              Borrow.builder().bookId(books.get(4).getBook_id())
                      .state(BorrowState.RETURNED).createdAt(LocalDate.now())
                      .expiredAt(LocalDate.now().plusDays(7)).borrower(new Borrower(2L, "kim")).build(),
              Borrow.builder().bookId(books.get(5).getBook_id())
                      .state(BorrowState.RETURNED).createdAt(LocalDate.now())
                      .expiredAt(LocalDate.now().plusDays(7)).borrower(new Borrower(2L, "kim")).build()
      );
   }
}