open-net 0.3.2

A cross-platform async networking library with WebSocket clients and network status monitoring.
Documentation
use super::{BackoffConfig, ReconnectPolicy};
use crate::error::{ErrorKind, ErrorStage};
use std::time::Duration;

type TestResult = std::result::Result<(), crate::BoxError>;

fn invalid(result: crate::Result<()>, field: &str) -> TestResult {
    let error = result
        .err()
        .ok_or_else(|| format!("accepted invalid {field}"))?;
    if error.kind() != ErrorKind::InvalidConfig
        || error.context().stage != Some(ErrorStage::Configuration)
        || error.config_error().map(|detail| detail.field()) != Some(field)
        || error
            .config_error()
            .is_none_or(|detail| detail.reason().is_empty())
    {
        return Err(format!("incorrect validation details for {field}: {error:?}").into());
    }
    Ok(())
}

#[test]
fn default_backoff_preserves_existing_retry_values() -> TestResult {
    let policy = ReconnectPolicy::default();
    policy.validate()?;
    let ReconnectPolicy::Backoff(config) = policy.clone() else {
        return Err("default reconnect policy is disabled".into());
    };
    for actual in [config, BackoffConfig::default()] {
        actual.validate()?;
        if actual.max_retries != 6
            || actual.initial_delay != Duration::from_millis(250)
            || actual.max_delay != Duration::from_secs(8)
            || actual.max_elapsed != Some(Duration::from_secs(30))
        {
            return Err("default reconnect policy values changed".into());
        }
    }
    if !format!("{policy:?}").contains("Backoff") {
        return Err("reconnect policy Debug lost its variant".into());
    }
    Ok(())
}

#[test]
fn unlimited_backoff_removes_only_retry_count_and_elapsed_limits() -> TestResult {
    let config = BackoffConfig::unlimited();
    config.validate()?;
    if config.max_retries != usize::MAX
        || config.initial_delay != Duration::from_millis(250)
        || config.max_delay != Duration::from_secs(8)
        || config.max_elapsed.is_some()
    {
        return Err("unlimited backoff changed the default delay caps or kept a limit".into());
    }
    Ok(())
}

#[test]
fn long_running_policy_is_valid_unlimited_backoff() -> TestResult {
    let policy = ReconnectPolicy::long_running();
    policy.validate()?;
    let ReconnectPolicy::Backoff(config) = policy else {
        return Err("long-running policy did not select backoff".into());
    };
    if config.max_retries != usize::MAX || config.max_elapsed.is_some() {
        return Err("long-running policy retained a retry limit".into());
    }
    Ok(())
}

#[test]
fn disabled_policy_has_no_ignored_backoff_values() -> TestResult {
    let policy = ReconnectPolicy::Disabled;
    policy.validate()?;
    if !matches!(policy.clone(), ReconnectPolicy::Disabled) {
        return Err("cloning disabled policy changed its variant".into());
    }
    Ok(())
}

#[test]
fn every_backoff_duration_rejects_zero_and_unrepresentable_values() -> TestResult {
    type Edit = fn(&mut BackoffConfig, Duration);
    let cases: &[(&str, Edit)] = &[
        ("reconnect.initial_delay", |config, value| {
            config.initial_delay = value
        }),
        ("reconnect.max_delay", |config, value| {
            config.max_delay = value
        }),
        ("reconnect.max_elapsed", |config, value| {
            config.max_elapsed = Some(value)
        }),
    ];
    for (field, edit) in cases {
        for duration in [Duration::ZERO, Duration::MAX] {
            let mut config = BackoffConfig::default();
            edit(&mut config, duration);
            invalid(config.validate(), field)?;
            invalid(ReconnectPolicy::Backoff(config).validate(), field)?;
        }
    }
    Ok(())
}

#[test]
fn maximum_delay_must_not_precede_initial_delay() -> TestResult {
    let mut config = BackoffConfig::default();
    config.initial_delay = Duration::from_secs(3);
    config.max_delay = Duration::from_secs(2);
    invalid(config.validate(), "reconnect.max_delay")?;
    config.max_delay = config.initial_delay;
    config.validate()?;
    Ok(())
}

#[test]
fn zero_retries_does_not_hide_invalid_backoff_fields() -> TestResult {
    let mut config = BackoffConfig::default();
    config.max_retries = 0;
    config.validate()?;
    for (initial_delay, max_delay, field) in [
        (
            Duration::ZERO,
            Duration::from_secs(1),
            "reconnect.initial_delay",
        ),
        (
            Duration::from_secs(1),
            Duration::ZERO,
            "reconnect.max_delay",
        ),
        (
            Duration::from_secs(2),
            Duration::from_secs(1),
            "reconnect.max_delay",
        ),
    ] {
        config.initial_delay = initial_delay;
        config.max_delay = max_delay;
        invalid(config.validate(), field)?;
    }
    Ok(())
}

#[test]
fn absent_cycle_budget_and_large_retry_count_add_no_extra_limits() -> TestResult {
    let config = BackoffConfig {
        max_retries: usize::MAX,
        initial_delay: Duration::from_nanos(1),
        max_delay: Duration::from_nanos(1),
        max_elapsed: None,
    };
    config.validate()?;
    ReconnectPolicy::Backoff(config.clone()).validate()?;
    if config.max_retries != usize::MAX
        || config.initial_delay != Duration::from_nanos(1)
        || config.max_delay != Duration::from_nanos(1)
        || config.max_elapsed.is_some()
    {
        return Err("validation changed borrowed backoff values".into());
    }
    Ok(())
}