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
#![cfg(test)]

//! Worker tests use explicit gates and never invoke an operating-system monitor.
use super::*;
use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::AtomicUsize;
use std::sync::Mutex;
use std::task::{Context, Poll};

type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;

fn observation() -> SampleObservation {
    SampleObservation {
        reachability: NetworkStatus::Available,
    }
}

fn request_deadline() -> Instant {
    Instant::now() + Duration::from_secs(10)
}

fn poll_once<F: Future>(future: Pin<&mut F>) -> Poll<F::Output> {
    future.poll(&mut Context::from_waker(futures::task::noop_waker_ref()))
}

async fn bounded<F: Future>(future: F) -> Result<F::Output, tokio::time::error::Elapsed> {
    tokio::time::timeout(Duration::from_secs(5), future).await
}

/// The release sender's Drop also unblocks the provider after a failed assertion.
struct WorkerFixture {
    sampler: Arc<WindowsSampler>,
    entered: tokio::sync::oneshot::Receiver<()>,
    release: mpsc::Sender<()>,
    calls: Arc<AtomicUsize>,
    changed_thread: Arc<AtomicBool>,
}

fn gated_worker() -> WorkerFixture {
    let (entered, received) = tokio::sync::oneshot::channel();
    let entered = Mutex::new(Some(entered));
    let (release, released) = mpsc::channel();
    let released = Mutex::new(released);
    let calls = Arc::new(AtomicUsize::new(0));
    let count = calls.clone();
    let thread = Mutex::new(None);
    let changed_thread = Arc::new(AtomicBool::new(false));
    let changed = changed_thread.clone();
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(move |_, _| {
        let current = std::thread::current().id();
        let mut previous = thread.lock().map_err(NetError::from_poison)?;
        if previous.is_some_and(|id| id != current) {
            changed.store(true, Ordering::Release);
        }
        *previous = Some(current);
        drop(previous);
        if count.fetch_add(1, Ordering::AcqRel) == 0 {
            if let Some(entered) = entered.lock().map_err(NetError::from_poison)?.take() {
                let _ = entered.send(());
            }
            released
                .lock()
                .map_err(NetError::from_poison)?
                .recv_timeout(Duration::from_secs(5))
                .map_err(|_| error(ErrorKind::Internal))?;
        }
        Ok(observation())
    })));
    WorkerFixture {
        sampler,
        entered: received,
        release,
        calls,
        changed_thread,
    }
}

fn launch(
    sampler: Arc<WindowsSampler>,
    cancelled: Arc<AtomicBool>,
) -> tokio::task::JoinHandle<Result<CompletedSample, NetError>> {
    tokio::spawn(async move { sampler.sample(request_deadline(), cancelled).await })
}

#[cfg(test)]
#[tokio::test]
async fn dropped_queued_future_never_invokes_the_provider() -> TestResult {
    let fixture = gated_worker();
    let first = launch(fixture.sampler.clone(), Arc::new(AtomicBool::new(false)));
    bounded(fixture.entered).await??;
    let mut abandoned = Box::pin(
        fixture
            .sampler
            .sample(request_deadline(), Arc::new(AtomicBool::new(false))),
    );
    assert!(poll_once(abandoned.as_mut()).is_pending());
    drop(abandoned);
    fixture.release.send(())?;
    bounded(first).await???;
    // Completion of a later request establishes that the abandoned queue item
    // has been inspected, without relying on a sleep or a scheduling guess.
    bounded(
        fixture
            .sampler
            .sample(request_deadline(), Arc::new(AtomicBool::new(false))),
    )
    .await??;
    assert_eq!(fixture.calls.load(Ordering::Acquire), 2);
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn sixteen_accepted_requests_share_one_blocked_worker() -> TestResult {
    let fixture = gated_worker();
    let first = launch(fixture.sampler.clone(), Arc::new(AtomicBool::new(false)));
    bounded(fixture.entered).await??;
    let mut queued = Vec::new();
    for _ in 0..15 {
        let mut request = Box::pin(
            fixture
                .sampler
                .sample(request_deadline(), Arc::new(AtomicBool::new(false))),
        );
        assert!(poll_once(request.as_mut()).is_pending());
        queued.push(request);
    }
    let rejected = fixture
        .sampler
        .sample(request_deadline(), Arc::new(AtomicBool::new(false)))
        .await;
    assert_eq!(
        rejected.err().ok_or("accepted beyond capacity")?.kind(),
        ErrorKind::QueueFull
    );
    assert_eq!(fixture.calls.load(Ordering::Acquire), 1);
    fixture.release.send(())?;
    let mut previous_id = bounded(first).await???.id;
    for request in queued {
        let completed = bounded(request).await??;
        assert!(completed.id > previous_id);
        previous_id = completed.id;
    }
    assert_eq!(fixture.calls.load(Ordering::Acquire), 16);
    assert!(!fixture.changed_thread.load(Ordering::Acquire));
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn cancelling_one_running_query_does_not_cancel_the_next() -> TestResult {
    let fixture = gated_worker();
    let cancel = Cancellation::new();
    let first = launch(fixture.sampler.clone(), cancel.flag.clone());
    bounded(fixture.entered).await??;
    let mut next = Box::pin(
        fixture
            .sampler
            .sample(request_deadline(), Arc::new(AtomicBool::new(false))),
    );
    assert!(poll_once(next.as_mut()).is_pending());
    drop(cancel);
    fixture.release.send(())?;
    let cancelled = bounded(first).await??;
    assert_eq!(
        cancelled.err().ok_or("cancelled sample succeeded")?.kind(),
        ErrorKind::Cancelled
    );
    let completed = bounded(next).await??;
    assert_eq!(completed.observation.reachability, NetworkStatus::Available);
    assert_eq!(fixture.calls.load(Ordering::Acquire), 2);
    assert!(!fixture.changed_thread.load(Ordering::Acquire));
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn provider_panic_releases_its_resources_and_worker_continues() -> TestResult {
    struct Resource(Arc<AtomicUsize>);
    impl Drop for Resource {
        fn drop(&mut self) {
            self.0.fetch_add(1, Ordering::AcqRel);
        }
    }
    let calls = Arc::new(AtomicUsize::new(0));
    let count = calls.clone();
    let released = Arc::new(AtomicUsize::new(0));
    let releases = released.clone();
    let sampler = WindowsSampler::with_provider(Arc::new(move |_, _| {
        let _resource = Resource(releases.clone());
        if count.fetch_add(1, Ordering::AcqRel) == 0 {
            panic!("injected provider panic");
        }
        Ok(observation())
    }));
    let first =
        bounded(sampler.sample(request_deadline(), Arc::new(AtomicBool::new(false)))).await?;
    assert_eq!(
        first.err().ok_or("panic was hidden")?.kind(),
        ErrorKind::Internal
    );
    assert_eq!(released.load(Ordering::Acquire), 1);
    let next =
        bounded(sampler.sample(request_deadline(), Arc::new(AtomicBool::new(false)))).await??;
    assert_eq!(next.id, 2);
    assert_eq!(calls.load(Ordering::Acquire), 2);
    assert_eq!(released.load(Ordering::Acquire), 2);
    Ok(())
}

#[cfg(test)]
#[test]
fn worker_can_be_polled_without_a_tokio_runtime() -> TestResult {
    let sampler = WindowsSampler::with_provider(Arc::new(|_, _| Ok(observation())));
    let completed = futures::executor::block_on(
        sampler.sample(request_deadline(), Arc::new(AtomicBool::new(false))),
    )?;
    assert_eq!(completed.id, 1);
    assert_eq!(completed.observation.reachability, NetworkStatus::Available);
    Ok(())
}

#[tokio::test]
async fn close_cancels_running_work_rejects_queue_and_joins_with_retained_sampler() -> TestResult {
    let fixture = gated_worker();
    let cancelled = Arc::new(AtomicBool::new(false));
    let first = launch(fixture.sampler.clone(), cancelled.clone());
    bounded(fixture.entered).await??;
    let mut queued = Box::pin(
        fixture
            .sampler
            .sample(request_deadline(), Arc::new(AtomicBool::new(false))),
    );
    assert!(poll_once(queued.as_mut()).is_pending());
    fixture.sampler.close();
    fixture.sampler.close();
    assert!(cancelled.load(Ordering::Acquire));
    let rejected = fixture
        .sampler
        .sample(request_deadline(), Arc::new(AtomicBool::new(false)))
        .await;
    assert_eq!(
        rejected
            .err()
            .ok_or("closed sampler accepted a request")?
            .kind(),
        ErrorKind::Closed
    );
    let background = fixture
        .sampler
        .sample_background(request_deadline(), Arc::new(AtomicBool::new(false)))
        .await;
    assert_eq!(
        background
            .err()
            .ok_or("closed sampler accepted background work")?
            .kind(),
        ErrorKind::Closed
    );
    let threads = fixture.sampler.threads.clone();
    let joining = tokio::task::spawn_blocking(move || threads.seal_and_join());
    fixture.release.send(())?;
    let running_result = bounded(first).await??;
    assert_eq!(
        running_result
            .err()
            .ok_or("running work ignored close")?
            .kind(),
        ErrorKind::Cancelled
    );
    let queued_result = bounded(queued).await?;
    assert_eq!(
        queued_result
            .err()
            .ok_or("queued work ran after close")?
            .kind(),
        ErrorKind::Closed
    );
    bounded(joining).await???;
    assert_eq!(fixture.calls.load(Ordering::Acquire), 1);
    // The sampler remains alive here: joining cannot depend on its last Arc drop.
    assert!(
        fixture
            .sampler
            .state
            .lock()
            .map_err(NetError::from_poison)?
            .closed
    );
    Ok(())
}

#[test]
fn close_before_first_query_does_not_start_a_worker() -> TestResult {
    let calls = Arc::new(AtomicUsize::new(0));
    let called = calls.clone();
    let sampler = WindowsSampler::with_provider(Arc::new(move |_, _| {
        called.fetch_add(1, Ordering::AcqRel);
        Ok(observation())
    }));
    sampler.close();
    let result = futures::executor::block_on(
        sampler.sample_background(request_deadline(), Arc::new(AtomicBool::new(false))),
    );
    assert_eq!(
        result.err().ok_or("closed sampler started")?.kind(),
        ErrorKind::Closed
    );
    sampler.threads.seal_and_join()?;
    assert_eq!(calls.load(Ordering::Acquire), 0);
    Ok(())
}