@sebastienrousseau/dotfiles 0.2.481 → 0.2.500

package/scripts/tests/README.md

@@ -1,241 +0,0 @@
-# Dotfiles Test Suite
-
-A comprehensive shell testing framework for validating dotfiles functionality.
-
-## Directory Structure
-
-```
-scripts/tests/
-├── framework/
-│   ├── test_runner.sh      # Main test runner
-│   ├── assertions.sh       # Assert functions
-│   └── mocks.sh            # Mock utilities
-├── unit/
-│   ├── test_extract.sh     # Tests for extract function
-│   ├── test_backup.sh      # Tests for backup function
-│   ├── test_genpass.sh     # Tests for genpass function
-│   ├── test_rd.sh          # Tests for rd function
-│   └── test_cd_aliases.sh  # Tests for cd aliases
-├── integration/
-│   └── test_install.sh     # Tests for install.sh
-└── README.md               # This file
-```
-
-## Quick Start
-
-### Run All Unit Tests
-
-```bash
-./scripts/tests/framework/test_runner.sh
-```
-
-### Run Specific Test
-
-```bash
-# Run only extract tests
-./scripts/tests/framework/test_runner.sh extract
-
-# Run only backup tests
-./scripts/tests/framework/test_runner.sh backup
-
-# Run only genpass tests
-./scripts/tests/framework/test_runner.sh genpass
-```
-
-### Run with Integration Tests
-
-```bash
-# Using environment variable
-RUN_INTEGRATION=1 ./scripts/tests/framework/test_runner.sh
-
-# Using flag
-./scripts/tests/framework/test_runner.sh -i
-```
-
-### Run Individual Test File
-
-```bash
-# Source assertions and run directly
-source ./scripts/tests/framework/assertions.sh
-source ./scripts/tests/unit/test_extract.sh
-print_summary
-```
-
-## Test Framework
-
-### Assertions
-
-The framework provides these assertion functions:
-
-| Function | Description |
-|----------|-------------|
-| `assert_equals expected actual [msg]` | Assert two values are equal |
-| `assert_not_equals unexpected actual [msg]` | Assert two values differ |
-| `assert_exit_code code command` | Assert command exits with code |
-| `assert_output_contains needle command` | Assert output contains string |
-| `assert_output_not_contains needle command` | Assert output lacks string |
-| `assert_output_matches pattern command` | Assert output matches regex |
-| `assert_file_exists path [msg]` | Assert file exists |
-| `assert_file_not_exists path [msg]` | Assert file doesn't exist |
-| `assert_dir_exists path [msg]` | Assert directory exists |
-| `assert_dir_not_exists path [msg]` | Assert directory doesn't exist |
-| `assert_true condition [msg]` | Assert condition is true |
-| `assert_false condition [msg]` | Assert condition is false |
-| `assert_empty value [msg]` | Assert string is empty |
-| `assert_not_empty value [msg]` | Assert string is not empty |
-| `assert_file_contains file needle [msg]` | Assert file contains text |
-
-### Mocks
-
-The mock library provides utilities for test isolation:
-
-| Function | Description |
-|----------|-------------|
-| `mock_init` | Initialize mock environment |
-| `mock_command name output [exit_code]` | Create mock command |
-| `mock_command_spy name [output] [exit_code]` | Create mock that records calls |
-| `mock_get_calls name` | Get spy call history |
-| `mock_call_count name` | Get number of spy calls |
-| `mock_file content [filename]` | Create temp file with content |
-| `mock_dir [prefix]` | Create temp directory |
-| `mock_archive type [content]` | Create mock archive file |
-| `mock_env var_name value` | Set environment variable |
-| `mock_cleanup` | Clean up all mocks |
-
-## Writing Tests
-
-### Basic Test Structure
-
-```bash
-#!/usr/bin/env bash
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-source "$SCRIPT_DIR/../framework/mocks.sh"
-
-# Source function being tested
-source "$REPO_ROOT/.chezmoitemplates/functions/myfunction.sh"
-
-# Test case
-test_start "my_function_basic"
-output=$(myfunction "arg" 2>&1)
-assert_equals "expected" "$output" "should return expected"
-
-# Another test
-test_start "my_function_error"
-output=$(myfunction 2>&1)
-exit_code=$?
-assert_equals "1" "$exit_code" "should fail without args"
-```
-
-### Using Mocks
-
-```bash
-test_start "function_with_mock"
-# Create temp directory
-test_dir=$(mock_dir "test")
-test_file="$test_dir/file.txt"
-echo "content" > "$test_file"
-
-# Run test
-result=$(myfunction "$test_file")
-
-# Verify
-assert_equals "expected" "$result"
-
-# Cleanup is automatic via trap
-```
-
-### Test Naming Convention
-
-- Test files: `test_<functionality>.sh`
-- Test functions: Descriptive names with `test_start`
-- Example: `test_start "extract_handles_missing_file"`
-
-## Environment Variables
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `RUN_INTEGRATION` | `0` | Set to `1` to run integration tests |
-| `VERBOSE` | `0` | Set to `1` for verbose output |
-| `REPO_ROOT` | Auto-detected | Repository root directory |
-| `TESTS_DIR` | Auto-detected | Tests directory |
-
-## Test Categories
-
-### Unit Tests
-
-Located in `scripts/tests/unit/`. These test individual functions in isolation:
-
-- **test_extract.sh** - Archive extraction function
-- **test_backup.sh** - Backup creation function
-- **test_genpass.sh** - Password generation function
-- **test_rd.sh** - Directory removal function (with security tests)
-- **test_cd_aliases.sh** - Directory navigation aliases
-
-### Integration Tests
-
-Located in `scripts/tests/integration/`. These test complete workflows:
-
-- **test_install.sh** - Installation script validation
-
-## CI/CD Integration
-
-Add to your CI pipeline:
-
-```yaml
-# GitHub Actions example
-- name: Run Tests
-  run: |
-    chmod +x ./scripts/tests/framework/test_runner.sh
-    ./scripts/tests/framework/test_runner.sh
-
-- name: Run Integration Tests
-  run: |
-    RUN_INTEGRATION=1 ./scripts/tests/framework/test_runner.sh
-```
-
-## Best Practices
-
-1. **Isolation**: Each test should be independent
-2. **Cleanup**: Use mocks that auto-cleanup via traps
-3. **No Sleep**: Avoid `sleep` or hardcoded delays
-4. **Descriptive Names**: Test names should describe what's being tested
-5. **Edge Cases**: Test error conditions, not just happy paths
-6. **Security**: Include tests for dangerous input rejection
-
-## Troubleshooting
-
-### Tests Not Found
-
-Ensure test files match the pattern `test_*.sh` and are executable:
-
-```bash
-chmod +x scripts/tests/unit/test_*.sh
-chmod +x scripts/tests/integration/test_*.sh
-```
-
-### Function Not Available
-
-If a test shows "function not available", the source file may not exist:
-
-```bash
-# Check if function file exists
-ls -la .chezmoitemplates/functions/
-```
-
-### Mock Cleanup Issues
-
-If mocks aren't cleaning up, ensure you're not running with `set -e` before mock operations that might fail.
-
-## Contributing
-
-When adding new functions to the dotfiles:
-
-1. Create corresponding test file in `unit/`
-2. Test happy path and error conditions
-3. Include security-relevant test cases
-4. Run full test suite before committing
-
----
-
-Made with ❤️ by [Sebastien Rousseau](https://github.com/sebastienrousseau)

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
-}