CONTRIBUTING.md

Contributing to SCARFBench

This guide explains how to contribute a new application to the SCARFBench benchmark suite.

Table of Contents

• Getting Started
• Contribution Workflow
• Overview
• Required Files
• 1. Dockerfile
• 2. Makefile
• 3. Smoke Test (smoke.py)
• Standard Patterns
• Checklist

Getting Started

Prerequisites

Before contributing, ensure you have:

• Git installed
• Docker installed and running
• makeMakefile build tool
• Basic familiarity with the three frameworks (Jakarta EE, Quarkus, Spring Boot)

Forking the Repository

1. Fork the repository on GitHub by clicking the "Fork" button at the top right of the repository page
2. Clone your fork locally:

   git clone https://github.com/<your-username>/scarfbench.git
   cd scarfbench
   

3. Add upstream remote to keep your fork synchronized:

   git remote add upstream https://github.com/original-repo/scarfbench.git
   

4. Create a branch for your contribution:

   git checkout -b add-<application-name>
   

Contribution Workflow

Follow these steps to contribute a new benchmark application:

1. Choose Application Category

Determine which category your application belongs to:

• business_domain/ - Core business logic patterns
• dependency_injection/ - DI and configuration patterns
• infrastructure/ - Infrastructure services (concurrency, messaging, etc.)
• integration/ - External system integration (batch, messaging, web services)
• persistence/ - Database and persistence patterns
• presentation/ - Web UI and REST API patterns
• security/ - Authentication and authorization patterns
• whole_applications/ - Complete, production-like applications

2. Create Directory Structure

Create your application directory under the appropriate category:

mkdir -p benchmark/<category>/<your-app-name>/{jakarta,quarkus,spring}

3. Implement Framework Variants

For each framework (Jakarta, Quarkus, Spring):

1. Implement the application using framework-specific patterns
2. Create Dockerfile (see Dockerfile section)
3. Create Makefile (see Makefile section)
4. Create smoke tests - either smoke.py or smoke/ folder (see Smoke Test section)

4. Verify All Implementations

For each framework, run the complete test sequence:

cd benchmark/<category>/<your-app-name>/<framework>
just build      # Build Docker image
just up         # Start container
just test       # Run smoke tests (should PASS)
just logs       # Verify application logs
just down       # Clean up

Repeat for all three frameworks: jakarta, quarkus, and spring.

5. Document Your Application

Create a README.md in your application directory:

benchmark/<category>/<your-app-name>/README.md

Include:

• Purpose: What the application demonstrates
• Key Features: Technologies and patterns showcased
• Framework Implementations: Brief notes on each variant
• Testing: What the smoke tests validate

6. Submit Pull Request

Once all implementations are working:

1. Commit your changes:

   git add benchmark/<category>/<your-app-name>
   git commit -m "Add <application-name> benchmark for <category>"
   

2. Push to your fork:

   git push origin add-<application-name>
   

3. Create Pull Request on GitHub:

   • Go to your fork on GitHub
   • Click "New Pull Request"
   • Fill out the PR template (automatically populated)
   • Ensure all checklist items are completed
   • Submit for review

4. Respond to feedback: Maintainers may request changes or improvements

7. Keep Your Fork Updated

Sync with upstream before starting new contributions:

git fetch upstream
git checkout main
git merge upstream/main
git push origin main

Overview

Each benchmark application in SCARFBench should support three frameworks:

• Jakarta EE (using Open Liberty)
• Quarkus
• Spring Boot

In addition to the source application files, each framework implementation requires three standard files:

1. Dockerfile - Container definition
2. Makefile - Build and run automation
3. smoke.py - Automated smoke tests

Note on Technology Choices: This guide demonstrates examples using Python, uv, and Playwright for smoke tests. However, these are not strict requirements. You are free to implement smoke tests in any language (Shell, JavaScript, Go, Java, etc.) as long as your Dockerfile and Makefile's test target work correctly. See Alternative Smoke Test Implementations for examples in other languages.

This guide uses the following applications as reference standards:

1. benchmark/infrastructure/concurrency-jobs for basic REST/HTTP applications
2. benchmark/infrastructure/ejb-async for applications requiring browser automation and UI testing
3. benchmark/whole_applications/daytrader for complex, multi-framework applications with extensive smoke tests

Required Files

1. Dockerfile

The Dockerfile creates a containerized environment for building and running your application.

Standard Structure (Basic Pattern)

For applications with simple REST/HTTP API testing:

FROM maven:3.9-eclipse-temurin-21

USER root
RUN apt-get update && apt-get install -y python3 curl && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Copy all project files
COPY pom.xml .
COPY src src
COPY smoke.py .

# Default command matches your local workflow
# Framework-specific goal to be replaced accordingly
# | Framework             | Maven Goal                    |
# |-----------------------|-------------------------------|
# | Jakarta/OpenLiberty   | liberty:run                 |
# | Quarkus               | quarkus:dev                 |
# | Spring                | spring-boot:run             |
CMD ["mvn", "clean", "package", "<framework-specific-goal>"]

Playwright Pattern (For UI/Browser Testing)

For applications requiring browser automation and UI testing (reference: benchmark/infrastructure/ejb-async):

FROM maven:3.9-eclipse-temurin-21

# Run everything as root (needed for Playwright installation)
USER root

# Install Python and needed tools (add python3-venv for virtual environment support)
RUN apt-get update && apt-get install -y python3 python3-venv python3-pip curl && rm -rf /var/lib/apt/lists/*

# Create and activate virtual environment for Python dependencies (PEP 668 safe)
RUN python3 -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

# Shared browsers path so Chromium is cached once
ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
RUN mkdir -p /ms-playwright && chmod 755 /ms-playwright

# Install Playwright and Chromium dependencies inside venv
RUN pip install --no-cache-dir --upgrade pip setuptools wheel \
 && pip install --no-cache-dir playwright==1.47.0 \
 && playwright install --with-deps chromium

WORKDIR /app

# Copy Maven wrapper first (cache efficient)
COPY .mvn .mvn
COPY mvnw .
RUN chmod +x mvnw

# Copy root pom and module poms for dependency layer caching
COPY pom.xml ./
# If you have multiple modules, copy each module's pom separately:
# COPY module1/pom.xml module1/pom.xml
# COPY module2/pom.xml module2/pom.xml
RUN ./mvnw -q -DskipTests dependency:go-offline || true

# Copy full module sources
COPY src src
# If you have multiple modules:
# COPY module1 module1
# COPY module2 module2

# Copy unified smoke test (includes Playwright logic)
COPY smoke.py .
RUN chmod +x smoke.py

# For Playwright tests, CMD can run smoke.py directly or the Maven goal
# Framework-specific goal to be replaced accordingly
# | Framework             | Maven Goal                    |
# |-----------------------|-------------------------------|
# | Jakarta/OpenLiberty   | liberty:run                 |
# | Quarkus               | quarkus:dev                 |
# | Spring                | spring-boot:run             |
CMD ["mvn", "clean", "package", "<framework-specific-goal>"]

Important Notes

1. Python3 and curl: Always install these for smoke tests
2. User ID 1001: Standard non-root user for security (basic pattern only)
3. Root User for Playwright: Playwright installation requires root privileges; use root user when browser automation is needed
4. Virtual Environment: Use Python venv (/opt/venv) for Playwright to comply with PEP 668
5. File Ownership: Use --chown=1001:1001 for all COPY commands in basic pattern; omit in Playwright pattern (root owns everything)
6. smoke.py: Must be copied into the container
7. No Port Exposure: Do NOT use EXPOSE directive - tests run internally via docker exec, not through exposed ports
8. Maven Wrapper: Ensure mvnw is executable with chmod +x
9. Layer Caching: For Playwright pattern, copy pom.xml files first to cache dependencies separately from source code
10. Browser Path: Set PLAYWRIGHT_BROWSERS_PATH=/ms-playwright to share browser binaries across builds

2. Makefile

The Makefile provides standard commands for building, running, testing, and managing your application.

Standard Structure

### <Application Name> (<Framework>) Makefile
APP_NAME       := "<app-name>-<framework>"
IMAGE_NAME     := "<app-name>-<framework>:latest"
SUCCESS_PATTERN := "<framework-specific-pattern>"

build:
    docker build -f Dockerfile -t {{IMAGE_NAME}} .
    @echo "[INFO] Built image: {{IMAGE_NAME}}"

rebuild:
    docker build --no-cache -f Dockerfile -t {{IMAGE_NAME}} .
    @echo "[INFO] Rebuilt image (no cache): {{IMAGE_NAME}}"

up: build
    ### The below section will look for exisiting containers and if so, remove them. 
    @if docker ps --all --quiet --filter name=^/{{APP_NAME}}$ | grep -q .; then \
        echo "[INFO] Removing existing container"; \
        docker rm -f {{APP_NAME}} >/dev/null; \
    fi
    
    ### Run the container in detached mode
    docker run -d --name {{APP_NAME}} {{IMAGE_NAME}}
    @echo "[INFO] Started {{APP_NAME}}, waiting for app to start..."

    ### Check for build failure
    @until docker logs {{APP_NAME}} 2>&1 | grep -q "BUILD FAILURE"; do \
        if docker logs {{APP_NAME}} 2>&1 | grep -q "{{SUCCESS_PATTERN}}"; then \
            break; \
        fi; \
        sleep 1; \
    done
    @if docker logs {{APP_NAME}} 2>&1 | grep -q "BUILD FAILURE"; then \
        echo "[ERROR] Build failed in container:"; \
        docker logs {{APP_NAME}} 2>&1; \
        exit 1; \
    fi

    ### Wait for success pattern
    @until docker logs {{APP_NAME}} 2>&1 | grep -q "{{SUCCESS_PATTERN}}"; do sleep 1; done
    @echo "[INFO] App started and ready."

logs:
    docker logs -f {{APP_NAME}}

down:
    - docker rm -f {{APP_NAME}}
    @echo "[INFO] Container removed (if it existed)"

test: up
    @docker exec {{APP_NAME}} sh -c 'python3 /app/smoke.py'

local:
    ./mvnw clean package <framework-goal>

Framework-Specific Startup Patterns

The SUCCESS_PATTERN variable should be set based on the framework:

Framework	Success Pattern	Example
Jakarta	CWWKF0011I	SUCCESS_PATTERN := "CWWKF0011I"
Quarkus	started in.*Listening on:	SUCCESS_PATTERN := "started in.*Listening on:"
Spring Boot	Tomcat started on port|Started .* in .* seconds	SUCCESS_PATTERN := "Tomcat started on port"

Note: These patterns are used in extended grep (grep -E), so use regex syntax where needed.

Startup Wait Loop Explained

The up target uses two separate checks:

1. Build Failure Check: Polls logs looking for BUILD FAILURE (a standard Maven failure message)

   • While checking, also looks for the success pattern
   • If success pattern found first, breaks out of the failure check
   • If BUILD FAILURE found: displays full logs and exits with error

2. Success Pattern Wait: If no build failure, continues waiting for the success pattern

   • Loops until the framework-specific success pattern appears in logs
   • Pattern indicates the application is fully started and ready

Port Notes

Applications bind to internal ports (usually 9080 or 8080) for communication within the container. Since tests run internally via docker exec, no port mapping to the host is needed. The Makefile does not expose ports, and containers run without -p flags.

Required Targets

All Makefiles must include these standard targets:

• build: Build the Docker image
• rebuild: Rebuild without cache (for troubleshooting)
• up: Start container, wait for readiness
• logs: Stream container logs
• down: Stop and remove container
• test: Run smoke tests
• local: Run locally without Docker

3. Smoke Test (smoke.py or custom smoke tests)

The smoke test validates your application's core functionality. While examples below use Python, you are free to write smoke tests in any language - the only requirements are:

1. Dockerfile must exist and be able to run the tests
2. Makefile must have a test target that executes the tests
3. Tests must exit with code 0 on success, non-zero on failure

This allows flexibility to use:

• Python with pytest/Playwright (recommended for complex UI testing)
• Shell scripts with curl (lightweight HTTP testing)
• JavaScript with Node.js (if you prefer JavaScript)
• Go, Java, or any other language
• Combinations of multiple test frameworks

The key requirement is that just test must work inside the container.

Standard Structure

#!/usr/bin/env python3
"""Smoke test for <Application Name> (<Framework>).

Checks:
  1) Discover reachable base path
  2) <Test 1 description>
  3) <Test 2 description>
  ...

Exit codes:
  0 success, non-zero on first failure encountered.
"""
import os
import sys
import time
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

# Configuration
VERBOSE = os.getenv("VERBOSE") == "1"

# Base URL candidates (try in order)
CANDIDATES = [
    os.getenv("<APP>_BASE_URL"),  # Environment variable override
    "http://localhost:<internal-port>/<path>/",  # Container internal
]

def vprint(msg: str):
    """Print only if VERBOSE=1"""
    if VERBOSE:
        print(msg)

def http_request(
    method: str,
    url: str,
    data: bytes | None = None,
    headers: dict | None = None,
    timeout: int = 10,
):
    """Make HTTP request, return (status, body) or None on network error"""
    req = Request(url, data=data, method=method, headers=headers or {})
    try:
        with urlopen(req, timeout=timeout) as resp:
            status = resp.getcode()
            body = resp.read().decode("utf-8", "replace")
    except HTTPError as e:
        status = e.code
        body = e.read().decode("utf-8", "replace")
    except (URLError, Exception) as e:
        return None, f"NETWORK-ERROR: {e}"
    return (status, body), None

def discover_base() -> str:
    """Try each candidate URL, return first working one"""
    for cand in CANDIDATES:
        if not cand:
            continue
        # Try to validate candidate
        if validate_candidate(cand):
            print(f"[INFO] Base discovered: {cand}")
            return cand
    # Fallback
    for cand in CANDIDATES:
        if cand:
            print(f"[WARN] No base validated, using fallback {cand}")
            return cand
    print("[ERROR] No base URL candidates available", file=sys.stderr)
    sys.exit(2)

def validate_candidate(base: str) -> bool:
    """Implement validation logic for your app"""
    # Example: Try a health check endpoint
    pass

def main():
    start = time.time()
    base = discover_base()
    
    # Run your test sequence here
    # Example:
    # test_endpoint_1(base)
    # test_endpoint_2(base)
    
    elapsed = time.time() - start
    print(f"[PASS] Smoke sequence complete in {elapsed:.2f}s")
    return 0

if __name__ == "__main__":
    sys.exit(main())

Key Components

1. Docstring: Describe what the smoke test validates
2. URL Discovery: Try multiple URL candidates (env var, localhost variations, container ports)
3. HTTP Helper: Reusable function for making requests
4. Verbose Logging: Support VERBOSE=1 environment variable
5. Exit Codes: Use specific exit codes for different failure types
6. Pass/Fail Messages: Clear [PASS]/[FAIL] prefixes
7. Timing: Report total test execution time

Playwright-Based Testing (Advanced)

For applications requiring browser automation and UI testing, use Playwright. Example structure:

#!/usr/bin/env python3
"""Smoke test with Playwright for UI validation.

Checks:
  1) Start application server
  2) Launch browser and navigate to UI
  3) Interact with UI elements
  4) Validate UI behavior and responses

Exit codes:
  0 success, non-zero on failure.
"""
import os
import sys
import time
import subprocess
from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeout

VERBOSE = os.getenv("VERBOSE") == "1"
BASE_URL = "http://localhost:9080"

def vprint(msg: str):
    if VERBOSE:
        print(msg)

def start_server():
    """Start the application server"""
    vprint("[INFO] Starting application server...")
    # Example: Start Liberty server
    proc = subprocess.Popen(
        ["./mvnw", "clean", "package", "liberty:run"],
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True
    )
    
    # Wait for server to be ready
    for line in proc.stdout:
        vprint(line.rstrip())
        if "CWWKF0011I" in line:  # Liberty started
            print("[INFO] Server started successfully")
            break
    
    return proc

def test_ui_with_playwright(base_url: str):
    """Test UI using Playwright browser automation"""
    print("[INFO] Launching browser...")
    
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        
        try:
            # Navigate to application
            vprint(f"[INFO] Navigating to {base_url}")
            page.goto(base_url, wait_until="networkidle", timeout=30000)
            
            # Example: Check page title
            title = page.title()
            if "Expected Title" not in title:
                print(f"[FAIL] Unexpected page title: {title}", file=sys.stderr)
                return False
            print(f"[PASS] Page title: {title}")
            
            # Example: Fill form and submit
            page.fill("#inputField", "test value")
            page.click("#submitButton")
            
            # Wait for response
            page.wait_for_selector(".result", timeout=10000)
            result = page.text_content(".result")
            
            if "expected result" not in result.lower():
                print(f"[FAIL] Unexpected result: {result}", file=sys.stderr)
                return False
            print(f"[PASS] Form submission successful: {result}")
            
            return True
            
        except PlaywrightTimeout as e:
            print(f"[FAIL] Timeout: {e}", file=sys.stderr)
            return False
        except Exception as e:
            print(f"[FAIL] Error: {e}", file=sys.stderr)
            return False
        finally:
            browser.close()

def main():
    start = time.time()
    
    # Start server
    server_proc = start_server()
    
    try:
        # Run UI tests
        success = test_ui_with_playwright(BASE_URL)
        
        if not success:
            return 1
        
        elapsed = time.time() - start
        print(f"[PASS] Smoke sequence complete in {elapsed:.2f}s")
        return 0
        
    finally:
        # Clean up
        if server_proc:
            vprint("[INFO] Stopping server...")
            server_proc.terminate()
            server_proc.wait()

if __name__ == "__main__":
    sys.exit(main())

Playwright Testing Notes

1. Browser Setup: Use chromium.launch(headless=True) for CI/CD compatibility
2. Timeouts: Set appropriate timeouts for page loads and element waits
3. Wait Strategies: Use wait_until="networkidle" for page loads, wait_for_selector for elements
4. Error Handling: Always use try/finally to ensure browser cleanup
5. Server Management: Start application server before tests, terminate after
6. Selectors: Use stable selectors (IDs, data attributes) instead of classes
7. Screenshots: Capture on failure for debugging: page.screenshot(path="error.png")
8. Virtual Display: In Docker, browsers run headless automatically

Best Practices

1. Test Real Functionality: Don't just check if the server responds - validate actual behavior
2. Multiple Scenarios: Test with and without authentication, different inputs, etc.
3. Meaningful Assertions: Check status codes AND response content
4. Clear Error Messages: Include URL, status, and response body in failures
5. Early Exit: Exit on first failure with specific exit code
6. Timeout Handling: Use reasonable timeouts (10s default)
7. Network Resilience: Handle both HTTP errors and network failures

Example Test Pattern

def test_endpoint(base: str, description: str, path: str, 
                  method: str = "GET", expected_status: int = 200,
                  expected_content: str = None, headers: dict = None):
    """Reusable test function"""
    url = f"{base.rstrip('/')}{path}"
    resp, err = http_request(method, url, headers=headers)
    
    if err:
        print(f"[FAIL] {description}: {err}", file=sys.stderr)
        sys.exit(1)
    
    status, body = resp
    body_stripped = body.strip()
    
    if status != expected_status:
        print(f"[FAIL] {description}: Expected {expected_status}, got {status}", 
              file=sys.stderr)
        sys.exit(1)
    
    if expected_content and expected_content not in body_stripped:
        print(f"[FAIL] {description}: Expected content '{expected_content}' not found",
              file=sys.stderr)
        sys.exit(1)
    
    print(f"[PASS] {description}")

Smoke Test Folder Structure (For Complex Applications)

For large, multi-framework applications (reference: benchmark/whole_applications/daytrader), organize smoke tests in a dedicated folder with multiple test files and a dependency manifest:

Folder Structure:

<application>/<framework>/smoke/
├── smoke.py              # Main entry point with pytest fixtures
├── test_*.py             # Individual test modules
├── playwright-test-cases.md  # Documentation of test scenarios
├── pyproject.toml        # Python dependencies (pytest, pytest-playwright, etc.)
├── pytest.ini            # Pytest configuration
├── conftest.py           # Pytest fixtures and configuration
└── README.md             # Test documentation

pyproject.toml (using uv for modern dependency management - recommended):

[project]
name = "smoke"
version = "0.1.0"
description = "Smoke tests for <Application>"
requires-python = ">=3.11"
dependencies = [
    "playwright>=1.47.0",
    "pytest>=8.0.0,<9.0.0",
    "pytest-playwright>=0.7.0",
]

[tool.pytest.ini_options]
testpaths = ["."]
python_files = ["test_*.py", "smoke.py"]

# Optional: specify script entry point
[project.scripts]
smoke = "smoke:main"

conftest.py (pytest fixtures):

import os
import pytest
from playwright.sync_api import sync_playwright

BASE_URL = os.getenv("BASE_URL", "http://localhost:9080/app")

@pytest.fixture
def page():
    """Provide a Playwright page fixture for all tests"""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context()
        page = context.new_page()
        yield page
        browser.close()

@pytest.fixture
def base_url():
    """Provide base URL to all tests"""
    return BASE_URL

smoke.py (example with pytest markers):

import pytest
from playwright.sync_api import Page, expect

BASE_URL = "http://localhost:9080/app"

@pytest.mark.smoke
def test_home_page_loads(page: Page) -> None:
    """Test that home page loads successfully"""
    page.goto(BASE_URL, wait_until="domcontentloaded")
    expect(page).to_have_title("Application Title")

@pytest.mark.smoke
def test_navigation_links(page: Page) -> None:
    """Test that main navigation links are present"""
    page.goto(BASE_URL, wait_until="domcontentloaded")
    links = page.get_by_role("link")
    assert links.count() > 0

@pytest.mark.smoke
def test_login_form(page: Page) -> None:
    """Test login functionality"""
    page.goto(f"{BASE_URL}/login", wait_until="domcontentloaded")
    page.fill('input[name="username"]', "testuser")
    page.fill('input[name="password"]', "password")
    page.click('button[type="submit"]')
    # Assert successful login
    assert page.url != f"{BASE_URL}/login"

Dockerfile Integration (using uv for fast, reproducible test environments - recommended):

FROM maven:3.9-eclipse-temurin-21

USER root
RUN apt-get update && apt-get install -y python3 curl && rm -rf /var/lib/apt/lists/*

# Install uv for fast Python dependency management
RUN curl -sSL https://astral.sh/uv/install.sh | sh
ENV PATH="$HOME/.cargo/bin:$PATH"

WORKDIR /app

# Copy application files
COPY pom.xml .
COPY src src
COPY .mvn .mvn
COPY mvnw .
RUN chmod +x mvnw

# Copy entire smoke test folder (includes pyproject.toml, uv.lock, test files)
COPY smoke smoke

CMD ["./mvnw", "clean", "package", "<framework-specific-goal>"]

Makefile Integration (using uv with Playwright - recommended for complex apps):

### <Application Name> (<Framework>) Makefile
APP_NAME        := "<app-name>-<framework>"
IMAGE_NAME      := "<app-name>-<framework>:latest"
APP_PORT        := "9080"

build:
    docker build -f Dockerfile -t {{IMAGE_NAME}} .
    @echo "[INFO] Built image: {{IMAGE_NAME}}"

rebuild:
    docker build --no-cache -f Dockerfile -t {{IMAGE_NAME}} .
    @echo "[INFO] Rebuilt image (no cache): {{IMAGE_NAME}}"

up: build
    - docker rm -f {{APP_NAME}} 2>/dev/null || true
    docker run -d --name {{APP_NAME}} {{IMAGE_NAME}}
    @echo "[INFO] Started {{APP_NAME}} (internal port {{APP_PORT}})..."
    @echo "[INFO] Waiting for application to start..."
    @until docker logs {{APP_NAME}} 2>&1 | grep -q "<startup-pattern>"; do sleep 1; done
    @echo "[INFO] Application started, port {{APP_PORT}} is ready."

logs:
    docker logs -f {{APP_NAME}}

down:
    - docker rm -f {{APP_NAME}}
    @echo "[INFO] Container {{APP_NAME}} removed (if it existed)."

# Run Playwright-based smoke tests inside the running container with uv
smoke: up
    @echo "[INFO] Running smoke tests inside container {{APP_NAME}}..."
    docker exec {{APP_NAME}} bash -lc "cd smoke && uv sync && uv run playwright install chromium && uv run pytest -v --tb=short"

test: smoke

local:
    ./mvnw clean package <framework-specific-goal>

Key Benefits of Folder Structure:

1. Scalability: Organize tests into multiple files as test suite grows
2. Modularity: Separate concerns (auth tests, API tests, UI tests, etc.)
3. pytest Features: Use markers, fixtures, and parameterization
4. Dependencies: Centralized management in pyproject.toml with uv.lock for reproducibility
5. Documentation: Each test file and test case is self-documenting
6. CI/CD Friendly: pytest integrates with most CI/CD systems
7. Fast Dependency Sync: uv sync is significantly faster than pip install

Running Tests Locally (with uv - recommended):

cd smoke
uv sync                       # Install dependencies from pyproject.toml
uv run pytest -v              # Run all tests
uv run pytest -m smoke       # Run only smoke tests
uv run pytest test_login.py  # Run specific test file
uv run pytest -v --tb=short  # Run with short traceback
VERBOSE=1 uv run pytest -v   # Run with verbose output

Running Tests Locally (with pip - legacy approach):

cd smoke
pip install -e .              # Install from pyproject.toml
pytest -v                     # Run all tests
pytest -m smoke              # Run only smoke tests

Alternative Smoke Test Implementations

While Python with pytest is recommended for complex applications, here are other valid approaches:

Shell Script Example (simple HTTP testing):

#!/bin/bash
# smoke.sh - Lightweight smoke test using curl

set -e
BASE_URL="http://localhost:9080/app"

echo "[INFO] Testing home page..."
curl -sf "$BASE_URL/" > /dev/null || exit 1

echo "[INFO] Testing API endpoint..."
curl -sf "$BASE_URL/api/status" | grep -q "ok" || exit 1

echo "[PASS] Smoke tests complete"
exit 0

JavaScript/Node.js Example (with Jest):

// smoke.test.js
const axios = require('axios');

const BASE_URL = 'http://localhost:9080/app';

describe('Smoke Tests', () => {
  test('home page loads', async () => {
    const response = await axios.get(BASE_URL);
    expect(response.status).toBe(200);
    expect(response.data).toContain('app');
  });

  test('API endpoint responds', async () => {
    const response = await axios.get(`${BASE_URL}/api/status`);
    expect(response.data.status).toBe('ok');
  });
});

Makefile Integration (shell script example):

smoke: up
    @echo "[INFO] Running smoke tests..."
    docker exec {{APP_NAME}} bash -c "cd /app && bash smoke.sh"

test: smoke

Key Point: The implementation language doesn't matter, as long as:

• The Dockerfile includes necessary runtime and dependencies
• The test target in Makefile successfully runs the tests within the container
• Tests exit with appropriate exit codes (0 = success)

Standard Patterns

Directory Structure

For simple applications (single smoke.py):

benchmark/<category>/<application-name>/
├── jakarta/
│   ├── Dockerfile
│   ├── Makefile
│   ├── smoke.py
│   ├── pom.xml
│   ├── mvnw
│   ├── mvnw.cmd
│   ├── .mvn/
│   └── src/
├── quarkus/
│   ├── Dockerfile
│   ├── Makefile
│   ├── smoke.py
│   ├── pom.xml
│   ├── mvnw
│   ├── mvnw.cmd
│   ├── .mvn/
│   └── src/
└── spring/
    ├── Dockerfile
    ├── Makefile
    ├── smoke.py
    ├── pom.xml
    ├── mvnw
    ├── mvnw.cmd
    ├── .mvn/
    └── src/

For complex applications (smoke folder with pytest):

benchmark/<category>/<application-name>/
├── jakarta/
│   ├── Dockerfile
│   ├── Makefile
│   ├── pom.xml
│   ├── mvnw
│   ├── mvnw.cmd
│   ├── .mvn/
│   ├── src/
│   └── smoke/                      # Folder instead of single file
│       ├── smoke.py
│       ├── test_home.py
│       ├── test_auth.py
│       ├── test_api.py
│       ├── conftest.py
│       ├── pytest.ini
│       ├── pyproject.toml
│       ├── playwright-test-cases.md
│       └── README.md
├── quarkus/
│   ├── ... (same structure)
│   └── smoke/
│       └── ... (same structure)
└── spring/
    ├── ... (same structure)
    └── smoke/
        └── ... (same structure)

Naming Conventions

1. Container Names: <app>-<framework> (e.g., jobs-jakarta, jobs-quarkus)
2. Image Names: <app>-<framework>:latest
3. Variables: Use uppercase with underscores (e.g., APP_NAME, IMAGE_NAME)
4. Paths: Use consistent endpoint paths across frameworks

Common Variables

These should appear in every Makefile:

APP_NAME       := "<app>-<framework>"
IMAGE_NAME     := "<app>-<framework>:latest"

Checklist

Before submitting your contribution, verify:

Dockerfile

• Uses appropriate JDK base image for framework
• Installs python3 and curl
• Basic pattern: Creates non-root user with UID 1001
• Playwright pattern: Runs as root and installs Python venv, pip, and Playwright
• Playwright pattern: Sets up PLAYWRIGHT_BROWSERS_PATH and installs Chromium
• Copies all necessary files with correct ownership (use --chown=1001:1001 for basic pattern)
• Makes mvnw executable
• Does NOT include EXPOSE directive (tests run internally)
• Uses correct Maven goal in CMD
• Playwright pattern: Implements layer caching for pom.xml files

Makefile

• All variables defined at top (APP_NAME, IMAGE_NAME)
• build target works
• rebuild target works (no cache)
• up target waits for correct startup pattern
• logs target streams container logs
• down target cleans up container
• test target runs smoke tests successfully
• local target runs app without Docker

Smoke Test (smoke.py)

• Has descriptive docstring
• Includes shebang #!/usr/bin/env python3
• Has URL discovery with multiple candidates
• Supports VERBOSE=1 environment variable
• Tests real application functionality (not just health checks)
• Uses clear [PASS]/[FAIL] messages
• Exits with code 0 on success, non-zero on failure
• Reports execution time
• Handles network errors gracefully
• Works both inside container and from host
• Playwright tests: Properly manages browser lifecycle (launch/close)
• Playwright tests: Uses appropriate timeouts and wait strategies
• Playwright tests: Handles server startup and shutdown

Testing

• just build succeeds for all frameworks
• just up starts container and waits for ready state
• just test passes all smoke tests
• just logs shows application logs
• just down cleans up successfully
• just local runs application locally
• All three frameworks (jakarta, quarkus, spring) work identically
• Playwright tests: Browser tests pass in headless mode
• Playwright tests: Tests work both inside container and from host

Documentation

• Add README.md explaining the application's purpose
• Document any special configuration or requirements
• Document if Playwright is used for UI testing
• Update main benchmark documentation if needed

Tips and Troubleshooting

Debugging

Test startup pattern: docker logs <container> 2>&1 | grep -q "<pattern>"

Run smoke test manually: docker exec <container> python3 /app/smoke.py

Verbose output: VERBOSE=1 python3 smoke.py

Playwright debugging: Set headless=False and use page.pause()

Common Issues

Container won't start: Check logs with docker logs <container>

Smoke test fails: Run with VERBOSE=1 to see detailed request/response

Startup timeout: Increase sleep or check startup pattern regex

Permission denied: Verify file ownership matches user UID 1001 (basic pattern only)

Playwright browser won't launch: Ensure you're running as root in Dockerfile or install system dependencies

Playwright timeout: Increase timeout values or check if page is actually loading

Python package conflicts: Use virtual environment with python3 -m venv (required for Playwright)

Chromium not found: Verify playwright install chromium ran successfully and PLAYWRIGHT_BROWSERS_PATH is set

Quick Start

# 1. Create structure
mkdir -p benchmark/<category>/<app>/{jakarta,quarkus,spring}

# 2. Implement first framework
cd benchmark/<category>/<app>/jakarta
# ... create Dockerfile, Makefile, smoke.py

# 3. Test
just build && just up && just test

# 4. Adapt to other frameworks
# 5. Submit PR

Reference Implementations

• Basic pattern: benchmark/infrastructure/concurrency-jobs
• Playwright pattern: benchmark/infrastructure/ejb-async
• Complex multi-test: benchmark/whole_applications/daytrader