#!/usr/bin/env nu

# Unit tests for AWS utility functions

use std assert

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

# Test: Validate instance ID format
def test-validate-instance-id [] {
   let valid_id = "i-1234567890abcdef0"
   let invalid_id = "invalid-id"

   let test1 = (test-result "parse_instance_id: valid format" ($valid_id | str contains "i-" and ($valid_id | str length) > 2))
   let test2 = (test-result "parse_instance_id: invalid format" (($invalid_id | str contains "i-") == false))

   $test1 and $test2
}

# Test: Extract IP address from string
def test-extract-ip [] {
   let with_ip = "Instance 10.0.1.100 running"
   let without_ip = "No IP address"

   let test1 = (test-result "extract_ip_address: IPv4 present" ($with_ip | str contains "10.0.1.100"))
   let test2 = (test-result "extract_ip_address: IPv4 absent" (($without_ip | str contains ".") == false))

   $test1 and $test2
}

# Test: Validate IPv4 format
def test-validate-ipv4 [] {
   let valid = "10.0.1.100"
   let invalid = "256.256.256.256"

   let test1 = (test-result "validate_ipv4: valid address" ((($valid | split row ".") | length) == 4))
   let test2 = (test-result "validate_ipv4: invalid address" ((($invalid | split row ".") | length) == 4))

   $test1 and $test2
}

# Test: Validate instance type format
def test-validate-instance-type [] {
   let valid_types = ["t3.micro" "t3.small" "m5.large" "c5.xlarge"]
   let invalid_type = "invalid_type"

   let test1 = (test-result "validate_instance_type: t3.micro" (($valid_types | contains ["t3.micro"])))
   let test2 = (test-result "validate_instance_type: invalid" (($valid_types | contains [$invalid_type]) == false))

   $test1 and $test2
}

# Test: Validate availability zone format
def test-validate-availability-zone [] {
   let valid_zones = ["us-east-1a" "us-east-1b" "us-west-2a" "eu-west-1a"]
   let invalid_zone = "invalid-zone"

   let test1 = (test-result "validate_zone: us-east-1a" (($valid_zones | contains ["us-east-1a"])))
   let test2 = (test-result "validate_zone: invalid" (($valid_zones | contains [$invalid_zone]) == false))

   $test1 and $test2
}

# Test: Validate volume ID format
def test-validate-volume-id [] {
   let valid_vol = "vol-12345678"
   let invalid_vol = "invalid-vol"

   let test1 = (test-result "parse_volume_id: valid format" ($valid_vol | str contains "vol-" and ($valid_vol | str length) > 4))
   let test2 = (test-result "parse_volume_id: invalid format" (($invalid_vol | str contains "vol-") == false))

   $test1 and $test2
}

# Test: Validate volume state
def test-validate-volume-state [] {
   let valid_states = ["creating" "available" "in-use" "deleting" "deleted" "error"]
   let invalid_state = "pending"

   let test1 = (test-result "validate_volume_state: available" (($valid_states | contains ["available"])))
   let test2 = (test-result "validate_volume_state: in-use" (($valid_states | contains ["in-use"])))
   let test3 = (test-result "validate_volume_state: invalid" (($valid_states | contains [$invalid_state]) == false))

   $test1 and $test2 and $test3
}

# Test: Validate CIDR block format
def test-validate-cidr-block [] {
   let valid_cidr = "10.0.0.0/16"
   let invalid_cidr = "10.0.0.1"

   let test1 = (test-result "validate_cidr_block: valid 10.0.0.0/16" ($valid_cidr | str contains "/"))
   let test2 = (test-result "validate_cidr_block: invalid format" (($invalid_cidr | str contains "/") == false))

   $test1 and $test2
}

# Test: Validate volume type
def test-validate-volume-type [] {
   let valid_types = ["gp2" "gp3" "io1" "io2" "st1" "sc1" "standard"]
   let invalid_type = "invalid-type"

   let test1 = (test-result "validate_volume_type: gp3" (($valid_types | contains ["gp3"])))
   let test2 = (test-result "validate_volume_type: io1" (($valid_types | contains ["io1"])))
   let test3 = (test-result "validate_volume_type: invalid" (($valid_types | contains [$invalid_type]) == false))

   $test1 and $test2 and $test3
}

# Test: Parse timestamp format
def test-parse-timestamp [] {
   let valid_timestamp = "2025-01-07T10:00:00.000Z"
   let invalid_timestamp = "not-a-timestamp"

   let test1 = (test-result "timestamp_parsing: valid ISO 8601" ($valid_timestamp | str contains "T" and $valid_timestamp | str contains "Z"))
   let test2 = (test-result "timestamp_parsing: invalid format" (($invalid_timestamp | str contains "T") == false))

   $test1 and $test2
}

# Test: Validate server state
def test-validate-server-state [] {
   let valid_states = ["pending" "running" "shutting-down" "terminated" "stopping" "stopped"]
   let invalid_state = "hibernating"

   let test1 = (test-result "validate_server_state: running" (($valid_states | contains ["running"])))
   let test2 = (test-result "validate_server_state: stopped" (($valid_states | contains ["stopped"])))
   let test3 = (test-result "validate_server_state: invalid" (($valid_states | contains [$invalid_state]) == false))

   $test1 and $test2 and $test3
}

# Test: Parse security group ID
def test-parse-security-group-id [] {
   let valid_sg = "sg-12345678"
   let invalid_sg = "invalid-sg"

   let test1 = (test-result "parse_security_group_id: valid format" ($valid_sg | str contains "sg-" and ($valid_sg | str length) > 3))
   let test2 = (test-result "parse_security_group_id: invalid format" (($invalid_sg | str contains "sg-") == false))

   $test1 and $test2
}

# Test: Validate memory amount
def test-validate-memory-amount [] {
   let valid_mems = ["512 MB" "1 GB" "2 GB" "4 GB" "8 GB" "16 GB"]
   let invalid_mem = "0 GB"

   let test1 = (test-result "validate_memory_amount: 1 GB" (($valid_mems | contains ["1 GB"])))
   let test2 = (test-result "validate_memory_amount: 4 GB" (($valid_mems | contains ["4 GB"])))
   let test3 = (test-result "validate_memory_amount: 0 GB invalid" (($valid_mems | contains [$invalid_mem]) == false))

   $test1 and $test2 and $test3
}

# Test: Validate vCPU count
def test-validate-vcpu-count [] {
   let valid_cpus = [1, 2, 4, 8, 16, 32]
   let invalid_cpu = 0

   let test1 = (test-result "validate_cpu_count: 1 vCPU" (($valid_cpus | contains [1])))
   let test2 = (test-result "validate_cpu_count: 4 vCPU" (($valid_cpus | contains [4])))
   let test3 = (test-result "validate_cpu_count: 0 vCPU invalid" (($valid_cpus | contains [$invalid_cpu]) == false))

   $test1 and $test2 and $test3
}

# Main test execution
def main [] {
   print "=== AWS Unit Tests ==="
   print ""

   let results = [
      (test-validate-instance-id),
      (test-extract-ip),
      (test-validate-ipv4),
      (test-validate-instance-type),
      (test-validate-availability-zone),
      (test-validate-volume-id),
      (test-validate-volume-state),
      (test-validate-cidr-block),
      (test-validate-volume-type),
      (test-parse-timestamp),
      (test-validate-server-state),
      (test-parse-security-group-id),
      (test-validate-memory-amount),
      (test-validate-vcpu-count)
   ]

   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