# Maven: run tests and capture timing in the Surefire report
mvn test
# Check: target/surefire-reports/*.xml — each test has 'time' attribute

# Find the slowest tests across all XML reports
grep -h 'time=' target/surefire-reports/*.xml | 
  grep -oP 'time="[0-9.]+"' | 
  sort -t'"' -k2 -rn | 
  head -20

# Gradle: generate a test report with timing
./gradlew test
# Check: build/reports/tests/test/index.html
# Sort by duration in the 'Classes' tab

// SLOW: Different @MockBean in each class = unique context = fresh startup each time
@SpringBootTest
class OrderControllerTest {
    @MockBean PaymentGateway gateway;  // unique context config A
}

@SpringBootTest
class InvoiceControllerTest {
    @MockBean TaxCalculator taxCalc;   // unique context config B = ANOTHER startup
}

// FAST: Shared context configuration = Spring caches and reuses it
// Define all @MockBeans in ONE base class — all subclasses share the same context
@SpringBootTest
@MockBeanAnnotationsFromClass  // or simply put all @MockBeans here
public abstract class BaseIntegrationTest {
    // Declare ALL mocks used by ANY integration test here
    @MockBean protected PaymentGateway paymentGateway;
    @MockBean protected TaxCalculator  taxCalculator;
    @MockBean protected EmailService   emailService;
    // Spring starts ONE context for all subclasses = startup cost paid ONCE
}

class OrderControllerTest extends BaseIntegrationTest { /* tests */ }
class InvoiceControllerTest extends BaseIntegrationTest { /* tests */ }
// Context reused — 3-10 second startup paid ONCE instead of per class

// SLOW: Full context for a controller test that only needs the web layer
@SpringBootTest  // loads EVERYTHING: JPA, security, services, caches, Kafka...
class ProductControllerTest {
    // Test only calls GET /api/products and checks JSON output
    // Does NOT need JPA, Kafka, or cache layers
}

// FAST: Slice test loads only what is needed
@WebMvcTest(ProductController.class)  // loads: controller, security, JSON converters
class ProductControllerTest {
    @MockBean private ProductService productService; // mock the service
    // Startup: ~300ms vs 5s for full @SpringBootTest
    // Net saving: 4.7 seconds per class
}

// SLOW: Using @SpringBootTest for service logic that has no Spring dependency
@SpringBootTest  // 5 second startup for pure calculation logic
class TaxCalculatorTest {
    @Autowired TaxCalculator taxCalculator; // could just be: new TaxCalculator()

    @Test
    void vatAppliedAtTwentyPercent() {
        assertEquals(120.00, taxCalculator.withVat(100.00), 0.001);
    }
}

// FAST: Pure unit test — no Spring, no @Autowired
class TaxCalculatorTest {
    private final TaxCalculator taxCalculator = new TaxCalculator();

    @Test
    void vatAppliedAtTwentyPercent() {
        assertEquals(120.00, taxCalculator.withVat(100.00), 0.001);
    }
    // Execution: <5ms vs 5000ms. 1000x faster.
}

// SLOW: Non-static @Container restarts Docker container for every test
@Testcontainers
class OrderRepositoryTest {
    // non-static = new container for each test METHOD = 3-5s per test
    @Container
    PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");
}

// FAST: Static @Container shared across all tests in the class
@Testcontainers
class OrderRepositoryTest {
    // static = one container for all tests in this class = 3-5s TOTAL
    @Container
    static final PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:16-alpine");
}

// FASTEST: Singleton container shared across ALL test classes
public abstract class AbstractPostgresTest {
    static final PostgreSQLContainer<?> POSTGRES;
    static {
        POSTGRES = new PostgreSQLContainer<>("postgres:16-alpine");
        POSTGRES.start(); // start once for the entire JVM session
    }
}

# Add to src/test/resources/junit-platform.properties

# Enable class-level parallelism (safest, biggest win)
junit.jupiter.execution.parallel.enabled=true
junit.jupiter.execution.parallel.mode.classes.default=concurrent
junit.jupiter.execution.parallel.mode.default=same_thread
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.config.dynamic.factor=1.5

# Typical result on an 8-core machine:
# Before parallel: 180 seconds
# After parallel:  48 seconds (3.75x speedup)