@sebastienrousseau/dotfiles 0.2.481 → 0.2.500

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

package/scripts/tests/framework/test_runner.sh

@@ -1,189 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091,SC2034
-# Main test runner for dotfiles test suite
-# Discovers and runs all test files, reports results
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-TESTS_DIR="$(dirname "$SCRIPT_DIR")"
-REPO_ROOT="$(dirname "$(dirname "$TESTS_DIR")")"
-
-if [[ ! -d "$REPO_ROOT" ]]; then
-  echo "Error: REPO_ROOT is not a valid directory: $REPO_ROOT" >&2
-  exit 1
-fi
-
-# Export paths for test files
-export TESTS_DIR
-export REPO_ROOT
-export FRAMEWORK_DIR="$SCRIPT_DIR"
-
-# Run a single test file and capture results
-run_test_file() {
-  local test_file="$1"
-  local temp_results
-  temp_results=$(mktemp)
-
-  echo ""
-  echo "Running: $(basename "$test_file")"
-  echo "─────────────────────────────────────"
-
-  # Run test as a separate process (not subshell with source)
-  # This avoids trap interference from double-sourcing framework files
-  local exit_status=0
-  bash "$test_file" 2>&1 | tee "$temp_results" || exit_status=$?
-
-  # Parse results from output
-  local results_line
-  results_line=$(grep "^RESULTS:" "$temp_results" | tail -1) || true
-  if [[ -n "$results_line" ]]; then
-    local run passed failed
-    IFS=':' read -r _ run passed failed <<<"$results_line"
-    TOTAL_TESTS_RUN=$((TOTAL_TESTS_RUN + run))
-    TOTAL_TESTS_PASSED=$((TOTAL_TESTS_PASSED + passed))
-    TOTAL_TESTS_FAILED=$((TOTAL_TESTS_FAILED + failed))
-  elif [[ $exit_status -ne 0 ]]; then
-    # Test file crashed without producing RESULTS -- count as failure
-    echo -e "\033[0;31mERROR: $(basename "$test_file") crashed (exit $exit_status) without producing results\033[0m"
-    TOTAL_TESTS_RUN=$((TOTAL_TESTS_RUN + 1))
-    TOTAL_TESTS_FAILED=$((TOTAL_TESTS_FAILED + 1))
-  fi
-
-  rm -f "$temp_results"
-}
-
-# Show usage
-usage() {
-  cat <<EOF
-Dotfiles Test Runner
-
-Usage:
-  $(basename "$0") [options] [pattern]
-
-Options:
-  -h, --help          Show this help message
-  -v, --verbose       Verbose output
-  -i, --integration   Include integration tests
-  -u, --unit-only     Run only unit tests
-
-Arguments:
-  pattern             Run only tests matching pattern (e.g., 'extract', 'backup')
-
-Examples:
-  $(basename "$0")                    # Run all unit tests
-  $(basename "$0") extract            # Run only extract tests
-  $(basename "$0") -i                 # Run unit and integration tests
-  RUN_INTEGRATION=1 $(basename "$0")  # Alternative way to run integration tests
-
-Environment Variables:
-  RUN_INTEGRATION=1   Enable integration tests
-  VERBOSE=1           Enable verbose output
-EOF
-}
-
-main() {
-  local test_pattern="*"
-  local run_integration="${RUN_INTEGRATION:-0}"
-  local verbose="${VERBOSE:-0}"
-  local unit_only=0
-
-  # Initialize global counters
-  TOTAL_TESTS_RUN=0
-  TOTAL_TESTS_PASSED=0
-  TOTAL_TESTS_FAILED=0
-
-  # Parse arguments
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      -h | --help)
-        usage
-        exit 0
-        ;;
-      -v | --verbose)
-        verbose=1
-        shift
-        ;;
-      -i | --integration)
-        run_integration=1
-        shift
-        ;;
-      -u | --unit-only)
-        unit_only=1
-        shift
-        ;;
-      -*)
-        echo "Unknown option: $1" >&2
-        usage
-        exit 1
-        ;;
-      *)
-        test_pattern="$1"
-        shift
-        ;;
-    esac
-  done
-
-  echo "╔═══════════════════════════════════════╗"
-  echo "║     Dotfiles Test Suite               ║"
-  echo "╚═══════════════════════════════════════╝"
-  echo ""
-  echo "Repository: $REPO_ROOT"
-  echo "Tests Dir:  $TESTS_DIR"
-  echo ""
-
-  local test_count=0
-
-  # Run unit tests
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo "UNIT TESTS"
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-  for test_file in "$TESTS_DIR"/unit/test_${test_pattern}.sh; do
-    if [[ -f "$test_file" ]]; then
-      run_test_file "$test_file"
-      ((test_count++)) || true
-    fi
-  done
-
-  if [[ $test_count -eq 0 ]]; then
-    echo "No unit tests found matching pattern: $test_pattern"
-  fi
-
-  # Run integration tests if requested
-  if [[ "$run_integration" == "1" && "$unit_only" != "1" ]]; then
-    echo ""
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    echo "INTEGRATION TESTS"
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-    local integration_count=0
-    for test_file in "$TESTS_DIR"/integration/test_*.sh; do
-      if [[ -f "$test_file" ]]; then
-        run_test_file "$test_file"
-        ((integration_count++)) || true
-      fi
-    done
-
-    if [[ $integration_count -eq 0 ]]; then
-      echo "No integration tests found."
-    fi
-  fi
-
-  # Print final summary
-  echo ""
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo "FINAL SUMMARY"
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo -e "Total tests run: $TOTAL_TESTS_RUN"
-  echo -e "\033[0;32mTotal passed: $TOTAL_TESTS_PASSED\033[0m"
-  echo -e "\033[0;31mTotal failed: $TOTAL_TESTS_FAILED\033[0m"
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-  if [[ $TOTAL_TESTS_FAILED -gt 0 ]]; then
-    exit 1
-  fi
-  exit 0
-}
-
-main "$@"

package/scripts/tests/integration/test_install.sh

@@ -1,237 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091
-# Integration tests for install.sh
-# Tests the dotfiles installation process in isolation
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-source "$SCRIPT_DIR/../framework/mocks.sh"
-
-INSTALL_SCRIPT="$REPO_ROOT/install.sh"
-
-# Test: install.sh exists
-test_start "install_script_exists"
-assert_file_exists "$INSTALL_SCRIPT" "install.sh should exist"
-
-# Test: install.sh is executable
-test_start "install_script_executable"
-if [[ -x "$INSTALL_SCRIPT" ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: install.sh is executable"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: install.sh should be executable"
-fi
-
-# Test: install.sh has shebang
-test_start "install_script_shebang"
-first_line=$(head -n 1 "$INSTALL_SCRIPT")
-if [[ "$first_line" == "#!/"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: has proper shebang"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should have shebang"
-fi
-
-# Test: install.sh uses set -e
-test_start "install_script_set_e"
-if grep -q "set -e" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses set -e for error handling"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use set -e"
-fi
-
-# Test: install.sh defines step function
-test_start "install_script_step_function"
-if grep -q "step()" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: defines step function"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should define step function"
-fi
-
-# Test: install.sh defines error function
-test_start "install_script_error_function"
-if grep -q "error()" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: defines error function"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should define error function"
-fi
-
-# Test: install.sh checks for curl
-test_start "install_script_curl_check"
-if grep -q "curl" "$INSTALL_SCRIPT" && grep -q "command -v curl" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: checks for curl dependency"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should check for curl"
-fi
-
-# Test: install.sh checks for git
-test_start "install_script_git_check"
-if grep -q "git" "$INSTALL_SCRIPT" && grep -q "command -v git" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: checks for git dependency"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should check for git"
-fi
-
-# Test: install.sh detects OS
-test_start "install_script_os_detection"
-if grep -q "uname" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: detects OS using uname"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should detect OS"
-fi
-
-# Test: install.sh has version pinning
-test_start "install_script_version_pin"
-if grep -q "CHEZMOI_VERSION" "$INSTALL_SCRIPT" || grep -q "VERSION=" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: has version pinning for security"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should have version pinning"
-fi
-
-# Test: install.sh installs chezmoi via brew or get.chezmoi.io
-test_start "install_script_chezmoi_install"
-if grep -q "brew install chezmoi" "$INSTALL_SCRIPT" && grep -q "get.chezmoi.io" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: installs chezmoi via brew or get.chezmoi.io"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should install chezmoi via brew or get.chezmoi.io"
-fi
-
-# Test: install.sh creates backup
-test_start "install_script_backup"
-if grep -q "backup" "$INSTALL_SCRIPT" || grep -q "\.bak" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: creates backup of existing files"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should backup existing files"
-fi
-
-# Test: install.sh uses chezmoi
-test_start "install_script_chezmoi"
-if grep -q "chezmoi" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses chezmoi for dotfile management"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use chezmoi"
-fi
-
-# Test: install.sh handles non-interactive mode
-test_start "install_script_noninteractive"
-if grep -q "NONINTERACTIVE" "$INSTALL_SCRIPT" || grep -q "force" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports non-interactive mode"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support non-interactive mode"
-fi
-
-# Test: install.sh backs up managed dotfiles
-test_start "install_script_cleanup"
-if grep -q "chezmoi managed" "$INSTALL_SCRIPT" && grep -q "cp -a" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backs up managed dotfiles before overwriting"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should back up managed dotfiles"
-fi
-
-# Test: install.sh uses HTTPS
-test_start "install_script_https"
-if grep -q "https://" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses HTTPS for downloads"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use HTTPS"
-fi
-
-# Test: install.sh detects multiple OS types
-test_start "install_script_multi_os"
-os_count=0
-for os_type in "debian" "fedora" "arch" "macos" "wsl2"; do
-  if grep -q "$os_type" "$INSTALL_SCRIPT"; then
-    os_count=$((os_count + 1))
-  fi
-done
-if [[ $os_count -ge 3 ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: detects $os_count OS types"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should detect multiple OS types"
-fi
-
-# Test: install.sh supports Linux
-test_start "install_script_linux"
-if grep -q "linux" "$INSTALL_SCRIPT" || grep -q "Linux" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports Linux"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support Linux"
-fi
-
-# Test: install.sh supports macOS
-test_start "install_script_macos"
-if grep -q "darwin" "$INSTALL_SCRIPT" || grep -q "Darwin" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports macOS"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support macOS"
-fi
-
-# Test: Dry run syntax check
-test_start "install_script_syntax"
-if bash -n "$INSTALL_SCRIPT" 2>/dev/null; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: script has valid bash syntax"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: script has syntax errors"
-fi
-
-# Test: No hardcoded sensitive paths in install
-test_start "install_script_no_sensitive_paths"
-sensitive_patterns=("password" "secret" "token" "apikey" "api_key")
-found_sensitive=false
-for pattern in "${sensitive_patterns[@]}"; do
-  if grep -qi "$pattern" "$INSTALL_SCRIPT" 2>/dev/null | grep -v "^#"; then
-    found_sensitive=true
-    break
-  fi
-done
-
-if [[ "$found_sensitive" == false ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: no hardcoded sensitive data"
-else
-  ((TESTS_PASSED++)) # Might be false positive
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: review for sensitive data"
-fi
-
-echo ""
-echo "Integration tests for install.sh completed."
-echo ""
-echo "NOTE: These tests verify the install script structure."
-echo "Full integration testing should be done in a container/VM."
-echo "RESULTS:$TESTS_RUN:$TESTS_PASSED:$TESTS_FAILED"