A builder pattern starting with an implementation of Default might be a place to start?

Like this?

Click to show diff

diff --git a/src/lib.rs b/src/lib.rs
index 5b7e608..79c485b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -123,7 +123,7 @@ use client::ClientConnection;
 use util::MessagesQueue;
 
 pub use common::{HTTPVersion, Header, HeaderField, Method, StatusCode};
-pub use request::{ReadWrite, Request};
+pub use request::{MockRequest, ReadWrite, Request};
 pub use response::{Response, ResponseBox};
 
 mod client;
diff --git a/src/request.rs b/src/request.rs
index 85a9acc..7a7991c 100644
--- a/src/request.rs
+++ b/src/request.rs
@@ -72,6 +72,93 @@ pub struct Request {
     notify_when_responded: Option<Sender<()>>,
 }
 
+/// A simpler version of a `Request` that is useful for testing. No data actually goes anywhere.
+///
+/// By default, `MockRequest` pretends to be an unsecure GET request for the server root (`/`)
+/// with no headers. To create a `MockRequest` with different parameters, use the builder pattern:
+///
+/// ```
+/// let request = MockRequest::new()
+///     .with_method(Method::Post)
+///     .with_path("/api/widgets")
+///     .with_body("42");
+/// ```
+///
+/// Then, convert the `MockRequest` into a real `Request` and pass it to the server under test:
+///
+/// ```
+/// let response = server.handle_request(request.into());
+/// assert_eq!(response.status_code(), StatusCode(200));
+/// ```
+pub struct MockRequest {
+    body: &'static str,
+    remote_addr: SocketAddr,
+    // true if HTTPS, false if HTTP
+    secure: bool,
+    method: Method,
+    path: &'static str,
+    http_version: HTTPVersion,
+    headers: Vec<Header>,
+}
+
+impl From<MockRequest> for Request {
+    fn from(mock: MockRequest) -> Request {
+        new_request(
+            mock.secure,
+            mock.method,
+            mock.path.to_string(),
+            mock.http_version,
+            mock.headers,
+            mock.remote_addr,
+            mock.body.as_bytes(),
+            std::io::sink(),
+        )
+        .unwrap()
+    }
+}
+
+impl MockRequest {
+    pub fn new() -> Self {
+        MockRequest {
+            body: "",
+            remote_addr: "0.0.0.0:0".parse().unwrap(),
+            secure: false,
+            method: Method::Get,
+            path: "/",
+            http_version: HTTPVersion::from((1, 1)),
+            headers: Vec::new(),
+        }
+    }
+    pub fn with_body(mut self, body: &'static str) -> Self {
+        self.body = body;
+        self
+    }
+    pub fn with_remote_addr(mut self, remote_addr: SocketAddr) -> Self {
+        self.remote_addr = remote_addr;
+        self
+    }
+    pub fn with_https(mut self) -> Self {
+        self.secure = true;
+        self
+    }
+    pub fn with_method(mut self, method: Method) -> Self {
+        self.method = method;
+        self
+    }
+    pub fn with_path(mut self, path: &'static str) -> Self {
+        self.path = path;
+        self
+    }
+    pub fn with_http_version(mut self, version: HTTPVersion) -> Self {
+        self.http_version = version;
+        self
+    }
+    pub fn with_headers(mut self, headers: Vec<Header>) -> Self {
+        self.headers = headers;
+        self
+    }
+}
+
 struct NotifyOnDrop<R> {
     sender: Sender<()>,
     inner: R,
@@ -97,6 +184,7 @@ impl<R> Drop for NotifyOnDrop<R> {
 }
 
 /// Error that can happen when building a `Request` object.
+#[derive(Debug)]
 pub enum RequestCreationError {
     /// The client sent an `Expect` header that was not recognized by tiny-http.
     ExpectationFailed,
diff --git a/src/response.rs b/src/response.rs
index 5168451..ec63bef 100644
--- a/src/response.rs
+++ b/src/response.rs
@@ -234,6 +234,13 @@ where
         self
     }
 
+    /// Convert the response into the underlying `Read` type.
+    ///
+    /// This is mainly useful for testing as it must consume the `Response`.
+    pub fn into_reader(self) -> R {
+        self.reader
+    }
+
     /// The current `Content-Length` threshold for switching over to
     /// chunked transfer. The default is 32768 bytes. Notice that
     /// chunked transfer is mutually exclusive with sending a
@@ -467,6 +474,11 @@ where
     pub fn data_length(&self) -> Option<usize> {
         self.data_length
     }
+
+    /// Retrieves the current list of `Response` headers
+    pub fn headers(&self) -> &[Header] {
+        &self.headers
+    }
 }
 
 impl<R> Response<R>

I went with new() instead of Default, which matches the builder pattern that clap uses.

Maybe with_headers() should really be with_header()? That way you could call it once for each header, rather than building a Vec<Header> on your own beforehand.

Do you think this is the right path overall?

[Question] How to create mock requests for writing tests? #189

Description

Metadata

Metadata

Assignees

Labels

Type

Fields

Projects

Milestone

Relationships

Development

Issue actions