@sebastienrousseau/dotfiles 0.2.468 → 0.2.481

package/scripts/tests/benchmark.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+
+# standard-benchmarks.sh
+# Measures shell startup time (total and per-component).
+# Optional threshold enforcement via DOTFILES_BENCH_MAX_MS.
+
+set -euo pipefail
+
+log_info() { echo -e "\n[INFO] $*"; }
+
+MAX_MS="${DOTFILES_BENCH_MAX_MS:-}"
+
+# ── Section 1: Total startup benchmark ──────────────────────────
+log_info "=== Total Startup Benchmark ==="
+
+if command -v hyperfine >/dev/null; then
+  log_info "Running benchmark with hyperfine..."
+  tmp_json="$(mktemp)"
+  hyperfine --warmup 3 --min-runs 10 --export-json "$tmp_json" "zsh -i -c exit"
+
+  if [[ -n "$MAX_MS" ]] && command -v python3 >/dev/null; then
+    python3 - "$tmp_json" "$MAX_MS" <<'PY'
+import json, sys
+path, max_ms = sys.argv[1], float(sys.argv[2])
+with open(path, "r", encoding="utf-8") as f:
+    data = json.load(f)
+mean_s = data["results"][0]["mean"]
+mean_ms = mean_s * 1000.0
+print(f"[INFO] Mean startup: {mean_ms:.1f} ms (limit: {max_ms:.1f} ms)")
+if mean_ms > max_ms:
+    print(f"[FAIL] Startup time exceeded limit: {mean_ms:.1f} ms > {max_ms:.1f} ms")
+    sys.exit(1)
+PY
+  fi
+  rm -f "$tmp_json"
+else
+  log_info "Hyperfine not found. Using simple loop..."
+  echo "Running 10 iterations of 'zsh -i -c exit'..."
+  for _ in {1..10}; do
+    time zsh -i -c exit
+  done
+fi
+
+# ── Section 2: Component-level profiling ────────────────────────
+log_info "=== Component-Level Profile ==="
+log_info "Profiling individual zshrc components via zsh/zprof..."
+
+# Use zsh's built-in zprof module if available
+if command -v zsh >/dev/null; then
+  zsh -c '
+    zmodload zsh/zprof 2>/dev/null
+    # Source the real zshrc (DOTFILES_SOURCED guard is reset in a fresh shell)
+    [[ -f "$HOME/.zshrc" ]] && source "$HOME/.zshrc"
+    zprof
+  ' 2>/dev/null | head -40
+
+  echo ""
+  log_info "Component timing (manual measurement):"
+
+  # Measure key init commands individually
+  _bench_component() {
+    local label="$1"
+    shift
+    local start end elapsed
+    if command -v perl >/dev/null 2>&1; then
+      start=$(perl -MTime::HiRes=time -e "printf \"%.0f\n\", time * 1000")
+      zsh -c "$*" >/dev/null 2>&1 || true
+      end=$(perl -MTime::HiRes=time -e "printf \"%.0f\n\", time * 1000")
+    else
+      start=$(($(date +%s) * 1000))
+      zsh -c "$*" >/dev/null 2>&1 || true
+      end=$(($(date +%s) * 1000))
+    fi
+    elapsed=$((end - start))
+    printf "  %-30s %4d ms\n" "$label" "$elapsed"
+  }
+
+  _bench_component "bare zsh (baseline)" "exit"
+  _bench_component "zinit + plugins" "source \"\${XDG_DATA_HOME:-\$HOME/.local/share}/zinit/zinit.git/zinit.zsh\" 2>/dev/null; exit"
+  _bench_component "compinit" "autoload -Uz compinit && compinit -C; exit"
+  _bench_component "starship init" "command -v starship >/dev/null && eval \"\$(starship init zsh)\"; exit"
+  _bench_component "atuin init" "command -v atuin >/dev/null && eval \"\$(atuin init zsh)\"; exit"
+  _bench_component "zoxide init" "command -v zoxide >/dev/null && eval \"\$(zoxide init zsh)\"; exit"
+  _bench_component "fnm env" "command -v fnm >/dev/null && eval \"\$(fnm env --use-on-cd)\"; exit"
+  _bench_component "fzf completions" "[[ -f /opt/homebrew/opt/fzf/shell/completion.zsh ]] && source /opt/homebrew/opt/fzf/shell/completion.zsh; exit"
+
+  echo ""
+  log_info "Component profiling complete."
+else
+  echo "[WARN] zsh not found, skipping component profiling."
+fi

package/scripts/tests/framework/assertions.sh

@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC2034
+# Assertion library for shell tests
+# Provides a comprehensive set of assertion functions for testing shell scripts
+#
+# Security note: This file uses eval to execute test commands and conditions.
+# This is intentional and necessary for the test assertion framework to work.
+# These functions are only used in test code and should never be called with
+# untrusted input. All eval calls carry a shellcheck disable directive.
+
+TESTS_RUN=0
+TESTS_PASSED=0
+TESTS_FAILED=0
+CURRENT_TEST=""
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+NC='\033[0m'
+
+# Start a new test case
+test_start() {
+  CURRENT_TEST="$1"
+  ((TESTS_RUN++)) || true
+}
+
+# Assert two values are equal
+assert_equals() {
+  local expected="$1" actual="$2" msg="${3:-values should be equal}"
+  if [[ "$expected" == "$actual" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    echo -e "    Expected: '$expected'"
+    echo -e "    Actual:   '$actual'"
+    return 1
+  fi
+}
+
+# Assert two values are not equal
+assert_not_equals() {
+  local unexpected="$1" actual="$2" msg="${3:-values should differ}"
+  if [[ "$unexpected" != "$actual" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    echo -e "    Unexpected: '$unexpected'"
+    echo -e "    Actual:     '$actual'"
+    return 1
+  fi
+}
+
+# Assert a command exits with expected code
+assert_exit_code() {
+  local expected="$1"
+  shift
+  local cmd="$*"
+  local actual
+  set +e
+  # shellcheck disable=SC2086
+  eval "$cmd" </dev/null >/dev/null 2>&1
+  actual=$?
+  set -e
+  assert_equals "$expected" "$actual" "exit code for: $cmd"
+}
+
+# Assert command output contains expected string
+assert_output_contains() {
+  local needle="$1"
+  shift
+  local cmd="$*"
+  local output
+  # shellcheck disable=SC2086
+  output=$(eval "$cmd" 2>&1) || true
+  if [[ "$output" == *"$needle"* ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: output contains '$needle'"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: output should contain '$needle'"
+    echo -e "    Actual output: $output"
+    return 1
+  fi
+}
+
+# Assert command output does NOT contain a string
+assert_output_not_contains() {
+  local needle="$1"
+  shift
+  local cmd="$*"
+  local output
+  # shellcheck disable=SC2086
+  output=$(eval "$cmd" 2>&1) || true
+  if [[ "$output" != *"$needle"* ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: output does not contain '$needle'"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: output should not contain '$needle'"
+    echo -e "    Actual output: $output"
+    return 1
+  fi
+}
+
+# Assert command output matches regex pattern
+assert_output_matches() {
+  local pattern="$1"
+  shift
+  local cmd="$*"
+  local output
+  # shellcheck disable=SC2086
+  output=$(eval "$cmd" 2>&1) || true
+  if [[ "$output" =~ $pattern ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: output matches pattern '$pattern'"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: output should match pattern '$pattern'"
+    echo -e "    Actual output: $output"
+    return 1
+  fi
+}
+
+# Assert file exists
+assert_file_exists() {
+  local file="$1" msg="${2:-file should exist}"
+  if [[ -f "$file" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg ($file not found)"
+    return 1
+  fi
+}
+
+# Assert file does not exist
+assert_file_not_exists() {
+  local file="$1" msg="${2:-file should not exist}"
+  if [[ ! -f "$file" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg ($file exists)"
+    return 1
+  fi
+}
+
+# Assert directory exists
+assert_dir_exists() {
+  local dir="$1" msg="${2:-directory should exist}"
+  if [[ -d "$dir" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg ($dir not found)"
+    return 1
+  fi
+}
+
+# Assert directory does not exist
+assert_dir_not_exists() {
+  local dir="$1" msg="${2:-directory should not exist}"
+  if [[ ! -d "$dir" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg ($dir exists)"
+    return 1
+  fi
+}
+
+# Assert a condition is true
+assert_true() {
+  local condition="$1" msg="${2:-condition should be true}"
+  # shellcheck disable=SC2086
+  if eval "$condition"; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    return 1
+  fi
+}
+
+# Assert a condition is false
+assert_false() {
+  local condition="$1" msg="${2:-condition should be false}"
+  # shellcheck disable=SC2086
+  if ! eval "$condition"; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    return 1
+  fi
+}
+
+# Assert string is empty
+assert_empty() {
+  local value="$1" msg="${2:-value should be empty}"
+  if [[ -z "$value" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    echo -e "    Actual: '$value'"
+    return 1
+  fi
+}
+
+# Assert string is not empty
+assert_not_empty() {
+  local value="$1" msg="${2:-value should not be empty}"
+  if [[ -n "$value" ]]; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    return 1
+  fi
+}
+
+# Assert file contains text (uses fixed-string matching for safety)
+assert_file_contains() {
+  local file="$1" needle="$2" msg="${3:-file should contain text}"
+  if [[ -z "$file" ]]; then
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg (no file path provided)"
+    return 1
+  fi
+  if [[ -f "$file" ]] && grep -qF "$needle" "$file"; then
+    ((TESTS_PASSED++)) || true
+    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: $msg"
+    return 0
+  else
+    ((TESTS_FAILED++)) || true
+    echo -e "  ${RED}✗${NC} $CURRENT_TEST: $msg"
+    return 1
+  fi
+}
+
+# Print test summary
+print_summary() {
+  echo ""
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo -e "Tests run: $TESTS_RUN"
+  echo -e "${GREEN}Passed: $TESTS_PASSED${NC}"
+  echo -e "${RED}Failed: $TESTS_FAILED${NC}"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  # Output machine-readable results for test_runner.sh
+  echo "RESULTS:$TESTS_RUN:$TESTS_PASSED:$TESTS_FAILED"
+
+  if [[ $TESTS_FAILED -gt 0 ]]; then
+    return 1
+  fi
+  return 0
+}

package/scripts/tests/framework/mocks.sh

@@ -0,0 +1,201 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC2034
+# Mock utilities for shell testing
+# Provides functions to create mock commands, files, and directories
+
+# Track created mocks for cleanup
+MOCK_COMMANDS=()
+MOCK_FILES=()
+MOCK_DIRS=()
+ORIGINAL_PATH="$PATH"
+MOCK_BIN_DIR=""
+
+# Initialize mock environment
+mock_init() {
+  MOCK_BIN_DIR=$(mktemp -d)
+  export MOCK_BIN_DIR
+  export PATH="$MOCK_BIN_DIR:$PATH"
+  MOCK_COMMANDS=()
+  MOCK_FILES=()
+  MOCK_DIRS=()
+}
+
+# Create a mock command
+# Usage: mock_command "command_name" "output" [exit_code]
+mock_command() {
+  local cmd_name="$1"
+  local output="$2"
+  local exit_code="${3:-0}"
+
+  if [[ -z "$MOCK_BIN_DIR" ]]; then
+    mock_init
+  fi
+
+  local mock_script="$MOCK_BIN_DIR/$cmd_name"
+  cat >"$mock_script" <<EOF
+#!/usr/bin/env bash
+echo "$output"
+exit $exit_code
+EOF
+  chmod +x "$mock_script"
+  MOCK_COMMANDS+=("$mock_script")
+}
+
+# Create a mock command that records arguments
+# Usage: mock_command_spy "command_name" [output] [exit_code]
+mock_command_spy() {
+  local cmd_name="$1"
+  local output="${2:-}"
+  local exit_code="${3:-0}"
+
+  if [[ -z "$MOCK_BIN_DIR" ]]; then
+    mock_init
+  fi
+
+  local mock_script="$MOCK_BIN_DIR/$cmd_name"
+  local spy_file="$MOCK_BIN_DIR/${cmd_name}.spy"
+
+  cat >"$mock_script" <<EOF
+#!/usr/bin/env bash
+echo "\$@" >> "$spy_file"
+echo "$output"
+exit $exit_code
+EOF
+  chmod +x "$mock_script"
+  touch "$spy_file"
+  MOCK_COMMANDS+=("$mock_script")
+  MOCK_FILES+=("$spy_file")
+}
+
+# Get spy call history
+# Usage: mock_get_calls "command_name"
+mock_get_calls() {
+  local cmd_name="$1"
+  local spy_file="$MOCK_BIN_DIR/${cmd_name}.spy"
+  if [[ -f "$spy_file" ]]; then
+    cat "$spy_file"
+  fi
+}
+
+# Get spy call count
+# Usage: mock_call_count "command_name"
+mock_call_count() {
+  local cmd_name="$1"
+  local spy_file="$MOCK_BIN_DIR/${cmd_name}.spy"
+  if [[ -f "$spy_file" ]]; then
+    wc -l <"$spy_file" | tr -d ' '
+  else
+    echo "0"
+  fi
+}
+
+# Create a temporary file with content
+# Usage: mock_file "content" [filename]
+mock_file() {
+  local content="$1"
+  local filename="${2:-}"
+  local file
+
+  if [[ -n "$filename" ]]; then
+    file=$(mktemp -t "$filename.XXXXXX")
+  else
+    file=$(mktemp)
+  fi
+
+  echo "$content" >"$file"
+  MOCK_FILES+=("$file")
+  echo "$file"
+}
+
+# Create a temporary directory
+# Usage: mock_dir [prefix]
+mock_dir() {
+  local prefix="${1:-mock}"
+  local dir
+  dir=$(mktemp -d -t "${prefix}.XXXXXX")
+  MOCK_DIRS+=("$dir")
+  echo "$dir"
+}
+
+# Create a mock archive file
+# Usage: mock_archive "type" [content_file]
+mock_archive() {
+  local type="$1"
+  local content="${2:-test content}"
+  local temp_dir
+  temp_dir=$(mktemp -d)
+  local temp_file="$temp_dir/test_file.txt"
+  local archive
+
+  echo "$content" >"$temp_file"
+
+  case "$type" in
+    tar)
+      archive=$(mktemp -t archive.XXXXXX.tar)
+      tar cf "$archive" -C "$temp_dir" test_file.txt
+      ;;
+    tar.gz | tgz)
+      archive=$(mktemp -t archive.XXXXXX.tar.gz)
+      tar czf "$archive" -C "$temp_dir" test_file.txt
+      ;;
+    zip)
+      archive=$(mktemp -t archive.XXXXXX.zip)
+      (cd "$temp_dir" && zip -q "$archive" test_file.txt)
+      ;;
+    gz)
+      archive=$(mktemp -t archive.XXXXXX.gz)
+      gzip -c "$temp_file" >"$archive"
+      ;;
+    *)
+      echo "Unsupported archive type: $type" >&2
+      rm -rf "$temp_dir"
+      return 1
+      ;;
+  esac
+
+  rm -rf "$temp_dir"
+  MOCK_FILES+=("$archive")
+  echo "$archive"
+}
+
+# Restore original environment variable
+# Usage: mock_env "VAR_NAME" "value"
+mock_env() {
+  local var_name="$1"
+  local value="$2"
+  export "$var_name=$value"
+}
+
+# Clean up all mocks
+mock_cleanup() {
+  # Restore PATH
+  export PATH="$ORIGINAL_PATH"
+
+  # Remove mock commands
+  for cmd in "${MOCK_COMMANDS[@]}"; do
+    rm -f "$cmd" 2>/dev/null
+  done
+
+  # Remove mock files
+  for file in "${MOCK_FILES[@]}"; do
+    rm -f "$file" 2>/dev/null
+  done
+
+  # Remove mock directories
+  for dir in "${MOCK_DIRS[@]}"; do
+    rm -rf "$dir" 2>/dev/null
+  done
+
+  # Remove mock bin directory
+  if [[ -n "$MOCK_BIN_DIR" && -d "$MOCK_BIN_DIR" ]]; then
+    rm -rf "$MOCK_BIN_DIR"
+  fi
+
+  MOCK_BIN_DIR=""
+  MOCK_COMMANDS=()
+  MOCK_FILES=()
+  MOCK_DIRS=()
+}
+
+# Setup trap to cleanup on exit
+trap mock_cleanup EXIT