agentgateway/controller/hack/run-e2e-test.sh

769 lines
31 KiB
Bash
Raw Permalink Normal View History

#!/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 "$@"