open-net 0.3.5

A cross-platform async networking library for Rust with HTTP and WebSocket clients, network status monitoring, configurable retries, WebSocket reconnection and heartbeats, and managed client lifecycles. Reuse common networking infrastructure across applications to avoid repeated implementation and debugging, helping save development time and AI coding tokens.
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(())
}