#!/usr/bin/env bash set -eEuo pipefail # Script to run a single e2e test case # # This script intelligently finds and runs e2e test cases using git grep. # It can run: # - Top-level test functions (e.g., TestKgateway) # - Entire test suites (e.g., SessionPersistence) # - Individual test methods within suites (e.g., TestCookieSessionPersistence) # # The script will automatically generate the most specific go test -run pattern. # # Environment Variables: # PERSIST_INSTALL - If set to true/1/yes/y, will skip 'make setup' if a kind # cluster already exists. This speeds up test runs when you're # iterating locally. # FAIL_FAST_AND_PERSIST - If set to true (default for this script), skip cleanup on # test failure to allow resource inspection. Set to false to # always cleanup. Use --cleanup-on-failure flag to override. # SKIP_ALL_TEARDOWN - If set to true/1/yes/y, skip all cleanup/teardown operations # regardless of test success or failure. Use --skip-teardown flag. # AUTO_SETUP - If set to true/1/yes/y, will automatically clean up conflicting # Helm releases if detected. Otherwise, will error out. # CLUSTER_NAME - Name of the kind cluster (default: kind) # TEST_PKG - Go test package to run (default: ./test/e2e/tests) # # Usage: ./hack/run-e2e-test.sh [OPTIONS] [TEST_PATTERN] # # Options: # --rebuild, -r Delete the kind cluster, rebuild all docker images, create a # new kind cluster, load images into kind, and then run tests. # This ensures a completely fresh environment. # --persist, -p Skip 'make setup' if kind cluster exists (faster iteration). # Equivalent to setting PERSIST_INSTALL=true. # --cleanup-on-failure, -c Always cleanup resources even if test fails (disables default # FAIL_FAST_AND_PERSIST behavior). Useful for CI or running all tests. # --skip-teardown, -s Skip all cleanup/teardown operations regardless of test result. # Equivalent to setting SKIP_ALL_TEARDOWN=true. # --list, -l List all available test suites and top-level tests # --dry-run, -n Print the test command that would be run without executing it # --help, -h Show this help message # # Examples: # # Run an entire test suite (default: skip cleanup on failure for debugging) # ./hack/run-e2e-test.sh SessionPersistence # # # Run a specific test method within a suite # ./hack/run-e2e-test.sh TestCookieSessionPersistence # # # Run a top-level test function # ./hack/run-e2e-test.sh TestKgateway # # # Always cleanup/tear-down, even on failure # ./hack/run-e2e-test.sh --cleanup-on-failure SessionPersistence # # # Run a suite within a specific parent test (using slash notation) # ./hack/run-e2e-test.sh TestKgateway/SessionPersistence # # # Run a specific test method using slash notation # ./hack/run-e2e-test.sh TestKgateway/^SessionPersistence$/TestHeaderSessionPersistence # # # Skip setup if cluster exists (faster iteration) - using flag # ./hack/run-e2e-test.sh --persist SessionPersistence # # # Skip setup if cluster exists (faster iteration) - using env var # PERSIST_INSTALL=true ./hack/run-e2e-test.sh SessionPersistence # # # Auto-cleanup conflicting Helm releases # AUTO_SETUP=true ./hack/run-e2e-test.sh SessionPersistence # # # Delete cluster and rebuild everything from scratch # ./hack/run-e2e-test.sh --rebuild SessionPersistence # # # Use a different cluster name # CLUSTER_NAME=my-cluster ./hack/run-e2e-test.sh SessionPersistence # # # Print the test command without running it # ./hack/run-e2e-test.sh -n TestCookieSessionPersistence # Get the script directory SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)" cd "${REPO_ROOT}" # Check if KIND is available KIND="${KIND:-kind}" CLUSTER_NAME="${CLUSTER_NAME:-kind}" log_info() { echo -e "INFO: $*" >&2 } log_success() { echo -e "SUCCESS: $*" >&2 } log_warn() { echo -e "WARNING: $*" >&2 } log_error() { echo -e "ERROR: $*" >&2 } # Check if an environment variable is truthy (1, true, yes, y) is_truthy() { local val="${!1:-}" [[ "${val,,}" =~ ^(1|true|yes|y)$ ]] } # Check if kind cluster exists kind_cluster_exists() { ${KIND} get clusters 2>/dev/null | grep -q "^${CLUSTER_NAME}$" } # Check for and handle conflicting Helm releases # Returns: 0 if no cleanup needed, 1 if cleanup was performed check_and_cleanup_helm_conflicts() { # Only check if kubectl is available and cluster exists if ! command -v kubectl &> /dev/null; then return 0 fi if ! kubectl cluster-info &> /dev/null; then return 0 fi log_info "Checking for existing kgateway installations..." # When AUTO_SETUP is enabled, clean up everything for a fresh start if is_truthy AUTO_SETUP; then log_info "AUTO_SETUP is enabled, cleaning up all kgateway installations..." # Uninstall Helm releases from common namespaces for ns in kgateway-system kgateway-test default; do for release in kgateway-crds kgateway; do if helm list -a -n "$ns" 2>/dev/null | grep -q "^${release}"; then log_info "Uninstalling Helm release '${release}' from namespace '${ns}'..." helm uninstall "${release}" -n "${ns}" 2>/dev/null || true fi done done # Delete ALL kgateway CRDs log_info "Deleting all kgateway CRDs..." local crds_list crds_list=$(kubectl get crds 2>/dev/null | grep 'kgateway.dev' | awk '{print $1}' || true) if [[ -n "$crds_list" ]]; then while IFS= read -r crd_name; do if [[ -n "$crd_name" ]]; then log_info "Deleting CRD: ${crd_name}" kubectl delete crd "${crd_name}" --ignore-not-found=true 2>/dev/null || true fi done <<< "$crds_list" fi # Wait a moment for deletions to complete sleep "${SLEEP_FOR_DELETE:-2}" log_info "Cleanup complete, will run 'make setup' to reinstall" echo "" return 1 # Signal that cleanup happened and setup is needed fi # If AUTO_SETUP is not enabled, just check and return log_info "No cleanup performed (set AUTO_SETUP=true to enable automatic cleanup)" return 0 } # Build the go test run pattern build_test_pattern() { local pattern="$1" # If pattern contains regex metacharacters, treat it as a regex if [[ "$pattern" =~ [\.\*\+\?\[\]\(\)\|] ]]; then log_info "Detected regex pattern: ${pattern}" # If it looks like a test method pattern (starts with Test), search across all suites if [[ "$pattern" == Test* ]]; then log_info "Searching across all suites for matching test methods" echo ".*/.*/${pattern}" else # Otherwise pass through as-is echo "${pattern}" fi return fi # Check if the pattern contains slashes (nested test path like TestKgateway/SessionPersistence/TestHeaderSessionPersistence) if [[ "$pattern" == */* ]]; then log_info "Detected nested test path: ${pattern}" # Split by '/', wrap each element with '^' and '$', then join with '/' IFS='/' read -ra parts <<< "$pattern" local result="" for ((i=0; i<${#parts[@]}; i++)); do local part="${parts[i]}" # Strip existing anchors part="${part#^}" part="${part%\$}" # Add to result if [[ $i -eq 0 ]]; then result="^${part}\$" else result="${result}/^${part}\$" fi done log_info "Running nested test: ${pattern}" echo "$result" return fi # Check if it's a top-level test function local test_func if [[ "$pattern" == Test* ]]; then # Pattern already starts with Test, search for exact match test_func=$(git grep -h --no-line-number "^func ${pattern}(" -- 'test/e2e/tests/*_test.go' 2>/dev/null | head -1 || true) else # Pattern doesn't start with Test, add it test_func=$(git grep -h --no-line-number "^func Test${pattern}(" -- 'test/e2e/tests/*_test.go' 2>/dev/null | head -1 || true) fi if [[ -n "$test_func" ]]; then # Extract the test function name local func_name func_name=$(echo "$test_func" | sed -E 's/func (Test[^(]*).*/\1/') log_info "Running top-level test: ${func_name}" echo "^${func_name}$" return fi # Check if it's a test method within a suite (e.g., TestCookieSessionPersistence) if [[ "$pattern" == Test* ]]; then # Search for method with exact or partial match (find ALL matches, not just first) local method_matches method_matches=$(git grep "func (.*) ${pattern}[^(]*\(\)" -- 'test/e2e/features' 2>/dev/null || true) if [[ -n "$method_matches" ]]; then # Extract the actual full method name from first match local method_name method_name=$(echo "$method_matches" | head -1 | sed -E 's/^[^:]*:[0-9]*:func .* (Test[^(]*)\(\).*/\1/') # Find ALL files containing this method local method_files method_files=$(git grep -l "func (.*) ${method_name}\(\)" -- 'test/e2e/features' 2>/dev/null || true) if [[ -n "$method_files" ]]; then # Build patterns for all matching suites local patterns=() local suite_info=() while IFS= read -r method_file; do # Get the package import path relative to the features directory local rel_path rel_path=$(echo "$method_file" | sed 's|test/e2e/features/||' | xargs dirname) # Find the suite registration that imports from this path local suite_line suite_line=$(git grep "Register(\"[^\"]*\", .*\\.NewTestingSuite)" -- 'test/e2e/tests/*.go' 2>/dev/null | \ grep -v "^\s*//" | \ while IFS=: read -r file line_content; do # Extract the package identifier from the Register call pkg_id=$(echo "$line_content" | sed -E 's/.*Register\("[^"]*", ([^.]*)\..*/\1/') # Check if this package identifier's import path matches our method's path # Look for either: # 1. Aliased import: pkg_id "path/to/features/rel_path" # 2. Non-aliased import: "path/to/features/rel_path" (where pkg_id matches the last component) # IMPORTANT: Match exactly /features/rel_path" to avoid matching /features/foo/rel_path" if git grep -q "[[:space:]]${pkg_id}[[:space:]]\".*\/features\/${rel_path}\"" "$file" 2>/dev/null; then echo "${file}:${line_content}" break elif git grep -q "\".*\/features\/${rel_path}\"" "$file" 2>/dev/null; then # For non-aliased imports, verify pkg_id matches the last path component local import_line import_line=$(git grep "\".*\/features\/${rel_path}\"" "$file" 2>/dev/null | head -1) # Extract the last component of the import path local last_component last_component=$(echo "$import_line" | sed -E 's|.*/([^/"]+)".*|\1|') if [[ "$last_component" == "$pkg_id" ]]; then echo "${file}:${line_content}" break fi fi done || true) if [[ -n "$suite_line" ]]; then local suite_name suite_name=$(echo "$suite_line" | sed -E 's/.*Register\("([^"]*)".*/\1/') local file file=$(echo "$suite_line" | cut -d: -f1) local parent_test parent_test=$(git grep "func Test.*\(t \*testing\.T\)" "$file" | cut -d: -f3- | head -1 | sed -E 's/func (Test[^(]*).*/\1/') if [[ -z "$parent_test" ]]; then local dir=$(dirname "$file") local base=$(basename "$file" .go) if [[ "$base" == *_tests ]]; then local alt_file="${dir}/${base%s}.go" if [[ -f "$alt_file" ]]; then parent_test=$(git grep "func Test.*\(t \*testing\.T\)" "$alt_file" | cut -d: -f3- | head -1 | sed -E 's/func (Test[^(]*).*/\1/') fi fi fi if [[ -n "$parent_test" ]]; then patterns+=("^${parent_test}$/^${suite_name}$/^${method_name}$") suite_info+=("${parent_test} -> ${suite_name} -> ${method_name}") fi fi done <<< "$method_files" # If we found patterns, combine them and return if [[ ${#patterns[@]} -gt 0 ]]; then if [[ ${#patterns[@]} -eq 1 ]]; then log_info "Running suite test: ${suite_info[0]}" echo "${patterns[0]}" else log_info "Running test in ${#patterns[@]} suites:" for info in "${suite_info[@]}"; do log_info " - ${info}" done # For multiple patterns, we need to combine them intelligently # If they share the same suite/method but different parent tests, # we can use alternation at the parent level # Otherwise, we need to run them separately or use complex regex # Extract parent tests, suite names, and method names local parent_tests=() local suite_names=() local method_names=() for pattern in "${patterns[@]}"; do # Pattern format: ^ParentTest$/^Suite$/^Method$ local parts IFS='/' read -ra parts <<< "$pattern" parent_tests+=("${parts[0]#^}") parent_tests[-1]="${parent_tests[-1]%\$}" suite_names+=("${parts[1]#^}") suite_names[-1]="${suite_names[-1]%\$}" method_names+=("${parts[2]#^}") method_names[-1]="${method_names[-1]%\$}" done # Check if suite and method are the same across all patterns local first_suite="${suite_names[0]}" local first_method="${method_names[0]}" local same_suite_method=true for ((i=1; i<${#suite_names[@]}; i++)); do if [[ "${suite_names[i]}" != "$first_suite" ]] || [[ "${method_names[i]}" != "$first_method" ]]; then same_suite_method=false break fi done if [[ "$same_suite_method" == true ]]; then # Same suite/method, different parents - use alternation at parent level local parent_alternation parent_alternation=$(IFS='|'; echo "${parent_tests[*]}") echo "^(${parent_alternation})$/^${first_suite}$/^${first_method}$" else # Different suites or methods - combine with | at top level local combined_pattern combined_pattern=$(IFS='|'; echo "${patterns[*]}") echo "(${combined_pattern})" fi fi return fi fi fi fi # Check if it's a suite local suite_line suite_line=$(git grep "Register(\"${pattern}\"" -- 'test/e2e/tests/*.go' 2>/dev/null | head -1 || true) if [[ -z "$suite_line" ]]; then # Try partial match suite_line=$(git grep "Register(\".*${pattern}.*\"" -- 'test/e2e/tests/*.go' 2>/dev/null | head -1 || true) fi if [[ -n "$suite_line" ]]; then # Extract the suite name from Register("SuiteName", ...) local suite_name suite_name=$(echo "$suite_line" | sed -E 's/.*Register\("([^"]*)".*/\1/') # Find the parent test function local file file=$(echo "$suite_line" | cut -d: -f1) # Find which test function calls this suite runner local parent_test parent_test=$(git grep "func Test.*\(t \*testing\.T\)" "$file" | cut -d: -f3- | head -1 | sed -E 's/func (Test[^(]*).*/\1/') # If not found in the same file, try related files (e.g., kgateway_test.go for kgateway_tests.go) if [[ -z "$parent_test" ]]; then local dir=$(dirname "$file") local base=$(basename "$file" .go) # Try removing 's' from 'tests' suffix (kgateway_tests.go -> kgateway_test.go) if [[ "$base" == *_tests ]]; then local alt_file="${dir}/${base%s}.go" if [[ -f "$alt_file" ]]; then parent_test=$(git grep "func Test.*\(t \*testing\.T\)" "$alt_file" | cut -d: -f3- | head -1 | sed -E 's/func (Test[^(]*).*/\1/') fi fi fi if [[ -z "$parent_test" ]]; then log_error "Could not find parent test function for suite: ${suite_name}" exit 1 fi # Check if the pattern might be a specific test method (starts with Test but not the suite name) if [[ "$pattern" != "$suite_name" && "$pattern" == Test* ]]; then # The pattern looks like a test method name local method_match method_match=$(git grep -h "func (.*) ${pattern}\(\)" -- 'test/e2e/features' 2>/dev/null | head -1 || true) if [[ -n "$method_match" ]]; then # Running a specific test method within a suite local method_name method_name=$(echo "$method_match" | sed -E 's/func .* ([^(]*)\(\).*/\1/') log_info "Running suite test: ${parent_test} -> ${suite_name} -> ${method_name}" echo "^${parent_test}$/^${suite_name}$/^${method_name}$" return fi fi # Running entire suite log_info "Running entire suite: ${parent_test} -> ${suite_name}" echo "^${parent_test}$/^${suite_name}$" return fi # Fallback: just use the pattern as-is log_error "Test pattern not found: ${pattern}" exit 1 } # List available tests list_tests() { log_info "Available test suites:" git grep -h 'Register("' -- 'test/e2e/tests/*.go' | \ sed -E 's/.*Register\("([^"]*)".*/ - \1/' | sort echo "" log_info "Available top-level tests:" git grep -h '^func Test.*\(t \*testing\.T\)' -- 'test/e2e/tests/*_test.go' | \ sed -E 's/func (Test[^(]*).*/ - \1/' | sort } # Show help message show_help() { cat << EOF Usage: $0 [OPTIONS] [TEST_PATTERN] Script to run a single e2e test case This script intelligently finds and runs e2e test cases using git grep. It can run: - Top-level test functions (e.g., TestKgateway) - Entire test suites (e.g., SessionPersistence) - Individual test methods within suites (e.g., TestCookieSessionPersistence) Options: --help, -h Show this help message --list, -l List all available test suites and top-level tests --rebuild, -r Delete the kind cluster, rebuild images, and create a fresh cluster --persist, -p Skip 'make setup' if kind cluster exists (faster iteration) --cleanup-on-failure, -c Always cleanup resources even if test fails (default: skip cleanup on failure) --skip-teardown, -s Skip all cleanup/teardown operations regardless of test result --dry-run, -n Print the test command that would be run without executing it Environment Variables: PERSIST_INSTALL If set to true/1/yes/y, skip 'make setup' if kind cluster exists FAIL_FAST_AND_PERSIST If set to true (default), skip cleanup on test failure SKIP_ALL_TEARDOWN If set to true/1/yes/y, skip all cleanup/teardown operations AUTO_SETUP If set to true/1/yes/y, automatically cleanup conflicting Helm releases CLUSTER_NAME Name of the kind cluster (default: kind) TEST_PKG Go test package to run (default: ./test/e2e/tests) Examples: # Run an entire test suite (default: skip cleanup on failure for debugging) $0 SessionPersistence # Run a specific test method within a suite $0 TestCookieSessionPersistence # Run a top-level test function $0 TestKgateway # Always cleanup/tear-down, even on failure $0 --cleanup-on-failure SessionPersistence # Skip all teardown/cleanup regardless of test result $0 --skip-teardown SessionPersistence # Run a suite within a specific parent test (using slash notation) $0 TestKgateway/SessionPersistence # Run a specific test method using slash notation $0 TestKgateway/^SessionPersistence$/TestHeaderSessionPersistence # Skip setup if cluster exists (faster iteration) - using flag $0 --persist SessionPersistence # Skip setup if cluster exists (faster iteration) - using env var PERSIST_INSTALL=true $0 SessionPersistence # Auto-cleanup conflicting Helm releases AUTO_SETUP=true $0 SessionPersistence # Delete cluster and rebuild everything from scratch $0 --rebuild SessionPersistence # Use a different cluster name CLUSTER_NAME=my-cluster $0 SessionPersistence # Print the test command without running it $0 -n TestCookieSessionPersistence EOF } # Main script main() { local rebuild_cluster=false local dry_run=false local persist_install=false local cleanup_on_failure=false local skip_teardown=false local test_pattern="" # Parse arguments while [[ "$#" -gt 0 ]]; do case "$1" in --help|-h) show_help exit 0 ;; --list|-l) list_tests exit 0 ;; --rebuild|-r) rebuild_cluster=true shift ;; --dry-run|-n) dry_run=true shift ;; --persist|-p) persist_install=true shift ;; --cleanup-on-failure|-c) cleanup_on_failure=true shift ;; --skip-teardown|-s) skip_teardown=true shift ;; *) test_pattern="$1" shift ;; esac done # Set PERSIST_INSTALL environment variable if --persist flag was used if [[ "$persist_install" == "true" ]]; then export PERSIST_INSTALL=true fi # Set SKIP_ALL_TEARDOWN environment variable if --skip-teardown flag was used if [[ "$skip_teardown" == "true" ]]; then export SKIP_ALL_TEARDOWN=true log_info "All teardown/cleanup is DISABLED (will skip cleanup regardless of test result)" elif is_truthy SKIP_ALL_TEARDOWN; then log_info "All teardown/cleanup is DISABLED (SKIP_ALL_TEARDOWN env var is set)" fi # Set FAIL_FAST_AND_PERSIST to true by default (for local development/debugging) # unless --cleanup-on-failure flag was used or it's already set if [[ "$cleanup_on_failure" == "true" ]]; then export FAIL_FAST_AND_PERSIST=false log_info "Cleanup on failure is ENABLED (will cleanup even if tests fail)" elif [[ -z "${FAIL_FAST_AND_PERSIST:-}" ]]; then export FAIL_FAST_AND_PERSIST=true log_info "Cleanup on failure is DISABLED by default (will skip cleanup if tests fail)" log_info "Use --cleanup-on-failure to always cleanup, even on test failure" fi if [[ -z "$test_pattern" ]]; then log_error "Usage: $0 [OPTIONS] TEST_PATTERN" echo "" echo "Examples:" echo " $0 SessionPersistence" echo " $0 TestCookieSessionPersistence" echo " $0 TestKgateway" echo " $0 TestKgateway/SessionPersistence" echo " $0 TestKgateway/SessionPersistence/TestHeaderSessionPersistence" echo " $0 --persist SessionPersistence" echo " $0 --cleanup-on-failure SessionPersistence" echo " $0 --rebuild SessionPersistence" echo " $0 -n TestCookieSessionPersistence" echo "" echo "Options:" echo " --help, -h Show full help message" echo " --list, -l List all available test suites and top-level tests" echo " --rebuild, -r Delete the kind cluster, rebuild images, and create a fresh cluster" echo " --persist, -p Skip 'make setup' if kind cluster exists (faster iteration)" echo " --cleanup-on-failure, -c Always cleanup resources even if test fails (default: skip cleanup on failure)" echo " --skip-teardown, -s Skip all cleanup/teardown operations regardless of test result" echo " --dry-run, -n Print the test command that would be run without executing it" exit 1 fi # Build the test run pattern local run_pattern run_pattern=$(build_test_pattern "$test_pattern") # Determine test package local test_pkg="${TEST_PKG:-./test/e2e/tests}" # Skip setup if in dry-run mode if [[ "$dry_run" == "true" ]]; then log_info "Dry-run mode: skipping setup and cluster operations" echo "" # Handle cluster rebuild elif [[ "$rebuild_cluster" == "true" ]]; then log_info "Rebuild flag set: deleting and recreating kind cluster" if kind_cluster_exists; then log_info "Deleting existing kind cluster '${CLUSTER_NAME}'..." ${KIND} delete cluster --name "${CLUSTER_NAME}" echo "" else log_info "Kind cluster '${CLUSTER_NAME}' does not exist" fi log_info "Running 'make setup' to rebuild images and create fresh cluster..." make setup echo "" else # Check for conflicting Helm releases before proceeding # Returns 1 if cleanup was performed, 0 otherwise check_and_cleanup_helm_conflicts local cleanup_performed=$? # Check if we should run setup local should_setup=true if is_truthy PERSIST_INSTALL; then log_info "PERSIST_INSTALL is set" if kind_cluster_exists; then if [[ $cleanup_performed -eq 1 ]]; then log_info "Kind cluster '${CLUSTER_NAME}' exists, but cleanup was performed, so running setup" should_setup=true else log_info "Kind cluster '${CLUSTER_NAME}' already exists, skipping setup" should_setup=false fi else log_info "Kind cluster '${CLUSTER_NAME}' does not exist, will run setup" fi fi # Run setup if needed if [[ "$should_setup" == "true" ]]; then log_info "Running 'make setup'..." make setup echo "" else log_info "Packaging charts (required for tests)..." make package-kgateway-charts package-agentgateway-charts echo "" fi fi # Run the test log_info "Running test with pattern: ${run_pattern}" log_info "Test package: ${test_pkg}" echo "" # Export PERSIST_INSTALL so the test code can use it if is_truthy PERSIST_INSTALL; then export PERSIST_INSTALL fi # Escape $ for make/shell local escaped_pattern="${run_pattern//\$/\$\$}" # If dry-run mode, just print the command and exit if [[ "$dry_run" == "true" ]]; then echo "" log_info "Dry-run mode: printing command without executing" echo "" echo "make go-test \\" echo " GO_TEST_USER_ARGS=\"-failfast -run '$escaped_pattern'\" \\" echo " TEST_PKG=\"${test_pkg}\" TEST_TAG=e2e" echo "" log_info "Environment variables:" if is_truthy PERSIST_INSTALL; then echo " PERSIST_INSTALL=true" fi if is_truthy SKIP_ALL_TEARDOWN; then echo " SKIP_ALL_TEARDOWN=true (skip all teardown/cleanup)" fi if is_truthy FAIL_FAST_AND_PERSIST; then echo " FAIL_FAST_AND_PERSIST=true (skip cleanup on failure)" else echo " FAIL_FAST_AND_PERSIST=false (always cleanup)" fi echo "" log_success "Dry-run completed!" exit 0 fi # Use a temp file to capture output for checking local test_output_file test_output_file=$(mktemp) trap "rm -f '$test_output_file'" EXIT # Temporarily disable exit-on-error so we can check the test results set +e set -x make go-test \ "GO_TEST_USER_ARGS=-failfast -run '$escaped_pattern'" \ TEST_PKG="${test_pkg}" TEST_TAG=e2e 2>&1 | tee "$test_output_file" test_exit_code=${PIPESTATUS[0]} set +x set -e # Check if no tests were run # Look for various indicators that no tests matched: # - "[no tests to run]" from gotestsum # - "DONE 0 tests" from test output # - "EMPTY" package with cached result if grep -q '\[no tests to run\]' "$test_output_file" || \ grep -q 'DONE 0 tests' "$test_output_file" || \ (grep -q 'EMPTY' "$test_output_file" && grep -q 'DONE 0 tests' "$test_output_file"); then echo "" log_error "No tests were run! The pattern '${run_pattern}' did not match any tests." log_error "" log_error "This usually means:" log_error " 1. The test pattern is incorrect" log_error " 2. The test name was misspelled" log_error " 3. The test does not exist in package ${test_pkg}" log_error "" log_error "Run '$0 --list' to see available tests" exit 1 fi # Check the test exit code if [[ $test_exit_code -ne 0 ]]; then echo "" log_error "Test execution failed with exit code $test_exit_code" exit $test_exit_code fi echo "" log_success "Test execution completed!" } main "$@"