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::*;
use crate::error::{ReceiveError, TryReceiveError};
use futures::{executor::block_on, task::noop_waker_ref, Stream};
use std::collections::VecDeque;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

type TestResult<T = ()> = std::result::Result<T, crate::BoxError>;
fn check(value: bool, message: &str) -> TestResult {
    if value {
        Ok(())
    } else {
        Err(std::io::Error::other(message).into())
    }
}
#[derive(Default)]
struct ManualExecutor {
    jobs: Mutex<VecDeque<Box<dyn FnOnce() + Send>>>,
}
impl CallbackExecutor for ManualExecutor {
    fn ensure_ready(&self) -> Result<()> {
        Ok(())
    }
    fn submit(&self, job: Box<dyn FnOnce() + Send>) -> Result<()> {
        self.jobs
            .lock()
            .map_err(NetError::from_poison)?
            .push_back(job);
        Ok(())
    }
}
impl ManualExecutor {
    fn next(&self) -> TestResult<Option<Box<dyn FnOnce() + Send>>> {
        Ok(self
            .jobs
            .lock()
            .map_err(|_| std::io::Error::other("executor lock"))?
            .pop_front())
    }
    fn drain(&self) -> TestResult {
        while let Some(job) = self.next()? {
            job();
        }
        Ok(())
    }
}
fn channel<T>(
    items: usize,
    bytes: usize,
    policy: EventOverflow,
) -> TestResult<(EventPublisher<T>, EventReceiver<T>, Arc<ManualExecutor>)> {
    let executor = Arc::new(ManualExecutor::default());
    let (publisher, receiver) = event_channel(
        EventQueueLimit {
            max_items: items,
            max_bytes: bytes,
        },
        policy,
        executor.clone(),
        None,
    )?;
    Ok((publisher, receiver, executor))
}

#[test]
fn non_clone_events_move_in_order_and_publisher_drop_finishes_the_stream() -> TestResult {
    struct Owned(u32);
    let (publisher, mut receiver, _) = channel(2, 8, EventOverflow::Wait)?;
    check(
        matches!(receiver.try_recv(), Err(TryReceiveError::Empty)),
        "empty queue was closed",
    )?;
    publisher.try_publish(Owned(7), 4)?;
    publisher.try_publish(Owned(8), 4)?;
    drop(publisher);
    let first = receiver.try_recv()?;
    check(first.0 == 7, "first owned event changed")?;
    let mut cx = Context::from_waker(noop_waker_ref());
    check(
        matches!(
            Pin::new(&mut receiver).poll_next(&mut cx),
            Poll::Ready(Some(Ok(Owned(8))))
        ),
        "Stream lost remaining owned event",
    )?;
    check(
        block_on(receiver.recv())?.is_none(),
        "publisher drop did not finish",
    )?;
    check(
        matches!(receiver.try_recv(), Err(TryReceiveError::Closed)),
        "EOF was not fused",
    )
}

#[test]
fn oldest_overflow_reports_exact_prefix_lag_and_preserves_newer_items() -> TestResult {
    let (publisher, mut receiver, _) = channel(4, 8, EventOverflow::DropOldest)?;
    publisher.try_publish(1, 2)?;
    publisher.try_publish(2, 2)?;
    publisher.try_publish(3, 2)?;
    publisher.try_publish(4, 2)?;
    publisher.try_publish(5, 6)?;
    check(
        matches!(
            receiver.try_recv(),
            Err(TryReceiveError::Lagged { skipped: 3 })
        ),
        "byte eviction did not report exact lag",
    )?;
    check(receiver.try_recv()? == 4, "oldest retained event missing")?;
    publisher.try_publish(6, 6)?;
    check(
        matches!(
            block_on(receiver.recv()),
            Err(ReceiveError::Lagged { skipped: 1 })
        ),
        "second gap was merged across delivered item",
    )?;
    check(receiver.try_recv()? == 6, "latest event missing")?;
    check(
        matches!(receiver.try_recv(), Err(TryReceiveError::Empty)),
        "Lagged repeated",
    )
}

#[test]
fn pending_receive_cancellation_does_not_take_a_woken_event() -> TestResult {
    let (publisher, mut receiver, _) = channel(1, 4, EventOverflow::Wait)?;
    let mut pending = Box::pin(receiver.recv());
    let mut cx = Context::from_waker(noop_waker_ref());
    check(
        pending.as_mut().poll(&mut cx).is_pending(),
        "empty recv completed",
    )?;
    publisher.try_publish(7, 4)?;
    drop(pending);
    check(receiver.try_recv()? == 7, "cancelled recv stole event")
}

#[test]
fn reliable_publish_waits_for_both_budgets_and_unsubscribe_releases_waiters() -> TestResult {
    let (publisher, mut receiver, _) = channel(2, 4, EventOverflow::Wait)?;
    publisher.try_publish(1, 4)?;
    let mut waiting = Box::pin(publisher.publish(2, 1));
    let mut cx = Context::from_waker(noop_waker_ref());
    check(
        waiting.as_mut().poll(&mut cx).is_pending(),
        "byte limit did not backpressure",
    )?;
    check(receiver.try_recv()? == 1, "queued value missing")?;
    check(
        matches!(waiting.as_mut().poll(&mut cx), Poll::Ready(Ok(()))),
        "space did not resume publisher",
    )?;
    drop(waiting);
    let mut waiting = Box::pin(publisher.publish(3, 4));
    check(
        waiting.as_mut().poll(&mut cx).is_pending(),
        "second byte limit did not backpressure",
    )?;
    check(receiver.unsubscribe(), "unsubscribe was ineffective")?;
    check(
        matches!(waiting.as_mut().poll(&mut cx), Poll::Ready(Err(error)) if error.kind() == ErrorKind::Closed),
        "unsubscribe stranded publisher",
    )
}

#[test]
fn rejected_publish_does_not_mutate_existing_queue() -> TestResult {
    let (publisher, mut receiver, _) = channel(1, 4, EventOverflow::Wait)?;
    publisher.try_publish(1, 4)?;
    check(
        publisher
            .try_publish(2, 1)
            .err()
            .is_some_and(|e| e.kind() == ErrorKind::QueueFull),
        "full try_publish was accepted",
    )?;
    check(
        publisher
            .try_publish(3, 5)
            .err()
            .is_some_and(|e| e.kind() == ErrorKind::ItemTooLarge),
        "oversized item accepted",
    )?;
    check(
        receiver.try_recv()? == 1,
        "rejected publish changed old queue",
    )?;
    check(
        matches!(receiver.try_recv(), Err(TryReceiveError::Empty)),
        "rejected publish created lag",
    )
}

#[test]
fn disconnect_overflow_delivers_failure_after_buffered_events_then_eof() -> TestResult {
    let (publisher, mut receiver, _) = channel(1, 4, EventOverflow::Disconnect)?;
    publisher.try_publish(1, 1)?;
    check(
        publisher
            .try_publish(2, 1)
            .err()
            .is_some_and(|e| e.kind() == ErrorKind::CallbackOverflow),
        "overflow was not reported to producer",
    )?;
    check(
        receiver.try_recv()? == 1,
        "buffered event silently discarded",
    )?;
    check(
        matches!(receiver.try_recv(), Err(TryReceiveError::Failed(e)) if e.kind() == ErrorKind::CallbackOverflow),
        "overflow was not delivered",
    )?;
    check(
        block_on(receiver.recv())?.is_none(),
        "failed receiver did not finish",
    )
}

#[test]
fn callback_conversion_preserves_buffer_and_exposes_lag_before_values() -> TestResult {
    let (publisher, receiver, executor) = channel(2, 8, EventOverflow::DropOldest)?;
    let id = receiver.id();
    publisher.try_publish(1, 1)?;
    publisher.try_publish(2, 1)?;
    publisher.try_publish(3, 1)?;
    let observed = Arc::new(Mutex::new(Vec::new()));
    let captured = observed.clone();
    let subscription = receiver.into_callback(move |context, value| {
        let rendered = match value {
            Ok(value) => value,
            Err(ReceiveError::Lagged { skipped }) => -(skipped as i32),
            Err(_) => -99,
        };
        if let Ok(mut values) = captured.lock() {
            values.push((context.id(), rendered));
        }
    })?;
    executor.drain()?;
    check(subscription.id() == id, "conversion changed ID")?;
    check(
        observed
            .lock()
            .map_err(|_| std::io::Error::other("capture lock"))?
            .as_slice()
            == [(id, -1), (id, 2), (id, 3)],
        "callback lost buffer or lag",
    )?;
    block_on(subscription.close())?;
    Ok(())
}