如何在Java編寫單元測試？

要編寫Java單元測試，首先需在項目中引入JUnit 5，Maven項目在pom.xml中添加junit-jupiter依賴，Gradle項目添加testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'，並將測試類置於src/test/java目錄下；接著創建測試類，使用@Test註解標記測試方法，通過assertEquals、assertThrows等斷言驗證行為，如測試Calculator類的add和divide方法；利用@BeforeEach和@AfterEach註解進行測試前準備和清理；遵循每次測試單一行為、使用描述性命名如shouldReturnSumWhenAddingTwoNumbers、採用AAA（Arrange-Act-Assert）結構組織測試代碼、覆蓋邊界條件如除零異常、保持測試獨立快速、通過Mockito模擬外部依賴如EmailService以隔離邏輯，最終實現可維護、可靠的單元測試體系。

Writing unit tests in Java is a fundamental practice for ensuring code correctness and maintainability. The most commonly used framework for this is JUnit , currently in its JUnit 5 version. Here's how to get started and write effective unit tests.

Set up JUnit in your project

Before writing tests, make sure JUnit is included in your project dependencies.

If you're using Maven , add this to your pom.xml :

 <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.3</version>
    <scope>test</scope>
</dependency>

For Gradle , include:

 testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'

Tests are typically placed in the src/test/java directory, mirroring your main package structure.

Write a simple unit test with JUnit 5

Suppose you have a simple class:

 public class Calculator {
    public int add(int a, int b) {
        return ab;
    }

    public int divide(int a, int b) {
        if (b == 0) throw new IllegalArgumentException("Division by zero");
        return a / b;
    }
}

Here's how to test it:

 import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {

    private Calculator calculator = new Calculator();

    @Test
    public void testAdd() {
        int result = calculator.add(2, 3);
        assertEquals(5, result, "2 3 should equal 5");
    }

    @Test
    public void testDivide() {
        int result = calculator.divide(10, 2);
        assertEquals(5, result);
    }

    @Test
    public void testDivideByZero() {
        assertThrows(IllegalArgumentException.class, () -> {
            calculator.divide(10, 0);
        });
    }
}

Key points:

• Use @Test to mark a method as a test.
• assertEquals(expected, actual) checks if values match.
• assertThrows verifies that an exception is thrown.

Use setup and teardown with annotations

If you need to prepare resources before or after tests:

 import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;

public class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @AfterEach
    void tearDown() {
        // Clean up if needed
    }

    @Test
    void testAdd() {
        assertEquals(4, calculator.add(1, 3));
    }
}

@BeforeEach runs before each test; @AfterEach runs after.

Best practices for writing good unit tests

• Test one thing at a time
  Each test should verify a single behavior or edge case.

• Use descriptive test names
  Instead of test1() , use shouldReturnSumWhenAddingTwoNumbers() .

  Example:

   @Test
  void shouldThrowExceptionWhenDividingByZero() {
      assertThrows(IllegalArgumentException.class, () -> {
          calculator.divide(5, 0);
      });
  }

• Follow the AAA pattern
  Arrange, Act, Assert:

   @Test
  void addShouldReturnSumOfTwoNumbers() {
      // Arrange
      int a = 5;
      int b = 7;
      // Act
      int result = calculator.add(a, b);
      // Assert
      assertEquals(12, result);
  }

• Test edge cases
  Include zero, negative numbers, null inputs, or invalid states.

• Keep tests independent and fast
  Avoid dependencies between tests. Unit tests should run quickly and not rely on external systems like databases or networks.

Use mocking for dependencies

When your class depends on other components (eg, services, repositories), use Mockito to simulate them.

Add Mockito to your project:

 <dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.2.0</version>
    <scope>test</scope>
</dependency>

Example:

 import static org.mockito.Mockito.*;
import org.mockito.Mock;
import org.junit.jupiter.api.BeforeEach;

public class PaymentServiceTest {

    @Mock
    private EmailService emailService;

    private PaymentService paymentService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        paymentService = new PaymentService(emailService);
    }

    @Test
    void processPaymentShouldSendEmailOnSuccess() {
        paymentService.processPayment(100.0);

        verify(emailService, times(1)).sendConfirmationEmail(100.0);
    }
}

This way, you isolate the logic of PaymentService without actually sending emails.

Basically, writing unit tests in Java involves setting up JUnit, writing focused test methods using assertions, organizing test lifecycle, and isolating dependencies with mocks when needed. It's not complicated, but consistency and good habits make a big difference.

以上是如何在Java編寫單元測試？的詳細內容。更多資訊請關注PHP中文網其他相關文章！