Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
68 changes: 68 additions & 0 deletions crates/edgezero-adapter-axum/tests/fixtures/blocking_accept.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,68 @@
//! Accept helper for test fixtures that poll a non-blocking std listener.

use std::io;
use std::net::{SocketAddr, TcpListener, TcpStream};

/// Accepts one connection and returns its stream in blocking mode.
///
/// Fixtures make the listener non-blocking so their accept loop can poll a deadline or stop
/// flag. macOS `accept(2)` copies `O_NONBLOCK` to the accepted socket (Linux does not), so a
/// read on the returned stream would otherwise fail with `WouldBlock` at once instead of
/// honouring its read timeout. `WouldBlock` from `accept` itself is still returned to the caller.
#[inline]
pub(crate) fn accept_blocking(listener: &TcpListener) -> io::Result<(TcpStream, SocketAddr)> {
let (stream, peer) = listener.accept()?;
stream.set_nonblocking(false)?;
Ok((stream, peer))
}

#[cfg(test)]
mod tests {
use super::accept_blocking;
use std::io::{ErrorKind, Read as _};
use std::net::{TcpListener, TcpStream};
use std::thread;
use std::time::{Duration, Instant};

#[test]
fn stream_accepted_from_nonblocking_listener_waits_for_read_timeout() {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind loopback");
listener
.set_nonblocking(true)
.expect("nonblocking listener");
let address = listener.local_addr().expect("listener address");
let _client = TcpStream::connect(address).expect("connect loopback client");
let deadline = Instant::now()
.checked_add(Duration::from_secs(2))
.expect("deadline fits the monotonic clock");
let (mut stream, _peer) = loop {
match accept_blocking(&listener) {
Ok(accepted) => break accepted,
Err(error) if error.kind() == ErrorKind::WouldBlock => {
assert!(
Instant::now() < deadline,
"loopback connection was not queued"
);
thread::sleep(Duration::from_millis(5));
}
Err(error) => panic!("accept failed: {error}"),
}
};
stream
.set_read_timeout(Some(Duration::from_millis(200)))
.expect("read timeout");
let started = Instant::now();
let error = stream
.read(&mut [0_u8; 1])
.expect_err("the client sent nothing");
let waited = started.elapsed();
assert!(
matches!(error.kind(), ErrorKind::WouldBlock | ErrorKind::TimedOut),
"unexpected read error: {error}"
);
assert!(
waited >= Duration::from_millis(150),
"read returned after {waited:?}, before its 200 ms timeout"
);
}
}
7 changes: 6 additions & 1 deletion crates/edgezero-adapter-axum/tests/native_aws_startup.rs
Original file line number Diff line number Diff line change
Expand Up @@ -4,12 +4,17 @@
//! They exercise the public runner and real pinned SDK, not a provider seam. No AWS account,
//! DNS hostname, external socket, image, or real cloud credential is used.

#[cfg(test)]
#[path = "fixtures/blocking_accept.rs"]
mod blocking_accept;

#[cfg(test)]
#[expect(
clippy::arbitrary_source_item_ordering,
reason = "loopback fixture helpers remain grouped before startup scenarios"
)]
mod tests {
use crate::blocking_accept::accept_blocking;
use std::fmt::Write as _;
use std::fs;
use std::io::{ErrorKind, Read, Write as _};
Expand Down Expand Up @@ -83,7 +88,7 @@ mod tests {
.checked_add(watch)
.expect("fixture deadline fits the monotonic clock");
loop {
match listener.accept() {
match accept_blocking(&listener) {
Ok((mut stream, peer)) => {
assert!(peer.ip().is_loopback(), "fixture peer was not loopback");
stream
Expand Down
7 changes: 6 additions & 1 deletion crates/edgezero-adapter-axum/tests/native_celld_startup.rs
Original file line number Diff line number Diff line change
Expand Up @@ -8,8 +8,13 @@
reason = "fixture helpers precede startup scenarios"
)]

#[cfg(test)]
#[path = "fixtures/blocking_accept.rs"]
mod blocking_accept;

#[cfg(test)]
mod tests {
use crate::blocking_accept::accept_blocking;
use std::fs;
use std::io::{ErrorKind, Read, Write as _};
use std::net::{SocketAddr, TcpListener, TcpStream};
Expand Down Expand Up @@ -47,7 +52,7 @@ mod tests {
thread::spawn(move || {
let deadline = Instant::now().checked_add(WAIT).expect("fixture deadline");
while !worker_stop.load(Ordering::Relaxed) && Instant::now() < deadline {
match listener.accept() {
match accept_blocking(&listener) {
Ok((mut stream, peer)) => {
assert!(peer.ip().is_loopback());
stream
Expand Down
Loading
Loading