provisioning-catalog/providers/upcloud/tests/integration/test_server_lifecycle.nu

#!/usr/bin/env nu

# UpCloud provider server lifecycle integration tests (with mocks)

# Mock API responses loader
def load-mock-responses []: nothing -> record {
    let mocks = (open ../../tests/mocks/mock_api_responses.json)
    $mocks
}

# Mock: list servers
def mock-list-servers []: nothing -> list {
    let mocks = (load-mock-responses)
    $mocks.servers_list.servers
}

# Mock: get server info
def mock-server-info [hostname: string]: nothing -> record {
    let mocks = (load-mock-responses)
    # For testing, return first server if exists
    if ($hostname == "test-server-1") {
        $mocks.server_info.server
    } else {
        error make {msg: $"Server not found: ($hostname)"}
    }
}

# Mock: create server
def mock-create-server [name: string]: nothing -> record {
    let mocks = (load-mock-responses)
    $mocks.server_create_success.server
}

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

# Test: List servers
def test_list_servers []: nothing -> record {
    let result = (do {
        let servers = (mock-list-servers)
        ($servers | length) > 0
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "list_servers: returns list" $passed
}

# Test: Server info structure
def test_server_info_structure []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        ($server | has uuid) and ($server | has hostname) and ($server | has state)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "server_info: has required fields" $passed
}

# Test: Server hostname field
def test_server_hostname_field []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        $server.hostname
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout == "test-server-1")
    test-result "server_info: hostname matches request" $passed
}

# Test: Server state field
def test_server_state_field []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        $server.state
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout == "started")
    test-result "server_info: state is started" $passed
}

# Test: Server public IPs
def test_server_public_ips []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        {
            has_interfaces: ($server | has networking)
            has_interfaces_data: ($server.networking.interfaces? | default [] | length) > 0
        }
    } | complete)

    let passed = ($result.exit_code == 0)
    test-result "server_info: public IPs present" $passed
}

# Test: Server plan information
def test_server_plan_info []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        {
            name: ($server.plan | default "")
            cores: ($server.cpu_count | default 0)
            memory: ($server.memory_amount | default 0)
        }
    } | complete)

    let passed = ($result.exit_code == 0)
    test-result "server_info: plan details available" $passed
}

# Test: Create server response structure
def test_create_server_response []: nothing -> record {
    let result = (do {
        let server = (mock-create-server "new-test-server")
        {
            has_uuid: ($server | has uuid)
            has_hostname: ($server | has hostname)
            has_state: ($server | has state)
        }
    } | complete)

    let passed = ($result.exit_code == 0 and
                  $result.stdout.has_uuid and
                  $result.stdout.has_hostname and
                  $result.stdout.has_state)
    test-result "create_server: response has required fields" $passed
}

# Test: Server not found error
def test_server_not_found_error []: nothing -> record {
    let result = (do { mock-server-info "nonexistent-server" } | complete)
    let passed = ($result.exit_code != 0)
    test-result "server_info: error on nonexistent server" $passed
}

# Test: List servers count
def test_list_servers_count []: nothing -> record {
    let result = (do {
        let servers = (mock-list-servers)
        $servers | length
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout > 0)
    test-result "list_servers: contains servers" $passed
}

# Test: Server zone information
def test_server_zone_info []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        {
            has_zone: ($server | has zone)
            zone_value: ($server.zone? | default "")
        }
    } | complete)

    let passed = ($result.exit_code == 0 and
                  $result.stdout.has_zone and
                  ($result.stdout.zone_value | str length) > 0)
    test-result "server_info: zone data complete" $passed
}

# Test: Storage device information
def test_server_storage_info []: nothing -> record {
    let result = (do {
        let server = (mock-server-info "test-server-1")
        {
            has_storage: ($server | has storage_devices)
            storage_count: ($server.storage_devices? | default [] | length)
        }
    } | complete)

    let passed = ($result.exit_code == 0 and
                  $result.stdout.has_storage and
                  $result.stdout.storage_count >= 0)
    test-result "server_info: storage devices present" $passed
}

# Main test runner
def main []: nothing -> record {
    print "=== UpCloud Provider Server Lifecycle Tests (Mock Mode) ==="
    print ""

    let results = [
        (test_list_servers)
        (test_server_info_structure)
        (test_server_hostname_field)
        (test_server_state_field)
        (test_server_public_ips)
        (test_server_plan_info)
        (test_create_server_response)
        (test_server_not_found_error)
        (test_list_servers_count)
        (test_server_zone_info)
        (test_server_storage_info)
    ]

    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}
}