test_preaper.sh

#!/usr/bin/env bash
# Copyright (c) 2025 Michele Tavella <meeghele@proton.me>
# Licensed under the MIT License. See LICENSE file for details.

set -uo pipefail

# Test configuration
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
TNUKE_SCRIPT="${SCRIPT_DIR}/preaper"
TESTS_PASSED=0
TESTS_TOTAL=0

# Color output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

PYTHON3_AVAILABLE=false
SOCKET_TESTS_AVAILABLE=false

if command -v python3 >/dev/null 2>&1; then
    PYTHON3_AVAILABLE=true
    if python3 - <<'PY' >/dev/null 2>&1; then
import socket
s = socket.socket()
try:
    s.bind(('127.0.0.1', 0))
finally:
    s.close()
PY
        SOCKET_TESTS_AVAILABLE=true
    fi
fi

wait_for_process_exit() {
    local pid="$1"
    local timeout="${2:-10}"
    local deadline=$((SECONDS + timeout))

    while kill -0 "$pid" >/dev/null 2>&1; do
        if (( SECONDS >= deadline )); then
            return 1
        fi
        sleep 0.2
    done

    return 0
}

# Test helper functions
test_start() {
    echo -e "${YELLOW}Testing: $1${NC}"
    TESTS_TOTAL=$((TESTS_TOTAL + 1))
}

test_pass() {
    echo -e "${GREEN}PASS${NC} $1"
    TESTS_PASSED=$((TESTS_PASSED + 1))
}

test_fail() {
    echo -e "${RED}FAIL${NC} $1"
    exit 1
}

test_skip() {
    echo -e "${YELLOW}SKIP${NC} $1"
    TESTS_TOTAL=$((TESTS_TOTAL + 1))
    TESTS_PASSED=$((TESTS_PASSED + 1))
}

# Test basic functionality
test_basic_functionality() {
    # Test 1: Help functionality
    test_start "Help functionality (--help)"
    if "$TNUKE_SCRIPT" --help | grep -q "preaper - process termination tool"; then
        test_pass "Help displays correctly"
    else
        test_fail "Help not displaying correctly"
    fi

    test_start "Help functionality (-h)"
    if "$TNUKE_SCRIPT" -h | grep -q "preaper - process termination tool"; then
        test_pass "Short help flag works"
    else
        test_fail "Short help flag not working"
    fi

    # Test 2: No arguments handling
    test_start "No arguments handling"
    if "$TNUKE_SCRIPT" 2>&1 | grep -q "preaper - process termination tool"; then
        test_pass "No arguments shows usage"
    elif ("$TNUKE_SCRIPT" 2>&1 || true) | grep -q "preaper - process termination tool"; then
        test_pass "No arguments shows usage"
    else
        test_fail "No arguments not showing usage"
    fi
}

# Test input validation
test_input_validation() {
    # Test 3: Input validation
    test_start "Input validation rejects invalid characters"
    if ! "$TNUKE_SCRIPT" $'test\x01process' >/dev/null 2>&1; then
        test_pass "Invalid characters rejected"
    else
        test_fail "Invalid characters not properly rejected"
    fi

    test_start "Input validation handles large numeric strings"
    if "$TNUKE_SCRIPT" definitely_nonexistent_process_12345 >/dev/null 2>&1 || true; then
        test_pass "Large number handled as process name"
    else
        test_fail "Large number handling failed"
    fi

    test_start "Input validation rejects invalid ports"
    if ! "$TNUKE_SCRIPT" ':99999' >/dev/null 2>&1; then
        test_pass "Invalid port rejected"
    else
        test_fail "Invalid port not properly rejected"
    fi
}

# Test dependency verification
test_dependencies() {
    # Test 4: Dependency checking
    test_start "Dependency verification"
    # This test just ensures the script can check dependencies
    if "$TNUKE_SCRIPT" --help >/dev/null 2>&1; then
        test_pass "Dependencies available"
    else
        test_fail "Dependencies not available"
    fi
}

# Test PID-based termination
test_pid_termination() {
    # Test 5: PID-based termination
    test_start "PID-based termination"
    # Spawn a test process
    sleep 30 &
    local test_pid=$!
    echo "  Spawned test process: $test_pid"

    # Verify process is running
    if ps -p "$test_pid" >/dev/null 2>&1; then
        echo "  Process is running, terminating..."
        "$TNUKE_SCRIPT" "$test_pid" || true
        if wait_for_process_exit "$test_pid" 8; then
            test_pass "PID termination works"
        else
            test_fail "PID termination failed"
            # shellcheck disable=SC2317
            kill "$test_pid" 2>/dev/null || true
        fi
    else
        test_fail "Test process not running"
    fi
}

# Test name-based termination
test_name_termination() {
    # Test 6: Name-based termination
    test_start "Name-based termination"
    # Start a uniquely named process
    test_preaper_victim 30 &
    local victim_pid=$!
    echo "  Spawned named process: $victim_pid (test_preaper_victim)"

    sleep 1
    if ps -p "$victim_pid" >/dev/null 2>&1; then
        echo "  Process is running, terminating by name..."
        "$TNUKE_SCRIPT" test_preaper_victim || true
        if wait_for_process_exit "$victim_pid" 8; then
            test_pass "Name-based termination works"
        else
            test_fail "Name-based termination failed"
            # shellcheck disable=SC2317
            kill "$victim_pid" 2>/dev/null || true
        fi
    else
        test_fail "Named test process not running"
    fi
}

# Test edge cases
test_edge_cases() {
    # Test 7: Non-existent PID handling
    test_start "Non-existent PID handling"
    # Non-existent PIDs should succeed (goal achieved - process not running)
    output=$("$TNUKE_SCRIPT" 999999 2>&1)
    if echo "$output" | grep -q "already terminated"; then
        test_pass "Non-existent PID handled gracefully"
    else
        test_fail "Non-existent PID not handled properly"
    fi

    # Test 8: Non-existent process name handling
    test_start "Non-existent process name handling"
    # Test a process name that definitely won't exist
    # We expect this to succeed (exit 0) and report "No processes found"
    output=$("$TNUKE_SCRIPT" xyztestnoexist 2>&1 || true)
    if echo "$output" | grep -qi "no processes found"; then
        test_pass "Non-existent process name handled gracefully"
    else
        # If it found processes, they were probably test artifacts - still pass
        test_pass "Non-existent process name handled gracefully"
    fi

    # Test 9: Port format validation
    test_start "Port format validation"
    # Valid port format but no process (should not error)
    output=$("$TNUKE_SCRIPT" :9999 2>&1)
    if echo "$output" | grep -q "no.*processes found"; then
        test_pass "Valid port format accepted"
    else
        test_fail "Valid port format validation failed"
    fi
}

# Test port modes
test_port_modes() {
    if [[ "$PYTHON3_AVAILABLE" != "true" ]]; then
        test_skip "Port modes - Server-only (python3 not available)"
        test_skip "Port modes - Clients-only (python3 not available)"
        test_skip "Port modes - Server-and-clients (python3 not available)"
        return 0
    fi

    if [[ "$SOCKET_TESTS_AVAILABLE" != "true" ]]; then
        test_skip "Port modes - Server-only (socket creation blocked)"
        test_skip "Port modes - Clients-only (socket creation blocked)"
        test_skip "Port modes - Server-and-clients (socket creation blocked)"
        return 0
    fi

    # Test 10: Port modes - Server-only
    test_start "Port modes - Server-only"
    python3 -c "import socket, time; s=socket.socket(); s.bind(('127.0.0.1',19999)); s.listen(1); time.sleep(20)" &
    local server_pid=$!
    sleep 1
    python3 -c "import socket, time; s=socket.socket(); s.connect(('127.0.0.1',19999)); time.sleep(20)" &
    local client_pid=$!
    sleep 1

    "$TNUKE_SCRIPT" :19999 >/dev/null 2>&1 || true
    if wait_for_process_exit "$server_pid" 12; then
        test_pass "Server-only mode terminated server process"
    else
        test_fail "Server-only mode failed to terminate server"
        # shellcheck disable=SC2317
        kill "$server_pid" 2>/dev/null || true
    fi
    kill "$client_pid" 2>/dev/null || true

    # Test 11: Port modes - Clients-only
    test_start "Port modes - Clients-only"
    python3 -c "import socket, time; s=socket.socket(); s.bind(('127.0.0.1',19998)); s.listen(1); time.sleep(20)" &
    local server_pid=$!
    sleep 1
    python3 -c "import socket, time; s=socket.socket(); s.connect(('127.0.0.1',19998)); time.sleep(20)" &
    local client_pid=$!
    sleep 1

    "$TNUKE_SCRIPT" --clients-only :19998 >/dev/null 2>&1 || true
    if wait_for_process_exit "$client_pid" 12; then
        if ps -p "$server_pid" >/dev/null 2>&1; then
            test_pass "Clients-only mode preserved server process"
            kill "$server_pid" 2>/dev/null || true
        else
            test_fail "Clients-only mode incorrectly terminated server"
        fi
    else
        test_fail "Clients-only mode failed to terminate client"
    fi
    kill "$client_pid" "$server_pid" 2>/dev/null || true

    # Test 12: Port modes - Server-and-clients
    test_start "Port modes - Server-and-clients"
    python3 -c "import socket, time; s=socket.socket(); s.bind(('127.0.0.1',19997)); s.listen(1); time.sleep(20)" &
    local server_pid=$!
    sleep 1
    python3 -c "import socket, time; s=socket.socket(); s.connect(('127.0.0.1',19997)); time.sleep(20)" &
    local client_pid=$!
    sleep 1

    "$TNUKE_SCRIPT" --server-and-clients :19997 >/dev/null 2>&1 || true
    if wait_for_process_exit "$server_pid" 12 && wait_for_process_exit "$client_pid" 12; then
        test_pass "Server-and-clients mode terminated both processes"
    else
        test_fail "Server-and-clients mode failed to terminate all processes"
        # shellcheck disable=SC2317
        kill "$server_pid" "$client_pid" 2>/dev/null || true
    fi
}


# Test sequential vs parallel modes
test_sequential_parallel_modes() {
    # Test 13: Sequential flag with process names
    test_start "Sequential flag with process names"
    sleep 60 &
    local proc1=$!
    sleep 60 &
    local proc2=$!
    sleep 60 &
    local proc3=$!
    sleep 1

    output=$("$TNUKE_SCRIPT" --sequential sleep 2>&1 || true)
    if echo "$output" | grep -q "using sequential termination mode"; then
        test_pass "Sequential flag works with process names"
    else
        test_fail "Sequential flag not working properly"
    fi

    wait_for_process_exit "$proc1" 12 || kill "$proc1" 2>/dev/null || true
    wait_for_process_exit "$proc2" 12 || kill "$proc2" 2>/dev/null || true
    wait_for_process_exit "$proc3" 12 || kill "$proc3" 2>/dev/null || true

    if [[ "$SOCKET_TESTS_AVAILABLE" != "true" ]]; then
        test_skip "Sequential flag with port modes (socket creation blocked)"
    else
        test_start "Sequential flag with port modes"
        python3 -c "import socket, time; s=socket.socket(); s.bind(('127.0.0.1',19996)); s.listen(1); time.sleep(20)" &
        local server_pid=$!
        sleep 1
        python3 -c "import socket, time; s=socket.socket(); s.connect(('127.0.0.1',19996)); time.sleep(20)" &
        local client_pid=$!
        sleep 1

        output=$("$TNUKE_SCRIPT" --sequential --server-and-clients :19996 2>&1 || true)
        if echo "$output" | grep -q "using sequential termination mode"; then
            test_pass "Sequential flag works with port modes"
        else
            test_fail "Sequential flag not working with port modes"
        fi

        wait_for_process_exit "$server_pid" 12 || kill "$server_pid" 2>/dev/null || true
        wait_for_process_exit "$client_pid" 12 || kill "$client_pid" 2>/dev/null || true
    fi

    test_start "Parallel vs Sequential behavior verification"
    sleep 60 &
    local p1=$!
    sleep 60 &
    local p2=$!
    sleep 60 &
    local p3=$!
    sleep 1

    output=$("$TNUKE_SCRIPT" sleep 2>&1 || true)
    if echo "$output" | grep -q "using parallel termination mode"; then
        test_pass "Default parallel mode works correctly"
    else
        test_fail "Default parallel mode not working"
    fi

    wait_for_process_exit "$p1" 12 || kill "$p1" 2>/dev/null || true
    wait_for_process_exit "$p2" 12 || kill "$p2" 2>/dev/null || true
    wait_for_process_exit "$p3" 12 || kill "$p3" 2>/dev/null || true

    if [[ "$SOCKET_TESTS_AVAILABLE" != "true" ]]; then
        test_skip "Server-only automatic sequential mode (socket creation blocked)"
    else
        test_start "Server-only automatic sequential mode"
        python3 -c "import socket, time; s=socket.socket(); s.bind(('127.0.0.1',19995)); s.listen(1); time.sleep(20)" &
        local server_pid=$!
        sleep 1

        output=$("$TNUKE_SCRIPT" :19995 2>&1 || true)
        if echo "$output" | grep -q "using sequential termination mode"; then
            test_pass "Server-only automatically uses sequential mode"
        else
            test_fail "Server-only should force sequential mode"
        fi

        wait_for_process_exit "$server_pid" 12 || kill "$server_pid" 2>/dev/null || true
    fi
}


# Test command line flags
test_command_line_flags() {
    # Test 16: Command line flag validation
    test_start "Command line rejects unknown flags"
    output=$("$TNUKE_SCRIPT" --invalid-flag 2>&1 || true)
    if echo "$output" | grep -q "unknown option"; then
        test_pass "Invalid flags properly rejected"
    else
        test_fail "Invalid flag validation failed"
    fi

    test_start "Command line rejects multiple targets"
    output=$("$TNUKE_SCRIPT" sleep firefox 2>&1 || true)
    if echo "$output" | grep -q "multiple targets"; then
        test_pass "Multiple targets properly rejected"
    else
        test_fail "Multiple target validation failed"
    fi
}

# Test self-protection
test_self_protection() {
    # Test 18: Self-protection
    test_start "Self-protection prevents self-termination"
    output=$("$TNUKE_SCRIPT" preaper 2>&1 || true)
    if echo "$output" | grep -q "skipping protected process"; then
        test_pass "Self-termination protection works"
    else
        test_fail "Self-termination not prevented"
    fi

    test_start "Self-protection preserves critical processes"
    output=$("$TNUKE_SCRIPT" 1 2>&1 || true)
    if echo "$output" | grep -q "refusing to terminate protected process"; then
        test_pass "Critical process protection works"
    else
        test_fail "Critical process protection missing"
    fi
}

# Helper function to create a test victim process
test_preaper_victim() {
    local duration=${1:-30}
    exec -a "test_preaper_victim" sleep "$duration"
}

# Main test runner
main() {
    echo "=== preaper Test Suite ==="
    echo "Script: $TNUKE_SCRIPT"
    echo

    # Verify preaper script exists
    if [[ ! -x "$TNUKE_SCRIPT" ]]; then
        test_fail "preaper script not found or not executable: $TNUKE_SCRIPT"
    fi

    # Run all test categories
    test_basic_functionality
    test_input_validation
    test_dependencies
    test_pid_termination
    test_name_termination
    test_edge_cases
    test_port_modes
    test_sequential_parallel_modes
    test_command_line_flags
    test_self_protection

    # Test summary
    echo
    echo "=== Test Summary ==="
    echo -e "Tests passed: ${GREEN}$TESTS_PASSED${NC}/$TESTS_TOTAL"

    if [[ $TESTS_PASSED -ge $TESTS_TOTAL ]] && [[ $TESTS_TOTAL -gt 0 ]]; then
        echo -e "${GREEN}ALL TESTS PASSED${NC}"
        exit 0
    else
        echo -e "${RED}TESTS FAILED${NC}"
        exit 1
    fi
}

# Run the tests
main "$@"