Mengautomasikan Ujian dalam But Spring dengan JUnit dan Mockito

Dalam pembangunan perisian, mengekalkan kod berkualiti tinggi adalah penting, terutamanya apabila sistem berkembang dalam kerumitan. Ujian automatik memainkan peranan penting dalam memastikan ciri baharu tidak memecahkan kefungsian sedia ada dan kod itu kekal teguh dan boleh dipercayai dari semasa ke semasa. Untuk aplikasi Spring Boot, JUnit dan Mockito ialah dua alat yang paling popular untuk ujian unit dan kebergantungan mengejek, masing-masing. Dalam siaran ini, kami akan meneroka cara memanfaatkan alatan ini untuk membuat ujian automatik yang berkesan dalam Spring Boot, memastikan aplikasi anda kekal stabil dan boleh diselenggara.

JUnit ialah rangka kerja ujian yang digunakan secara meluas untuk Java yang menyediakan anotasi dan penegasan untuk membantu menstruktur dan melaksanakan ujian dengan berkesan. Ia membolehkan pembangun menulis ujian boleh berulang dan menyokong kedua-dua ujian unit dan penyepaduan. Sebaliknya, Mockito ialah rangka kerja mengejek yang berkuasa yang membolehkan penciptaan objek olok-olok untuk tujuan ujian. Ia membolehkan pembangun mensimulasikan tingkah laku kebergantungan kompleks, mengasingkan kefungsian yang sedang diuji. Dengan menggunakan JUnit dalam kombinasi dengan Mockito, kami boleh menguji logik perniagaan aplikasi Spring Boot kami dengan teliti tanpa bergantung pada sambungan pangkalan data sebenar, perkhidmatan luaran atau konfigurasi yang kompleks.

Mari kita menyelami contoh praktikal untuk melihat cara JUnit dan Mockito boleh digunakan bersama dalam aplikasi Spring Boot. Kami akan membuat kelas perkhidmatan ringkas dan menulis ujian untuknya menggunakan JUnit dan Mockito.

Andaikan kami mempunyai kelas UserService yang bergantung pada UserRepository untuk mengambil data pengguna:

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

Di sini, UserService bergantung pada UserRepository, iaitu antara muka repositori Spring Data JPA. Untuk menguji getUserByIdmethod tanpa memukul pangkalan data, kita boleh menggunakan Mockito untuk mengejek UserRepositorydan JUnit untuk menegaskan tingkah laku UserService.

Begini cara kami boleh menulis ujian untuk UserService:

@SpringBootTest
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testGetUserById_Success() {
        // Arrange
        User user = new User(1L, "John Doe", "john.doe@example.com");
        when(userRepository.findById(1L)).thenReturn(Optional.of(user));

        // Act
        User result = userService.getUserById(1L);

        // Assert
        assertEquals("John Doe", result.getName());
        assertEquals("john.doe@example.com", result.getEmail());
    }

    @Test
    public void testGetUserById_UserNotFound() {
        // Arrange
        when(userRepository.findById(1L)).thenReturn(Optional.empty());

        // Act & Assert
        assertThrows(UserNotFoundException.class, () -> userService.getUserById(1L));
    }
}

Dalam kelas UserServiceTest, kami menggunakan anotasi @Mock untuk mencipta contoh olok-olok UserRepository dan anotasi @InjectMocks untuk menyuntik olok-olok ini ke dalam UserService. Kaedah setUp memulakan olok-olok sebelum setiap ujian.

Kami kemudian mentakrifkan dua ujian:

testGetUserById_Success: Ujian ini mengesahkan bahawa apabila pengguna ditemui oleh UserRepository, UserService mengembalikan pengguna yang betul.
testGetUserById_UserNotFound: Ujian ini memastikan bahawa apabila UserRepository mengembalikan hasil kosong, UserService membuang UserNotFoundException.
Ujian ini membolehkan kami mengesahkan kelakuan UserService tanpa perlu bergantung pada pangkalan data sebenar, menjadikannya lebih pantas dan lebih dipercayai.

Mengautomasikan ujian dengan aplikasi JUnit dan Mockito dalam Spring Boot menyediakan cara yang berkesan untuk memastikan kualiti kod dan kestabilan aplikasi. Dengan menulis ujian unit yang komprehensif, pembangun boleh menangkap pepijat pada awal proses pembangunan, menjadikannya lebih mudah untuk memfaktorkan semula kod dan menambah ciri baharu dengan yakin. Gabungan JUnit dan Mockito membolehkan ujian yang jelas dan padat yang memfokuskan pada logik perniagaan aplikasi anda, bebas daripada kerumitan kebergantungan luaran.

Mengambil ujian automatik sebagai amalan teras bukan sahaja meningkatkan kebolehpercayaan pangkalan kod anda tetapi juga meningkatkan aliran kerja pembangunan keseluruhan. Dengan menyepadukan ujian ini ke dalam saluran paip CI/CD anda, anda memastikan bahawa pemeriksaan kualiti adalah automatik dan konsisten, membuka jalan kepada proses pembangunan yang lebih tangkas dan berdaya tahan. Jadi, sama ada anda memulakan projek baharu atau mempertingkatkan projek sedia ada, jadikan ujian automatik dengan JUnit dan Mockito sebagai sebahagian daripada strategi pembangunan anda.

Atas ialah kandungan terperinci Mengautomasikan Ujian dalam But Spring dengan JUnit dan Mockito. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!