Add ReqwestRequestExecutor behind reqwest-request-executor Cargo feature

wp_api/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [features]
 integration-tests = []
+reqwest-request-executor = ["dep:reqwest"]
 
 [lib]
 crate-type = ["lib", "cdylib", "staticlib"]
@@ -21,6 +22,7 @@ url = { workspace = true }
 parse_link_header = { workspace = true }
 paste = { workspace = true }
 regex = { workspace = true }
+reqwest = { workspace = true, features = [ "multipart", "json", "stream", "gzip", "brotli", "zstd", "deflate" ], optional = true }
 scraper = { workspace = true }
 serde = { workspace = true, features = [ "derive", "rc" ] }
 serde_json = { workspace = true }

wp_api/src/lib.rs

@@ -38,6 +38,9 @@ pub mod users;
 pub mod wordpress_org;
 pub mod wp_site_health_tests;
 
+#[cfg(feature = "reqwest-request-executor")]
+pub mod reqwest_request_executor;
+
 #[cfg(test)]
 mod unit_test_common;
 

wp_api/src/reqwest_request_executor.rs

@@ -0,0 +1,136 @@
+use crate::{
+    request::{
+        endpoint::media_endpoint::MediaUploadRequest, RequestExecutor, RequestMethod,
+        WpNetworkHeaderMap, WpNetworkRequest, WpNetworkResponse,
+    },
+    MediaUploadRequestExecutionError, RequestExecutionError, RequestExecutionErrorReason,
+};
+use async_trait::async_trait;
+use http::{HeaderMap, HeaderValue};
+use reqwest::multipart::Part;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct ReqwestRequestExecutor {
+    client: reqwest::Client,
+}
+
+impl ReqwestRequestExecutor {
+    pub fn new(danger_accept_invalid_certs: bool) -> Self {
+        Self {
+            client: reqwest::Client::builder()
+                .danger_accept_invalid_certs(danger_accept_invalid_certs)
+                .build()
+                .expect("We should be able to build the reqwest client with this configuration"),
+        }
+    }
+}
+
+impl ReqwestRequestExecutor {
+    pub async fn async_request(
+        &self,
+        wp_request: Arc<WpNetworkRequest>,
+    ) -> Result<WpNetworkResponse, reqwest::Error> {
+        let mut request = self
+            .client
+            .request(
+                Self::request_method(wp_request.method()),
+                wp_request.url().0.as_str(),
+            )
+            .headers(wp_request.header_map().to_header_map());
+        if let Some(body) = wp_request.body() {
+            request = request.body(body.contents());
+        }
+        let mut response = request.send().await?;
+
+        let header_map = std::mem::take(response.headers_mut());
+        Ok(WpNetworkResponse {
+            status_code: response.status().as_u16(),
+            body: response.bytes().await.unwrap().to_vec(),
+            header_map: Arc::new(WpNetworkHeaderMap::new(header_map)),
+        })
+    }
+
+    pub async fn upload_media_request(
+        &self,
+        media_upload_request: Arc<MediaUploadRequest>,
+    ) -> Result<WpNetworkResponse, reqwest::Error> {
+        let request = self
+            .client
+            .request(
+                Self::request_method(media_upload_request.method()),
+                media_upload_request.url().0.as_str(),
+            )
+            .headers(media_upload_request.header_map().to_header_map());
+        let file_path = media_upload_request.file_path();
+        let mut file_header_map = HeaderMap::new();
+        file_header_map.insert(
+            http::header::CONTENT_TYPE,
+            HeaderValue::from_str(&media_upload_request.file_content_type()).unwrap(),
+        );
+        let mut form = reqwest::multipart::Form::new().part(
+            "file",
+            Part::file(file_path)
+                .await
+                .unwrap()
+                .headers(file_header_map),
+        );
+        for (k, v) in media_upload_request.media_params() {
+            form = form.text(k, v)
+        }
+
+        let request = request.multipart(form);
+        let mut response = request.send().await?;
+
+        let header_map = std::mem::take(response.headers_mut());
+        Ok(WpNetworkResponse {
+            status_code: response.status().as_u16(),
+            body: response.bytes().await.unwrap().to_vec(),
+            header_map: Arc::new(WpNetworkHeaderMap::new(header_map)),
+        })
+    }
+
+    pub fn request_method(method: RequestMethod) -> http::Method {
+        match method {
+            RequestMethod::GET => reqwest::Method::GET,
+            RequestMethod::POST => reqwest::Method::POST,
+            RequestMethod::PUT => reqwest::Method::PUT,
+            RequestMethod::DELETE => reqwest::Method::DELETE,
+            RequestMethod::HEAD => reqwest::Method::HEAD,
+        }
+    }
+}
+#[async_trait]
+impl RequestExecutor for ReqwestRequestExecutor {
+    async fn execute(
+        &self,
+        request: Arc<WpNetworkRequest>,
+    ) -> Result<WpNetworkResponse, RequestExecutionError> {
+        self.async_request(request).await.map_err(|err| {
+            RequestExecutionError::RequestExecutionFailed {
+                status_code: err.status().map(|s| s.as_u16()),
+                redirects: None,
+                reason: RequestExecutionErrorReason::GenericError {
+                    error_message: err.to_string(),
+                },
+            }
+        })
+    }
+
+    async fn upload_media(
+        &self,
+        media_upload_request: Arc<MediaUploadRequest>,
+    ) -> Result<WpNetworkResponse, MediaUploadRequestExecutionError> {
+        self.upload_media_request(media_upload_request)
+            .await
+            .map_err(
+                |err| MediaUploadRequestExecutionError::RequestExecutionFailed {
+                    status_code: err.status().map(|s| s.as_u16()),
+                    redirects: None,
+                    reason: RequestExecutionErrorReason::GenericError {
+                        error_message: err.to_string(),
+                    },
+                },
+            )
+    }
+}

wp_api_integration_tests/Cargo.toml

@@ -18,7 +18,7 @@ serde = { workspace = true, features = [ "derive" ] }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = [ "full" ] }
 url = { workspace = true }
-wp_api = { path = "../wp_api", features = [ "integration-tests" ] }
+wp_api = { path = "../wp_api", features = [ "integration-tests", "reqwest-request-executor" ] }
 wp_cli = { path = "../wp_cli" }
 
 [dev-dependencies]

wp_api_integration_tests/src/lib.rs

@@ -1,21 +1,8 @@
-use async_trait::async_trait;
-use http::{HeaderMap, HeaderValue};
-use reqwest::multipart::Part;
 use std::sync::Arc;
 use wp_api::{
-    categories::CategoryId,
-    comments::CommentId,
-    date::WpGmtDateTime,
-    media::MediaId,
-    posts::PostId,
-    request::{
-        endpoint::media_endpoint::MediaUploadRequest, RequestExecutor, RequestMethod,
-        WpNetworkHeaderMap, WpNetworkRequest, WpNetworkResponse,
-    },
-    tags::TagId,
-    users::UserId,
-    MediaUploadRequestExecutionError, ParsedUrl, RequestExecutionError,
-    RequestExecutionErrorReason, WpApiClient, WpApiError, WpAuthentication, WpErrorCode,
+    categories::CategoryId, comments::CommentId, date::WpGmtDateTime, media::MediaId,
+    posts::PostId, reqwest_request_executor::ReqwestRequestExecutor, tags::TagId, users::UserId,
+    ParsedUrl, WpApiClient, WpApiError, WpAuthentication, WpErrorCode,
 };
 
 // A `TestCredentials::instance()` function will be generated by this
@@ -89,7 +76,7 @@ pub fn api_client() -> WpApiClient {
     WpApiClient::new(
         test_site_url(),
         authentication,
-        Arc::new(AsyncWpNetworking::default()),
+        Arc::new(ReqwestRequestExecutor::new(true)),
     )
 }
 
@@ -101,7 +88,7 @@ pub fn api_client_as_author() -> WpApiClient {
     WpApiClient::new(
         test_site_url(),
         authentication,
-        Arc::new(AsyncWpNetworking::default()),
+        Arc::new(ReqwestRequestExecutor::new(true)),
     )
 }
 
@@ -113,15 +100,15 @@ pub fn api_client_as_subscriber() -> WpApiClient {
     WpApiClient::new(
         test_site_url(),
         authentication,
-        Arc::new(AsyncWpNetworking::default()),
+        Arc::new(ReqwestRequestExecutor::new(true)),
     )
 }
 
 pub fn api_client_as_unauthenticated() -> WpApiClient {
     WpApiClient::new(
         test_site_url(),
         WpAuthentication::None,
-        Arc::new(AsyncWpNetworking::default()),
+        Arc::new(ReqwestRequestExecutor::new(true)),
     )
 }
 
@@ -155,131 +142,6 @@ impl<T: std::fmt::Debug> AssertWpError<T> for Result<T, WpApiError> {
     }
 }
 
-#[derive(Debug)]
-pub struct AsyncWpNetworking {
-    client: reqwest::Client,
-}
-
-impl Default for AsyncWpNetworking {
-    fn default() -> Self {
-        Self {
-            client: reqwest::Client::builder()
-                .danger_accept_invalid_certs(true)
-                .build()
-                .expect("We should be able to build the reqwest client with this configuration"),
-        }
-    }
-}
-
-impl AsyncWpNetworking {
-    pub async fn async_request(
-        &self,
-        wp_request: Arc<WpNetworkRequest>,
-    ) -> Result<WpNetworkResponse, reqwest::Error> {
-        let mut request = self
-            .client
-            .request(
-                Self::request_method(wp_request.method()),
-                wp_request.url().0.as_str(),
-            )
-            .headers(wp_request.header_map().to_header_map());
-        if let Some(body) = wp_request.body() {
-            request = request.body(body.contents());
-        }
-        let mut response = request.send().await?;
-
-        let header_map = std::mem::take(response.headers_mut());
-        Ok(WpNetworkResponse {
-            status_code: response.status().as_u16(),
-            body: response.bytes().await.unwrap().to_vec(),
-            header_map: Arc::new(WpNetworkHeaderMap::new(header_map)),
-        })
-    }
-
-    pub async fn upload_media_request(
-        &self,
-        media_upload_request: Arc<MediaUploadRequest>,
-    ) -> Result<WpNetworkResponse, reqwest::Error> {
-        let request = self
-            .client
-            .request(
-                Self::request_method(media_upload_request.method()),
-                media_upload_request.url().0.as_str(),
-            )
-            .headers(media_upload_request.header_map().to_header_map());
-        let file_path = media_upload_request.file_path();
-        let mut file_header_map = HeaderMap::new();
-        file_header_map.insert(
-            http::header::CONTENT_TYPE,
-            HeaderValue::from_str(&media_upload_request.file_content_type()).unwrap(),
-        );
-        let mut form = reqwest::multipart::Form::new().part(
-            "file",
-            Part::file(file_path)
-                .await
-                .unwrap()
-                .headers(file_header_map),
-        );
-        for (k, v) in media_upload_request.media_params() {
-            form = form.text(k, v)
-        }
-
-        let request = request.multipart(form);
-        let mut response = request.send().await?;
-
-        let header_map = std::mem::take(response.headers_mut());
-        Ok(WpNetworkResponse {
-            status_code: response.status().as_u16(),
-            body: response.bytes().await.unwrap().to_vec(),
-            header_map: Arc::new(WpNetworkHeaderMap::new(header_map)),
-        })
-    }
-
-    pub fn request_method(method: RequestMethod) -> http::Method {
-        match method {
-            RequestMethod::GET => reqwest::Method::GET,
-            RequestMethod::POST => reqwest::Method::POST,
-            RequestMethod::PUT => reqwest::Method::PUT,
-            RequestMethod::DELETE => reqwest::Method::DELETE,
-            RequestMethod::HEAD => reqwest::Method::HEAD,
-        }
-    }
-}
-#[async_trait]
-impl RequestExecutor for AsyncWpNetworking {
-    async fn execute(
-        &self,
-        request: Arc<WpNetworkRequest>,
-    ) -> Result<WpNetworkResponse, RequestExecutionError> {
-        self.async_request(request).await.map_err(|err| {
-            RequestExecutionError::RequestExecutionFailed {
-                status_code: err.status().map(|s| s.as_u16()),
-                redirects: None,
-                reason: RequestExecutionErrorReason::GenericError {
-                    error_message: err.to_string(),
-                },
-            }
-        })
-    }
-
-    async fn upload_media(
-        &self,
-        media_upload_request: Arc<MediaUploadRequest>,
-    ) -> Result<WpNetworkResponse, MediaUploadRequestExecutionError> {
-        self.upload_media_request(media_upload_request)
-            .await
-            .map_err(
-                |err| MediaUploadRequestExecutionError::RequestExecutionFailed {
-                    status_code: err.status().map(|s| s.as_u16()),
-                    redirects: None,
-                    reason: RequestExecutionErrorReason::GenericError {
-                        error_message: err.to_string(),
-                    },
-                },
-            )
-    }
-}
-
 pub trait AssertResponse {
     type Item;