Java Web项目测试教程

// 示例：创建一个POST请求来添加新用户
// URL: http://localhost:8080/api/users
// Headers: 
//   Content-Type: application/json
// Body:
{
  "username": "testuser",
  "email": "test@example.com",
  "password": "securePassword123",
  "role": "USER"
}

// 在Postman的Tests标签页中添加以下脚本
// 验证状态码
pm.test("Status code is 201", function () {
    pm.response.to.have.status(201);
});

// 验证响应时间
pm.test("Response time is less than 200ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(200);
});

// 验证响应格式
pm.test("Response is JSON", function () {
    pm.response.to.be.json;
});

// 验证响应内容
pm.test("User created successfully", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.success).to.eql(true);
    pm.expect(jsonData.data.username).to.eql("testuser");
    pm.expect(jsonData.data).to.have.property('id');
});

# 使用Newman运行Postman集合
npm install -g newman
newman run your-collection.json -e your-environment.json

<!-- Maven依赖 -->
<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <version>5.3.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

public class UserApiTest {
    
    @BeforeAll
    public static void setup() {
        baseURI = "http://localhost:8080";
        basePath = "/api";
    }
    
    @Test
    public void testGetAllUsers() {
        given()
            .header("Content-Type", "application/json")
        .when()
            .get("/users")
        .then()
            .statusCode(200)
            .body("size()", greaterThan(0))
            .time(lessThan(1000L));
    }
    
    @Test
    public void testCreateUser() {
        String userJson = "{\n" +
            "  \"username\": \"testuser\",\n" +
            "  \"email\": \"test@example.com\",\n" +
            "  \"password\": \"securePassword123\",\n" +
            "  \"role\": \"USER\"\n" +
            "}";
            
        given()
            .header("Content-Type", "application/json")
            .body(userJson)
        .when()
            .post("/users")
        .then()
            .statusCode(201)
            .body("success", equalTo(true))
            .body("data.username", equalTo("testuser"))
            .body("data.id", notNullValue());
    }
}

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

import io.restassured.http.ContentType;
import io.restassured.response.Response;
import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.Map;

public class AdvancedApiTest {
    
    // 测试身份验证
    @Test
    public void testAuthenticatedEndpoint() {
        // 先获取认证令牌
        String token = given()
            .contentType(ContentType.JSON)
            .body("{ \"username\": \"admin\", \"password\": \"admin123\" }")
        .when()
            .post("/auth/login")
        .then()
            .statusCode(200)
            .extract()
            .path("token");
            
        // 使用令牌访问受保护的API
        given()
            .header("Authorization", "Bearer " + token)
        .when()
            .get("/admin/dashboard")
        .then()
            .statusCode(200)
            .body("authorized", equalTo(true));
    }
    
    // 测试并发请求
    @Test
    public void testConcurrentRequests() throws InterruptedException {
        Map<Integer, Response> responses = new HashMap<>();
        
        // 创建10个并发请求
        for (int i = 0; i < 10; i++) {
            final int requestId = i;
            new Thread(() -> {
                Response response = given()
                    .param("id", requestId)
                .when()
                    .get("/users/search");
                    
                synchronized (responses) {
                    responses.put(requestId, response);
                }
            }).start();
        }
        
        // 等待所有请求完成
        Thread.sleep(2000);
        
        // 验证所有响应
        for (Map.Entry<Integer, Response> entry : responses.entrySet()) {
            entry.getValue().then().statusCode(200);
        }
    }
    
    // 文件上传测试
    @Test
    public void testFileUpload() {
        File testFile = new File("src/test/resources/test-image.jpg");
        
        given()
            .multiPart("file", testFile)
            .formParam("description", "Test image upload")
        .when()
            .post("/upload")
        .then()
            .statusCode(200)
            .body("fileName", containsString("test-image"))
            .body("fileSize", greaterThan(0));
    }
}

<dependency>
    <groupId>org.easymock</groupId>
    <artifactId>easymock</artifactId>
    <version>5.1.0</version>
    <scope>test</scope>
</dependency>

testImplementation 'org.easymock:easymock:5.1.0'

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

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

// 被测试的服务接口
public interface UserService {
    User findById(long id);
    boolean saveUser(User user);
}

// 被测试的类
public class UserController {
    private UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    public String getUserName(long id) {
        User user = userService.findById(id);
        return user != null ? user.getName() : "未知用户";
    }
}

// 测试类
public class UserControllerTest {
    @Test
    public void testGetUserName() {
        // 创建模拟对象
        UserService mockUserService = mock(UserService.class);
        
        // 记录预期行为
        User testUser = new User(1L, "张三");
        expect(mockUserService.findById(1L)).andReturn(testUser);
        expect(mockUserService.findById(2L)).andReturn(null);
        
        // 激活模拟对象
        replay(mockUserService);
        
        // 使用模拟对象测试
        UserController controller = new UserController(mockUserService);
        assertEquals("张三", controller.getUserName(1L));
        assertEquals("未知用户", controller.getUserName(2L));
        
        // 验证模拟对象的所有预期都被调用
        verify(mockUserService);
    }
}

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

public class DatabaseConnectorTest {
    @Test
    public void testDatabaseOperation() {
        // 创建类模拟对象
        Database mockDatabase = createMock(Database.class);
        
        // 记录预期行为
        mockDatabase.connect("test_db");
        expect(mockDatabase.executeQuery("SELECT * FROM users")).andReturn(new String[]{"user1", "user2"});
        mockDatabase.disconnect();
        
        // 激活模拟对象
        replay(mockDatabase);
        
        // 使用模拟对象
        DatabaseConnector connector = new DatabaseConnector(mockDatabase);
        String[] results = connector.queryUsers();
        
        // 验证结果
        assertArrayEquals(new String[]{"user1", "user2"}, results);
        
        // 验证交互
        verify(mockDatabase);
    }
}

// 使用anyInt()匹配任意整数
expect(mockService.process(anyInt())).andReturn(true);

// 使用eq()匹配特定值
expect(mockService.process(eq(100))).andReturn(true);

// 使用matches()使用正则表达式匹配
expect(mockRepository.findByEmail(matches(".*@example\\.com"))).andReturn(user);

// 使用自定义匹配器
expect(mockValidator.validate(and(notNull(), isA(User.class)))).andReturn(true);

// 模拟方法多次调用返回不同结果
expect(mockCounter.getCount())
    .andReturn(1)
    .andReturn(2)
    .andReturn(3);

// 模拟方法抛出异常
expect(mockDatabase.connect("invalid_db"))
    .andThrow(new DatabaseException("连接失败"));

// 模拟方法执行自定义逻辑
expect(mockTransformer.transform(anyString()))
    .andAnswer(() -> getCurrentArguments()[0].toString().toUpperCase());

// 创建部分模拟
Calculator calculator = partialMockBuilder(Calculator.class)
    .addMockedMethod("multiply")
    .createMock();

// 设置被模拟方法的行为
expect(calculator.multiply(10, 20)).andReturn(500); // 故意返回错误结果
replay(calculator);

// 测试：模拟方法返回我们设定的值
assertEquals(500, calculator.multiply(10, 20));

// 测试：非模拟方法保持原有行为
assertEquals(30, calculator.add(10, 20));

import static org.easymock.EasyMock.*;
import org.easymock.EasyMockExtension;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(EasyMockExtension.class)
public class OrderServiceTest {

    // 使用EasyMock注解简化模拟对象创建
    @Mock
    private OrderRepository orderRepository;
    
    @Mock
    private PaymentService paymentService;
    
    @Mock
    private NotificationService notificationService;
    
    // 标记被测试的类
    @TestSubject
    private OrderServiceImpl orderService = new OrderServiceImpl();
    
    @Test
    public void testPlaceOrder_Success() {
        // 准备测试数据
        Order order = new Order();
        order.setId(1L);
        order.setUserId(100L);
        order.setAmount(199.99);
        order.setStatus(OrderStatus.PENDING);
        
        PaymentResult paymentResult = new PaymentResult(true, "支付成功");
        
        // 记录期望行为
        expect(orderRepository.save(anyObject(Order.class))).andReturn(order);
        expect(paymentService.processPayment(eq(100L), eq(199.99))).andReturn(paymentResult);
        notificationService.sendOrderConfirmation(eq(1L), eq(100L));
        expectLastCall().once();
        
        // 激活所有模拟对象
        replay(orderRepository, paymentService, notificationService);
        
        // 执行被测试方法
        OrderResult result = orderService.placeOrder(order);
        
        // 验证结果
        assertTrue(result.isSuccess());
        assertEquals("订单处理成功", result.getMessage());
        assertEquals(OrderStatus.PAID, order.getStatus());
        
        // 验证所有交互
        verify(orderRepository, paymentService, notificationService);
    }
    
    @Test
    public void testPlaceOrder_PaymentFailure() {
        // 准备测试数据
        Order order = new Order();
        order.setId(2L);
        order.setUserId(101L);
        order.setAmount(299.99);
        order.setStatus(OrderStatus.PENDING);
        
        PaymentResult paymentResult = new PaymentResult(false, "支付失败：余额不足");
        
        // 记录期望行为
        expect(orderRepository.save(anyObject(Order.class))).andReturn(order);
        expect(paymentService.processPayment(eq(101L), eq(299.99))).andReturn(paymentResult);
        // 支付失败不应发送确认通知
        
        // 激活所有模拟对象
        replay(orderRepository, paymentService, notificationService);
        
        // 执行被测试方法
        OrderResult result = orderService.placeOrder(order);
        
        // 验证结果
        assertFalse(result.isSuccess());
        assertEquals("支付失败：余额不足", result.getMessage());
        assertEquals(OrderStatus.PAYMENT_FAILED, order.getStatus());
        
        // 验证所有交互
        verify(orderRepository, paymentService, notificationService);
    }
}