如何在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 a   b;
    }

    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 (e.g., 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中文网其他相关文章！