//! Unit tests for the `sizing` module.

use ontoref_compute::sizing::{from_hetzner_name, hetzner_tier, tier_spec, SizeTier};

#[test]
fn next_tier_chain_full() {
    assert_eq!(SizeTier::XS.next(), Some(SizeTier::S));
    assert_eq!(SizeTier::S.next(), Some(SizeTier::M));
    assert_eq!(SizeTier::M.next(), Some(SizeTier::L));
    assert_eq!(SizeTier::L.next(), None);
}

#[test]
fn hetzner_tier_names_match_cax_line() {
    assert_eq!(hetzner_tier(SizeTier::XS), "cax11");
    assert_eq!(hetzner_tier(SizeTier::S), "cax21");
    assert_eq!(hetzner_tier(SizeTier::M), "cax31");
    assert_eq!(hetzner_tier(SizeTier::L), "cax41");
}

#[test]
fn from_hetzner_name_parses_all_known() {
    assert_eq!(from_hetzner_name("cax11"), Some(SizeTier::XS));
    assert_eq!(from_hetzner_name("cax21"), Some(SizeTier::S));
    assert_eq!(from_hetzner_name("cax31"), Some(SizeTier::M));
    assert_eq!(from_hetzner_name("cax41"), Some(SizeTier::L));
}

#[test]
fn from_hetzner_name_unknown_returns_none() {
    assert_eq!(from_hetzner_name("cx11"), None);
    assert_eq!(from_hetzner_name("cax99"), None);
    assert_eq!(from_hetzner_name(""), None);
}

#[test]
fn tier_spec_vcpus_and_memory_are_ordered() {
    let xs = tier_spec(SizeTier::XS);
    let s = tier_spec(SizeTier::S);
    let m = tier_spec(SizeTier::M);
    let l = tier_spec(SizeTier::L);

    assert!(xs.vcpus < s.vcpus, "XS vcpus < S vcpus");
    assert!(s.vcpus < m.vcpus, "S vcpus < M vcpus");
    assert!(m.vcpus < l.vcpus, "M vcpus < L vcpus");

    assert!(xs.memory_mb < s.memory_mb, "XS mem < S mem");
    assert!(s.memory_mb < m.memory_mb, "S mem < M mem");
    assert!(m.memory_mb < l.memory_mb, "M mem < L mem");
}

#[test]
fn from_cpu_memory_finds_smallest_fitting_tier() {
    assert_eq!(SizeTier::from_cpu_memory(1, 512), Some(SizeTier::XS));
    assert_eq!(SizeTier::from_cpu_memory(2, 4_096), Some(SizeTier::XS));
    assert_eq!(SizeTier::from_cpu_memory(3, 4_096), Some(SizeTier::S));
    assert_eq!(SizeTier::from_cpu_memory(8, 16_384), Some(SizeTier::M));
    assert_eq!(SizeTier::from_cpu_memory(16, 32_768), Some(SizeTier::L));
    // Exceeds largest tier.
    assert_eq!(SizeTier::from_cpu_memory(32, 64_000), None);
}

#[test]
fn hetzner_roundtrip_via_free_fns() {
    for tier in [SizeTier::XS, SizeTier::S, SizeTier::M, SizeTier::L] {
        let name = hetzner_tier(tier);
        assert_eq!(from_hetzner_name(name), Some(tier));
    }
}