@sebastienrousseau/dotfiles 0.2.481 → 0.2.499

package/scripts/tests/unit/test_genpass.sh

@@ -1,298 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091,SC2034
-# Unit tests for the genpass function
-# Tests password generation with various options
-
-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/genpass.sh"
-if [[ -f "$FUNC_FILE" ]]; then
-  source "$FUNC_FILE"
-else
-  echo "Warning: genpass.sh not found at $FUNC_FILE"
-fi
-
-# Check if openssl is available
-if ! command -v openssl >/dev/null 2>&1; then
-  echo "Warning: openssl not available, some tests may fail"
-fi
-
-# Mock clipboard tools to prevent blocking in non-interactive environments
-mock_init
-mock_command "xclip" ""
-mock_command "wl-copy" ""
-mock_command "pbcopy" ""
-mock_command "clip" ""
-
-# Test: genpass with --help flag shows help
-test_start "genpass_help"
-output=$(
-  set +u
-  genpass --help 2>&1
-)
-if [[ "$output" == *"Usage:"* || "$output" == *"genpass"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: --help shows usage information"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: --help should show usage information"
-fi
-
-# Test: genpass with --help returns exit code 0
-test_start "genpass_help_exit_code"
-(
-  set +u
-  genpass --help >/dev/null 2>&1
-)
-assert_equals "0" "$?" "exit code should be 0 for --help"
-
-# Test: genpass default (no arguments) generates password
-test_start "genpass_default"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 2>&1
-  )
-  if [[ "$output" == *"Generated password:"* ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: generates password with default settings"
-  else
-    ((TESTS_FAILED++))
-    echo -e "  ${RED}✗${NC} $CURRENT_TEST: should generate password"
-    echo -e "    Output: $output"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass default generates 3 blocks
-test_start "genpass_default_blocks"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 2>&1
-  )
-  # Extract password from output
-  password=$(echo "$output" | grep "Generated password:" | sed 's/.*Generated password: //')
-  # Count dashes (separators) - default should have 2 dashes for 3 blocks
-  dash_count=$(echo "$password" | tr -cd '-' | wc -c | tr -d ' ')
-
-  if [[ "$dash_count" -eq 2 ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: default generates 3 blocks"
-  else
-    ((TESTS_PASSED++)) # Acceptable variation
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: password generated (block count may vary)"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass with custom block count
-test_start "genpass_custom_blocks"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 5 2>&1
-  )
-  password=$(echo "$output" | grep "Generated password:" | sed 's/.*Generated password: //')
-  # 5 blocks should have 4 separators
-  dash_count=$(echo "$password" | tr -cd '-' | wc -c | tr -d ' ')
-
-  if [[ "$dash_count" -eq 4 ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: generates 5 blocks correctly"
-  else
-    ((TESTS_PASSED++)) # Function worked
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: password generated with custom blocks"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass with single block
-test_start "genpass_single_block"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 1 2>&1
-  )
-  password=$(echo "$output" | grep "Generated password:" | sed 's/.*Generated password: //')
-  # Single block should have no separators
-  dash_count=$(echo "$password" | tr -cd '-' | wc -c | tr -d ' ')
-
-  if [[ "$dash_count" -eq 0 ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: single block has no separator"
-  else
-    ((TESTS_PASSED++)) # Function worked
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: password generated"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass with custom separator
-test_start "genpass_custom_separator"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 3 "/" 2>&1
-  )
-  password=$(echo "$output" | grep "Generated password:" | sed 's/.*Generated password: //')
-
-  if [[ "$password" == *"/"* ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses custom separator '/'"
-  else
-    ((TESTS_FAILED++))
-    echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use custom separator"
-    echo -e "    Password: $password"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass with colon separator
-test_start "genpass_colon_separator"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 2 ":" 2>&1
-  )
-  password=$(echo "$output" | grep "Generated password:" | sed 's/.*Generated password: //')
-
-  if [[ "$password" == *":"* ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses colon separator"
-  else
-    ((TESTS_FAILED++))
-    echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use colon separator"
-    echo -e "    Password: $password"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass returns exit code 0
-test_start "genpass_exit_code"
-if command -v openssl >/dev/null 2>&1; then
-  (
-    set +u
-    genpass >/dev/null 2>&1
-  )
-  assert_equals "0" "$?" "exit code should be 0"
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass shows INFO message
-test_start "genpass_info_message"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 2>&1
-  )
-  if [[ "$output" == *"INFO"* ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: shows INFO message"
-  else
-    ((TESTS_FAILED++))
-    echo -e "  ${RED}✗${NC} $CURRENT_TEST: should show INFO message"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass passwords are unique
-test_start "genpass_unique_passwords"
-if command -v openssl >/dev/null 2>&1; then
-  pass1=$( (
-    set +u
-    genpass 2>&1
-  ) | grep "Generated password:" | sed 's/.*Generated password: //')
-  pass2=$( (
-    set +u
-    genpass 2>&1
-  ) | grep "Generated password:" | sed 's/.*Generated password: //')
-
-  if [[ "$pass1" != "$pass2" ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: generates unique passwords"
-  else
-    ((TESTS_FAILED++))
-    echo -e "  ${RED}✗${NC} $CURRENT_TEST: passwords should be unique"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass password length with blocks
-test_start "genpass_password_length"
-if command -v openssl >/dev/null 2>&1; then
-  output=$(
-    set +u
-    genpass 3 2>&1
-  )
-  password=$(echo "$output" | grep "Generated password:" | sed 's/.*Generated password: //')
-  # Remove separators to count actual characters
-  password_no_sep=$(echo "$password" | tr -d '-')
-  length=${#password_no_sep}
-
-  # 3 blocks * 12 chars = 36 chars (per default block_size)
-  if [[ "$length" -ge 30 && "$length" -le 40 ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: password length is appropriate ($length chars)"
-  else
-    ((TESTS_PASSED++)) # Length varies based on implementation
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: password generated with length $length"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-# Test: genpass contains special characters (high entropy)
-test_start "genpass_special_chars"
-if command -v openssl >/dev/null 2>&1; then
-  # Generate several passwords and check for special chars
-  has_special=false
-  for i in {1..5}; do
-    password=$( (
-      set +u
-      genpass 2>&1
-    ) | grep "Generated password:" | sed 's/.*Generated password: //')
-    if [[ "$password" =~ [!@#\$%\^\&\*\(\)_\+\{\}\|:\<\>\?~\[\]\;\',./=-] ]]; then
-      has_special=true
-      break
-    fi
-  done
-
-  if [[ "$has_special" == true ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: includes special characters"
-  else
-    ((TESTS_PASSED++)) # Might not always include special chars
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: password generated (special chars optional)"
-  fi
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (openssl not available)"
-fi
-
-echo ""
-echo "Genpass function tests completed."
-echo "RESULTS:$TESTS_RUN:$TESTS_PASSED:$TESTS_FAILED"

package/scripts/tests/unit/test_install_edge_cases.sh

@@ -1,167 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091
-# Unit tests for install.sh edge cases, idempotency, and input validation
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-
-INSTALL_SCRIPT="$REPO_ROOT/install.sh"
-
-echo "Testing install.sh edge cases..."
-
-# Test: install.sh has set -euo pipefail
-test_start "install_strict_mode"
-if grep -q "set -euo pipefail" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses strict mode (set -euo pipefail)"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use set -euo pipefail"
-fi
-
-# Test: install.sh checks for existing chezmoi before installing
-test_start "install_chezmoi_check"
-if grep -q 'command -v chezmoi' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: checks for existing chezmoi"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should check for existing chezmoi"
-fi
-
-# Test: install.sh installs chezmoi via Homebrew when available
-test_start "install_chezmoi_brew"
-if grep -q 'brew install chezmoi' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: installs chezmoi via Homebrew when available"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should install chezmoi via Homebrew"
-fi
-
-# Test: install.sh falls back to get.chezmoi.io for binary install
-test_start "install_chezmoi_fallback"
-if grep -q 'get.chezmoi.io' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: falls back to get.chezmoi.io"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should fall back to get.chezmoi.io"
-fi
-
-# Test: install.sh adds BIN_DIR to PATH for fallback install
-test_start "install_path_update"
-if grep -q 'bin_dir=.*local/bin' "$INSTALL_SCRIPT" && grep -q 'export PATH=.*bin_dir' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: adds ~/.local/bin to PATH via bin_dir"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should add ~/.local/bin to PATH"
-fi
-
-# Test: install.sh handles backup of existing .dotfiles
-test_start "install_backup_existing"
-if grep -q '\.dotfiles\.bak' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backs up existing .dotfiles directory"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should backup existing .dotfiles"
-fi
-
-# Test: install.sh supports noninteractive mode
-test_start "install_noninteractive_mode"
-if grep -q "DOTFILES_NONINTERACTIVE" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports DOTFILES_NONINTERACTIVE"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support noninteractive mode"
-fi
-
-# Test: install.sh uses --force --no-tty in noninteractive mode
-test_start "install_noninteractive_flags"
-if grep -q "\-\-force" "$INSTALL_SCRIPT" && grep -q "\-\-no-tty" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses --force --no-tty in noninteractive mode"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use --force --no-tty"
-fi
-
-# Test: install.sh uses HTTPS for all URLs
-test_start "install_https_only"
-http_urls=$(grep -n 'http://' "$INSTALL_SCRIPT" | grep -v '^#' | grep -v 'http://deb' || true)
-if [[ -z "$http_urls" ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: all URLs use HTTPS"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: found non-HTTPS URLs"
-  echo -e "    $http_urls"
-fi
-
-# Test: install.sh backs up user dotfiles (not source repo)
-test_start "install_backup_user_dotfiles"
-if grep -q 'chezmoi managed' "$INSTALL_SCRIPT" && grep -q 'cp -a' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backs up files chezmoi will overwrite"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should back up managed dotfiles"
-fi
-
-# Test: install.sh detects multiple OS types
-test_start "install_multi_os_detection"
-os_count=0
-for os in "debian" "fedora" "arch" "macos" "wsl2"; do
-  if grep -q "$os" "$INSTALL_SCRIPT"; then
-    os_count=$((os_count + 1))
-  fi
-done
-if [[ $os_count -ge 3 ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: detects $os_count OS types"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should detect at least 3 OS types, found $os_count"
-fi
-
-# Test: install.sh does not contain curl | sh (pipes to shell) # gitleaks:allow
-test_start "install_no_curl_pipe_sh"
-# The Homebrew install line is a known pattern but uses /bin/bash -c, not pipe
-curl_pipe=$(grep 'curl.*|.*sh' "$INSTALL_SCRIPT" | grep -v "Homebrew" | grep -v "^#" || true) # gitleaks:allow
-if [[ -z "$curl_pipe" ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: no unsafe curl|sh patterns" # gitleaks:allow
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: found curl piped to shell"
-  echo -e "    $curl_pipe"
-fi
-
-# Test: ensure_chezmoi_source function exists
-test_start "install_ensure_chezmoi_source"
-if grep -q "ensure_chezmoi_source" "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: has ensure_chezmoi_source function"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should have ensure_chezmoi_source"
-fi
-
-# Test: install.sh handles legacy source migration
-test_start "install_legacy_migration"
-if grep -q 'Migrating from legacy source' "$INSTALL_SCRIPT"; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: migrates legacy chezmoi source directory"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should handle legacy source migration"
-fi
-
-echo ""
-echo "install.sh edge case tests completed."
-print_summary

package/scripts/tests/unit/test_installers.sh

@@ -1,172 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091
-# Unit tests for install/lib/installers.sh
-
-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"
-
-LOGGING_FILE="$REPO_ROOT/install/lib/logging.sh"
-INSTALLERS_FILE="$REPO_ROOT/install/lib/installers.sh"
-
-echo "Testing installers library..."
-
-# Test: installers.sh exists
-test_start "installers_file_exists"
-assert_file_exists "$INSTALLERS_FILE" "installers.sh should exist"
-
-# Test: installers.sh has valid syntax
-test_start "installers_syntax"
-assert_exit_code 0 "bash -n '$INSTALLERS_FILE'"
-
-# Test: installers.sh has double-source guard
-test_start "installers_guard"
-assert_file_contains "$INSTALLERS_FILE" "_DOTFILES_INSTALLERS_LOADED" "should have double-source guard"
-
-# Test: sha256_file computes checksum
-test_start "sha256_file_computes"
-tmp_file=$(mock_file "hello world")
-output=$(bash -c '
-  source "'"$LOGGING_FILE"'"
-  source "'"$INSTALLERS_FILE"'"
-  sha256_file "'"$tmp_file"'"
-')
-# sha256 of "hello world\n" is known
-if [[ -n "$output" && ${#output} -eq 64 ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: sha256_file returns 64-char hash"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: sha256_file should return 64-char hash"
-  echo -e "    Output: $output (length: ${#output})"
-fi
-
-# Test: resolve_arch returns valid architecture
-test_start "resolve_arch_valid"
-output=$(bash -c '
-  source "'"$LOGGING_FILE"'"
-  source "'"$INSTALLERS_FILE"'"
-  resolve_arch
-')
-if [[ "$output" == "x86_64" || "$output" == "aarch64" ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: resolve_arch returns $output"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: resolve_arch should return x86_64 or aarch64"
-  echo -e "    Output: $output"
-fi
-
-# Test: resolve_sudo returns empty or "sudo"
-test_start "resolve_sudo_returns"
-output=$(bash -c '
-  source "'"$LOGGING_FILE"'"
-  source "'"$INSTALLERS_FILE"'"
-  resolve_sudo
-')
-if [[ -z "$output" || "$output" == "sudo" ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: resolve_sudo returns '$output'"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: resolve_sudo should return empty or 'sudo'"
-  echo -e "    Output: $output"
-fi
-
-# Test: warn_unpinned dies on "latest" tag
-test_start "warn_unpinned_dies_on_latest"
-assert_exit_code 1 "bash -c 'source \"$LOGGING_FILE\"; source \"$INSTALLERS_FILE\"; warn_unpinned Test latest TEST_TAG'"
-
-# Test: warn_unpinned dies on "nightly" tag
-test_start "warn_unpinned_dies_on_nightly"
-assert_exit_code 1 "bash -c 'source \"$LOGGING_FILE\"; source \"$INSTALLERS_FILE\"; warn_unpinned Test nightly TEST_TAG'"
-
-# Test: warn_unpinned succeeds on pinned tag
-test_start "warn_unpinned_ok_pinned"
-assert_exit_code 0 "bash -c 'source \"$LOGGING_FILE\"; source \"$INSTALLERS_FILE\"; warn_unpinned Test v1.2.3 TEST_TAG'"
-
-# Test: github_asset_url constructs fallback URL for tagged release
-test_start "github_asset_url_tagged"
-output=$(bash -c '
-  source "'"$LOGGING_FILE"'"
-  source "'"$INSTALLERS_FILE"'"
-  github_asset_url "owner/repo" "binary-linux.tar.gz" "v1.0.0"
-' 2>/dev/null)
-if [[ "$output" == *"github.com"* && "$output" == *"v1.0.0"* && "$output" == *"binary-linux.tar.gz"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: github_asset_url returns correct tagged URL"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: github_asset_url should construct tagged URL"
-  echo -e "    Output: $output"
-fi
-
-# Test: github_asset_url constructs fallback URL for latest release
-test_start "github_asset_url_latest"
-output=$(bash -c '
-  source "'"$LOGGING_FILE"'"
-  source "'"$INSTALLERS_FILE"'"
-  github_asset_url "owner/repo" "binary.tar.gz" "latest"
-' 2>/dev/null)
-if [[ "$output" == *"github.com/owner/repo/releases/latest/download/binary.tar.gz"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: github_asset_url returns correct latest URL"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: github_asset_url should construct latest URL"
-  echo -e "    Output: $output"
-fi
-
-# Test: download_and_verify_sha256 verifies matching checksum
-test_start "download_verify_matching"
-tmp_dir=$(mock_dir "verify_test")
-echo "test file content" >"$tmp_dir/test.bin"
-# Use sha256sum on Linux, shasum on macOS
-if command -v sha256sum >/dev/null 2>&1; then
-  expected_hash=$(sha256sum "$tmp_dir/test.bin" | awk '{print $1}')
-else
-  expected_hash=$(shasum -a 256 "$tmp_dir/test.bin" | awk '{print $1}')
-fi
-echo "$expected_hash  test.bin" >"$tmp_dir/test.bin.sha256"
-# Create mock curl that copies local files
-mock_init
-cat >"$MOCK_BIN_DIR/curl" <<'SCRIPT'
-#!/usr/bin/env bash
-# Extract -o destination from args
-dest=""
-url=""
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -o) dest="$2"; shift 2 ;;
-    -*) shift ;;
-    *) url="$1"; shift ;;
-  esac
-done
-if [[ -n "$dest" && -n "$url" && -f "$url" ]]; then
-  cp "$url" "$dest"
-fi
-SCRIPT
-chmod +x "$MOCK_BIN_DIR/curl"
-
-result=$(bash -c '
-  export PATH="'"$MOCK_BIN_DIR"':$PATH"
-  source "'"$LOGGING_FILE"'"
-  source "'"$INSTALLERS_FILE"'"
-  download_and_verify_sha256 "'"$tmp_dir/test.bin"'" "'"$tmp_dir/test.bin.sha256"'" "'"$tmp_dir/downloaded.bin"'"
-  echo "OK"
-' 2>&1) || true
-if [[ "$result" == *"OK"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: verify succeeds with matching checksum"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: verify should succeed with matching checksum"
-  echo -e "    Output: $result"
-fi
-
-# Test: double-sourcing installers is idempotent
-test_start "installers_idempotent"
-assert_exit_code 0 "bash -c 'source \"$LOGGING_FILE\"; source \"$INSTALLERS_FILE\"; source \"$INSTALLERS_FILE\"; echo ok'"
-
-print_summary