#!/usr/bin/env bash
# Mock infrastructure for reliable testing

# Mock Docker API
mock_docker() {
  local operation="$1"
  shift

  case "$operation" in
    ps)
      printf "CONTAINER ID   IMAGE     STATUS\n"
      printf "abc123         nginx     Up 5 minutes\n"
      ;;
    inspect)
      printf '{"State":{"Running":true,"Health":{"Status":"healthy"}}}\n'
      ;;
    logs)
      printf "Mock container logs\n"
      ;;
    exec)
      printf "Mock exec output\n"
      ;;
    *)
      return 0
      ;;
  esac
}

# Mock network calls
mock_curl() {
  local url="$1"
  local response="${MOCK_RESPONSE:-{\"status\":\"ok\"}}"

  printf "%s\n" "$response"
  return 0
}

# Controllable time for timeout tests
mock_date() {
  local format="${1:-%s}"
  local mock_time="${MOCK_TIME:-$(date +%s)}"

  if [[ "$format" == "+%s" ]] || [[ "$format" == "%s" ]]; then
    printf "%s\n" "$mock_time"
  else
    command date "$format"
  fi
}

# Deterministic random data
mock_random() {
  local seed="${MOCK_SEED:-12345}"
  printf "%s\n" "$seed"
}

# Fast tmpfs-backed file operations
create_test_tmpfs() {
  local test_dir

  if [[ "$(uname)" == "Darwin" ]]; then
    test_dir=$(mktemp -d)
  else
    # Linux with tmpfs
    test_dir="/dev/shm/nself-test-$$"
    mkdir -p "$test_dir"
  fi

  printf "%s\n" "$test_dir"
}

# Export mock functions
export -f mock_docker
export -f mock_curl
export -f mock_date
export -f mock_random
export -f create_test_tmpfs

#!/usr/bin/env bash
# Enhanced test framework with reliability features

# Source existing framework
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/../test_framework.sh"

# Timeout protection (30s default)
run_test_with_timeout() {
  local test_name="$1"
  local timeout="${2:-30}"

  if command -v timeout >/dev/null 2>&1; then
    timeout "$timeout" bash -c "$test_name"
    local result=$?
    if [[ $result -eq 124 ]]; then
      printf "TIMEOUT: %s exceeded %ss\n" "$test_name" "$timeout" >&2
      return 1
    fi
    return $result
  elif command -v gtimeout >/dev/null 2>&1; then
    gtimeout "$timeout" bash -c "$test_name"
    return $?
  else
    # No timeout available - run directly
    bash -c "$test_name"
    return $?
  fi
}

# Retry logic for flaky operations
retry_test() {
  local test_func="$1"
  local max_attempts="${2:-3}"
  local attempt=1

  while [[ $attempt -le $max_attempts ]]; do
    if $test_func; then
      return 0
    fi
    attempt=$((attempt + 1))
    sleep 1
  done

  printf "FAILED: %s after %d attempts\n" "$test_func" "$max_attempts" >&2
  return 1
}

# Cleanup guarantees
ensure_cleanup() {
  local cleanup_func="$1"

  # Register cleanup on EXIT
  trap "$cleanup_func" EXIT INT TERM
}

# Fast fail on critical errors
fail_fast() {
  local error_msg="$1"

  printf "\033[31mCRITICAL ERROR:\033[0m %s\n" "$error_msg" >&2
  exit 1
}

# Skip test gracefully
skip_test() {
  local reason="$1"

  printf "\033[33mSKIP:\033[0m %s\n" "$reason"
  return 0
}

# Check if running in CI
is_ci() {
  [[ -n "$CI" ]] || [[ -n "$GITHUB_ACTIONS" ]] || [[ -n "$GITLAB_CI" ]]
}

# Export enhanced functions
export -f run_test_with_timeout
export -f retry_test
export -f ensure_cleanup
export -f fail_fast
export -f skip_test
export -f is_ci

#!/usr/bin/env bash
# Generate comprehensive test coverage report

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
COVERAGE_DIR="$PROJECT_ROOT/coverage"

# Create coverage directory
mkdir -p "$COVERAGE_DIR"

# Find all source files
mapfile -t source_files < <(find "$PROJECT_ROOT/src" -type f -name "*.sh" \
  ! -path "*/tests/*" \
  ! -path "*/templates/*" \
  ! -path "*/_deprecated/*" \
  | sort)

# Find all test files
mapfile -t test_files < <(find "$PROJECT_ROOT/src/tests" -type f \( -name "*.sh" -o -name "*.bats" \) | sort)

total_source_files=${#source_files[@]}
total_test_files=${#test_files[@]}

printf "# nself Test Coverage Report\n\n"
printf "Generated: %s\n\n" "$(date '+%Y-%m-%d %H:%M:%S')"

printf "## Summary\n\n"
printf "- **Source Files:** %d\n" "$total_source_files"
printf "- **Test Files:** %d\n" "$total_test_files"
printf "- **Coverage Ratio:** %.1f%%\n\n" "$(echo "scale=1; $total_test_files * 100 / $total_source_files" | bc)"

printf "## Coverage by Category\n\n"

# Analyze CLI coverage
cli_source=$(find "$PROJECT_ROOT/src/cli" -type f -name "*.sh" ! -path "*/_deprecated/*" | wc -l)
cli_tests=$(find "$PROJECT_ROOT/src/tests" -type f -name "*cli*.sh" -o -name "*cli*.bats" | wc -l)
printf "### CLI Commands\n"
printf "- Source files: %d\n" "$cli_source"
printf "- Test files: %d\n" "$cli_tests"
printf "- Coverage: %.1f%%\n\n" "$(echo "scale=1; $cli_tests * 100 / $cli_source" | bc)"

# Analyze library coverage
lib_source=$(find "$PROJECT_ROOT/src/lib" -type f -name "*.sh" | wc -l)
lib_tests=$(find "$PROJECT_ROOT/src/tests/unit" -type f -name "*.sh" | wc -l)
lib_tests=$((lib_tests + $(find "$PROJECT_ROOT/src/tests" -type f -name "*.bats" ! -path "*/integration/*" | wc -l)))
printf "### Library Modules\n"
printf "- Source files: %d\n" "$lib_source"
printf "- Test files: %d\n" "$lib_tests"
printf "- Coverage: %.1f%%\n\n" "$(echo "scale=1; $lib_tests * 100 / $lib_source" | bc)"

# List untested files
printf "## Untested Source Files\n\n"

for source_file in "${source_files[@]}"; do
  base_name=$(basename "$source_file" .sh)
  has_test=false

  for test_file in "${test_files[@]}"; do
    if [[ "$test_file" == *"$base_name"* ]]; then
      has_test=true
      break
    fi
  done

  if [[ "$has_test" == "false" ]]; then
    rel_path="${source_file#$PROJECT_ROOT/}"
    printf "- \`%s\`\n" "$rel_path"
  fi
done

printf "\n---\n\n"
printf "Run \`./scripts/generate-missing-tests.sh\` to create test stubs for untested files.\n"

test_with_timeout() {
  run_test_with_timeout "my_test_function" 30
  assert_success
}

my_test_function() {
  # Test code that might hang
  nself build
}

test_network_operation() {
  retry_test check_network 3
  assert_success
}

check_network() {
  curl -sSf https://api.example.com/health
}

test_external_service() {
  if ! check_network_available; then
    skip_test "Network not available (CI environment)"
    return 0
  fi

  # Actual test
  run_external_api_test
  assert_success
}

test_with_cleanup() {
  local test_dir
  test_dir=$(create_test_tmpfs)

  ensure_cleanup "rm -rf '$test_dir'"

  # Test code
  touch "$test_dir/test.txt"
  assert_file_exists "$test_dir/test.txt"

  # Cleanup runs automatically on EXIT
}

test_docker_operation() {
  if ! docker ps >/dev/null 2>&1; then
    # Docker not available - use mock
    export -f mock_docker
    alias docker=mock_docker
  fi

  # Test code works with real or mocked Docker
  result=$(docker ps)
  assert_success
}

# Defensive programming - mark as untestable
# coverage:ignore-next
if [[ "$IMPOSSIBLE_SCENARIO" == "true" ]]; then
  log_error "This should never happen"
  exit 1
fi

# Debug logging - exclude from coverage
# coverage:ignore-start
if [[ "$DEBUG" == "true" ]]; then
  printf "Debug: %s\n" "$debug_info"
fi
# coverage:ignore-end

#!/usr/bin/env bash
# Run tests in parallel for faster execution

set -euo pipefail

PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
TEST_DIR="$PROJECT_ROOT/src/tests"

# Number of parallel jobs
JOBS=${JOBS:-4}

# Run unit tests in parallel
printf "Running unit tests in parallel (jobs=%d)...\n" "$JOBS"
find "$TEST_DIR/unit" -name "test-*.sh" -print0 | \
  xargs -0 -P "$JOBS" -I {} bash -c '{} || exit 255'

# Run integration tests sequentially (may have dependencies)
printf "Running integration tests sequentially...\n"
find "$TEST_DIR/integration" -name "test-*.sh" -exec {} \;

printf "All tests passed!\n"