《Spring Boot 入门》17.1 单元测试

@Test
void assertions() {
    // 相等断言：期望值在前，实际值在后（顺序反了报错信息会误导人）
    assertEquals("Effective Java", book.getTitle());

    // 断言抛异常：返回捕获到的异常，可继续断言它的属性
    BookNotFoundException ex = assertThrows(
            BookNotFoundException.class,
            () -> bookService.getById(999L));
    assertEquals(999L, ex.getId());

    // 一组断言一起执行：任一失败都不中断其余断言，最后汇总报告
    assertAll("book",
            () -> assertEquals("Effective Java", book.getTitle()),
            () -> assertEquals("Joshua Bloch", book.getAuthor()),
            () -> assertEquals(2018, book.getPublishedYear()));
}

when(bookRepository.findByTitle("Effective Java"))
        .thenReturn(Optional.of(existingBook));

verify(bookRepository).save(any(Book.class));
verify(bookRepository, never()).delete(any(Book.class));

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class BookServiceTest {
    // ...
}

package com.example.library.service;

import java.util.List;

import org.springframework.stereotype.Service;

import com.example.library.domain.Book;
import com.example.library.repository.BookRepository;

@Service
public class BookService {

    private final BookRepository bookRepository;

    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public Book create(Book book) {
        bookRepository.findByTitle(book.getTitle()).ifPresent(existing -> {
            throw new DuplicateBookException(book.getTitle());
        });
        return bookRepository.save(book);
    }

    public Book getById(Long id) {
        return bookRepository.findById(id)
                .orElseThrow(() -> new BookNotFoundException(id));
    }
}

package com.example.library.service;

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.Optional;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import com.example.library.domain.Book;
import com.example.library.repository.BookRepository;

@ExtendWith(MockitoExtension.class)
class BookServiceTest {

    @Mock
    private BookRepository bookRepository;

    @InjectMocks
    private BookService bookService;

    @Nested
    @DisplayName("create")
    class Create {

        @Test
        @DisplayName("标题不重复时保存并返回图书")
        void create_withNewTitle_savesBook() {
            Book input = new Book("Effective Java", "Joshua Bloch", 2018);
            when(bookRepository.findByTitle("Effective Java")).thenReturn(Optional.empty());
            when(bookRepository.save(any(Book.class))).thenAnswer(inv -> inv.getArgument(0));

            Book result = bookService.create(input);

            assertAll("saved book",
                    () -> assertEquals("Effective Java", result.getTitle()),
                    () -> assertEquals(2018, result.getPublishedYear()));

            ArgumentCaptor<Book> captor = ArgumentCaptor.forClass(Book.class);
            verify(bookRepository).save(captor.capture());
            assertEquals("Effective Java", captor.getValue().getTitle());
        }

        @Test
        @DisplayName("标题已存在时抛出异常且不写库")
        void create_duplicateTitle_throws() {
            Book input = new Book("Effective Java", "Joshua Bloch", 2018);
            when(bookRepository.findByTitle("Effective Java"))
                    .thenReturn(Optional.of(new Book("Effective Java", "Someone Else", 2015)));

            assertThrows(DuplicateBookException.class, () -> bookService.create(input));

            verify(bookRepository, never()).save(any(Book.class));
        }
    }

    @Nested
    @DisplayName("getById")
    class GetById {

        @Test
        @DisplayName("存在时返回图书")
        void getById_found_returnsBook() {
            when(bookRepository.findById(1L))
                    .thenReturn(Optional.of(new Book("Effective Java", "Joshua Bloch", 2018)));

            assertEquals("Effective Java", bookService.getById(1L).getTitle());
        }

        @Test
        @DisplayName("不存在时抛出 BookNotFoundException")
        void getById_missing_throws() {
            when(bookRepository.findById(999L)).thenReturn(Optional.empty());

            BookNotFoundException ex = assertThrows(
                    BookNotFoundException.class,
                    () -> bookService.getById(999L));

            assertEquals(999L, ex.getId());
        }
    }
}