Merge remote-tracking branch 'origin/main' into handle_form_data

Author: yanns

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wiremock"
-version = "0.5.19"
+version = "0.6.0"
 authors = ["Luca Palmieri <[email protected]>"]
 edition = "2018"
 
@@ -20,19 +20,21 @@ path = "src/lib.rs"
 
 [dependencies]
 log = "0.4"
-http-types = { version = "2.11", default-features = false, features = ["hyperium_http"] }
 serde_json = "1"
 serde = "1"
 regex = "1"
-futures-timer = "3.0.2"
 futures = "0.3.5"
-hyper = { version = "0.14", features = ["full"] }
-tokio = { version = "1.5.0", features = ["rt"] }
-deadpool = "0.9.2"
+http = "1.0"
+http-body-util = "0.1"
+hyper = { version = "1.0", features = ["full"] }
+hyper-util = { version = "0.1", features = ["tokio"] }
+tokio = { version = "1.5.0", features = ["rt", "macros"] }
+deadpool = "0.10.0"
 async-trait = "0.1"
 once_cell = "1"
 assert-json-diff = "2.0.1"
 base64 = "0.21.0"
+url = "2.2"
 serde_urlencoded = "0.7.1"
 
 [dev-dependencies]
@@ -41,4 +43,3 @@ surf = "2.3.2"
 reqwest = "0.11.3"
 tokio = { version = "1.5.0", features = ["macros", "rt-multi-thread"] }
 actix-rt = "2.2.0"
-isahc = "1.3.1"

src/http.rs

@@ -1,3 +1,3 @@
-//! Convenient re-exports of `http-types`' types that are part of `wiremock`'s public API.
-pub use http_types::headers::{HeaderName, HeaderValue, HeaderValues};
-pub use http_types::{Method, Url};
+//! Convenient re-exports of http types that are part of `wiremock`'s public API.
+pub use http::{HeaderMap, HeaderName, HeaderValue, Method};
+pub use url::Url;

src/matchers.rs

@@ -10,15 +10,14 @@
 use crate::{Match, Request};
 use assert_json_diff::{assert_json_matches_no_panic, CompareMode};
 use base64::prelude::{Engine as _, BASE64_STANDARD};
-use http_types::headers::{HeaderName, HeaderValue, HeaderValues};
-use http_types::{Method, Url};
+use http::{HeaderName, HeaderValue, Method};
 use log::debug;
 use regex::Regex;
 use serde::Serialize;
 use serde_json::Value;
 use std::convert::TryInto;
-use std::ops::Deref;
 use std::str;
+use url::Url;
 
 /// Implement the `Match` trait for all closures, out of the box,
 /// if their signature is compatible.
@@ -342,7 +341,7 @@ impl Match for PathRegexMatcher {
 ///     assert_eq!(status, 200);
 /// }
 /// ```
-pub struct HeaderExactMatcher(HeaderName, HeaderValues);
+pub struct HeaderExactMatcher(HeaderName, Vec<HeaderValue>);
 
 /// Shorthand for [`HeaderExactMatcher::new`].
 pub fn header<K, V>(key: K, value: V) -> HeaderExactMatcher
@@ -352,7 +351,7 @@ where
     V: TryInto<HeaderValue>,
     <V as TryInto<HeaderValue>>::Error: std::fmt::Debug,
 {
-    HeaderExactMatcher::new(key, value.try_into().map(HeaderValues::from).unwrap())
+    HeaderExactMatcher::new(key, vec![value])
 }
 
 /// Shorthand for [`HeaderExactMatcher::new`] supporting multi valued headers.
@@ -363,38 +362,44 @@ where
     V: TryInto<HeaderValue>,
     <V as TryInto<HeaderValue>>::Error: std::fmt::Debug,
 {
-    let values = values
-        .into_iter()
-        .filter_map(|v| v.try_into().ok())
-        .collect::<HeaderValues>();
     HeaderExactMatcher::new(key, values)
 }
 
 impl HeaderExactMatcher {
-    pub fn new<K, V>(key: K, value: V) -> Self
+    pub fn new<K, V>(key: K, values: Vec<V>) -> Self
     where
         K: TryInto<HeaderName>,
         <K as TryInto<HeaderName>>::Error: std::fmt::Debug,
-        V: TryInto<HeaderValues>,
-        <V as TryInto<HeaderValues>>::Error: std::fmt::Debug,
+        V: TryInto<HeaderValue>,
+        <V as TryInto<HeaderValue>>::Error: std::fmt::Debug,
     {
         let key = key.try_into().expect("Failed to convert to header name.");
-        let value = value
-            .try_into()
-            .expect("Failed to convert to header value.");
-        Self(key, value)
+        let values = values
+            .into_iter()
+            .map(|value| {
+                value
+                    .try_into()
+                    .expect("Failed to convert to header value.")
+            })
+            .collect();
+        Self(key, values)
     }
 }
 
 impl Match for HeaderExactMatcher {
     fn matches(&self, request: &Request) -> bool {
-        match request.headers.get(&self.0) {
-            None => false,
-            Some(values) => {
-                let headers: Vec<&str> = self.1.iter().map(HeaderValue::as_str).collect();
-                values.eq(headers.as_slice())
-            }
-        }
+        let values = request
+            .headers
+            .get_all(&self.0)
+            .iter()
+            .filter_map(|v| v.to_str().ok())
+            .flat_map(|v| {
+                v.split(',')
+                    .map(str::trim)
+                    .filter_map(|v| HeaderValue::from_str(v).ok())
+            })
+            .collect::<Vec<_>>();
+        values == self.1 // order matters
     }
 }
 
@@ -513,12 +518,16 @@ impl HeaderRegexMatcher {
 
 impl Match for HeaderRegexMatcher {
     fn matches(&self, request: &Request) -> bool {
-        match request.headers.get(&self.0) {
-            None => false,
-            Some(values) => {
-                let has_values = values.iter().next().is_some();
-                has_values && values.iter().all(|v| self.1.is_match(v.as_str()))
-            }
+        let mut it = request
+            .headers
+            .get_all(&self.0)
+            .iter()
+            .filter_map(|v| v.to_str().ok())
+            .peekable();
+        if it.peek().is_some() {
+            it.all(|v| self.1.is_match(v))
+        } else {
+            false
         }
     }
 }
@@ -861,6 +870,64 @@ impl Match for QueryParamExactMatcher {
     }
 }
 
+#[derive(Debug)]
+/// Match when a query parameter contains the specified value as a substring.
+///
+/// ### Example:
+/// ```rust
+/// use wiremock::{MockServer, Mock, ResponseTemplate};
+/// use wiremock::matchers::query_param_contains;
+///
+/// #[async_std::main]
+/// async fn main() {
+///     // Arrange
+///     let mock_server = MockServer::start().await;
+///
+///     // It matches since "world" is a substring of "some_world".
+///     Mock::given(query_param_contains("hello", "world"))
+///         .respond_with(ResponseTemplate::new(200))
+///         .mount(&mock_server)
+///         .await;
+///
+///     // Act
+///     let status = surf::get(format!("{}?hello=some_world", &mock_server.uri()))
+///         .await
+///         .unwrap()
+///         .status();
+///
+///     // Assert
+///     assert_eq!(status, 200);
+/// }
+/// ```
+pub struct QueryParamContainsMatcher(String, String);
+
+impl QueryParamContainsMatcher {
+    /// Specify the substring that the query parameter should contain.
+    pub fn new<K: Into<String>, V: Into<String>>(key: K, value: V) -> Self {
+        let key = key.into();
+        let value = value.into();
+        Self(key, value)
+    }
+}
+
+/// Shorthand for [`QueryParamContainsMatcher::new`].
+pub fn query_param_contains<K, V>(key: K, value: V) -> QueryParamContainsMatcher
+where
+    K: Into<String>,
+    V: Into<String>,
+{
+    QueryParamContainsMatcher::new(key, value)
+}
+
+impl Match for QueryParamContainsMatcher {
+    fn matches(&self, request: &Request) -> bool {
+        request
+            .url
+            .query_pairs()
+            .any(|q| q.0 == self.0.as_str() && q.1.contains(self.1.as_str()))
+    }
+}
+
 #[derive(Debug)]
 /// Only match requests that do **not** contain a specified query parameter.
 ///
@@ -994,7 +1061,6 @@ where
 /// use wiremock::{MockServer, Mock, ResponseTemplate};
 /// use wiremock::matchers::basic_auth;
 /// use serde::{Deserialize, Serialize};
-/// use http_types::auth::BasicAuth;
 /// use std::convert::TryInto;
 ///
 /// #[async_std::main]
@@ -1008,10 +1074,9 @@ where
 ///         .mount(&mock_server)
 ///         .await;
 ///
-///     let auth = BasicAuth::new("username", "password");
 ///     let client: surf::Client = surf::Config::new()
 ///         .set_base_url(surf::Url::parse(&mock_server.uri()).unwrap())
-///         .add_header(auth.name(), auth.value()).unwrap()
+///         .add_header("Authorization", "Basic dXNlcm5hbWU6cGFzc3dvcmQ=").unwrap()
 ///         .try_into().unwrap();
 ///
 ///     // Act
@@ -1040,7 +1105,7 @@ impl BasicAuthMatcher {
     pub fn from_token(token: impl AsRef<str>) -> Self {
         Self(header(
             "Authorization",
-            format!("Basic {}", token.as_ref()).deref(),
+            &*format!("Basic {}", token.as_ref()),
         ))
     }
 }
@@ -1069,7 +1134,6 @@ impl Match for BasicAuthMatcher {
 /// use wiremock::{MockServer, Mock, ResponseTemplate};
 /// use wiremock::matchers::bearer_token;
 /// use serde::{Deserialize, Serialize};
-/// use http_types::auth::BasicAuth;
 ///
 /// #[async_std::main]
 /// async fn main() {
@@ -1098,7 +1162,7 @@ impl BearerTokenMatcher {
     pub fn from_token(token: impl AsRef<str>) -> Self {
         Self(header(
             "Authorization",
-            format!("Bearer {}", token.as_ref()).deref(),
+            &*format!("Bearer {}", token.as_ref()),
         ))
     }
 }

src/mock.rs

@@ -15,13 +15,13 @@ use std::ops::{
 /// use std::convert::TryInto;
 ///
 /// // Check that a header with the specified name exists and its value has an odd length.
-/// pub struct OddHeaderMatcher(http_types::headers::HeaderName);
+/// pub struct OddHeaderMatcher(http::HeaderName);
 ///
 /// impl Match for OddHeaderMatcher {
 ///     fn matches(&self, request: &Request) -> bool {
 ///         match request.headers.get(&self.0) {
 ///             // We are ignoring multi-valued headers for simplicity
-///             Some(values) => values[0].as_str().len() % 2 == 1,
+///             Some(value) => value.to_str().unwrap_or_default().len() % 2 == 1,
 ///             None => false
 ///         }
 ///     }
@@ -69,11 +69,11 @@ use std::ops::{
 ///     // Arrange
 ///     let mock_server = MockServer::start().await;
 ///     
-///     let header_name: http_types::headers::HeaderName = "custom".try_into().unwrap();
+///     let header_name = http::HeaderName::from_static("custom");
 ///     // Check that a header with the specified name exists and its value has an odd length.
 ///     let matcher = move |request: &Request| {
 ///         match request.headers.get(&header_name) {
-///             Some(values) => values[0].as_str().len() % 2 == 1,
+///             Some(value) => value.to_str().unwrap_or_default().len() % 2 == 1,
 ///             None => false
 ///         }
 ///     };
@@ -160,7 +160,7 @@ impl Debug for Matcher {
 ///     mock_server.register(mock).await;
 ///
 ///     // We won't register this mock instead.
-///     let unregistered_mock = Mock::given(method("GET")).respond_with(response);
+///     let unregistered_mock = Mock::given(method("POST")).respond_with(response);
 ///     
 ///     // Act
 ///     let status = surf::get(&mock_server.uri())
@@ -253,6 +253,7 @@ impl Debug for Matcher {
 /// [`register`]: MockServer::register
 /// [`mount`]: Mock::mount
 /// [`mount_as_scoped`]: Mock::mount_as_scoped
+#[must_use = "`Mock`s have to be mounted or registered with a `MockServer` to become effective"]
 pub struct Mock {
     pub(crate) matchers: Vec<Matcher>,
     pub(crate) response: Box<dyn Respond>,
@@ -539,7 +540,7 @@ impl Mock {
     /// # Limitations
     ///
     /// When expectations of a scoped [`Mock`] are not verified, it will trigger a panic - just like a normal [`Mock`].
-    /// Due to [limitations](https://internals.rust-lang.org/t/should-drop-glue-use-track-caller/13682) in Rust's [`Drop`](std::ops::Drop) trait,
+    /// Due to [limitations](https://internals.rust-lang.org/t/should-drop-glue-use-track-caller/13682) in Rust's [`Drop`] trait,
     /// the panic message will not include the filename and the line location
     /// where the corresponding [`MockGuard`] was dropped - it will point into `wiremock`'s source code.  
     ///
@@ -626,7 +627,7 @@ impl Mock {
         server.register_as_scoped(self).await
     }
 
-    /// Given a [`Request`](crate::Request) build an instance a [`ResponseTemplate`] using
+    /// Given a [`Request`] build an instance a [`ResponseTemplate`] using
     /// the responder associated with the `Mock`.
     pub(crate) fn response_template(&self, request: &Request) -> ResponseTemplate {
         self.response.respond(request)