Add service request validation and tests (#23)

Signed-off-by: declark1 <[email protected]>

Author: declark1

mocktail-tests/tests/misc/mod.rs

@@ -0,0 +1 @@
+mod validation;

mocktail-tests/tests/misc/validation.rs

@@ -0,0 +1,44 @@
+use anyhow::Error;
+use mocktail::prelude::*;
+use test_log::test;
+
+#[test(tokio::test)]
+async fn test_grpc_service() -> Result<(), Error> {
+    let server = MockServer::new("test").grpc();
+    server.start().await?;
+
+    let client = reqwest::Client::builder().http2_prior_knowledge().build()?;
+
+    // Invalid method
+    let response = client.get(server.url("/hello")).send().await?;
+    assert_eq!(response.status(), http::StatusCode::METHOD_NOT_ALLOWED);
+    assert!(response
+        .headers()
+        .get("allow")
+        .is_some_and(|value| value == "POST"));
+
+    // Invalid content-type
+    let response = client.post(server.url("/hello")).send().await?;
+    assert_eq!(response.status(), http::StatusCode::UNSUPPORTED_MEDIA_TYPE);
+    assert!(response
+        .headers()
+        .get("accept-post")
+        .is_some_and(|value| value == "application/grpc"));
+
+    Ok(())
+}
+
+#[test(tokio::test)]
+async fn test_http_service() -> Result<(), Error> {
+    let server = MockServer::new("test");
+    server.start().await?;
+
+    let client = reqwest::Client::builder().http2_prior_knowledge().build()?;
+
+    // Invalid method
+    let response = client.patch(server.url("/hello")).send().await?;
+    assert_eq!(response.status(), http::StatusCode::METHOD_NOT_ALLOWED);
+    assert!(response.headers().get("allow").is_some());
+
+    Ok(())
+}

mocktail/src/headers.rs

@@ -70,14 +70,6 @@ impl Headers {
         other.is_subset(self)
     }
 
-    /// Returns true if the headers contains a `content-type` header equal to value.
-    pub fn has_content_type(&self, value: &str) -> bool {
-        if let Some(content_type) = self.get("content-type") {
-            return content_type.starts_with(value);
-        }
-        false
-    }
-
     /// Returns an iterator over the headers.
     pub fn iter(&self) -> std::slice::Iter<'_, (HeaderName, HeaderValue)> {
         self.0.iter()

mocktail/src/server.rs

@@ -195,7 +195,7 @@ where
                     ServerKind::Grpc => conn::auto::Builder::new(TokioExecutor::new()).http2_only(),
                 };
                 if let Err(err) = builder.serve_connection(io, service).await {
-                    error!("connection error: {err}");
+                    debug!("connection error: {err}");
                 }
                 debug!("connection dropped: {addr}");
             });

mocktail/src/service/grpc.rs

@@ -15,7 +15,7 @@ use tokio_stream::wrappers::ReceiverStream;
 use tonic::body::BoxBody;
 use tracing::debug;
 
-use crate::{headers::Headers, mock_set::MockSet, request::Request};
+use crate::{mock_set::MockSet, request::Request};
 
 /// Mock gRPC service.
 #[derive(Debug, Clone)]
@@ -38,10 +38,27 @@ impl Service<http::Request<Incoming>> for GrpcMockService {
         let mocks = self.mocks.clone();
         let fut = async move {
             debug!(?req, "handling request");
-            let headers: Headers = req.headers().into();
-            if !headers.has_content_type("application/grpc") {
-                return Ok(invalid_content_type_response());
+
+            if req.method() != http::Method::POST {
+                return Ok(http::Response::builder()
+                    .status(http::StatusCode::METHOD_NOT_ALLOWED)
+                    .header("Allow", "POST")
+                    .body(tonic::body::empty_body())
+                    .unwrap());
+            }
+            let content_type = req.headers().get("content-type");
+            if !content_type.is_some_and(|v| {
+                v.to_str()
+                    .unwrap_or_default()
+                    .starts_with("application/grpc")
+            }) {
+                return Ok(http::Response::builder()
+                    .status(http::StatusCode::UNSUPPORTED_MEDIA_TYPE)
+                    .header("Accept-Post", "application/grpc")
+                    .body(tonic::body::empty_body())
+                    .unwrap());
             }
+
             let (parts, body) = req.into_parts();
             let mut stream = body.into_data_stream();
 
@@ -106,18 +123,6 @@ impl Service<http::Request<Incoming>> for GrpcMockService {
     }
 }
 
-fn invalid_content_type_response() -> http::Response<BoxBody> {
-    http::Response::builder()
-        .header("content-type", "application/grpc")
-        .header("grpc-status", tonic::Code::InvalidArgument as i32)
-        .header(
-            "grpc-message",
-            "invalid content-type: expected `application/grpc`",
-        )
-        .body(tonic::body::empty_body())
-        .unwrap()
-}
-
 fn mock_not_found_trailer() -> HeaderMap {
     let mut headers = HeaderMap::new();
     headers.insert("grpc-status", (tonic::Code::NotFound as i32).into());

mocktail/src/service/http.rs

@@ -8,7 +8,7 @@ use bytes::{Bytes, BytesMut};
 use futures::{future::BoxFuture, StreamExt};
 use http::HeaderMap;
 use http_body::{Body as _, Frame};
-use http_body_util::{BodyExt, Full, StreamBody};
+use http_body_util::{BodyExt, Empty, Full, StreamBody};
 use hyper::{body::Incoming, service::Service};
 use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
@@ -18,6 +18,14 @@ use crate::{mock_set::MockSet, request::Request};
 
 type BoxBody = http_body_util::combinators::BoxBody<Bytes, hyper::Error>;
 
+const ALLOWED_METHODS: [http::Method; 5] = [
+    http::Method::GET,
+    http::Method::POST,
+    http::Method::PUT,
+    http::Method::HEAD,
+    http::Method::DELETE,
+];
+
 /// Mock HTTP service.
 #[derive(Debug, Clone)]
 pub struct HttpMockService {
@@ -39,6 +47,15 @@ impl Service<http::Request<Incoming>> for HttpMockService {
         let mocks = self.mocks.clone();
         let fut = async move {
             debug!(?req, "handling request");
+
+            if !ALLOWED_METHODS.contains(req.method()) {
+                return Ok(http::Response::builder()
+                    .status(http::StatusCode::METHOD_NOT_ALLOWED)
+                    .header("Allow", "GET, POST, PUT, HEAD, DELETE")
+                    .body(empty())
+                    .unwrap());
+            }
+
             let (parts, mut body) = req.into_parts();
 
             // Get initial data frame
@@ -144,3 +161,7 @@ impl Service<http::Request<Incoming>> for HttpMockService {
 fn full(data: Bytes) -> BoxBody {
     Full::new(data).map_err(|err| match err {}).boxed()
 }
+
+fn empty() -> BoxBody {
+    Empty::new().map_err(|err| match err {}).boxed()
+}