Ship one BDD suite to many environments

import * as dotenv from 'dotenv';
import * as path from 'path';

export interface Config {
  env: string; baseUrl: string; apiUrl: string;
  user: string; password: string;
  headless: boolean; readOnly: boolean;
}

export function loadConfig(): Config {
  const env = process.env.TEST_ENV || 'dev';
  dotenv.config({ path: path.join(process.cwd(), 'env', `.env.${env}`) });
  const need = (k: string) => {
    const v = process.env[k];
    if (!v || v === '__from_vault__') throw new Error(`missing ${k}`);
    return v;
  };
  return {
    env,
    baseUrl:  need('BASE_URL'),
    apiUrl:   need('API_URL'),
    user:     need('TEST_USER'),
    password: need('TEST_PASSWORD'),
    headless: (process.env.HEADLESS || 'true') !== 'false',
    readOnly: (process.env.READ_ONLY || 'false') === 'true',
  };
}

import { Before, After, BeforeAll, AfterAll, Status } from '@cucumber/cucumber';
import { chromium, Browser } from '@playwright/test';
import * as fs from 'fs';
import { loadConfig } from './env';
import { CustomWorld } from './world';

let sharedBrowser: Browser;
const config = loadConfig();

BeforeAll(async () => {
  sharedBrowser = await chromium.launch({ headless: config.headless });
});

Before(async function (this: CustomWorld, scenario) {
  const isMutating = scenario.pickle.tags.some((t) => t.name === '@mutating');
  if (config.readOnly && isMutating) {
    return 'skipped';
  }
  this.config  = config;
  this.context = await sharedBrowser.newContext();
  this.page    = await this.context.newPage();
});

After(async function (this: CustomWorld, scenario) {
  if (scenario.result?.status === Status.FAILED && this.page) {
    const buf = await this.page.screenshot({ fullPage: true });
    this.attach(buf, 'image/png');
    fs.mkdirSync('reports/screenshots', { recursive: true });
    fs.writeFileSync(
      `reports/screenshots/${scenario.pickle.name.replace(/[^a-z0-9]+/gi, '_')}.png`,
      buf
    );
  }
  if (this.context) await this.context.close();
});

AfterAll(async () => { await sharedBrowser.close(); });

{
  "scripts": {
    "test:smoke":      "cucumber-js --tags '@smoke and not @flaky and not @wip'",
    "test:regression": "cucumber-js --tags 'not @flaky and not @wip'",
    "test:dev":        "cross-env TEST_ENV=dev     npm run test:smoke",
    "test:staging":    "cross-env TEST_ENV=staging npm run test:regression",
    "test:prod":       "cross-env TEST_ENV=prod    npm run test:smoke",
    "report:html":     "node scripts/build-report.js",
    "ci:smoke":        "npm run test:smoke -- --format json:reports/cucumber.json && npm run report:html"
  }
}

name: cucumber-multi-env
on:
  pull_request:
  workflow_dispatch:
jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        env: [dev, staging]
        shard: [1, 2, 3]
    env:
      TEST_ENV: ${{ matrix.env }}
      TEST_USER: ${{ secrets.TTA_USER }}
      TEST_PASSWORD: ${{ secrets.TTA_PASSWORD }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, cache: npm }
      - run: npm ci
      - run: npx playwright install --with-deps chromium
      - run: |
          npx cucumber-js \
            --tags "@smoke and not @flaky" \
            --shard ${{ matrix.shard }}/3 \
            --format json:reports/cucumber.json
      - if: always()
        run: npm run report:html
      - if: always()
        uses: actions/upload-artifact@v4
        with:
          name: report-${{ matrix.env }}-shard${{ matrix.shard }}
          path: reports/

package hooks;

import io.cucumber.java.*;
import com.microsoft.playwright.*;
import java.io.IOException;
import java.nio.file.*;

public class Hooks {
  private final World w;
  public Hooks(World w) { this.w = w; }

  @Before
  public void before(Scenario sc) {
    String env = System.getenv().getOrDefault("TEST_ENV", "dev");
    Config cfg = Config.load(env);
    if (cfg.readOnly && sc.getSourceTagNames().contains("@mutating")) {
      sc.log("Skipped - readOnly env + mutating tag");
      throw new io.cucumber.java.PendingException();
    }
    w.config = cfg;
    w.playwright = Playwright.create();
    w.browser = w.playwright.chromium()
        .launch(new BrowserType.LaunchOptions().setHeadless(cfg.headless));
    w.context = w.browser.newContext();
    w.page = w.context.newPage();
  }

  @After
  public void after(Scenario sc) throws IOException {
    if (sc.isFailed() && w.page != null) {
      byte[] png = w.page.screenshot();
      sc.attach(png, "image/png", "fail-shot");
      Path dir = Paths.get("reports/screenshots");
      Files.createDirectories(dir);
      Files.write(dir.resolve(sc.getName().replaceAll("[^a-zA-Z0-9]+", "_") + ".png"), png);
    }
    if (w.context != null) w.context.close();
    if (w.browser != null) w.browser.close();
    if (w.playwright != null) w.playwright.close();
  }
}

package hooks;

import java.io.IOException;
import java.nio.file.*;
import java.util.Properties;

public class Config {
  public String env, baseUrl, apiUrl, user, password;
  public boolean headless, readOnly;

  public static Config load(String envName) {
    Properties p = new Properties();
    try (var in = Files.newInputStream(Paths.get("env", ".env." + envName))) {
      p.load(in);
    } catch (IOException e) { throw new RuntimeException(e); }

    Config c = new Config();
    c.env = envName;
    c.baseUrl  = need(p, "BASE_URL");
    c.apiUrl   = need(p, "API_URL");
    c.user     = need(p, "TEST_USER");
    c.password = need(p, "TEST_PASSWORD");
    c.headless = !"false".equals(p.getProperty("HEADLESS", "true"));
    c.readOnly = "true".equals(p.getProperty("READ_ONLY", "false"));
    return c;
  }

  private static String need(Properties p, String k) {
    String v = System.getenv(k) != null ? System.getenv(k) : p.getProperty(k);
    if (v == null || v.isBlank() || v.equals("__from_vault__"))
      throw new IllegalStateException("missing env: " + k);
    return v;
  }
}

<profile>
  <id>smoke</id>
  <properties>
    <cucumber.filter.tags>@smoke and not @flaky</cucumber.filter.tags>
  </properties>
</profile>
<profile>
  <id>regression</id>
  <properties>
    <cucumber.filter.tags>not @flaky and not @wip</cucumber.filter.tags>
  </properties>
</profile>
<!-- mvn -Psmoke -DTEST_ENV=staging test -->

import os
from pathlib import Path
from dotenv import load_dotenv
from playwright.sync_api import sync_playwright

def _load_env():
    name = os.environ.get('TEST_ENV', 'dev')
    load_dotenv(Path('env') / f'.env.{name}')
    return {
        'env':      name,
        'baseUrl':  os.environ['BASE_URL'],
        'apiUrl':   os.environ['API_URL'],
        'user':     os.environ['TEST_USER'],
        'password': os.environ['TEST_PASSWORD'],
        'headless': os.environ.get('HEADLESS', 'true') != 'false',
        'readOnly': os.environ.get('READ_ONLY', 'false') == 'true',
    }

def before_all(context):
    context.cfg = _load_env()
    context.pw = sync_playwright().start()
    context.browser = context.pw.chromium.launch(headless=context.cfg['headless'])

def before_scenario(context, scenario):
    if context.cfg['readOnly'] and 'mutating' in scenario.effective_tags:
        scenario.skip(reason='readOnly env')
        return
    context.ctx = context.browser.new_context()
    context.page = context.ctx.new_page()

def after_scenario(context, scenario):
    if scenario.status == 'failed':
        Path('reports/screenshots').mkdir(parents=True, exist_ok=True)
        safe = ''.join(c if c.isalnum() else '_' for c in scenario.name)
        png_path = f'reports/screenshots/{safe}.png'
        context.page.screenshot(path=png_path, full_page=True)
        scenario.attach = png_path
    context.ctx.close()

def after_all(context):
    context.browser.close()
    context.pw.stop()

[behave]
default_format = pretty
junit = true
junit_directory = reports
show_skipped = false

[behave.userdata]
smoke_tags = @smoke and not @flaky
full_tags  = not @flaky and not @wip

SHELL := /bin/bash

smoke-dev:
	TEST_ENV=dev behave --tags='@smoke and not @flaky'

smoke-staging:
	TEST_ENV=staging behave --tags='@smoke and not @flaky'

regression-staging:
	TEST_ENV=staging behave --tags='not @flaky and not @wip'

report:
	python -m behave_html_pretty_formatter reports/