Testing

@Test
void should_calculate_total_price_when_create_order() {
    OrderItem item1 = OrderItem.create("P1", 2, new BigDecimal("10.00"));
    OrderItem item2 = OrderItem.create("P2", 3, new BigDecimal("20.00"));
    
    Order order = Order.create(
        "ORDER_123",
        Arrays.asList(item1, item2),
        createAddress()
    );
    
    assertEquals(new BigDecimal("80.00"), order.getTotalPrice());
}

@Test
void should_throw_exception_when_change_paid_order() {
    Order order = createPaidOrder();
    
    assertThrows(
        OrderCannotBeModifiedException.class,
        () -> order.changeProductCount("P1", 5)
    );
}

@SpringBootTest
@Transactional
class OrderRepositoryComponentTest extends BaseComponentTest {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Test
    void should_save_and_retrieve_order() {
        Order order = createTestOrder();
        
        orderRepository.save(order);
        
        Optional<Order> retrieved = orderRepository.findById(order.getId());
        assertTrue(retrieved.isPresent());
        assertEquals(order.getTotalPrice(), retrieved.get().getTotalPrice());
    }
    
    @Test
    void should_support_pagination() {
        // Create multiple orders
        for (int i = 0; i < 15; i++) {
            orderRepository.save(createTestOrder());
        }
        
        PageRequest pageRequest = PageRequest.of(0, 10);
        Page<Order> page = orderRepository.findAll(pageRequest);
        
        assertEquals(10, page.getContent().size());
        assertEquals(15, page.getTotalElements());
    }
}

@SpringBootTest
@TestPropertySource(properties = {
    "spring.datasource.url=jdbc:mysql://localhost:13306/ecommerce_order_mysql"
})
public abstract class BaseComponentTest {
    // Shared test configuration
}

@SpringBootTest(webEnvironment = RANDOM_PORT)
class OrderApiTest extends BaseApiTest {
    
    @Test
    void should_create_order() {
        CreateOrderCommand command = CreateOrderCommand.builder()
            .items(Arrays.asList(
                new OrderItemCommand("P1", 2, new BigDecimal("10.00"))
            ))
            .address(createTestAddress())
            .build();
        
        given()
            .contentType(ContentType.JSON)
            .body(command)
        .when()
            .post("/orders")
        .then()
            .statusCode(201)
            .body("id", notNullValue());
    }
    
    @Test
    void should_return_404_when_order_not_found() {
        given()
            .contentType(ContentType.JSON)
        .when()
            .get("/orders/NONEXISTENT")
        .then()
            .statusCode(404)
            .body("errorCode", equalTo("ORDER_NOT_FOUND"));
    }
    
    @Test
    void should_complete_order_workflow() {
        // Create order
        String orderId = createOrder();
        
        // Modify quantity
        changeProductCount(orderId, "P1", 5);
        
        // Get updated order
        OrderRepresentation order = getOrder(orderId);
        assertEquals(new BigDecimal("50.00"), order.getTotalPrice());
        
        // Pay order
        payOrder(orderId, new BigDecimal("50.00"));
        
        // Verify status changed
        order = getOrder(orderId);
        assertEquals("PAID", order.getStatus());
    }
}

sourceSets {
    componentTest {
        compileClasspath += sourceSets.main.output + sourceSets.test.output
        runtimeClasspath += sourceSets.main.output + sourceSets.test.output
    }

    apiTest {
        compileClasspath += sourceSets.main.output + sourceSets.test.output
        runtimeClasspath += sourceSets.main.output + sourceSets.test.output
    }
}

task componentTest(type: Test) {
    description = 'Run component tests.'
    group = 'verification'
    testClassesDirs = sourceSets.componentTest.output.classesDirs
    classpath = sourceSets.componentTest.runtimeClasspath
    shouldRunAfter test
}

task apiTest(type: Test) {
    description = 'Run API tests.'
    group = 'verification'
    testClassesDirs = sourceSets.apiTest.output.classesDirs
    classpath = sourceSets.apiTest.runtimeClasspath
    shouldRunAfter componentTest
}

check.dependsOn componentTest
check.dependsOn apiTest

steps:
  - name: Start MySQL
    run: docker-compose up -d mysql
    
  - name: Run tests
    run: ./gradlew test componentTest apiTest
    
  - name: Upload coverage
    uses: codecov/codecov-action@v1

public class TestDataBuilder {
    
    public static Order createTestOrder() {
        return Order.create(
            "ORDER_" + System.currentTimeMillis(),
            Arrays.asList(createTestOrderItem()),
            createTestAddress()
        );
    }
    
    public static OrderItem createTestOrderItem() {
        return OrderItem.create(
            "PRODUCT_123",
            2,
            new BigDecimal("29.99")
        );
    }
    
    public static Address createTestAddress() {
        return Address.builder()
            .province("California")
            .city("San Francisco")
            .detail("123 Market St")
            .build();
    }
}