@sebastienrousseau/dotfiles 0.2.481 → 0.2.499

package/scripts/tests/benchmark.sh

@@ -1,91 +0,0 @@
-#!/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

@@ -1,283 +0,0 @@
-#!/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

@@ -1,201 +0,0 @@
-#!/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