Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

12.1 KB
Raw Blame
#!/usr/bin/env bash
#
# Smoke test for scripts/toggle-mock.sh managed runtime helpers.

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
TOGGLE_MOCK="${ROOT_DIR}/scripts/toggle-mock.sh"

if [[ ! -f "${TOGGLE_MOCK}" ]]; then
  echo "toggle-mock.sh not found at ${TOGGLE_MOCK}" >&2
  exit 1
fi

failures=0
temp_dirs=()

cleanup() {
  local dir
  for dir in "${temp_dirs[@]:-}"; do
    rm -rf "${dir}" 2>/dev/null || true
  done
}
trap cleanup EXIT

assert_contains() {
  local desc="$1"
  local haystack="$2"
  local needle="$3"

  if [[ "${haystack}" == *"${needle}"* ]]; then
    echo "[PASS] ${desc}"
  else
    echo "[FAIL] ${desc}" >&2
    echo "Expected to find: ${needle}" >&2
    ((failures++))
  fi
}

assert_file_absent() {
  local desc="$1"
  local path="$2"

  if [[ ! -e "${path}" ]]; then
    echo "[PASS] ${desc}"
  else
    echo "[FAIL] ${desc}" >&2
    echo "Did not expect file to exist: ${path}" >&2
    ((failures++))
  fi
}

make_stub_hot_dev_bg() {
  local dir
  dir="$(mktemp -d)"
  temp_dirs+=("${dir}")
  cat > "${dir}/hot-dev-bg.sh" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

COMMAND="${1:-}"
shift || true

printf "%s %s\n" "${COMMAND}" "$*" >> "${HOT_DEV_BG_STUB_LOG}"

case "${COMMAND}" in
  status)
    if [[ "${HOT_DEV_BG_STUB_RUNNING:-false}" == "true" ]]; then
      echo "[hot-dev-bg] Running (pid: 12345)"
      echo "[hot-dev-bg] Frontend shell HTTP: 200"
      echo "[hot-dev-bg] Frontend proxy /api/health: 200"
      echo "[hot-dev-bg] Backend /api/health: 200"
    else
      echo "[hot-dev-bg] Not running"
    fi
    ;;
  start)
    if [[ "${HOT_DEV_BG_STUB_START_FAIL:-false}" == "true" ]]; then
      echo "[hot-dev-bg] ERROR: managed runtime startup failed" >&2
      exit 1
    fi
    echo "[hot-dev-bg] Started"
    ;;
  stop)
    echo "[hot-dev-bg] Stopped"
    ;;
  *)
    echo "[hot-dev-bg] ${COMMAND}"
    ;;
esac
EOF
  chmod +x "${dir}/hot-dev-bg.sh"
  printf "%s\n" "${dir}/hot-dev-bg.sh"
}

test_detects_managed_hot_dev_runtime() {
  local stub state output
  state="$(mktemp -d)"
  temp_dirs+=("${state}")
  stub="$(make_stub_hot_dev_bg)"

  output="$(
    HOT_DEV_BG_PATH="${stub}" \
    HOT_DEV_BG_STUB_LOG="${state}/calls.log" \
    HOT_DEV_BG_STUB_RUNNING=true \
    TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
    bash -lc '
      source "${TOGGLE_MOCK_PATH}"
      printf "mode=%s\n" "$(detect_runtime_mode)"
    '
  )"

  assert_contains "detect_runtime_mode prefers managed hot-dev" "${output}" "mode=managed-hot-dev"
}

test_managed_hot_dev_start_uses_takeover() {
  local stub state output calls
  state="$(mktemp -d)"
  temp_dirs+=("${state}")
  stub="$(make_stub_hot_dev_bg)"

  output="$(
    HOT_DEV_BG_PATH="${stub}" \
    HOT_DEV_BG_STUB_LOG="${state}/calls.log" \
    HOT_DEV_BG_STUB_RUNNING=false \
    TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
    bash -lc '
      source "${TOGGLE_MOCK_PATH}"
      start_hot_dev_runtime
    '
  )"
  calls="$(cat "${state}/calls.log")"

  assert_contains "start_hot_dev_runtime announces managed startup" "${output}" "Starting managed hot-dev runtime"
  assert_contains "start_hot_dev_runtime uses managed takeover start" "${calls}" "start --takeover"
}

test_managed_hot_dev_stop_uses_control_plane() {
  local stub state output calls
  state="$(mktemp -d)"
  temp_dirs+=("${state}")
  stub="$(make_stub_hot_dev_bg)"

  output="$(
    HOT_DEV_BG_PATH="${stub}" \
    HOT_DEV_BG_STUB_LOG="${state}/calls.log" \
    HOT_DEV_BG_STUB_RUNNING=true \
    TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
    bash -lc '
      source "${TOGGLE_MOCK_PATH}"
      stop_hot_dev_runtime managed-hot-dev
    '
  )"
  calls="$(cat "${state}/calls.log")"

  assert_contains "stop_hot_dev_runtime announces managed stop" "${output}" "Stopping managed hot-dev runtime"
  assert_contains "stop_hot_dev_runtime uses managed stop command" "${calls}" "stop "
}

test_apply_mode_accepts_recovered_managed_mock_state_after_start_failure() {
  local stub state output calls
  state="$(mktemp -d)"
  temp_dirs+=("${state}")
  stub="$(make_stub_hot_dev_bg)"

  output="$(
    HOT_DEV_BG_PATH="${stub}" \
    HOT_DEV_BG_STUB_LOG="${state}/calls.log" \
    HOT_DEV_BG_STUB_RUNNING=true \
    HOT_DEV_BG_STUB_START_FAIL=true \
    TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
    bash -lc '
      source "${TOGGLE_MOCK_PATH}"
      detect_runtime_mode(){ printf "managed-hot-dev\n"; }
      set_mock_mode(){ printf "set_mode=%s\n" "$1"; }
      stop_hot_dev_runtime(){ printf "stop=%s\n" "$1"; }
      verify_mock_state_via_frontend_proxy(){ printf "verified=%s\n" "$1"; return 0; }
      apply_mode true
    '
  )"
  calls="$(cat "${state}/calls.log")"

  assert_contains "apply_mode still uses managed takeover start" "${calls}" "start --takeover"
  assert_contains "apply_mode warns on a non-clean managed restart" "${output}" "Managed hot-dev start command did not complete cleanly"
  assert_contains "apply_mode accepts a recovered requested mock state" "${output}" "browser entrypoint is serving the requested mock state"
  assert_contains "apply_mode completes the toggle after recovery proof" "${output}" "Mock mode is now enabled"
}

test_ensure_mock_env_file_seeds_canonical_demo_defaults() {
  local state output env_contents
  state="$(mktemp -d)"
  temp_dirs+=("${state}")

  output="$(
    TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
    MOCK_ENV_OVERRIDE="${state}/mock.env" \
    LEGACY_ROOT_MOCK_ENV_OVERRIDE="${state}/legacy-root.mock.env" \
    LEGACY_DEV_MOCK_ENV_OVERRIDE="${state}/legacy-dev.mock.env" \
    LEGACY_RUNTIME_MOCK_ENV_OVERRIDE="${state}/legacy-runtime.mock.env" \
    bash -lc '
      source "${TOGGLE_MOCK_PATH}"
      MOCK_ENV_FILE="${MOCK_ENV_OVERRIDE}"
      LEGACY_ROOT_MOCK_ENV_FILE="${LEGACY_ROOT_MOCK_ENV_OVERRIDE}"
      LEGACY_DEV_MOCK_ENV_FILE="${LEGACY_DEV_MOCK_ENV_OVERRIDE}"
      LEGACY_RUNTIME_MOCK_ENV_FILE="${LEGACY_RUNTIME_MOCK_ENV_OVERRIDE}"
      ensure_mock_env_file
      cat "${MOCK_ENV_FILE}"
    '
  )"
  env_contents="${output}"

  assert_contains "ensure_mock_env_file seeds mock mode default" "${env_contents}" "PULSE_MOCK_MODE=false"
  assert_contains "ensure_mock_env_file seeds canonical node count" "${env_contents}" "PULSE_MOCK_NODES=50"
  assert_contains "ensure_mock_env_file seeds canonical vm count" "${env_contents}" "PULSE_MOCK_VMS_PER_NODE=10"
  assert_contains "ensure_mock_env_file seeds canonical lxc count" "${env_contents}" "PULSE_MOCK_LXCS_PER_NODE=8"
  assert_contains "ensure_mock_env_file seeds canonical docker host count" "${env_contents}" "PULSE_MOCK_DOCKER_HOSTS=5"
  assert_contains "ensure_mock_env_file seeds canonical docker container count" "${env_contents}" "PULSE_MOCK_DOCKER_CONTAINERS=14"
  assert_contains "ensure_mock_env_file seeds canonical generic host count" "${env_contents}" "PULSE_MOCK_GENERIC_HOSTS=4"
  assert_contains "ensure_mock_env_file seeds canonical k8s cluster count" "${env_contents}" "PULSE_MOCK_K8S_CLUSTERS=3"
  assert_contains "ensure_mock_env_file seeds canonical k8s node count" "${env_contents}" "PULSE_MOCK_K8S_NODES=5"
  assert_contains "ensure_mock_env_file seeds canonical k8s pod count" "${env_contents}" "PULSE_MOCK_K8S_PODS=40"
  assert_contains "ensure_mock_env_file seeds canonical k8s deployment count" "${env_contents}" "PULSE_MOCK_K8S_DEPLOYMENTS=14"
  assert_contains "ensure_mock_env_file seeds canonical random metrics flag" "${env_contents}" "PULSE_MOCK_RANDOM_METRICS=true"
  assert_contains "ensure_mock_env_file seeds canonical stopped percent" "${env_contents}" "PULSE_MOCK_STOPPED_PERCENT=6"
}

test_ensure_mock_env_file_migrates_legacy_sidecar() {
  local state output env_contents
  state="$(mktemp -d)"
  temp_dirs+=("${state}")

  cat > "${state}/legacy.mock.env" <<'EOF'
PULSE_MOCK_MODE=true
PULSE_MOCK_NODES=9
EOF

  output="$(
    TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
    MOCK_ENV_OVERRIDE="${state}/runtime.env" \
    LEGACY_DEV_MOCK_ENV_OVERRIDE="${state}/legacy.mock.env" \
    LEGACY_ROOT_MOCK_ENV_OVERRIDE="${state}/legacy-root.mock.env" \
    LEGACY_RUNTIME_MOCK_ENV_OVERRIDE="${state}/legacy-runtime.mock.env" \
    bash -lc '
      source "${TOGGLE_MOCK_PATH}"
      MOCK_ENV_FILE="${MOCK_ENV_OVERRIDE}"
      LEGACY_DEV_MOCK_ENV_FILE="${LEGACY_DEV_MOCK_ENV_OVERRIDE}"
      LEGACY_ROOT_MOCK_ENV_FILE="${LEGACY_ROOT_MOCK_ENV_OVERRIDE}"
      LEGACY_RUNTIME_MOCK_ENV_FILE="${LEGACY_RUNTIME_MOCK_ENV_OVERRIDE}"
      ensure_mock_env_file
      cat "${MOCK_ENV_FILE}"
    '
  )"
  env_contents="${output}"

  assert_contains "ensure_mock_env_file migrates legacy mock mode" "${env_contents}" "PULSE_MOCK_MODE=true"
  assert_contains "ensure_mock_env_file migrates legacy node count" "${env_contents}" "PULSE_MOCK_NODES=9"
  assert_contains "ensure_mock_env_file still seeds missing defaults" "${env_contents}" "PULSE_MOCK_VMS_PER_NODE=10"
}

test_set_mock_mode_does_not_recreate_legacy_sidecars() {
  local state dev_env runtime_env
  state="$(mktemp -d)"
  temp_dirs+=("${state}")
  dev_env="${state}/dev/.env"
  runtime_env="${state}/runtime/.env"

  TOGGLE_MOCK_PATH="${TOGGLE_MOCK}" \
  MOCK_ENV_OVERRIDE="${dev_env}" \
  DEV_DATA_DIR_OVERRIDE="${state}/dev" \
  RUNTIME_MOCK_ENV_OVERRIDE="${runtime_env}" \
  LEGACY_DEV_MOCK_ENV_OVERRIDE="${state}/dev/mock.env" \
  LEGACY_ROOT_MOCK_ENV_OVERRIDE="${state}/mock.env" \
  LEGACY_RUNTIME_MOCK_ENV_OVERRIDE="${state}/runtime/mock.env" \
  bash -lc '
    source "${TOGGLE_MOCK_PATH}"
    MOCK_ENV_FILE="${MOCK_ENV_OVERRIDE}"
    DEV_DATA_DIR="${DEV_DATA_DIR_OVERRIDE}"
    RUNTIME_MOCK_ENV_FILE="${RUNTIME_MOCK_ENV_OVERRIDE}"
    LEGACY_DEV_MOCK_ENV_FILE="${LEGACY_DEV_MOCK_ENV_OVERRIDE}"
    LEGACY_ROOT_MOCK_ENV_FILE="${LEGACY_ROOT_MOCK_ENV_OVERRIDE}"
    LEGACY_RUNTIME_MOCK_ENV_FILE="${LEGACY_RUNTIME_MOCK_ENV_OVERRIDE}"
    set_mock_mode true
  '

  assert_contains "set_mock_mode writes canonical dev env" "$(cat "${dev_env}")" "PULSE_MOCK_MODE=true"
  assert_contains "set_mock_mode writes canonical runtime env" "$(cat "${runtime_env}")" "PULSE_MOCK_MODE=true"
  assert_file_absent "set_mock_mode does not recreate dev legacy mock sidecar" "${state}/dev/mock.env"
  assert_file_absent "set_mock_mode does not recreate root legacy mock sidecar" "${state}/mock.env"
  assert_file_absent "set_mock_mode does not recreate runtime legacy mock sidecar" "${state}/runtime/mock.env"
}

test_package_json_mock_wrappers_delegate_to_toggle_mock() {
  local script name value
  for name in mock:on mock:off mock:status mock:edit; do
    value="$(node -e '
      const pkg = require(process.argv[1]);
      process.stdout.write((pkg.scripts || {})[process.argv[2]] || "");
    ' "${ROOT_DIR}/package.json" "${name}")"

    assert_contains "package.json ${name} delegates to toggle-mock.sh" \
      "${value}" "scripts/toggle-mock.sh"

    # An inline flag rewrite targets the repo-root .env, which hot-dev.sh does
    # not consult, and GNU `sed -i` fails outright on the default macOS BSD sed.
    if [[ "${value}" == *"PULSE_MOCK_MODE="* || "${value}" == *"sed -i"* ]]; then
      echo "[FAIL] package.json ${name} must not rewrite the mock flag inline" >&2
      echo "Got: ${value}" >&2
      ((failures++))
    else
      echo "[PASS] package.json ${name} does not rewrite the mock flag inline"
    fi
  done

  # Anything the hot-dev startup banner tells operators to run must exist.
  while read -r script; do
    [[ -n "${script}" ]] || continue
    value="$(node -e '
      const pkg = require(process.argv[1]);
      process.stdout.write((pkg.scripts || {})[process.argv[2]] === undefined ? "" : "present");
    ' "${ROOT_DIR}/package.json" "${script}")"

    assert_contains "hot-dev banner advertises existing npm script ${script}" \
      "${value}" "present"
  done < <(grep -oE 'npm run (mock:[a-z]+)' "${ROOT_DIR}/scripts/hot-dev.sh" \
    | sed 's/^npm run //' | sort -u)
}

main() {
  test_detects_managed_hot_dev_runtime
  test_managed_hot_dev_start_uses_takeover
  test_managed_hot_dev_stop_uses_control_plane
  test_apply_mode_accepts_recovered_managed_mock_state_after_start_failure
  test_ensure_mock_env_file_seeds_canonical_demo_defaults
  test_ensure_mock_env_file_migrates_legacy_sidecar
  test_set_mock_mode_does_not_recreate_legacy_sidecars
  test_package_json_mock_wrappers_delegate_to_toggle_mock

  if (( failures > 0 )); then
    echo "Total failures: ${failures}" >&2
    exit 1
  fi

  echo "toggle-mock managed runtime smoke tests passed."
}

main "$@"