<!-- Add to your reporting section in pom.xml -->
<reporting>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-report-plugin</artifactId>
            <version>3.2.5</version>
        </plugin>
    </plugins>
</reporting>

# Generate surefire HTML report after running tests
mvn surefire-report:report

# Or generate as part of the site lifecycle
mvn test site

# Output: target/site/surefire-report.html

<build>
    <plugins>
        <!-- JaCoCo Maven Plugin -->
        <plugin>
            <groupId>org.jacoco</groupId>
            <artifactId>jacoco-maven-plugin</artifactId>
            <version>0.8.12</version>
            <executions>

                <!-- Execution 1: prepare-agent
                     Attaches JaCoCo Java agent BEFORE tests run.
                     The agent instruments bytecode at runtime to track coverage. -->
                <execution>
                    <id>prepare-agent</id>
                    <goals><goal>prepare-agent</goal></goals>
                </execution>

                <!-- Execution 2: report
                     Generates HTML, XML, and CSV reports AFTER tests complete.
                     Output: target/site/jacoco/index.html -->
                <execution>
                    <id>generate-report</id>
                    <phase>verify</phase>
                    <goals><goal>report</goal></goals>
                </execution>

                <!-- Execution 3: check
                     Enforces minimum coverage thresholds.
                     Fails the build if coverage drops below the defined rules. -->
                <execution>
                    <id>enforce-coverage</id>
                    <phase>verify</phase>
                    <goals><goal>check</goal></goals>
                    <configuration>
                        <rules>
                            <rule>
                                <element>BUNDLE</element>  <!-- entire project -->
                                <limits>
                                    <!-- Require at least 80% line coverage -->
                                    <limit>
                                        <counter>LINE</counter>
                                        <value>COVEREDRATIO</value>
                                        <minimum>0.80</minimum>
                                    </limit>
                                    <!-- Require at least 70% branch coverage -->
                                    <limit>
                                        <counter>BRANCH</counter>
                                        <value>COVEREDRATIO</value>
                                        <minimum>0.70</minimum>
                                    </limit>
                                </limits>
                            </rule>
                        </rules>
                    </configuration>
                </execution>

            </executions>
        </plugin>
    </plugins>
</build>

# .github/workflows/ci.yml
name: CI Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      # Cache Maven dependencies — speeds up subsequent runs significantly
      - name: Cache Maven packages
        uses: actions/cache@v4
        with:
          path: ~/.m2/repository
          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
          restore-keys: ${{ runner.os }}-maven-

      # Run unit tests on every push (fast)
      - name: Run unit tests
        run: mvn test -Dgroups=unit --batch-mode

      # Run integration tests only on PRs to main (slower)
      - name: Run integration tests
        if: github.event_name == 'pull_request'
        run: mvn verify -Dgroups=integration --batch-mode

      # Publish JUnit XML results as a GitHub Check
      - name: Publish test results
        uses: EnricoMi/publish-unit-test-result-action@v2
        if: always()
        with:
          files: target/surefire-reports/**/*.xml

      # Upload JaCoCo HTML coverage report as artifact
      - name: Upload coverage report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: coverage-report
          path: target/site/jacoco/

# .github/workflows/full-ci.yml
name: Full CI with Parallel Stages

on:
  pull_request:
    branches: [ main ]

jobs:
  # Stage 1: Unit tests (fast, runs first)
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '17', distribution: 'temurin' }
      - uses: actions/cache@v4
        with:
          path: ~/.m2/repository
          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
      - name: Unit tests with coverage
        run: mvn test -Dgroups=unit jacoco:report --batch-mode
      - name: Check coverage threshold (min 80%)
        run: mvn jacoco:check --batch-mode
      - uses: actions/upload-artifact@v4
        with: { name: unit-coverage, path: target/site/jacoco/ }

  # Stage 2: Integration tests (parallel with unit tests above)
  integration-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '17', distribution: 'temurin' }
      - uses: actions/cache@v4
        with:
          path: ~/.m2/repository
          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
      # Docker is pre-installed on ubuntu-latest — Testcontainers works out of the box
      - name: Integration tests with Testcontainers
        run: mvn verify -Dgroups=integration -DexcludedGroups=unit --batch-mode
      - uses: EnricoMi/publish-unit-test-result-action@v2
        if: always()
        with: { files: target/failsafe-reports/**/*.xml }

  # Stage 3: Deploy (only if both test stages pass)
  deploy:
    needs: [ unit-tests, integration-tests ]  # waits for both parallel jobs
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - name: Deploy to staging
        run: echo "Deploying to staging..."

@Test
@DisplayName("Applying a 10% discount reduces order total correctly")
void applyingTenPercentDiscountReducesTotal() {
    // Inline test data — no setup method needed
    Order order = new Order(
        1L,
        "[email protected]",
        100.00,
        OrderStatus.PENDING
    );
    Discount discount = new Discount(DiscountType.PERCENTAGE, 10.0);

    // Act
    double discountedTotal = discountService.apply(order, discount);

    // Assert
    assertEquals(90.00, discountedTotal, 0.001,
        "10% of 100.00 should give 90.00");
}

package com.example.testdata;

/**
 * OrderMother: factory for standard Order test objects.
 * Centralises test data creation — one place to update when Order changes.
 */
public class OrderMother {

    // A valid, fully-populated Order ready to process
    public static Order validPendingOrder() {
        return Order.builder()
            .id(1L)
            .customerEmail("[email protected]")
            .totalAmount(99.99)
            .status(OrderStatus.PENDING)
            .createdAt(LocalDateTime.now())
            .build();
    }

    // An order that has already been completed
    public static Order completedOrder() {
        return validPendingOrder().toBuilder()
            .id(2L)
            .status(OrderStatus.COMPLETED)
            .completedAt(LocalDateTime.now())
            .build();
    }

    // An order with an unusually large total — for boundary testing
    public static Order highValueOrder() {
        return validPendingOrder().toBuilder()
            .id(3L)
            .totalAmount(10_000.00)
            .build();
    }

    // An order with null email — for negative/validation testing
    public static Order orderWithNullEmail() {
        return validPendingOrder().toBuilder()
            .customerEmail(null)
            .build();
    }
}

// Usage: clean, readable, no duplication
class OrderServiceTest {

    @Test
    void completingAValidOrderChangesStatusToCompleted() {
        Order order = OrderMother.validPendingOrder();
        orderService.complete(order);
        assertEquals(OrderStatus.COMPLETED, order.getStatus());
    }

    @Test
    void highValueOrdersRequireManagerApproval() {
        Order order = OrderMother.highValueOrder();
        assertTrue(orderService.requiresManagerApproval(order));
    }
}