Тестирование в Java: JUnit 5 + Mockito

1import org.junit.jupiter.api.*;
2import static org.junit.jupiter.api.Assertions.*;
3
4class UserServiceTest {
5
6    private UserService userService;
7
8    @BeforeEach
9    void setUp() {
10        userService = new UserService();
11    }
12
13    @Test
14    void shouldCreateUser() {
15        // Arrange
16        CreateUserRequest request = new CreateUserRequest("John", "john@test.com");
17
18        // Act
19        User result = userService.create(request);
20
21        // Assert
22        assertNotNull(result);
23        assertEquals("John", result.getName());
24        assertEquals("john@test.com", result.getEmail());
25    }
26
27    @Test
28    void shouldThrowExceptionWhenEmailExists() {
29        // Arrange
30        CreateUserRequest request = new CreateUserRequest("John", "existing@test.com");
31
32        // Act & Assert
33        assertThrows(DuplicateEmailException.class,
34            () -> userService.create(request));
35    }
36}

1@ParameterizedTest
2@CsvSource({
3    "1, 1, 2",
4    "2, 3, 5",
5    "0, 0, 0"
6})
7void shouldAddNumbers(int a, int b, int expected) {
8    assertEquals(expected, calculator.add(a, b));
9}
10
11@ParameterizedTest
12@ValueSource(strings = {"racecar", "radar", "level"})
13void shouldDetectPalindromes(String word) {
14    assertTrue(calculator.isPalindrome(word));
15}

1@ExtendWith(MockitoExtension.class)
2class OrderServiceTest {
3
4    @Mock
5    private OrderRepository orderRepository;
6
7    @Mock
8    private PaymentService paymentService;
9
10    @InjectMocks
11    private OrderService orderService;
12
13    @Test
14    void shouldCreateOrder() {
15        // Arrange
16        CreateOrderRequest request = new CreateOrderRequest(1L, List.of(item1, item2));
17        Order expectedOrder = new Order(1L, request.getItems(), OrderStatus.CREATED);
18
19        when(orderRepository.save(any(Order.class))).thenReturn(expectedOrder);
20
21        // Act
22        Order result = orderService.createOrder(request);
23
24        // Assert
25        assertNotNull(result);
26        assertEquals(OrderStatus.CREATED, result.getStatus());
27        verify(orderRepository).save(any(Order.class));
28    }
29}

1ArgumentCaptor<Order> orderCaptor = ArgumentCaptor.forClass(Order.class);
2
3orderService.createOrder(request);
4
5verify(orderRepository).save(orderCaptor.capture());
6Order savedOrder = orderCaptor.getValue();
7assertEquals(OrderStatus.CREATED, savedOrder.getStatus());

1@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
2@AutoConfigureTestDatabase
3class UserRepositoryIntegrationTest {
4
5    @Autowired
6    private TestEntityManager entityManager;
7
8    @Autowired
9    private UserRepository userRepository;
10
11    @Test
12    void shouldFindUserByEmail() {
13        // Arrange
14        User user = new User("John", "john@test.com");
15        entityManager.persistAndFlush(user);
16
17        // Act
18        Optional<User> found = userRepository.findByEmail("john@test.com");
19
20        // Assert
21        assertTrue(found.isPresent());
22        assertEquals("John", found.get().getName());
23    }
24}

1@SpringBootTest
2@Testcontainers
3class UserRepositoryTest {
4
5    @Container
6    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
7        .withDatabaseName("testdb")
8        .withUsername("test")
9        .withPassword("test");
10
11    @DynamicPropertySource
12    static void configureProperties(DynamicPropertyRegistry registry) {
13        registry.add("spring.datasource.url", postgres::getJdbcUrl);
14        registry.add("spring.datasource.username", postgres::getUsername);
15        registry.add("spring.datasource.password", postgres::getPassword);
16    }
17}

1@DisplayName("UserService")
2class UserServiceTest {
3
4    @Test
5    @DisplayName("should return user when valid ID provided")
6    void shouldReturnUserWhenValidIdProvided() { }
7
8    @Test
9    @DisplayName("should throw exception when user not found")
10    void shouldThrowExceptionWhenUserNotFound() { }
11}