path: root/tests/unit/test_config.bats

#!/usr/bin/env bats
# Unit tests for installer/lib/config.sh

setup() {
    # shellcheck disable=SC1091
    source "${BATS_TEST_DIRNAME}/../../installer/lib/common.sh"
    # shellcheck disable=SC1091
    source "${BATS_TEST_DIRNAME}/../../installer/lib/raid.sh"
    # shellcheck disable=SC1091
    source "${BATS_TEST_DIRNAME}/../../installer/lib/config.sh"
}

@test "parse_args stores --config-file path" {
    parse_args --config-file /tmp/foo.conf
    [ "$CONFIG_FILE" = "/tmp/foo.conf" ]
}

@test "parse_args rejects --config-file with no argument" {
    run parse_args --config-file
    [ "$status" -eq 1 ]
    [[ "$output" == *"requires a path"* ]]
}

@test "parse_args rejects --config-file when value looks like a flag" {
    run parse_args --config-file --help
    [ "$status" -eq 1 ]
    [[ "$output" == *"requires a path"* ]]
}

@test "parse_args --color enables color vars" {
    [ -z "$RED" ]
    parse_args --color
    [ -n "$RED" ]
}

@test "parse_args --help shows usage and exits 0" {
    run parse_args --help
    [ "$status" -eq 0 ]
    [[ "$output" == *"Usage:"* ]]
    [[ "$output" == *"--config-file"* ]]
}

@test "parse_args rejects unknown option" {
    run parse_args --not-a-real-flag
    [ "$status" -eq 1 ]
    [[ "$output" == *"Unknown option"* ]]
}

@test "load_config errors on missing file" {
    run load_config /nonexistent/path/archangel.conf
    [ "$status" -eq 1 ]
    [[ "$output" == *"Config file not found"* ]]
}

@test "load_config parses a minimal config and sets UNATTENDED" {
    local tmp
    tmp=$(mktemp)
    cat >"$tmp" <<'EOF'
HOSTNAME=testhost
TIMEZONE=UTC
DISKS=/dev/sda,/dev/sdb
ROOT_PASSWORD=secret
EOF
    load_config "$tmp"
    [ "$HOSTNAME" = "testhost" ]
    [ "$TIMEZONE" = "UTC" ]
    [ "$ROOT_PASSWORD" = "secret" ]
    [ "${SELECTED_DISKS[0]}" = "/dev/sda" ]
    [ "${SELECTED_DISKS[1]}" = "/dev/sdb" ]
    [ "$UNATTENDED" = "true" ]
    rm -f "$tmp"
}

@test "load_config parses a single-disk config into 1-element array" {
    local tmp
    tmp=$(mktemp)
    echo "DISKS=/dev/nvme0n1" >"$tmp"
    load_config "$tmp"
    [ "${#SELECTED_DISKS[@]}" -eq 1 ]
    [ "${SELECTED_DISKS[0]}" = "/dev/nvme0n1" ]
    rm -f "$tmp"
}

@test "validate_config fails and lists every missing required field" {
    HOSTNAME=""
    TIMEZONE=""
    SELECTED_DISKS=()
    ROOT_PASSWORD=""
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"HOSTNAME not set"* ]]
    [[ "$output" == *"TIMEZONE not set"* ]]
    [[ "$output" == *"No disks selected"* ]]
    [[ "$output" == *"ROOT_PASSWORD not set"* ]]
    [[ "$output" == *"4 error"* ]]
}

@test "validate_config under set -e reports every error, not just the first" {
    # Reproduces the monolith's call structure: `set -e` is active and
    # validate_config is invoked as the final command of an && list. A
    # post-increment that returns the pre-increment value (0 on the first
    # error) trips set -e and aborts the function after one warning. This
    # test runs outside bats' `run` shield (which sets +e) so the real
    # accumulate-and-report behavior is exercised.
    run bash -c '
        set -e
        source "'"${BATS_TEST_DIRNAME}"'/../../installer/lib/common.sh"
        source "'"${BATS_TEST_DIRNAME}"'/../../installer/lib/raid.sh"
        source "'"${BATS_TEST_DIRNAME}"'/../../installer/lib/config.sh"
        HOSTNAME=""; TIMEZONE=""; SELECTED_DISKS=(); ROOT_PASSWORD=""
        UNATTENDED=true
        [[ "$UNATTENDED" == true ]] && validate_config
    '
    [ "$status" -eq 1 ]
    [[ "$output" == *"HOSTNAME not set"* ]]
    [[ "$output" == *"TIMEZONE not set"* ]]
    [[ "$output" == *"No disks selected"* ]]
    [[ "$output" == *"ROOT_PASSWORD not set"* ]]
    [[ "$output" == *"4 error"* ]]
}

@test "validate_config rejects a RAID_LEVEL invalid for the disk count" {
    HOSTNAME=h
    TIMEZONE=UTC
    ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda /dev/sdb)
    RAID_LEVEL=raidz1
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid RAID_LEVEL"* ]]
    [[ "$output" == *"raidz1"* ]]
}

@test "validate_config accepts a RAID_LEVEL valid for the disk count" {
    HOSTNAME=h
    TIMEZONE=UTC
    ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda /dev/sdb /dev/sdc)
    RAID_LEVEL=raidz1
    run validate_config
    [[ "$output" != *"Invalid RAID_LEVEL"* ]]
}

@test "validate_config accepts an empty RAID_LEVEL for a single disk" {
    HOSTNAME=h
    TIMEZONE=UTC
    ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda)
    RAID_LEVEL=""
    run validate_config
    [[ "$output" != *"Invalid RAID_LEVEL"* ]]
}

@test "validate_config rejects an invalid timezone" {
    HOSTNAME="h"
    TIMEZONE="Not/A_Real_Zone_xyz"
    SELECTED_DISKS=()
    ROOT_PASSWORD="x"
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid timezone"* ]]
}

@test "check_config is a no-op when CONFIG_FILE is unset" {
    CONFIG_FILE=""
    run check_config
    [ "$status" -eq 0 ]
    [ -z "$output" ]
}

@test "check_config loads the config file when CONFIG_FILE is set" {
    local tmp
    tmp=$(mktemp)
    cat >"$tmp" <<'EOF'
HOSTNAME=fromcheckconfig
TIMEZONE=UTC
EOF
    CONFIG_FILE="$tmp"
    check_config
    [ "$HOSTNAME" = "fromcheckconfig" ]
    [ "$TIMEZONE" = "UTC" ]
    [ "$UNATTENDED" = "true" ]
    rm -f "$tmp"
}

@test "validate_config flags an existing-but-not-block path in SELECTED_DISKS" {
    HOSTNAME=h
    TIMEZONE=UTC
    ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/null)
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Disk not found: /dev/null"* ]]
}

@test "validate_config flags a missing path in SELECTED_DISKS" {
    HOSTNAME=h
    TIMEZONE=UTC
    ROOT_PASSWORD=x
    SELECTED_DISKS=(/nonexistent/disk-xyz-42)
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Disk not found"* ]]
}

@test "parse_args accepts --color and --config-file together (color first)" {
    parse_args --color --config-file /tmp/foo.conf
    [ "$CONFIG_FILE" = "/tmp/foo.conf" ]
    [ -n "$RED" ]
}

@test "parse_args accepts --config-file and --color together (config first)" {
    parse_args --config-file /tmp/foo.conf --color
    [ "$CONFIG_FILE" = "/tmp/foo.conf" ]
    [ -n "$RED" ]
}

#############################
# Default values sourced from config.sh
#############################
# config.sh is the single source of truth for installer defaults. The
# monolith no longer re-applies them in gather_input. These tests pin
# the values so a regression that drops a default surfaces here, not
# halfway through an unattended install.

@test "config.sh sets defaults for FILESYSTEM, LOCALE, KEYMAP, ENABLE_SSH, NO_ENCRYPT" {
    [ "$FILESYSTEM" = "zfs" ]
    [ "$LOCALE" = "en_US.UTF-8" ]
    [ "$KEYMAP" = "us" ]
    [ "$ENABLE_SSH" = "yes" ]
    [ "$NO_ENCRYPT" = "no" ]
}

#############################
# validate_filesystem
#############################
# Called from main() between check_config and gather_input. Catches a
# typo in FILESYSTEM= from a config file before the install starts.

@test "validate_filesystem accepts zfs" {
    FILESYSTEM=zfs
    run validate_filesystem
    [ "$status" -eq 0 ]
}

@test "validate_filesystem accepts btrfs" {
    FILESYSTEM=btrfs
    run validate_filesystem
    [ "$status" -eq 0 ]
}

@test "validate_filesystem rejects an unknown filesystem" {
    FILESYSTEM=ext4
    run validate_filesystem
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid FILESYSTEM"* ]]
    [[ "$output" == *"ext4"* ]]
}

@test "validate_filesystem rejects an empty FILESYSTEM" {
    FILESYSTEM=""
    run validate_filesystem
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid FILESYSTEM"* ]]
}

#############################
# validate_encryption_passphrase
#############################
# Called from gather_input's unattended branch. Errors when encryption
# is enabled (NO_ENCRYPT != "yes") but the named passphrase variable
# is empty. Indirect expansion lets one helper cover both ZFS and Btrfs.

@test "validate_encryption_passphrase passes when NO_ENCRYPT=yes regardless of passphrase" {
    NO_ENCRYPT=yes
    ZFS_PASSPHRASE=""
    run validate_encryption_passphrase ZFS_PASSPHRASE
    [ "$status" -eq 0 ]
}

@test "validate_encryption_passphrase errors when NO_ENCRYPT=no and passphrase empty" {
    NO_ENCRYPT=no
    ZFS_PASSPHRASE=""
    run validate_encryption_passphrase ZFS_PASSPHRASE
    [ "$status" -eq 1 ]
    [[ "$output" == *"ZFS_PASSPHRASE"* ]]
    [[ "$output" == *"NO_ENCRYPT=yes"* ]]
}

@test "validate_encryption_passphrase passes when NO_ENCRYPT=no and passphrase set" {
    NO_ENCRYPT=no
    LUKS_PASSPHRASE="hunter2hunter2"
    run validate_encryption_passphrase LUKS_PASSPHRASE
    [ "$status" -eq 0 ]
}

@test "validate_encryption_passphrase names the offending variable in the error" {
    NO_ENCRYPT=no
    LUKS_PASSPHRASE=""
    run validate_encryption_passphrase LUKS_PASSPHRASE
    [ "$status" -eq 1 ]
    [[ "$output" == *"LUKS_PASSPHRASE"* ]]
    ! [[ "$output" == *"ZFS_PASSPHRASE"* ]]
}

@test "validate_encryption_passphrase rejects a passphrase under the minimum length" {
    NO_ENCRYPT=no
    ZFS_PASSPHRASE="welcome"
    run validate_encryption_passphrase ZFS_PASSPHRASE 8
    [ "$status" -eq 1 ]
    [[ "$output" == *"at least 8"* ]]
    [[ "$output" == *"ZFS_PASSPHRASE"* ]]
}

@test "validate_encryption_passphrase accepts a passphrase at exactly the minimum length" {
    NO_ENCRYPT=no
    ZFS_PASSPHRASE="welcome1"
    run validate_encryption_passphrase ZFS_PASSPHRASE 8
    [ "$status" -eq 0 ]
}

@test "validate_encryption_passphrase without a minimum keeps the empty-only check" {
    NO_ENCRYPT=no
    LUKS_PASSPHRASE="hunter2"
    run validate_encryption_passphrase LUKS_PASSPHRASE
    [ "$status" -eq 0 ]
}

@test "validate_encryption_passphrase skips the length check when NO_ENCRYPT=yes" {
    NO_ENCRYPT=yes
    ZFS_PASSPHRASE="short"
    run validate_encryption_passphrase ZFS_PASSPHRASE 8
    [ "$status" -eq 0 ]
}

@test "validate_encryption_passphrase rejects a passphrase over the maximum length" {
    NO_ENCRYPT=no
    ZFS_PASSPHRASE=$(printf 'a%.0s' {1..513})
    run validate_encryption_passphrase ZFS_PASSPHRASE 8 512
    [ "$status" -eq 1 ]
    [[ "$output" == *"at most 512"* ]]
}

@test "validate_encryption_passphrase accepts a passphrase at exactly the maximum length" {
    NO_ENCRYPT=no
    ZFS_PASSPHRASE=$(printf 'a%.0s' {1..512})
    run validate_encryption_passphrase ZFS_PASSPHRASE 8 512
    [ "$status" -eq 0 ]
}

#############################
# SWAP_SIZE validation
#############################

@test "validate_config accepts empty SWAP_SIZE (default layout)" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=""
    run validate_config
    [[ "$output" != *"SWAP_SIZE"* ]]
}

@test "validate_config accepts a well-formed SWAP_SIZE on a single disk" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=100G
    run validate_config
    [[ "$output" != *"Invalid SWAP_SIZE"* ]]
    [[ "$output" != *"single-disk"* ]]
}

@test "validate_config rejects SWAP_SIZE without a unit suffix" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=100
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid SWAP_SIZE"* ]]
}

@test "validate_config rejects SWAP_SIZE with a bogus unit" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=100Q
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid SWAP_SIZE"* ]]
}

@test "validate_config rejects a zero SWAP_SIZE" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=0G
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid SWAP_SIZE"* ]]
}

@test "validate_config rejects a leading-zero SWAP_SIZE" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=00G
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"Invalid SWAP_SIZE"* ]]
}

@test "validate_config warns that swap is unencrypted when encryption is on" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=100G; NO_ENCRYPT=no
    run validate_config
    [[ "$output" == *"unencrypted"* ]]
}

@test "validate_config does not warn about swap encryption when NO_ENCRYPT=yes" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda); RAID_LEVEL=""; SWAP_SIZE=100G; NO_ENCRYPT=yes
    run validate_config
    [[ "$output" != *"unencrypted"* ]]
}

@test "validate_config rejects SWAP_SIZE on a multi-disk layout" {
    HOSTNAME=h; TIMEZONE=UTC; ROOT_PASSWORD=x
    SELECTED_DISKS=(/dev/sda /dev/sdb); RAID_LEVEL=mirror; SWAP_SIZE=100G
    run validate_config
    [ "$status" -eq 1 ]
    [[ "$output" == *"single-disk"* ]]
}