Refactor test server to prepare for more tests (#90)

* Rename xwt-echo-test-server to xwt-test-server

* Adjust CI for the new test server name

* Refactor the test server to allow for more test scenarios

.github/workflows/code.yml

@@ -67,10 +67,10 @@ jobs:
           buildEnvScript: ${{ matrix.plan.platform.buildEnvScript }}
         timeout-minutes: 10
 
-      - name: Build and run the test echo server
+      - name: Build and run the test server
         run: |
-          cargo build --bin xwt-test-echo-server
-          cargo run --bin xwt-test-echo-server &
+          cargo build --bin xwt-test-server
+          cargo run --bin xwt-test-server &
         if: ${{ matrix.plan.mode.needsEchoServer }}
 
       - name: Run cargo ${{ matrix.plan.mode.cargoCommand }}

crates/xwt-test-echo-server/Cargo.toml → crates/xwt-test-server/Cargo.toml

@@ -1,18 +1,18 @@
 [package]
-name = "xwt-test-echo-server"
+name = "xwt-test-server"
 version = "0.2.0"
 edition = "2021"
 resolver = "2"
 license = "MIT"
 description = """
-The echo server to use for xwt testing.
+The server to use for xwt testing.
 Not intended to be wasm-compatible.
 """
 repository = "https://github.com/MOZGIII/xwt"
 autobins = false
 
 [[bin]]
-name = "xwt-test-echo-server"
+name = "xwt-test-server"
 path = "src/main.rs"
 required-features = ["bin"]
 

crates/xwt-test-echo-server/src/lib.rs → crates/xwt-test-server/src/echo.rs

@@ -1,76 +1,10 @@
-//! The implementation of the echo server to use for xwt testing.
-//! Not intended to be wasm-compatible.
-
-#![allow(missing_docs)]
-#![cfg(not(target_family = "wasm"))]
+//! The implementation of the echo server.
 
 use std::sync::Arc;
 
-#[derive(Default)]
-pub struct EndpointParams {
-    pub addr: Option<std::net::SocketAddr>,
-    pub cert: Option<wtransport::tls::Certificate>,
-}
-
-pub async fn endpoint(
-    params: EndpointParams,
-) -> Result<wtransport::Endpoint<wtransport::endpoint::endpoint_side::Server>, std::io::Error> {
-    let EndpointParams { addr, cert } = params;
-
-    let cert = cert.unwrap_or_else(|| {
-        wtransport::tls::Certificate::new(vec![xwt_test_assets::CERT], xwt_test_assets::KEY)
-            .unwrap()
-    });
-
-    match cert.certificates().first() {
-        Some(cert) => {
-            let sha256_fingerpint = xwt_cert_utils::fingerprint::sha256(cert);
-            tracing::info!(message = "using tls certificate", %sha256_fingerpint);
-        }
-        None => tracing::info!(message = "not using tls certificate"),
-    };
-
-    let server_config =
-        wtransport::ServerConfig::builder()
-            .with_bind_address(addr.unwrap_or(std::net::SocketAddr::V4(
-                std::net::SocketAddrV4::new(std::net::Ipv4Addr::new(127, 0, 0, 1), 0),
-            )))
-            .with_certificate(cert)
-            .build();
-
-    let endpoint = wtransport::Endpoint::server(server_config)?;
-
-    Ok(endpoint)
-}
-
-pub async fn serve_endpoint(
-    endpoint: wtransport::Endpoint<wtransport::endpoint::endpoint_side::Server>,
-) -> Result<std::convert::Infallible, std::io::Error> {
-    let bind_addr = endpoint.local_addr()?;
-    tracing::info!(message = "serving endpoint", %bind_addr);
-
-    loop {
-        let incoming_session = endpoint.accept().await;
-        tokio::spawn(async move {
-            if let Err(error) = serve_incoming_session(incoming_session).await {
-                tracing::error!(message = "error while serving incoming session", %error);
-            }
-        });
-    }
-}
-
-pub async fn serve_incoming_session(
-    incoming_session: wtransport::endpoint::IncomingSession,
+pub async fn serve_session_request(
+    session_request: wtransport::endpoint::SessionRequest,
 ) -> Result<(), wtransport::error::ConnectionError> {
-    tracing::info!(message = "got an incoming session");
-    let session_request = incoming_session.await?;
-
-    if session_request.path() != "/echo" {
-        tracing::info!(message = "rejecting incoming session due to path mismatch");
-        session_request.not_found().await;
-        return Ok(());
-    }
-
     tracing::info!(message = "accepting incoming session");
     let connection = session_request.accept().await?;
 

crates/xwt-test-server/src/lib.rs

@@ -0,0 +1,81 @@
+//! The implementation of the echo server to use for xwt testing.
+//! Not intended to be wasm-compatible.
+
+#![allow(missing_docs)]
+#![cfg(not(target_family = "wasm"))]
+
+pub mod echo;
+
+#[derive(Default)]
+pub struct EndpointParams {
+    pub addr: Option<std::net::SocketAddr>,
+    pub cert: Option<wtransport::tls::Certificate>,
+}
+
+pub async fn endpoint(
+    params: EndpointParams,
+) -> Result<wtransport::Endpoint<wtransport::endpoint::endpoint_side::Server>, std::io::Error> {
+    let EndpointParams { addr, cert } = params;
+
+    let cert = cert.unwrap_or_else(|| {
+        wtransport::tls::Certificate::new(vec![xwt_test_assets::CERT], xwt_test_assets::KEY)
+            .unwrap()
+    });
+
+    match cert.certificates().first() {
+        Some(cert) => {
+            let sha256_fingerpint = xwt_cert_utils::fingerprint::sha256(cert);
+            tracing::info!(message = "using tls certificate", %sha256_fingerpint);
+        }
+        None => tracing::info!(message = "not using tls certificate"),
+    };
+
+    let server_config =
+        wtransport::ServerConfig::builder()
+            .with_bind_address(addr.unwrap_or(std::net::SocketAddr::V4(
+                std::net::SocketAddrV4::new(std::net::Ipv4Addr::new(127, 0, 0, 1), 0),
+            )))
+            .with_certificate(cert)
+            .build();
+
+    let endpoint = wtransport::Endpoint::server(server_config)?;
+
+    Ok(endpoint)
+}
+
+pub async fn serve_endpoint(
+    endpoint: wtransport::Endpoint<wtransport::endpoint::endpoint_side::Server>,
+) -> Result<std::convert::Infallible, std::io::Error> {
+    let bind_addr = endpoint.local_addr()?;
+    tracing::info!(message = "serving endpoint", %bind_addr);
+
+    loop {
+        let incoming_session = endpoint.accept().await;
+        tokio::spawn(async move {
+            if let Err(error) = serve_incoming_session(incoming_session).await {
+                tracing::error!(message = "error while serving incoming session", %error);
+            }
+        });
+    }
+}
+
+pub async fn serve_incoming_session(
+    incoming_session: wtransport::endpoint::IncomingSession,
+) -> Result<(), wtransport::error::ConnectionError> {
+    tracing::info!(message = "got an incoming session");
+    let session_request = incoming_session.await?;
+
+    let path = session_request.path();
+
+    match path {
+        "/echo" => {
+            tracing::info!(message = "invoking echo handler");
+            self::echo::serve_session_request(session_request).await
+        }
+        _ => {
+            tracing::info!(message = "rejecting incoming session due to path mismatch");
+            session_request.not_found().await;
+            Ok(())
+        }
+    }
+}

crates/xwt-test-echo-server/src/main.rs → crates/xwt-test-server/src/main.rs

@@ -11,12 +11,12 @@ async fn main() -> color_eyre::eyre::Result<()> {
     color_eyre::install()?;
 
     let addr = envfury::or_parse("ADDR", "127.0.0.1:8080")?;
-    let endpoint = xwt_test_echo_server::endpoint(xwt_test_echo_server::EndpointParams {
+    let endpoint = xwt_test_server::endpoint(xwt_test_server::EndpointParams {
         addr: Some(addr),
         cert: None,
     })
     .await?;
-    xwt_test_echo_server::serve_endpoint(endpoint).await?;
+    xwt_test_server::serve_endpoint(endpoint).await?;
 
     Ok(())
 }