provisioning-catalog/providers/hetzner/tests/unit/test_utils.nu

#!/usr/bin/env nu

# Hetzner provider utilities unit tests
use ../../nulib/hetzner/utils.nu *

# Test framework
def test-assert [condition: bool, message: string]: nothing -> null {
    if (not $condition) {
        error make {msg: $"Test failed: ($message)"}
    }
    null
}

def test-result [name: string, passed: bool]: nothing -> record {
    if $passed {
        print $"✓ ($name)"
    } else {
        print $"✗ ($name)"
    }
    {name: $name, passed: $passed}
}

# Test: parse_server_identifier with string
def test_parse_server_identifier_string []: nothing -> record {
    let result = (parse_server_identifier "test-server")
    let passed = ($result == "test-server")
    test-result "parse_server_identifier: string input" $passed
}

# Test: parse_server_identifier with hostname record
def test_parse_server_identifier_hostname []: nothing -> record {
    let server = {hostname: "my-server", id: 123}
    let result = (parse_server_identifier $server)
    let passed = ($result == "my-server")
    test-result "parse_server_identifier: hostname field" $passed
}

# Test: parse_server_identifier with name record
def test_parse_server_identifier_name []: nothing -> record {
    let server = {name: "server-name", id: 456}
    let result = (parse_server_identifier $server)
    let passed = ($result == "server-name")
    test-result "parse_server_identifier: name field" $passed
}

# Test: parse_server_identifier with id record
def test_parse_server_identifier_id []: nothing -> record {
    let server = {id: 789}
    let result = (parse_server_identifier $server)
    let passed = ($result == "789")
    test-result "parse_server_identifier: id field" $passed
}

# Test: is_valid_ipv4 valid address
def test_is_valid_ipv4_valid []: nothing -> record {
    let result = (is_valid_ipv4 "192.0.2.1")
    test-result "is_valid_ipv4: valid address" $result
}

# Test: is_valid_ipv4 invalid address
def test_is_valid_ipv4_invalid []: nothing -> record {
    let result = (is_valid_ipv4 "999.999.999.999")
    let passed = (not $result)
    test-result "is_valid_ipv4: invalid address" $passed
}

# Test: is_valid_ipv4 malformed
def test_is_valid_ipv4_malformed []: nothing -> record {
    let result = (is_valid_ipv4 "not.an.ip.address")
    let passed = (not $result)
    test-result "is_valid_ipv4: malformed" $passed
}

# Test: is_valid_ipv6 valid address
def test_is_valid_ipv6_valid []: nothing -> record {
    let result = (is_valid_ipv6 "2001:db8::1")
    test-result "is_valid_ipv6: valid address" $result
}

# Test: is_valid_ipv6 invalid address
def test_is_valid_ipv6_invalid []: nothing -> record {
    let result = (is_valid_ipv6 "gggg::1")
    let passed = (not $result)
    test-result "is_valid_ipv6: invalid address" $passed
}

# Test: extract_api_error from error field
def test_extract_api_error_error_field []: nothing -> record {
    let response = {error: {message: "API Error"}}
    let result = (extract_api_error $response)
    let passed = ($result == "API Error")
    test-result "extract_api_error: from error.message" $passed
}

# Test: extract_api_error from message field
def test_extract_api_error_message_field []: nothing -> record {
    let response = {message: "Direct message"}
    let result = (extract_api_error $response)
    let passed = ($result == "Direct message")
    test-result "extract_api_error: from message" $passed
}

# Test: extract_api_error fallback
def test_extract_api_error_fallback []: nothing -> record {
    let response = {data: "some data"}
    let result = (extract_api_error $response)
    let passed = ($result != "")
    test-result "extract_api_error: fallback to string" $passed
}

# Test: validate_server_config valid
def test_validate_server_config_valid []: nothing -> record {
    let server = {hostname: "test", server_type: "cx11", location: "fsn1"}
    let result = (validate_server_config $server)
    test-result "validate_server_config: valid config" $result
}

# Test: validate_server_config missing fields
def test_validate_server_config_missing []: nothing -> record {
    let server = {hostname: "test"}
    let result = (do { validate_server_config $server } | complete)
    let passed = ($result.exit_code != 0)
    test-result "validate_server_config: missing fields" $passed
}

# Test: validate_server_config empty hostname
def test_validate_server_config_empty_hostname []: nothing -> record {
    let server = {hostname: "", server_type: "cx11", location: "fsn1"}
    let result = (do { validate_server_config $server } | complete)
    let passed = ($result.exit_code != 0)
    test-result "validate_server_config: empty hostname" $passed
}

# Main test runner
def main []: nothing -> record {
    print "=== Hetzner Provider Unit Tests ==="
    print ""

    # Run all tests and collect results
    let results = [
        (test_parse_server_identifier_string)
        (test_parse_server_identifier_hostname)
        (test_parse_server_identifier_name)
        (test_parse_server_identifier_id)
        (test_is_valid_ipv4_valid)
        (test_is_valid_ipv4_invalid)
        (test_is_valid_ipv4_malformed)
        (test_is_valid_ipv6_valid)
        (test_is_valid_ipv6_invalid)
        (test_extract_api_error_error_field)
        (test_extract_api_error_message_field)
        (test_extract_api_error_fallback)
        (test_validate_server_config_valid)
        (test_validate_server_config_missing)
        (test_validate_server_config_empty_hostname)
    ]

    print ""
    print "Test Summary:"
    print "============="

    let passed = ($results | where {|r| $r.passed} | length)
    let failed = ($results | where {|r| not $r.passed} | length)
    let total = ($results | length)

    print $"Passed: ($passed)/$total"
    print $"Failed: ($failed)/$total"

    {passed: $passed, failed: $failed, total: $total}
}