Spring Boot 应用的测试能力

package com.example.myapp.my_spring_boot_app.service;
 
import com.example.myapp.my_spring_boot_app.model.Course;
import com.example.myapp.my_spring_boot_app.repository.CourseRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
 
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
 
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
 
@ExtendWith(MockitoExtension.class)
class CourseServiceTest {
 
    @Mock
    private CourseRepository courseRepository;
 
    @InjectMocks
    private CourseService courseService;
 
    private Course testCourse;
 
    @BeforeEach
    void setUp() {
        testCourse = new Course(1L, "Spring Boot测试", "学习如何编写测试", "编程", 2);
    }
 
    @Test
    void testListCourses() {
        List<Course> courses = Arrays.asList(testCourse);
        when(courseRepository.findAll()).thenReturn(courses);
 
        List<Course> result = courseService.listCourses();
 
        assertEquals(1, result.size());
        assertEquals("Spring Boot测试", result.get(0).getTitle());
        verify(courseRepository, times(1)).findAll();
    }
 
    @Test
    void testGetCourseOrThrow_WhenCourseExists() {
        when(courseRepository.findById(1L)).thenReturn(Optional.of(testCourse));
 
        Course result = courseService.getCourseOrThrow(1L);
 
        assertNotNull(result);
        assertEquals("Spring Boot测试", result.getTitle());
        verify(courseRepository, times(1)).findById(1L);
    }
 
    @Test
    void testGetCourseOrThrow_WhenCourseNotExists() {
        when(courseRepository.findById(999L)).thenReturn(Optional.empty());
 
        assertThrows(IllegalArgumentException.class, () -> {
            courseService.getCourseOrThrow(999L);
        });
 
        verify(courseRepository, times(1)).findById(999L);
    }
 
    @Test
    void testCreateCourse_WithValidData() {
        when(courseRepository.save(any(Course.class))).thenReturn(testCourse);
 
        Course result = courseService.createCourse("Spring Boot测试", "学习如何编写测试", "编程", 2);
 
        assertNotNull(result);
        assertEquals("Spring Boot测试", result.getTitle());
        verify(courseRepository, times(1)).save(any(Course.class));
    }
 
    @Test
    void testCreateCourse_WithEmptyTitle() {
        assertThrows(IllegalArgumentException.class, () -> {
            courseService.createCourse("", "描述", "编程", 2);
        });
 
        verify(courseRepository, never()).save(any(Course.class));
    }
 
    @Test
    void testUpdateCourse_WhenCourseExists() {
        Course updatedCourse = new Course(1L, "更新的标题", "更新的描述", "编程", 3);
        when(courseRepository.findById(1L)).thenReturn(Optional.of(testCourse));
        when(courseRepository.save(any(Course.class))).thenReturn(updatedCourse);
 
        Course result = courseService.updateCourse(1L, "更新的标题", "更新的描述", "编程", 3);
 
        assertEquals("更新的标题", result.getTitle());
        assertEquals("更新的描述", result.getDescription());
        verify(courseRepository, times(1)).findById(1L);
        verify(courseRepository, times(1)).save(any(Course.class));
    }
 
    @Test
    void testDeleteCourse_WhenCourseExists() {
        when(courseRepository.existsById(1L)).thenReturn(true);
        doNothing().when(courseRepository).deleteById(1L);
 
        courseService.deleteCourse(1L);
 
        verify(courseRepository, times(1)).existsById(1L);
        verify(courseRepository, times(1)).deleteById(1L);
    }
 
    @Test
    void testDeleteCourse_WhenCourseNotExists() {
        when(courseRepository.existsById(999L)).thenReturn(false);
 
        assertThrows(IllegalArgumentException.class, () -> {
            courseService.deleteCourse(999L);
        });
 
        verify(courseRepository, times(1)).existsById(999L);
        verify(courseRepository, never()).deleteById(anyLong());
    }
}

package com.example.myapp.my_spring_boot_app.repository;
 
import com.example.myapp.my_spring_boot_app.model.Course;
import org.junit.jupiter.api.Test;
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 java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
 
import static org.junit.jupiter.api.Assertions.*;
 
@DataJpaTest
class CourseRepositoryTest {
 
    @Autowired

package com.example.myapp.my_spring_boot_app.controller;
 
import com.example.myapp.my_spring_boot_app.model.Course;
import com.example.myapp.my_spring_boot_app.service.CourseService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
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 java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
 
import static org.mockito.ArgumentMatchers.any;

package com.example.myapp.my_spring_boot_app;
 
import com.example.myapp.my_spring_boot_app.model.Course;
import com.example.myapp.my_spring_boot_app.repository.CourseRepository;
import com.example.myapp.my_spring_boot_app.service.CourseService;
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.context.ActiveProfiles;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.HashMap;
import java.util.Map;

package com.example.myapp.my_spring_boot_app.service;
 
import com.example.myapp.my_spring_boot_app.model.Course;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
 
import java.time.Duration;
 
class ReactiveCourseServiceTest {
 
    private ReactiveCourseService service = new ReactiveCourseService();
 
    @Test
    void testFindCourseById() {
        Mono<Course> courseMono =

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
 
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
 
logging.level.root=WARN
logging.level.com.example.myapp=DEBUG

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mysql</artifactId>
    <scope>test</scope>

@SpringBootTest
@Testcontainers
class CourseRepositoryWithTestcontainersTest {
 
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
 
    @DynamicPropertySource
    static void

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.11</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <