net: Add test-support cargo feature

rust/net/Cargo.toml

@@ -5,6 +5,9 @@ edition = "2021"
 authors = ["Signal Messenger LLC"]
 license = "AGPL-3.0-only"
 
+[features]
+test-support = []
+
 [dependencies]
 attest = { path = "../attest" }
 libsignal-core = { path = "../core" }
@@ -75,3 +78,19 @@ tls-parser = "0.11.0"
 tokio = { version = "1", features = ["test-util", "io-std", "rt-multi-thread"] }
 url = "2.4.1"
 warp = { version = "0.3.6", features = ["tls"] }
+
+[[example]]
+name = "svr3"
+required-features = ["test-support"]
+
+[[example]]
+name = "svr3_prop_test"
+required-features = ["test-support"]
+
+[[example]]
+name = "chat_smoke_test"
+required-features = ["test-support"]
+
+[[test]]
+name = "svr3_migration"
+required-features = ["test-support"]

rust/net/examples/chat_smoke_test.rs

@@ -4,19 +4,14 @@
 //
 
 use std::process::ExitCode;
-use std::time::Duration;
 
 use clap::{Args, Parser, ValueEnum};
-use http::uri::PathAndQuery;
+
 use libsignal_net::auth::Auth;
-use libsignal_net::chat::{chat_service, ChatServiceError};
-use libsignal_net::env::constants::WEB_SOCKET_PATH;
+use libsignal_net::chat::test_support::simple_chat_service;
+use libsignal_net::chat::ChatServiceError;
 use libsignal_net::env::Svr3Env;
-use libsignal_net::infra::dns::DnsResolver;
-use libsignal_net::infra::tcp_ssl::DirectConnector;
-use libsignal_net::infra::{make_ws_config, ConnectionParams, EndpointConnection, RouteType};
-use libsignal_net::utils::ObservableEvent;
-use tokio::sync::mpsc;
+use libsignal_net::infra::{ConnectionParams, RouteType};
 
 #[derive(Parser)]
 struct Config {
@@ -101,33 +96,7 @@ async fn test_connection(
     env: &libsignal_net::env::Env<'static, Svr3Env<'static>>,
     connection_params: Vec<ConnectionParams>,
 ) -> Result<(), ChatServiceError> {
-    let one_route_connect_timeout = Duration::from_secs(5);
-    let network_change_event = ObservableEvent::default();
-    let dns_resolver =
-        DnsResolver::new_with_static_fallback(env.static_fallback(), &network_change_event);
-    let transport_connector = DirectConnector::new(dns_resolver);
-    let chat_endpoint = PathAndQuery::from_static(WEB_SOCKET_PATH);
-    let chat_ws_config = make_ws_config(chat_endpoint, one_route_connect_timeout);
-    let connection = EndpointConnection::new_multi(
-        connection_params,
-        one_route_connect_timeout,
-        chat_ws_config,
-        &network_change_event,
-    );
-
-    let (incoming_auth_tx, _incoming_rx) = mpsc::channel(1);
-    let (incoming_unauth_tx, _incoming_rx) = mpsc::channel(1);
-    let chat = chat_service(
-        &connection,
-        transport_connector,
-        incoming_auth_tx,
-        incoming_unauth_tx,
-        Auth {
-            username: "".to_owned(),
-            password: "".to_owned(),
-        },
-        false,
-    );
+    let chat = simple_chat_service(env, Auth::default(), connection_params);
 
     chat.connect_unauthenticated().await?;
     chat.disconnect().await;

rust/net/src/auth.rs

@@ -28,6 +28,7 @@ impl<T: HttpBasicAuth> From<T> for HttpRequestDecorator {
 /// - username is a "hex(uid)"
 /// - password is a "timestamp:hex(otp(uid, timestamp, secret))"
 #[derive(Clone)]
+#[cfg_attr(feature = "test-support", derive(Default))]
 pub struct Auth {
     pub username: String,
     pub password: String,

rust/net/src/chat.rs

@@ -475,6 +475,63 @@ pub fn chat_service<T: TransportConnector + 'static>(
     }
 }
 
+#[cfg(feature = "test-support")]
+pub mod test_support {
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    use http::uri::PathAndQuery;
+    use tokio::sync::mpsc;
+
+    use crate::auth::Auth;
+    use crate::chat::{Chat, ChatServiceWithDebugInfo};
+    use crate::env::constants::WEB_SOCKET_PATH;
+    use crate::env::{Env, Svr3Env};
+    use crate::infra::dns::DnsResolver;
+    use crate::infra::tcp_ssl::DirectConnector;
+    use crate::infra::{make_ws_config, ConnectionParams, EndpointConnection};
+    use crate::utils::ObservableEvent;
+
+    use super::*;
+
+    pub type AnyChat = Chat<
+        Arc<dyn ChatServiceWithDebugInfo + Send + Sync>,
+        Arc<dyn ChatServiceWithDebugInfo + Send + Sync>,
+    >;
+
+    pub fn simple_chat_service(
+        env: &Env<'static, Svr3Env<'static>>,
+        auth: Auth,
+        connection_params: Vec<ConnectionParams>,
+    ) -> AnyChat {
+        let one_route_connect_timeout = Duration::from_secs(5);
+        let network_change_event = ObservableEvent::default();
+        let dns_resolver =
+            DnsResolver::new_with_static_fallback(env.static_fallback(), &network_change_event);
+        let transport_connector = DirectConnector::new(dns_resolver);
+        let chat_endpoint = PathAndQuery::from_static(WEB_SOCKET_PATH);
+        let chat_ws_config = make_ws_config(chat_endpoint, one_route_connect_timeout);
+        let connection = EndpointConnection::new_multi(
+            connection_params,
+            one_route_connect_timeout,
+            chat_ws_config,
+            &network_change_event,
+        );
+
+        let (incoming_auth_tx, _incoming_rx) = mpsc::channel(1);
+        let (incoming_unauth_tx, _incoming_rx) = mpsc::channel(1);
+        chat_service(
+            &connection,
+            transport_connector,
+            incoming_auth_tx,
+            incoming_unauth_tx,
+            auth,
+            false,
+        )
+        .into_dyn()
+    }
+}
+
 #[cfg(test)]
 pub(crate) mod test {
     use crate::chat::{Response, ResponseProto, ResponseProtoInvalidError};

rust/net/src/svr3.rs

@@ -3,15 +3,9 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 
-use crate::auth::Auth;
-use crate::enclave::PpssSetup;
-use crate::env::Svr3Env;
 use crate::infra::errors::LogSafeDisplay;
-use crate::infra::ws::{
-    AttestedConnectionError, DefaultStream, WebSocketConnectError, WebSocketServiceError,
-};
+use crate::infra::ws::{AttestedConnectionError, WebSocketConnectError, WebSocketServiceError};
 use bincode::Options as _;
-use direct::DirectConnect;
 use libsignal_svr3::{EvaluationResult, MaskedShareSet};
 use rand_core::CryptoRngCore;
 use serde::{Deserialize, Serialize};
@@ -275,15 +269,24 @@ where
     Ok(share_set)
 }
 
-impl Svr3Env<'static> {
-    /// Simplest way to connect to an SVR3 Environment in integration tests, command
-    /// line tools, and examples.
-    pub async fn connect_directly(
-        &self,
-        auth: &Auth,
-    ) -> <Self as PpssSetup<DefaultStream>>::ConnectionResults {
-        let endpoints = (self.sgx(), self.nitro(), self.tpm2snp());
-        endpoints.connect(auth).await
+#[cfg(feature = "test-support")]
+pub mod test_support {
+    use crate::auth::Auth;
+    use crate::enclave::PpssSetup;
+    use crate::env::Svr3Env;
+    use crate::infra::ws::DefaultStream;
+    use crate::svr3::direct::DirectConnect as _;
+
+    impl Svr3Env<'static> {
+        /// Simplest way to connect to an SVR3 Environment in integration tests, command
+        /// line tools, and examples.
+        pub async fn connect_directly(
+            &self,
+            auth: &Auth,
+        ) -> <Self as PpssSetup<DefaultStream>>::ConnectionResults {
+            let endpoints = (self.sgx(), self.nitro(), self.tpm2snp());
+            endpoints.connect(auth).await
+        }
     }
 }