测试代码重构：如何将1000行测试代码砍到200行_千锋教育

// 坏味道示例
@Test
public void testUserAge() {
    User user = new User("Alice", 25);
    assertEquals(25, user.getAge());
    assertTrue(user.isAdult());
}

@Test
public void testOrderProcessing() {
    // 50行初始化代码
    User user = new User("test@test.com", "Test1234", "123 Main St", "555-1234", 1);
    Order order = new Order(user, LocalDateTime.now(), "CREDIT_CARD", 99.99);
    Payment payment = new Payment(order, 99.99, "USD", "SUCCESS");
    Shipping shipping = new Shipping(order, "123 Main St", "FEDEX", "TRACKING123");
    // ... 更多重复代码
}

assertTrue(result.contains("success"));

@Test
public void testOrderTotal() {
    User user = new User("test@test.com", "Test1234", "123 Main St", "555-1234", 1);
    Order order = new Order(user, LocalDateTime.now(), "CREDIT_CARD", 99.99);
    order.addItem(new OrderItem("book", 1, 29.99));
    order.addItem(new OrderItem("pen", 2, 5.99));
    assertEquals(41.97, order.getTotal(), 0.01);
}

@Test
public void testOrderDiscount() {
    User user = new User("test@test.com", "Test1234", "123 Main St", "555-1234", 1);
    Order order = new Order(user, LocalDateTime.now(), "CREDIT_CARD", 99.99);
    order.addItem(new OrderItem("book", 10, 29.99));
    order.applyDiscount(0.1);
    assertEquals(269.91, order.getTotal(), 0.01);
}

// 测试工厂
public class TestDataFactory {
    public static User createDefaultUser() {
        return new User("default@test.com", "Default123", "Default Address", "000-0000", 1);
    }
    
    public static Order createOrderWithItems(User user, double... itemPrices) {
        Order order = new Order(user, LocalDateTime.now(), "CREDIT_CARD", 0);
        for (double price : itemPrices) {
            order.addItem(new OrderItem("item", 1, price));
        }
        return order;
    }
}

// 测试方法
@Test
public void testOrderTotal() {
    User user = TestDataFactory.createDefaultUser();
    Order order = TestDataFactory.createOrderWithItems(user, 29.99, 5.99, 5.99);
    assertEquals(41.97, order.getTotal(), 0.01);
}

@Test
public void testOrderDiscount() {
    User user = TestDataFactory.createDefaultUser();
    Order order = TestDataFactory.createOrderWithItems(user, 29.99, 29.99, 29.99);
    order.applyDiscount(0.1);
    assertEquals(80.97, order.getTotal(), 0.01);
}

@Test
public void testAdultAge18() {
    User user = new User("test", 18);
    assertTrue(user.isAdult());
}

@Test
public void testAdultAge25() {
    User user = new User("test", 25);
    assertTrue(user.isAdult());
}

@Test
public void testNotAdultAge17() {
    User user = new User("test", 17);
    assertFalse(user.isAdult());
}

@ParameterizedTest
@CsvSource({
    "18, true",
    "25, true",
    "17, false",
    "0, false",
    "120, true"
})
public void testIsAdult(int age, boolean expected) {
    User user = new User("test", age);
    assertEquals(expected, user.isAdult());
}

@ParameterizedTest
@MethodSource("provideOrderData")
public void testOrderTotalWithDiscount(double price, int quantity, double discount, double expected) {
    Order order = new Order(TestDataFactory.createDefaultUser());
    order.addItem(new OrderItem("item", quantity, price));
    order.applyDiscount(discount);
    assertEquals(expected, order.getTotal(), 0.01);
}

private static Stream<Arguments> provideOrderData() {
    return Stream.of(
        Arguments.of(10.0, 1, 0.0, 10.0),
        Arguments.of(10.0, 2, 0.1, 18.0),
        Arguments.of(50.0, 1, 0.5, 25.0),
        Arguments.of(100.0, 3, 0.2, 240.0)
    );
}

assertTrue(result.contains("error"));
assertNotNull(response);
assertFalse(list.isEmpty());

// 自定义断言类
public class OrderAssertions {
    public static void assertOrderTotal(Order order, double expectedTotal) {
        double actualTotal = order.getTotal();
        String message = String.format("Expected order total: %.2f, but got: %.2f", expectedTotal, actualTotal);
        assertEquals(expectedTotal, actualTotal, 0.01, message);
    }
    
    public static void assertOrderContainsItem(Order order, String itemName, int expectedQuantity) {
        boolean found = order.getItems().stream()
            .anyMatch(item -> item.getName().equals(itemName) && item.getQuantity() == expectedQuantity);
        assertTrue(found, "Order should contain item: " + itemName + " with quantity: " + expectedQuantity);
    }
    
    public static void assertOrderStatus(Order order, OrderStatus expectedStatus) {
        assertEquals(expectedStatus, order.getStatus(), 
            "Order status mismatch. Expected: " + expectedStatus + ", Actual: " + order.getStatus());
    }
}

// 使用自定义断言
@Test
public void testComplexOrderScenario() {
    Order order = createComplexOrder();
    order.processPayment();
    order.ship();
    
    OrderAssertions.assertOrderTotal(order, 299.99);
    OrderAssertions.assertOrderContainsItem(order, "Premium Book", 3);
    OrderAssertions.assertOrderStatus(order, OrderStatus.SHIPPED);
}

@Test
public void testUserCanPurchasePremiumItem() {
    // Given
    User user = TestDataFactory.createPremiumUser();
    Order order = TestDataFactory.createEmptyOrder(user);
    Item item = new Item("Premium Book", 99.99, ItemCategory.PREMIUM);
    
    // When
    boolean canPurchase = order.canAddItem(item);
    
    // Then
    assertTrue(canPurchase, "Premium user should be able to purchase premium items");
    OrderAssertions.assertOrderTotal(order, 0.0);
}