@sebastienrousseau/dotfiles 0.2.469 → 0.2.481

package/scripts/tests/performance/stress_test.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC1091
+set -euo pipefail
+
+# Stress test for shell functions
+# Tests behavior under repeated rapid invocation
+
+ITERATIONS="${1:-100}"
+
+# Portable millisecond timing function
+get_time_ms() {
+  if command -v perl >/dev/null 2>&1; then
+    perl -MTime::HiRes=time -e 'printf "%.0f\n", time * 1000'
+  else
+    # Fallback: seconds * 1000 (less precise)
+    echo $(($(date +%s) * 1000))
+  fi
+}
+
+# Note: This is test-only code. The eval below is necessary to execute
+# dynamically constructed test commands. Do not use with untrusted input.
+stress_test_function() {
+  local func_name="$1"
+  local test_cmd="$2"
+  local start end elapsed
+
+  # Validate test_cmd is not empty
+  if [[ -z "$test_cmd" ]]; then
+    echo "  ERROR: empty test command for $func_name"
+    return 1
+  fi
+
+  echo "Stress testing $func_name ($ITERATIONS iterations)..."
+
+  start=$(get_time_ms)
+  for ((i = 1; i <= ITERATIONS; i++)); do
+    # shellcheck disable=SC2086
+    eval "$test_cmd" >/dev/null 2>&1 || true
+  done
+  end=$(get_time_ms)
+
+  elapsed=$((end - start))
+  local per_call=$((elapsed / ITERATIONS))
+
+  echo "  Total: ${elapsed}ms, Per call: ${per_call}ms"
+}
+
+main() {
+  echo "Starting stress tests..."
+  echo ""
+
+  # Test genpass under load
+  source "$HOME/.dotfiles/.chezmoitemplates/functions/genpass.sh" 2>/dev/null || true
+  if type genpass &>/dev/null; then
+    stress_test_function "genpass" "genpass 16"
+  fi
+
+  # Test extract help (no actual extraction)
+  source "$HOME/.dotfiles/.chezmoitemplates/functions/extract.sh" 2>/dev/null || true
+  if type extract &>/dev/null; then
+    stress_test_function "extract --help" "extract --help"
+  fi
+}
+
+main "$@"

package/scripts/tests/test-aliases.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# MIT License
+# Copyright (c) 2026 Sebastien Rousseau
+# See LICENSE file for details.
+
+# Script: test-aliases.sh
+# Description: Verifies disjoint alias files for syntax errors.
+
+set -e
+
+echo "Testing alias syntax..."
+
+ALIAS_DIR="$HOME/.dotfiles/.chezmoitemplates/aliases"
+
+find "$ALIAS_DIR" -name "*.aliases.sh" | while read -r file; do
+  # Check for syntax errors using bash -n
+  if bash -n "$file"; then
+    echo " Checked: $(basename "$file")"
+  else
+    echo " Syntax Error: $(basename "$file")"
+    exit 1
+  fi
+done
+
+echo "All alias files passed syntax check."

package/scripts/tests/test-docker.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# Test dotfiles README instructions across all environments using Docker
+# Usage: ./scripts/tests/test-docker.sh [target...]
+# Examples:
+#   ./scripts/tests/test-docker.sh              # Run all tests
+#   ./scripts/tests/test-docker.sh ubuntu-test  # Run only Ubuntu test
+#   ./scripts/tests/test-docker.sh arch-test    # Run only Arch test
+
+set -euo pipefail
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+TARGETS=(ubuntu-test debian-test arch-test ubuntu-eza-test)
+PASSED=0
+FAILED=0
+FAILURES=()
+
+# Use specified targets or all
+if [ $# -gt 0 ]; then
+  TARGETS=("$@")
+fi
+
+echo -e "${BLUE}${BOLD}Testing dotfiles across ${#TARGETS[@]} environment(s)${NC}"
+echo ""
+
+for target in "${TARGETS[@]}"; do
+  echo -e "${BLUE}==> Building: ${BOLD}${target}${NC}"
+  if docker build --target "$target" -f Dockerfile.test -t "dotfiles-test:${target}" . 2>&1; then
+    echo -e "${GREEN}==> PASSED: ${target}${NC}"
+    PASSED=$((PASSED + 1))
+  else
+    echo -e "${RED}==> FAILED: ${target}${NC}"
+    FAILED=$((FAILED + 1))
+    FAILURES+=("$target")
+  fi
+  echo ""
+done
+
+echo -e "${BOLD}Results: ${GREEN}${PASSED} passed${NC}, ${RED}${FAILED} failed${NC} (${#TARGETS[@]} total)"
+
+if [ ${FAILED} -gt 0 ]; then
+  echo -e "${RED}Failed targets: ${FAILURES[*]}${NC}"
+  exit 1
+fi

package/scripts/tests/unit/test_ai_aliases.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC1090,SC1091,SC2034,SC2030,SC2031
+# Test AI aliases functionality
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../framework/assertions.sh"
+source "$SCRIPT_DIR/../framework/mocks.sh"
+
+# Test setup
+ALIASES_FILE="$REPO_ROOT/.chezmoitemplates/aliases/ai/ai.aliases.sh"
+
+test_start "ai_aliases_file_exists"
+assert_file_exists "$ALIASES_FILE" "AI aliases file should exist"
+
+test_start "github_copilot_aliases_when_gh_available"
+mock_init
+# Mock gh command as available
+mock_command "gh" "gh 2.42.0" 0
+
+# Source aliases in a subshell with expand_aliases enabled
+(
+  shopt -s expand_aliases
+  export PATH="$MOCK_BIN_DIR:$PATH"
+  source "$ALIASES_FILE"
+
+  # Check aliases are defined using alias command
+  alias ghcp >/dev/null 2>&1 && echo "ghcp_defined"
+  alias ghs >/dev/null 2>&1 && echo "ghs_defined"
+  alias ghe >/dev/null 2>&1 && echo "ghe_defined"
+) >/tmp/test_output
+
+assert_file_contains "/tmp/test_output" "ghcp_defined" "ghcp alias should be defined when gh available"
+assert_file_contains "/tmp/test_output" "ghs_defined" "ghs alias should be defined when gh available"
+assert_file_contains "/tmp/test_output" "ghe_defined" "ghe alias should be defined when gh available"
+
+rm -f /tmp/test_output
+mock_cleanup
+
+test_start "github_copilot_aliases_when_gh_unavailable"
+mock_init
+# Use empty mock dir as PATH to ensure real gh isn't found
+# (command -v, source, alias are builtins - don't need PATH)
+
+(
+  shopt -s expand_aliases
+  export PATH="$MOCK_BIN_DIR"
+  source "$ALIASES_FILE"
+
+  # Check aliases are NOT defined
+  alias ghcp >/dev/null 2>&1 || echo "ghcp_not_defined"
+  alias ghs >/dev/null 2>&1 || echo "ghs_not_defined"
+  alias ghe >/dev/null 2>&1 || echo "ghe_not_defined"
+) >/tmp/test_output
+
+assert_file_contains "/tmp/test_output" "ghcp_not_defined" "ghcp alias should not be defined when gh unavailable"
+assert_file_contains "/tmp/test_output" "ghs_not_defined" "ghs alias should not be defined when gh unavailable"
+assert_file_contains "/tmp/test_output" "ghe_not_defined" "ghe alias should not be defined when gh unavailable"
+
+rm -f /tmp/test_output
+mock_cleanup
+
+test_start "fabric_alias_when_fabric_available"
+mock_init
+mock_command "fabric" "fabric v1.0.0" 0
+
+(
+  shopt -s expand_aliases
+  export PATH="$MOCK_BIN_DIR:$PATH"
+  source "$ALIASES_FILE"
+
+  alias fab >/dev/null 2>&1 && echo "fab_defined"
+) >/tmp/test_output
+
+assert_file_contains "/tmp/test_output" "fab_defined" "fab alias should be defined when fabric available"
+
+rm -f /tmp/test_output
+mock_cleanup
+
+test_start "fabric_alias_when_fabric_unavailable"
+mock_init
+# Use empty mock dir as PATH to ensure real fabric isn't found
+
+(
+  shopt -s expand_aliases
+  export PATH="$MOCK_BIN_DIR"
+  source "$ALIASES_FILE"
+
+  alias fab >/dev/null 2>&1 || echo "fab_not_defined"
+) >/tmp/test_output
+
+assert_file_contains "/tmp/test_output" "fab_not_defined" "fab alias should not be defined when fabric unavailable"
+
+rm -f /tmp/test_output
+mock_cleanup
+
+test_start "ollama_aliases_when_ollama_available"
+mock_init
+mock_command "ollama" "ollama version 1.0.0" 0
+
+(
+  shopt -s expand_aliases
+  export PATH="$MOCK_BIN_DIR:$PATH"
+  source "$ALIASES_FILE"
+
+  alias ol >/dev/null 2>&1 && echo "ol_defined"
+  alias olr >/dev/null 2>&1 && echo "olr_defined"
+  alias oll >/dev/null 2>&1 && echo "oll_defined"
+  alias olp >/dev/null 2>&1 && echo "olp_defined"
+  alias ollama-status >/dev/null 2>&1 && echo "ollama_status_defined"
+  alias ollama-show >/dev/null 2>&1 && echo "ollama_show_defined"
+) >/tmp/test_output
+
+assert_file_contains "/tmp/test_output" "ol_defined" "ol alias should be defined when ollama available"
+assert_file_contains "/tmp/test_output" "olr_defined" "olr alias should be defined when ollama available"
+assert_file_contains "/tmp/test_output" "oll_defined" "oll alias should be defined when ollama available"
+assert_file_contains "/tmp/test_output" "olp_defined" "olp alias should be defined when ollama available"
+assert_file_contains "/tmp/test_output" "ollama_status_defined" "ollama-status alias should be defined when ollama available"
+assert_file_contains "/tmp/test_output" "ollama_show_defined" "ollama-show alias should be defined when ollama available"
+
+rm -f /tmp/test_output
+mock_cleanup
+
+test_start "ollama_aliases_when_ollama_unavailable"
+mock_init
+# Use empty mock dir as PATH to ensure real ollama isn't found
+
+(
+  shopt -s expand_aliases
+  export PATH="$MOCK_BIN_DIR"
+  source "$ALIASES_FILE"
+
+  alias ol >/dev/null 2>&1 || echo "ol_not_defined"
+  alias olr >/dev/null 2>&1 || echo "olr_not_defined"
+  alias oll >/dev/null 2>&1 || echo "oll_not_defined"
+  alias olp >/dev/null 2>&1 || echo "olp_not_defined"
+  alias ollama-status >/dev/null 2>&1 || echo "ollama_status_not_defined"
+  alias ollama-show >/dev/null 2>&1 || echo "ollama_show_not_defined"
+) >/tmp/test_output
+
+assert_file_contains "/tmp/test_output" "ol_not_defined" "ol alias should not be defined when ollama unavailable"
+assert_file_contains "/tmp/test_output" "olr_not_defined" "olr alias should not be defined when ollama unavailable"
+assert_file_contains "/tmp/test_output" "oll_not_defined" "oll alias should not be defined when ollama unavailable"
+assert_file_contains "/tmp/test_output" "olp_not_defined" "olp alias should not be defined when ollama unavailable"
+assert_file_contains "/tmp/test_output" "ollama_status_not_defined" "ollama-status alias should not be defined when ollama unavailable"
+assert_file_contains "/tmp/test_output" "ollama_show_not_defined" "ollama-show alias should not be defined when ollama unavailable"
+
+rm -f /tmp/test_output
+mock_cleanup
+
+test_start "aliases_syntax_check"
+assert_exit_code 0 "bash -n '$ALIASES_FILE'"
+
+test_start "aliases_shellcheck"
+if command -v shellcheck >/dev/null 2>&1; then
+  assert_exit_code 0 "shellcheck '$ALIASES_FILE'"
+else
+  echo "SKIP: shellcheck not available"
+fi

package/scripts/tests/unit/test_ai_cli_checks.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+
+fail() {
+  echo "FAIL: $1" >&2
+  exit 1
+}
+
+pass() {
+  echo "PASS: $1"
+}
+
+check_contains() {
+  local file="$1"
+  local pattern="$2"
+  if command -v rg >/dev/null 2>&1; then
+    rg -n --fixed-strings "$pattern" "$file" >/dev/null || fail "Missing pattern in $file: $pattern"
+  else
+    grep -nF "$pattern" "$file" >/dev/null || fail "Missing pattern in $file: $pattern"
+  fi
+}
+
+HC_FILE="$REPO_ROOT/scripts/ops/health-check.sh"
+APPLY_FILE="$REPO_ROOT/scripts/ops/chezmoi-apply.sh"
+DOC_FILE="$REPO_ROOT/docs/TOOLS.md"
+PYTOOLS_FILE="$REPO_ROOT/install/provision/run_onchange_25-python-tools.sh.tmpl"
+
+# Health check should include AI CLIs in optional deps
+check_contains "$HC_FILE" "optional_deps=(ripgrep fd bat fzf eza jq claude gemini sgpt ollama opencode aider)"
+
+# Chezmoi apply should emit AI CLI checks
+check_contains "$APPLY_FILE" "AI provider CLI checks (optional):"
+check_contains "$APPLY_FILE" "check_ai_cli \"sgpt\""
+check_contains "$APPLY_FILE" "check_ai_cli \"ollama\""
+
+# Tools catalog should list sgpt and ollama
+check_contains "$DOC_FILE" "| sgpt | shell-gpt |"
+check_contains "$DOC_FILE" "| ollama | ollama |"
+
+# Python tools should include key dev tools
+check_contains "$PYTOOLS_FILE" "install_python_tool \"pytest\""
+check_contains "$PYTOOLS_FILE" "install_python_tool \"bandit\""
+check_contains "$PYTOOLS_FILE" "install_python_tool \"mypy\""
+
+pass "AI CLI dependency checks and docs are wired"

package/scripts/tests/unit/test_backup.sh

@@ -0,0 +1,227 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC1090,SC1091,SC2012,SC2034
+# Unit tests for the backup function
+# Tests backup creation with various options and edge cases
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
+source "$SCRIPT_DIR/../framework/assertions.sh"
+source "$SCRIPT_DIR/../framework/mocks.sh"
+
+# Source the function being tested
+FUNC_FILE="$REPO_ROOT/.chezmoitemplates/functions/backup.sh"
+if [[ -f "$FUNC_FILE" ]]; then
+  source "$FUNC_FILE"
+else
+  echo "Warning: backup.sh not found at $FUNC_FILE"
+fi
+
+# Test: backup with no arguments shows error
+test_start "backup_no_args"
+output=$(backup 2>&1)
+exit_code=$?
+assert_equals "1" "$exit_code" "exit code should be 1 for no args"
+
+# Test: backup with no arguments shows error message
+test_start "backup_no_args_message"
+output=$(backup 2>&1)
+if [[ "$output" == *"ERROR"* && "$output" == *"provide"* ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: shows error message for no arguments"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should show error message for no arguments"
+  echo -e "    Output: $output"
+fi
+
+# Test: backup with nonexistent file
+test_start "backup_nonexistent_file"
+test_dir=$(mock_dir "backup_test")
+export BACKUP_DIR="$test_dir/backups"
+output=$(backup "/nonexistent/file.txt" 2>&1)
+exit_code=$?
+assert_equals "1" "$exit_code" "exit code should be 1 for nonexistent file"
+rm -rf "$test_dir"
+
+# Test: backup with unknown option shows error
+test_start "backup_unknown_option"
+output=$(backup --unknown-option 2>&1)
+exit_code=$?
+assert_equals "1" "$exit_code" "exit code should be 1 for unknown option"
+
+# Test: backup with unknown option shows error message
+test_start "backup_unknown_option_message"
+output=$(backup --unknown-option 2>&1)
+if [[ "$output" == *"ERROR"* && "$output" == *"Unknown option"* ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: shows error for unknown option"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should show error for unknown option"
+  echo -e "    Output: $output"
+fi
+
+# Test: backup creates backup directory if not exists
+test_start "backup_creates_directory"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup "$test_file" 2>&1)
+
+if [[ -d "$BACKUP_DIR" ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backup directory created"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: backup directory should be created"
+fi
+rm -rf "$test_dir"
+
+# Test: backup creates tar archive
+test_start "backup_creates_archive"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup "$test_file" 2>&1)
+exit_code=$?
+
+# Check if backup file was created
+backup_files=$(ls "$BACKUP_DIR"/backup_*.tar* 2>/dev/null | wc -l | tr -d ' ')
+if [[ "$backup_files" -gt 0 ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backup archive created"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: backup archive should be created"
+  echo -e "    Output: $output"
+fi
+rm -rf "$test_dir"
+
+# Test: backup with --max-size option
+test_start "backup_max_size_option"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup --max-size 1K "$test_file" 2>&1)
+exit_code=$?
+
+assert_equals "0" "$exit_code" "backup with --max-size should succeed"
+rm -rf "$test_dir"
+
+# Test: backup with --keep option
+test_start "backup_keep_option"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup --keep 3 "$test_file" 2>&1)
+exit_code=$?
+
+assert_equals "0" "$exit_code" "backup with --keep should succeed"
+rm -rf "$test_dir"
+
+# Test: backup with invalid size unit
+test_start "backup_invalid_size_unit"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup --max-size 100X "$test_file" 2>&1)
+exit_code=$?
+
+# Should fail or warn with invalid unit
+if [[ "$exit_code" -ne 0 ]] || [[ "$output" == *"Invalid unit"* ]] || [[ "$output" == *"ERROR"* ]] || [[ "$output" == *"WARNING"* ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: invalid size unit handled"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should reject or warn about invalid size unit '100X'"
+  echo -e "    Exit code: $exit_code"
+  echo -e "    Output: $output"
+fi
+rm -rf "$test_dir"
+
+# Test: backup multiple files
+test_start "backup_multiple_files"
+test_dir=$(mock_dir "backup_test")
+test_file1="$test_dir/testfile1.txt"
+test_file2="$test_dir/testfile2.txt"
+echo "content 1" >"$test_file1"
+echo "content 2" >"$test_file2"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup "$test_file1" "$test_file2" 2>&1)
+exit_code=$?
+
+assert_equals "0" "$exit_code" "backup of multiple files should succeed"
+rm -rf "$test_dir"
+
+# Test: backup shows INFO messages
+test_start "backup_info_messages"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup "$test_file" 2>&1)
+
+if [[ "$output" == *"INFO"* ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: shows INFO messages"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should show INFO messages"
+  echo -e "    Output: $output"
+fi
+rm -rf "$test_dir"
+
+# Test: backup retention (--keep)
+test_start "backup_retention"
+test_dir=$(mock_dir "backup_test")
+test_file="$test_dir/testfile.txt"
+echo "test content" >"$test_file"
+export BACKUP_DIR="$test_dir/backups"
+
+# Create multiple backups
+for i in {1..4}; do
+  backup --keep 2 "$test_file" >/dev/null 2>&1
+done
+
+# Count remaining backups
+backup_count=$(ls "$BACKUP_DIR"/backup_*.tar* 2>/dev/null | wc -l | tr -d ' ')
+
+if [[ "$backup_count" -le 2 ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backup retention works (kept $backup_count)"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should keep only 2 backups, found $backup_count"
+fi
+rm -rf "$test_dir"
+
+# Test: backup a directory
+test_start "backup_directory"
+test_dir=$(mock_dir "backup_test")
+content_dir="$test_dir/content"
+mkdir -p "$content_dir"
+echo "file1" >"$content_dir/file1.txt"
+echo "file2" >"$content_dir/file2.txt"
+export BACKUP_DIR="$test_dir/backups"
+
+output=$(backup "$content_dir" 2>&1)
+exit_code=$?
+
+assert_equals "0" "$exit_code" "backup of directory should succeed"
+rm -rf "$test_dir"
+
+echo ""
+echo "Backup function tests completed."
+echo "RESULTS:$TESTS_RUN:$TESTS_PASSED:$TESTS_FAILED"