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

#!/usr/bin/env nu

# Demo provider unit tests

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

def test-instance-id-format [] {
    let valid = "srv-001"
    let invalid = "invalid"

    let t1 = (test-result "Instance ID valid" ($valid | str contains "srv-"))
    let t2 = (test-result "Instance ID invalid" (($invalid | str contains "srv-") == false))

    $t1 and $t2
}

def test-volume-id-format [] {
    let valid = "vol-001"
    let invalid = "invalid"

    let t1 = (test-result "Volume ID valid" ($valid | str contains "vol-"))
    let t2 = (test-result "Volume ID invalid" (($invalid | str contains "vol-") == false))

    $t1 and $t2
}

def test-network-id-format [] {
    let valid = "net-001"
    let invalid = "invalid"

    let t1 = (test-result "Network ID valid" ($valid | str contains "net-"))
    let t2 = (test-result "Network ID invalid" (($invalid | str contains "net-") == false))

    $t1 and $t2
}

def test-zone-format [] {
    let zone_value = "us-west-1"
    let has_dash = ($zone_value | str contains "-")

    test-result "Zone format valid" $has_dash
}

def test-instance-type-format [] {
    let type_value = "small"
    let is_valid = ($type_value | str length) > 0

    test-result "Instance type format" $is_valid
}

def test-volume-type-format [] {
    let type_value = "standard"
    let is_valid = ($type_value | str length) > 0

    test-result "Volume type format" $is_valid
}

def test-size-validation [] {
    let size = 100
    let is_positive = $size > 0

    test-result "Size validation positive" $is_positive
}

def test-price-validation [] {
    let price = 0.10
    let is_positive = $price > 0

    test-result "Price validation positive" $is_positive
}

def test-cidr-format [] {
    let valid = "10.0.0.0/16"
    let has_slash = ($valid | str contains "/")

    test-result "CIDR format valid" $has_slash
}

def test-ipv4-format [] {
    let ip = "10.0.1.100"
    let parts = ($ip | split row ".")
    let has_four = ($parts | length) == 4

    test-result "IPv4 four octets" $has_four
}

def test-status-validation [] {
    let status = "running"
    let is_valid = ($status | str length) > 0

    test-result "Status validation" $is_valid
}

def test-memory-format [] {
    let memory = "1 GB"
    let has_gb = ($memory | str contains "GB")

    test-result "Memory format valid" $has_gb
}

def test-cpu-count [] {
    let cpu = 2
    let is_valid = $cpu > 0

    test-result "CPU count valid" $is_valid
}

def test-timestamp-format [] {
    let timestamp = "2025-01-07T10:00:00Z"
    let has_t = ($timestamp | str contains "T")
    let has_z = ($timestamp | str contains "Z")

    test-result "Timestamp ISO8601 format" ($has_t and $has_z)
}

def main [] {
    print "=== Unit Tests ==="
    print ""

    let results = [
        (test-instance-id-format),
        (test-volume-id-format),
        (test-network-id-format),
        (test-zone-format),
        (test-instance-type-format),
        (test-volume-type-format),
        (test-size-validation),
        (test-price-validation),
        (test-cidr-format),
        (test-ipv4-format),
        (test-status-validation),
        (test-memory-format),
        (test-cpu-count),
        (test-timestamp-format)
    ]

    let passed = ($results | where {|it| $it == true} | length)
    let failed = ($results | where {|it| $it == false} | length)

    print ""
    print $"Test Results: ($passed) passed, ($failed) failed"

    {
        passed: $passed,
        failed: $failed,
        total: ($passed + $failed)
    }
}

main