Integrating BDD into CI/CD Pipelines: A Practical Guide

commit → [static analysis] → [unit tests] → [build] → [smoke BDD] → [deploy staging] → [regression BDD] → [deploy production]

# .github/workflows/bdd-pipeline.yml
name: BDD Test Pipeline

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

env:
  JAVA_VERSION: '17'
  NODE_VERSION: '20'

jobs:
  static-analysis:
    name: Static Analysis
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
      - name: Run Checkstyle
        run: mvn checkstyle:check -q
      - name: Run SpotBugs
        run: mvn spotbugs:check -q

  unit-tests:
    name: Unit Tests
    runs-on: ubuntu-latest
    needs: static-analysis
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
      - name: Cache Maven dependencies
        uses: actions/cache@v4
        with:
          path: ~/.m2
          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
      - name: Run unit tests
        run: mvn test -Dtest="**/unit/**/*Test" -q
      - name: Upload test results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: unit-test-results
          path: target/surefire-reports/

  smoke-bdd:
    name: Smoke BDD Tests
    runs-on: ubuntu-latest
    needs: unit-tests
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
      - name: Cache Maven dependencies
        uses: actions/cache@v4
        with:
          path: ~/.m2
          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
      - name: Start application
        run: |
          mvn spring-boot:start -DskipTests &
          echo "Waiting for application to start..."
          timeout 60 bash -c 'until curl -sf http://localhost:8080/actuator/health; do sleep 2; done'
      - name: Run smoke BDD tests
        run: |
          mvn test \
            -Dtest=SmokeTestRunner \
            -Dcucumber.filter.tags="@smoke" \
            -Dcucumber.plugin="pretty,json:target/cucumber-smoke.json,html:target/cucumber-smoke-report"
      - name: Generate Allure report
        if: always()
        run: mvn allure:report
      - name: Upload Allure report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: allure-smoke-report
          path: target/site/allure-maven-plugin/
      - name: Publish test results
        uses: EnricoMi/publish-unit-test-result-action@v2
        if: always()
        with:
          files: target/surefire-reports/*.xml

  regression-bdd:
    name: Regression BDD Tests
    runs-on: ubuntu-latest
    needs: smoke-bdd
    if: github.ref == 'refs/heads/main' || github.event_name == 'pull_request'
    strategy:
      matrix:
        shard: [1, 2, 3, 4]  # 4 parallel shards
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
      - name: Start application
        run: |
          mvn spring-boot:start -DskipTests &
          timeout 60 bash -c 'until curl -sf http://localhost:8080/actuator/health; do sleep 2; done'
      - name: Run regression BDD shard ${{ matrix.shard }}
        run: |
          mvn test \
            -Dtest=RegressionTestRunner \
            -Dcucumber.filter.tags="@regression and not @wip" \
            -DthreadCount=4 \
            -Dshard.index=${{ matrix.shard }} \
            -Dshard.total=4 \
            -Dcucumber.plugin="json:target/cucumber-regression-${{ matrix.shard }}.json"
      - name: Upload shard results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: regression-shard-${{ matrix.shard }}
          path: target/cucumber-regression-${{ matrix.shard }}.json

  aggregate-regression-report:
    name: Aggregate Regression Reports
    runs-on: ubuntu-latest
    needs: regression-bdd
    if: always()
    steps:
      - uses: actions/checkout@v4
      - name: Download all shard results
        uses: actions/download-artifact@v4
        with:
          pattern: regression-shard-*
          merge-multiple: true
          path: target/
      - name: Merge JSON reports and generate HTML
        run: |
          # Merge all shard JSON files
          jq -s 'add' target/cucumber-regression-*.json > target/cucumber-regression-merged.json
          
          # Generate HTML report from merged JSON
          npx cucumber-html-reporter \
            --jsonFile target/cucumber-regression-merged.json \
            --output target/regression-report.html \
            --reportSuiteAsScenarios true
      - name: Upload merged report
        uses: actions/upload-artifact@v4
        with:
          name: regression-report
          path: target/regression-report.html

// Jenkinsfile
pipeline {
    agent any
    
    tools {
        maven 'Maven-3.9'
        jdk 'JDK-17'
    }
    
    environment {
        APP_URL = 'http://localhost:8080'
        ALLURE_RESULTS = 'target/allure-results'
    }
    
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean compile test-compile -q'
            }
        }
        
        stage('Unit Tests') {
            steps {
                sh 'mvn test -Dtest="**/unit/**" -q'
            }
            post {
                always {
                    junit 'target/surefire-reports/*.xml'
                }
            }
        }
        
        stage('Start Application') {
            steps {
                sh '''
                    mvn spring-boot:start -DskipTests -q &
                    timeout 60 bash -c 'until curl -sf $APP_URL/actuator/health; do sleep 2; done'
                '''
            }
        }
        
        stage('BDD Tests') {
            parallel {
                stage('Smoke Tests') {
                    steps {
                        sh '''
                            mvn test -Dtest=SmokeTestRunner \
                                -Dcucumber.filter.tags="@smoke" \
                                -Dcucumber.plugin="io.qameta.allure.cucumber7jvm.AllureCucumber7Jvm,json:target/smoke.json"
                        '''
                    }
                }
                
                stage('Regression - Shard 1') {
                    steps {
                        sh '''
                            mvn test -Dtest=RegressionTestRunner \
                                -Dcucumber.filter.tags="@regression and not @wip" \
                                -DshardIndex=0 -DshardCount=3 \
                                -Dcucumber.plugin="json:target/regression-0.json"
                        '''
                    }
                }
                
                stage('Regression - Shard 2') {
                    steps {
                        sh '''
                            mvn test -Dtest=RegressionTestRunner \
                                -Dcucumber.filter.tags="@regression and not @wip" \
                                -DshardIndex=1 -DshardCount=3 \
                                -Dcucumber.plugin="json:target/regression-1.json"
                        '''
                    }
                }
                
                stage('Regression - Shard 3') {
                    steps {
                        sh '''
                            mvn test -Dtest=RegressionTestRunner \
                                -Dcucumber.filter.tags="@regression and not @wip" \
                                -DshardIndex=2 -DshardCount=3 \
                                -Dcucumber.plugin="json:target/regression-2.json"
                        '''
                    }
                }
            }
            
            post {
                always {
                    allure([
                        includeProperties: false,
                        jdk: '',
                        results: [[path: env.ALLURE_RESULTS]]
                    ])
                }
            }
        }
        
        stage('Stop Application') {
            steps {
                sh 'mvn spring-boot:stop -q || true'
            }
        }
    }
    
    post {
        failure {
            emailext(
                subject: "BDD Tests Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                body: "Build URL: ${env.BUILD_URL}\nAllure Report: ${env.BUILD_URL}allure/",
                to: 'qa-team@example.com'
            )
        }
    }
}

// junit-platform.properties
cucumber.execution.parallel.enabled=true
cucumber.execution.parallel.config.strategy=fixed
cucumber.execution.parallel.config.fixed.parallelism=4

# Scenario-based sharding using Cucumber's built-in shard support (Cucumber 7.14+)
mvn <span class="hljs-built_in">test -Dcucumber.execution.split-test=4 -Dcucumber.execution.split-test-index=0  <span class="hljs-comment"># shard 1 of 4
mvn <span class="hljs-built_in">test -Dcucumber.execution.split-test=4 -Dcucumber.execution.split-test-index=1  <span class="hljs-comment"># shard 2 of 4

@shard-1
Scenario: Login with valid credentials

@shard-2  
Scenario: Order placement flow

@shard-3
Scenario: Password reset

mvn test -Dcucumber.filter.tags=<span class="hljs-string">"@shard-1"
mvn <span class="hljs-built_in">test -Dcucumber.filter.tags=<span class="hljs-string">"@shard-2"
mvn <span class="hljs-built_in">test -Dcucumber.filter.tags=<span class="hljs-string">"@shard-3"

# docker-compose.test.yml — spin up N test containers
version: '3.8'
services:
  app:
    image: myapp:${VERSION}
    ports:
      - "8080:8080"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 10s
      timeout: 5s
      retries: 5

  selenium-hub:
    image: selenium/hub:4.18.0
    ports:
      - "4444:4444"

  chrome-node-1:
    image: selenium/node-chrome:4.18.0
    environment:
      - SE_EVENT_BUS_HOST=selenium-hub

  chrome-node-2:
    image: selenium/node-chrome:4.18.0
    environment:
      - SE_EVENT_BUS_HOST=selenium-hub

  chrome-node-3:
    image: selenium/node-chrome:4.18.0
    environment:
      - SE_EVENT_BUS_HOST=selenium-hub

  chrome-node-4:
    image: selenium/node-chrome:4.18.0
    environment:
      - SE_EVENT_BUS_HOST=selenium-hub

  bdd-tests:
    image: myapp-tests:${VERSION}
    depends_on:
      app:
        condition: service_healthy
      selenium-hub:
        condition: service_started
    environment:
      - APP_URL=http://app:8080
      - SELENIUM_URL=http://selenium-hub:4444
      - PARALLEL_COUNT=4
    command: mvn test -Dcucumber.execution.parallel.enabled=true

<!-- pom.xml -->
<dependency>
    <groupId>io.qameta.allure</groupId>
    <artifactId>allure-cucumber7-jvm</artifactId>
    <version>2.26.0</version>
    <scope>test</scope>
</dependency>

<plugin>
    <groupId>io.qameta.allure</groupId>
    <artifactId>allure-maven</artifactId>
    <version>2.12.0</version>
    <configuration>
        <reportVersion>2.26.0</reportVersion>
        <resultsDirectory>${project.build.directory}/allure-results</resultsDirectory>
    </configuration>
</plugin>

// Enriching Allure reports with screenshots and step details
@After
public void captureFailure(Scenario scenario) {
    if (scenario.isFailed()) {
        byte[] screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES);
        scenario.attach(screenshot, "image/png", "Screenshot on failure");
        
        // Also attach page source for debugging
        String pageSource = driver.getPageSource();
        scenario.attach(pageSource.getBytes(), "text/html", "Page source on failure");
        
        // Attach to Allure as well
        Allure.addAttachment("Screenshot", new ByteArrayInputStream(screenshot));
        Allure.addAttachment("Current URL", driver.getCurrentUrl());
    }
}

// cucumber.js configuration for multiple report formats
module.exports = {
    default: {
        paths: ['features/**/*.feature'],
        require: ['features/support/**/*.js', 'features/steps/**/*.js'],
        format: [
            'progress-bar',
            ['html', 'reports/cucumber-report.html'],
            ['json', 'reports/cucumber-report.json'],
            ['junit', 'reports/cucumber-junit.xml'],
            ['@cucumber/pretty-formatter', ''],
        ],
        formatOptions: {
            snippetInterface: 'async-await',
        },
        parallel: 4,
        retry: 1,  // retry flaky tests once
        retryTagFilter: '@flaky',
    },
    smoke: {
        paths: ['features/**/*.feature'],
        require: ['features/support/**/*.js', 'features/steps/**/*.js'],
        tags: '@smoke',
        format: [
            ['html', 'reports/smoke-report.html'],
            ['json', 'reports/smoke-report.json'],
        ],
        parallel: 2,
    }
};

# Simple flakiness detection script
<span class="hljs-comment">#!/bin/bash
<span class="hljs-comment"># Run tests N times and count failures per scenario

RUNS=10
FLAKY_THRESHOLD=2  <span class="hljs-comment"># fail 2+ times out of 10 = flaky

<span class="hljs-keyword">for i <span class="hljs-keyword">in $(<span class="hljs-built_in">seq 1 <span class="hljs-variable">$RUNS); <span class="hljs-keyword">do
    mvn <span class="hljs-built_in">test -Dcucumber.filter.tags=<span class="hljs-string">"@regression" \
             -Dcucumber.plugin=<span class="hljs-string">"json:target/run-${i}.json" \
             -q 2>/dev/null
<span class="hljs-keyword">done

<span class="hljs-comment"># Analyze results with jq
jq -r <span class="hljs-string">'.[].elements[] | select(.status == "failed") <span class="hljs-pipe">| .name' \
    target/run-*.json <span class="hljs-pipe">| <span class="hljs-built_in">sort <span class="hljs-pipe">| <span class="hljs-built_in">uniq -c <span class="hljs-pipe">| <span class="hljs-built_in">sort -rn <span class="hljs-pipe">| \
    awk -v threshold=<span class="hljs-string">"$FLAKY_THRESHOLD" <span class="hljs-string">'$1 >= threshold {print "FLAKY:", $2, "failed", $1, "times"}'

// CucumberOptions with retry
@CucumberOptions(
    tags = "@regression and not @wip",
    plugin = {
        "pretty",
        "json:target/cucumber.json",
        "rerun:target/rerun.txt"  // writes failing scenario locations
    }
)
public class RegressionTestRunner {}

// Re-run only failed scenarios
@CucumberOptions(
    features = "@target/rerun.txt",  // re-run file from previous run
    plugin = {"pretty", "json:target/cucumber-rerun.json"}
)
public class FailedScenariosRunner {}

// Anti-pattern: arbitrary sleep
Thread.sleep(2000);
driver.findElement(By.id("submit-button")).click();

// Better: explicit wait with condition
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.elementToBeClickable(By.id("submit-button"))).click();

// Even better: custom wait with meaningful error message
wait.withMessage("Submit button not clickable after 10 seconds")
    .until(ExpectedConditions.elementToBeClickable(By.id("submit-button")))
    .click();

@Before
public void isolateTestData(Scenario scenario) {
    // Create a unique user for this scenario
    testUser = userFactory.create("test-" + UUID.randomUUID().toString().substring(0, 8));
    context.setTestUser(testUser);
}

@After
public void cleanupTestData(Scenario scenario) {
    if (testUser != null) {
        userFactory.delete(testUser.getId());
    }
}

# Smoke: critical paths, runs in < 10 minutes
@smoke @checkout @critical
Scenario: Successful order placement with credit card

# Regression: full coverage, runs before release  
@regression @checkout @payment
Scenario: Order rejected when card is declined

# Integration: requires external services
@integration @email @regression
Scenario: Confirmation email received after order

# Slow: long-running, runs nightly only
@slow @performance @regression  
Scenario: 500 concurrent users can browse catalog

# WIP: excluded from all CI runs
@wip
Scenario: Guest checkout with saved address (not yet implemented)

# Flaky: auto-retried, tracked for investigation
@flaky @regression
Scenario: Product search returns results within 2 seconds

# Fast CI gate (< 15 minutes total)
--tags <span class="hljs-string">"@smoke"

<span class="hljs-comment"># PR validation gate (< 30 minutes)
--tags <span class="hljs-string">"@smoke or @integration"

<span class="hljs-comment"># Pre-release gate (60-90 minutes with parallel execution)
--tags <span class="hljs-string">"@regression and not @wip and not @slow"

<span class="hljs-comment"># Nightly comprehensive run
--tags <span class="hljs-string">"not @wip"

<span class="hljs-comment"># Performance validation
--tags <span class="hljs-string">"@performance"

<span class="hljs-comment"># Investigate flaky tests
--tags <span class="hljs-string">"@flaky"

// features/support/world.js
const { setWorldConstructor, setDefaultTimeout } = require('@cucumber/cucumber');
const { chromium } = require('@playwright/test');

class PlaywrightWorld {
    constructor({ attach, parameters }) {
        this.attach = attach;
        this.parameters = parameters;
        this.browser = null;
        this.page = null;
    }

    async openBrowser() {
        this.browser = await chromium.launch({
            headless: process.env.CI === 'true',  // headless in CI
            slowMo: process.env.CI ? 0 : 50,       // slower locally for debugging
        });
        this.page = await this.browser.newPage();
    }

    async closeBrowser() {
        if (this.page && !this.page.isClosed()) {
            if (this.currentScenario?.isFailed()) {
                const screenshot = await this.page.screenshot({ fullPage: true });
                await this.attach(screenshot, 'image/png');
            }
            await this.page.close();
        }
        if (this.browser) {
            await this.browser.close();
        }
    }
}

setWorldConstructor(PlaywrightWorld);
setDefaultTimeout(process.env.CI ? 30000 : 15000);  // longer timeout in CI

# GitHub Actions with Playwright
- name: Install Playwright browsers
  run: npx playwright install chromium --with-deps

- name: Run BDD smoke tests
  run: npx cucumber-js --config cucumber.js --profile smoke
  env:
    CI: true
    APP_URL: http://localhost:3000

- name: Run BDD regression tests
  run: npx cucumber-js --config cucumber.js --profile default
  env:
    CI: true
    APP_URL: http://localhost:3000

- name: Upload test artifacts
  uses: actions/upload-artifact@v4
  if: failure()
  with:
    name: bdd-failure-artifacts
    path: |
      reports/
      test-results/