tests: rework the actually useful tests to live in the integration crate

crates/irtt-server/src/runtime.rs

@@ -403,203 +403,7 @@ pub enum ServerRuntimeError {
 
 #[cfg(test)]
 mod tests {
-    use std::{net::Ipv4Addr, time::Duration};
-
-    use irtt_proto::{
-        decode_echo_reply, decode_open_reply, encode_request, Clock, Params, ReceivedStats,
-        RequestToEncode, StampAt,
-    };
-    use tokio::{net::UdpSocket, sync::oneshot, time::timeout};
-
-    use super::*;
-
-    #[tokio::test(flavor = "current_thread")]
-    async fn bind_reports_local_address_and_shutdown_stops_run() {
-        let requested = SocketAddr::from((Ipv4Addr::LOCALHOST, 0));
-        let mut server = Server::bind(requested, ServerConfig::default())
-            .await
-            .unwrap();
-        let bound = server.local_addr().unwrap();
-        assert_eq!(bound.ip(), requested.ip());
-        assert_ne!(bound.port(), 0);
-
-        let (shutdown_tx, shutdown_rx) = oneshot::channel();
-        shutdown_tx.send(()).unwrap();
-        server
-            .run(async {
-                let _ = shutdown_rx.await;
-            })
-            .await
-            .unwrap();
-    }
-
-    /// Construction is where a wildcard listener's promise is made or refused.
-    ///
-    /// Both outcomes are asserted from the same code, because which one a target
-    /// gets is exactly the thing under test: a target with a source-selection
-    /// path configures it and serves; one without refuses the bind rather than
-    /// starting a listener whose replies may come from an address no client
-    /// contacted. An explicit bind is unaffected either way.
-    #[tokio::test(flavor = "current_thread")]
-    async fn from_socket_settles_wildcard_source_selection_before_serving_anything() {
-        let explicit = UdpSocket::bind("127.0.0.1:0").await.unwrap();
-        assert!(Server::from_socket(explicit, ServerConfig::default()).is_ok());
-
-        let wildcard = UdpSocket::bind("0.0.0.0:0").await.unwrap();
-        let wildcard = Server::from_socket(wildcard, ServerConfig::default());
-        if socket_io::SUPPORTED {
-            let server = wildcard.expect("a supported target configures source selection");
-            assert!(server.select_reply_source);
-        } else {
-            assert!(matches!(
-                wildcard,
-                Err(ServerRuntimeError::WildcardSourceSelectionUnsupported { .. })
-            ));
-        }
-    }
-
-    #[tokio::test(flavor = "current_thread")]
-    async fn ipv4_open_echo_close_crosses_a_real_udp_socket() {
-        exercise_udp_path(SocketAddr::from((Ipv4Addr::LOCALHOST, 0))).await;
-    }
-
-    #[tokio::test(flavor = "current_thread")]
-    async fn ipv6_open_echo_close_when_loopback_is_available() {
-        let addr = "[::1]:0".parse().unwrap();
-        let server = match Server::bind(addr, unthrottled()).await {
-            Ok(server) => server,
-            Err(ServerRuntimeError::Bind { source, .. })
-                if matches!(
-                    source.kind(),
-                    io::ErrorKind::AddrNotAvailable | io::ErrorKind::Unsupported
-                ) =>
-            {
-                return;
-            }
-            Err(error) => panic!("unexpected IPv6 loopback bind failure: {error}"),
-        };
-        exercise_bound_server(server).await;
-    }
-
-    async fn exercise_udp_path(addr: SocketAddr) {
-        let server = Server::bind(addr, unthrottled()).await.unwrap();
-        exercise_bound_server(server).await;
-    }
-
-    async fn exercise_bound_server(mut server: Server) {
-        let server_addr = server.local_addr().unwrap();
-        let client_bind = match server_addr {
-            SocketAddr::V4(_) => "127.0.0.1:0",
-            SocketAddr::V6(_) => "[::1]:0",
-        };
-        let client = UdpSocket::bind(client_bind).await.unwrap();
-        let (shutdown_tx, shutdown_rx) = oneshot::channel();
-        let server_task = tokio::spawn(async move {
-            server
-                .run(async {
-                    let _ = shutdown_rx.await;
-                })
-                .await
-        });
-
-        let requested = Params {
-            protocol_version: 1,
-            duration_ns: 1_000_000_000,
-            interval_ns: 100_000_000,
-            received_stats: ReceivedStats::Both,
-            stamp_at: StampAt::Both,
-            clock: Clock::Both,
-            ..Params::default()
-        };
-        let open = encode_request(
-            RequestToEncode::Open {
-                params: &requested,
-                no_test: false,
-            },
-            None,
-        )
-        .unwrap();
-        client.send_to(&open, server_addr).await.unwrap();
-
-        let mut buffer = vec![0; RECEIVE_BUFFER_LEN];
-        let (len, reply_source) = timeout(Duration::from_secs(1), client.recv_from(&mut buffer))
-            .await
-            .expect("OPEN reply timeout")
-            .unwrap();
-        assert_eq!(reply_source, server_addr);
-        let open_reply = decode_open_reply(&buffer[..len], None).unwrap();
-        assert_ne!(open_reply.token, 0);
-
-        let echo = encode_request(
-            RequestToEncode::Echo {
-                token: open_reply.token,
-                sequence: 0,
-                params: &open_reply.params,
-                payload: &[],
-            },
-            None,
-        )
-        .unwrap();
-        client.send_to(&echo, server_addr).await.unwrap();
-        let (len, reply_source) = timeout(Duration::from_secs(1), client.recv_from(&mut buffer))
-            .await
-            .expect("ECHO reply timeout")
-            .unwrap();
-        assert_eq!(reply_source, server_addr);
-        let echo_reply = decode_echo_reply(&buffer[..len], &open_reply.params, None).unwrap();
-        assert_eq!(echo_reply.token, open_reply.token);
-        assert_eq!(echo_reply.sequence, 0);
-        assert_eq!(echo_reply.recv_count, Some(1));
-        assert_eq!(echo_reply.recv_window, Some(1));
-
-        let close = encode_request(
-            RequestToEncode::Close {
-                token: open_reply.token,
-            },
-            None,
-        )
-        .unwrap();
-        client.send_to(&close, server_addr).await.unwrap();
-        client.send_to(&echo, server_addr).await.unwrap();
-        assert!(
-            timeout(Duration::from_millis(100), client.recv_from(&mut buffer))
-                .await
-                .is_err()
-        );
-
-        shutdown_tx.send(()).unwrap();
-        server_task.await.unwrap().unwrap();
-    }
-
-    fn unthrottled() -> ServerConfig {
-        ServerConfig::default().with_min_send_interval(Duration::ZERO)
-    }
-
-    /// Which bound addresses owe their replies a selected source.
-    ///
-    /// The IPv4-mapped unspecified address is the one that is not obvious, and
-    /// it is not hypothetical: Linux accepts `[::ffff:0.0.0.0]` as an IPv4
-    /// wildcard bind and reports it back unchanged, so missing it would leave a
-    /// working wildcard listener on the plain send path. A mapped address
-    /// naming a real host address is explicit and must stay there.
-    #[test]
-    fn a_bound_address_naming_no_particular_local_address_is_a_wildcard() {
-        for (addr, wildcard) in [
-            ("0.0.0.0:2112", true),
-            ("[::]:2112", true),
-            ("[::ffff:0.0.0.0]:2112", true),
-            ("127.0.0.1:2112", false),
-            ("192.0.2.10:2112", false),
-            ("[::1]:2112", false),
-            ("[::ffff:127.0.0.1]:2112", false),
-        ] {
-            assert_eq!(
-                is_wildcard(addr.parse().unwrap()),
-                wildcard,
-                "{addr} classified wrongly"
-            );
-        }
-    }
+    use super::may_send_unappliable;
 
     /// The rule that decides what an unappliable traffic class means, which no
     /// normal interface can reach: it needs a host that refuses the socket