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
//! V2 contract regression tests; fixtures construct native session authorities.
use crate::error::ErrorKind;
use crate::module::ws_client::{
    test_support::{check, check_eq, test_error, TestResult},
    v2_test_support as fixture,
};
use crate::ws::*;
use std::sync::Arc;
use std::time::{Duration, Instant};

#[tokio::test]
async fn expired_absolute_and_registration_deadlines_reject_before_queue_or_pending() -> TestResult
{
    let runtime = fixture::runtime(
        WebSocketClientConfig::default(),
        ResponseRouting::Manual,
        true,
    )
    .await?;
    let deadline = Instant::now();
    let error = fixture::sender(&runtime)
        .message("body")
        .options(SendOptions {
            deadline: Some(deadline),
            ..Default::default()
        })
        .try_enqueue()
        .err()
        .ok_or_else(|| test_error("expired message admitted"))?;
    check_eq!(error.error().kind(), ErrorKind::TimedOut)?;
    for registration in [true, false] {
        let mut options = RequestOptions::default();
        if registration {
            options.registration_deadline = Some(deadline);
        } else {
            options.send.deadline = Some(deadline);
        }
        let error = fixture::requests(&runtime)
            .request(fixture::request("expired")?)
            .options(options)
            .try_prepare()
            .err()
            .ok_or_else(|| test_error("expired request admitted"))?;
        check_eq!(error.error().kind(), ErrorKind::TimedOut)?;
    }
    check!(runtime.pending.snapshot()?.is_empty())?;
    check!(runtime.queue.try_next().is_none())?;
    Ok(())
}
#[tokio::test]
async fn enqueue_timeout_is_typed_and_does_not_cancel_the_admitted_owner() -> TestResult {
    let mut config = WebSocketClientConfig::default();
    config.queues.normal.max_items = 1;
    let runtime = fixture::runtime(config, ResponseRouting::Disabled, true).await?;
    let sender = fixture::sender(&runtime);
    let first = sender.try_enqueue("first").map_err(|e| e.into_error())?;
    let result = fixture::bounded(
        sender
            .message("waiting")
            .options(SendOptions {
                enqueue_timeout: Some(Duration::from_millis(10)),
                ..Default::default()
            })
            .enqueue(),
    )
    .await?;
    check_eq!(
        result.err().map(|e| e.error().kind()),
        Some(ErrorKind::TimedOut)
    )?;
    check!(first.state()?.result.is_none())?;
    first.cancel()?;
    check!(sender.try_enqueue("after").is_ok())?;
    Ok(())
}
#[tokio::test]
async fn registered_and_written_response_origins_start_at_different_stages() -> TestResult {
    for origin in [
        ResponseTimeoutOrigin::Registered,
        ResponseTimeoutOrigin::Written,
    ] {
        let runtime = fixture::runtime(
            WebSocketClientConfig::default(),
            ResponseRouting::Manual,
            true,
        )
        .await?;
        let receipt = fixture::requests(&runtime)
            .request(fixture::request("origin")?)
            .options(RequestOptions {
                response_timeout_origin: origin,
                ..Default::default()
            })
            .try_enqueue()
            .map_err(|e| e.into_error())?;
        let handle = receipt.handle();
        check_eq!(
            handle.registration().response_deadline()?.is_some(),
            origin == ResponseTimeoutOrigin::Registered
        )?;
        let queued = runtime
            .queue
            .try_next()
            .ok_or_else(|| test_error("request absent"))?;
        check!(queued
            .dispatch_phase
            .mark_writing(ConnectionId::from_allocated(1)))?;
        runtime
            .pending
            .bind_connection(handle.registration(), ConnectionId::from_allocated(1))?;
        queued.complete(Ok(()));
        check!(handle.registration().response_deadline()?.is_some())?;
        check_eq!(handle.written().await?, WriteOutcome::Written)?;
        handle.cancel()?;
    }
    Ok(())
}
#[tokio::test]
async fn pending_timer_resolves_response_timeout_and_releases_capacity() -> TestResult {
    let runtime = fixture::runtime(
        WebSocketClientConfig::default(),
        ResponseRouting::Manual,
        true,
    )
    .await?;
    let shutdown = tokio_util::sync::CancellationToken::new();
    let timer = tokio::spawn(
        crate::module::ws_client::native_pending::NativePending::run_timers(
            Arc::downgrade(&runtime.pending),
            shutdown.clone(),
        ),
    );
    let receipt = fixture::requests(&runtime)
        .request(fixture::request("timer")?)
        .options(RequestOptions {
            response_timeout: Duration::from_millis(10),
            response_timeout_origin: ResponseTimeoutOrigin::Registered,
            ..Default::default()
        })
        .try_enqueue()
        .map_err(|e| e.into_error())?;
    check_eq!(
        fixture::bounded(receipt.response())
            .await?
            .err()
            .map(|e| e.kind()),
        Some(ErrorKind::TimedOut)
    )?;
    check!(runtime.pending.snapshot()?.is_empty())?;
    check!(runtime.queue.try_next().is_none())?;
    shutdown.cancel();
    fixture::bounded(timer).await??;
    Ok(())
}