feat(http): add HTTP server

Cargo.toml

@@ -1,15 +1,17 @@
 [dependencies]
 async-trait = {version = "0.1", optional = true}
+axum = {version = "0.6", optional = true}
 bytes = {version = "1.5", optional = true}
 chrono = {version = "0.4", optional = true}
 mockall = {version = "0.11", optional = true}
 open = {version = "5.0", optional = true}
-tokio = {version = "1.32", features = ["process"], optional = true}
+tokio = {version = "1.32", features = ["process", "rt"], optional = true}
 tracing = "0.1"
 uuid = {version = "0.8", features = ["v4"], optional = true}
 
 [dev-dependencies]
 mockall = "0.11"
+reqwest = "0.11"
 tokio = {version = "1.32", features = ["full"]}
 tokio-test = "0.4"
 
@@ -18,6 +20,7 @@ browser = ["dep:open"]
 clock = ["dep:chrono"]
 cmd = ["dep:async-trait", "dep:tokio"]
 full = ["browser", "clock", "cmd", "uuid"]
+http = ["dep:axum", "dep:tokio"]
 mock = ["dep:mockall"]
 uuid = ["dep:uuid"]
 

examples/http.rs

@@ -0,0 +1,38 @@
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+
+use mockable::{DefaultHttpServer, HttpServer};
+
+#[tokio::main]
+async fn main() {
+    let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 8000));
+    let mut server = DefaultHttpServer::start(&addr)
+        .await
+        .expect("failed to start server");
+    let req = server.next().await.expect("failed to get request");
+    println!("{:?}", req);
+    server.stop().await;
+}
+
+#[cfg(test)]
+mod test {
+    use mockable::{HttpRequest, MockHttpServer};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test() {
+        let expected = HttpRequest {
+            body: vec![],
+            headers: Default::default(),
+            method: "GET".into(),
+            path: "/".into(),
+            query: Default::default(),
+        };
+        let mut server = MockHttpServer::new();
+        server.expect_next().return_const(expected.clone());
+        server.expect_stop().return_const(());
+        let req = server.next().await.expect("failed to get request");
+        server.stop().await;
+        assert_eq!(req, expected);
+    }
+}

src/http.rs

@@ -0,0 +1,220 @@
+use std::{collections::HashMap, io, net::SocketAddr};
+
+use async_trait::async_trait;
+use axum::{
+    body::Bytes,
+    extract::Query,
+    http::{HeaderMap, Method, StatusCode, Uri},
+    Router, Server,
+};
+use tokio::{
+    spawn,
+    sync::{mpsc, oneshot},
+    task::JoinHandle,
+};
+use tracing::{error, warn};
+
+// HttpRequest
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct HttpRequest {
+    pub body: Vec<u8>,
+    pub headers: HashMap<String, String>,
+    pub method: String,
+    pub path: String,
+    pub query: HashMap<String, Vec<String>>,
+}
+
+// HttpServer
+
+/// Simple HTTP server that listen all requests.
+///
+/// **This is supported on `feature=http` only.**
+///
+/// [Example](https://github.com/leroyguillaume/mockable/tree/main/examples/http.rs).
+#[async_trait]
+pub trait HttpServer {
+    /// Returns the next request received by the server.
+    ///
+    /// `None` is returned if the server is stopped.
+    async fn next(&mut self) -> Option<HttpRequest>;
+
+    /// Stops the server.
+    async fn stop(self);
+}
+
+// DefaultHttpServer
+
+/// Default implementation of [`HttpServer`](trait.HttpServer.html).
+///
+/// **This is supported on `feature=http` only.**
+///
+/// [Example](https://github.com/leroyguillaume/mockable/tree/main/examples/http.rs).
+pub struct DefaultHttpServer {
+    req_rx: mpsc::Receiver<HttpRequest>,
+    server: JoinHandle<()>,
+    stop_tx: oneshot::Sender<()>,
+}
+
+impl DefaultHttpServer {
+    /// Starts a new server listening on the given address.
+    pub async fn start(addr: &SocketAddr) -> io::Result<Self> {
+        let (stop_tx, stop_rx) = oneshot::channel();
+        let (req_tx, req_rx) = mpsc::channel(1);
+        let app = Router::new().fallback(
+            move |method: Method,
+                  uri: Uri,
+                  Query(query): Query<Vec<(String, String)>>,
+                  headers: HeaderMap,
+                  body: Bytes| async move {
+                let mut req_headers = HashMap::new();
+                for (name, val) in headers {
+                    let name = if let Some(name) = &name {
+                        name.as_str()
+                    } else {
+                        warn!("request contains header with no name");
+                        continue;
+                    };
+                    let val = match val.to_str() {
+                        Ok(val) => val,
+                        Err(err) => {
+                            warn!(details = %err, header = name, "failed to decode header value");
+                            continue;
+                        }
+                    };
+                    req_headers.insert(name.into(), val.into());
+                }
+                let query = query.into_iter().fold(
+                    HashMap::<String, Vec<String>>::new(),
+                    |mut query, (key, val)| {
+                        query.entry(key).or_default().push(val);
+                        query
+                    },
+                );
+                let req = HttpRequest {
+                    body: body.to_vec(),
+                    headers: req_headers,
+                    method: method.to_string(),
+                    path: uri.path().into(),
+                    query,
+                };
+                req_tx.send(req).await.ok();
+                StatusCode::OK
+            },
+        );
+        let server = Server::bind(addr)
+            .serve(app.into_make_service())
+            .with_graceful_shutdown(async {
+                stop_rx.await.ok();
+            });
+        let server = spawn(async {
+            if let Err(err) = server.await {
+                error!(details = %err, "failed to start server");
+            }
+        });
+        Ok(Self {
+            req_rx,
+            server,
+            stop_tx,
+        })
+    }
+}
+
+#[async_trait]
+impl HttpServer for DefaultHttpServer {
+    async fn next(&mut self) -> Option<HttpRequest> {
+        self.req_rx.recv().await
+    }
+
+    async fn stop(self) {
+        self.stop_tx.send(()).ok();
+        if let Err(err) = self.server.await {
+            error!(details = %err, "failed to stop server");
+        }
+    }
+}
+
+// MockHttpServer
+
+#[cfg(feature = "mock")]
+mockall::mock! {
+    /// `mockall` implementation of [`HttpServer`](trait.HttpServer.html).
+    ///
+    /// **This is supported on `feature=http,mock` only.**
+    ///
+    /// [Example](https://github.com/leroyguillaume/mockable/tree/main/examples/http.rs).
+    pub HttpServer {}
+
+    #[async_trait]
+    impl HttpServer for HttpServer {
+        async fn next(&mut self) -> Option<HttpRequest>;
+        async fn stop(self);
+    }
+}
+
+// Tests
+
+#[cfg(test)]
+mod test {
+    use std::{
+        net::{Ipv4Addr, SocketAddrV4},
+        time::Duration,
+    };
+
+    use reqwest::Client;
+    use tokio::time::sleep;
+
+    use super::*;
+
+    mod default_http_server {
+        use super::*;
+
+        #[tokio::test]
+        async fn test() {
+            let port = 8000;
+            let expected = HttpRequest {
+                body: "abc".to_string().into_bytes(),
+                headers: HashMap::from_iter([
+                    ("accept".into(), "*/*".into()),
+                    ("content-length".into(), "3".into()),
+                    ("host".into(), format!("localhost:{port}")),
+                ]),
+                method: "GET".into(),
+                path: "/a/b".into(),
+                query: HashMap::from_iter([("foo".into(), vec!["bar1".into(), "bar2".into()])]),
+            };
+            let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, port));
+            let mut server = DefaultHttpServer::start(&addr)
+                .await
+                .expect("failed to start server");
+            sleep(Duration::from_secs(1)).await;
+            let client = Client::new();
+            let query: Vec<(String, String)> = expected
+                .query
+                .clone()
+                .into_iter()
+                .flat_map(|(key, val)| val.into_iter().map(move |val| (key.clone(), val)))
+                .collect();
+            let resp = client
+                .get(format!("http://localhost:{port}{}", expected.path))
+                .query(&query)
+                .body(expected.body.clone())
+                .send()
+                .await
+                .expect("failed to send request");
+            let status = resp.status();
+            if status != reqwest::StatusCode::OK {
+                let body = resp.text().await.expect("failed to read response body");
+                panic!("request failed with status {status}: {body}");
+            }
+            let req = server.next().await.expect("failed to receive request");
+            assert_eq!(req, expected);
+            server.stop().await;
+            client
+                .get(format!("http://localhost:{port}"))
+                .send()
+                .await
+                .expect_err("request should fail after server is stopped");
+        }
+    }
+}

src/lib.rs

@@ -8,6 +8,10 @@ pub use self::clock::{Clock, DefaultClock};
 pub use self::cmd::MockCommandRunner;
 #[cfg(feature = "cmd")]
 pub use self::cmd::{Command, CommandOutput, CommandRunner, DefaultCommandRunner};
+#[cfg(all(feature = "http", feature = "mock"))]
+pub use self::http::MockHttpServer;
+#[cfg(feature = "http")]
+pub use self::http::{DefaultHttpServer, HttpRequest, HttpServer};
 #[cfg(any(feature = "mock", test))]
 pub use self::mock::Mock;
 #[cfg(all(feature = "uuid", feature = "mock"))]
@@ -28,6 +32,8 @@ mod clock;
 #[cfg(feature = "cmd")]
 mod cmd;
 mod env;
+#[cfg(feature = "http")]
+mod http;
 #[cfg(any(feature = "mock", test))]
 mod mock;
 mod sys;