Add basic auth support

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-package.version = "0.1.1"
+package.version = "0.2.0"
 package.edition = "2021"
 package.documentation = "https://docs.rs/reqwest_enum"
 package.authors = ["Tao Xu <[email protected]>"]
@@ -16,5 +16,5 @@ reqwest = { version = "^0.12.0", features = ["json"] }
 serde = { version = "^1.0.0", features = ["derive"] }
 serde_json = "^1.0.0"
 
-async-trait = "^0.1.0"
 futures = "^0.3.0"
+tokio-test = "0.4.2"

README.md

@@ -17,7 +17,7 @@ Features:
 
 ```toml
 [dependencies]
-reqwest-enum = "0.1.0"
+reqwest-enum = "0.2.0"
 ```
 
 ## Example
@@ -30,6 +30,7 @@ reqwest-enum = "0.1.0"
 pub enum HttpBin {
     Get,
     Post,
+    Bearer,
 }
 ```
 
@@ -42,6 +43,7 @@ pub trait Target {
     fn path(&self) -> &'static str;
     fn query(&self) -> HashMap<&'static str, &'static str>;
     fn headers(&self) -> HashMap<&'static str, &'static str>;
+    fn authentication(&self) -> Option<AuthMethod>;
     fn body(&self) -> HTTPBody;
 }
 ```

examples/ethereum-rpc/Cargo.toml

@@ -11,4 +11,4 @@ reqwest = { workspace = true }
 reqwest-enum = { workspace = true, features = ["jsonrpc"] }
 
 [dev-dependencies]
-tokio-test = "0.4.2"
+tokio-test = { workspace = true }

examples/ethereum-rpc/src/ethereum_rpc.rs

@@ -1,9 +1,9 @@
 extern crate reqwest;
 extern crate reqwest_enum;
-use reqwest_enum::jsonrpc::{JsonRpcRequest, JsonRpcTarget};
+use reqwest_enum::jsonrpc::JsonRpcRequest;
 use reqwest_enum::{
-    http::{HTTPBody, HTTPMethod},
-    target::Target,
+    http::{AuthMethod, HTTPBody, HTTPMethod},
+    target::{JsonRpcTarget, Target},
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{Number, Value};
@@ -158,6 +158,10 @@ impl Target for EthereumRPC {
         headers
     }
 
+    fn authentication(&self) -> Option<AuthMethod> {
+        None
+    }
+
     fn body(&self) -> HTTPBody {
         let method = self.method_name();
         let params = self.params();

reqwest-enum/Cargo.toml

@@ -20,3 +20,6 @@ reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 futures = { workspace = true, optional = true }
+
+[dev-dependencies]
+tokio-test = { workspace = true }

reqwest-enum/src/http.rs

@@ -56,3 +56,10 @@ impl HTTPBody {
         }
     }
 }
+
+pub enum AuthMethod {
+    // Basic(username, password)
+    Basic(&'static str, &'static str),
+    // Bearer(token)
+    Bearer(&'static str),
+}

reqwest-enum/src/jsonrpc.rs

@@ -1,4 +1,4 @@
-use crate::{http::HTTPBody, target::Target};
+use crate::http::HTTPBody;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -88,12 +88,6 @@ pub enum JsonRpcResult<T> {
     Error(JsonRpcErrorResponse),
 }
 
-#[cfg(feature = "jsonrpc")]
-pub trait JsonRpcTarget: Target {
-    fn method_name(&self) -> &'static str;
-    fn params(&self) -> Vec<Value>;
-}
-
 #[cfg(feature = "jsonrpc")]
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]

reqwest-enum/src/provider.rs

@@ -1,10 +1,12 @@
 #[cfg(feature = "jsonrpc")]
-use crate::jsonrpc::{JsonRpcError, JsonRpcRequest, JsonRpcResult, JsonRpcTarget};
+use crate::jsonrpc::{JsonRpcError, JsonRpcRequest, JsonRpcResult};
+#[cfg(feature = "jsonrpc")]
+use crate::target::JsonRpcTarget;
 #[cfg(feature = "jsonrpc")]
 use futures::future::join_all;
 
 use crate::{
-    http::{HTTPBody, HTTPResponse},
+    http::{AuthMethod, HTTPBody, HTTPResponse},
     target::Target,
 };
 use core::future::Future;
@@ -189,6 +191,16 @@ where
                 request = request.header(k, v);
             }
         }
+        if let Some(auth) = target.authentication() {
+            match auth {
+                AuthMethod::Basic(username, password) => {
+                    request = request.basic_auth(username, Some(password));
+                }
+                AuthMethod::Bearer(token) => {
+                    request = request.bearer_auth(token);
+                }
+            }
+        }
         request
     }
 }
@@ -208,13 +220,13 @@ where
 #[cfg(test)]
 mod tests {
     use crate::{
-        http::{HTTPBody, HTTPMethod},
-        provider::Provider,
+        http::{AuthMethod, HTTPBody, HTTPMethod},
+        provider::{JsonProviderType, Provider},
         target::Target,
     };
     use serde::{Deserialize, Serialize};
     use std::collections::HashMap;
-
+    use tokio_test::block_on;
     #[derive(Serialize, Deserialize)]
     struct Person {
         name: String,
@@ -225,6 +237,7 @@ mod tests {
     enum HttpBin {
         Get,
         Post,
+        Bearer,
     }
 
     impl Target for HttpBin {
@@ -236,13 +249,15 @@ mod tests {
             match self {
                 HttpBin::Get => HTTPMethod::GET,
                 HttpBin::Post => HTTPMethod::POST,
+                HttpBin::Bearer => HTTPMethod::GET,
             }
         }
 
         fn path(&self) -> &'static str {
             match self {
                 HttpBin::Get => "/get",
                 HttpBin::Post => "/post",
+                HttpBin::Bearer => "/bearer",
             }
         }
 
@@ -254,9 +269,16 @@ mod tests {
             HashMap::default()
         }
 
+        fn authentication(&self) -> Option<AuthMethod> {
+            match self {
+                HttpBin::Bearer => Some(AuthMethod::Bearer("token")),
+                _ => None,
+            }
+        }
+
         fn body(&self) -> HTTPBody {
             match self {
-                HttpBin::Get => HTTPBody::default(),
+                HttpBin::Get | HttpBin::Bearer => HTTPBody::default(),
                 HttpBin::Post => HTTPBody::from(&Person {
                     name: "test".to_string(),
                     age: 20,
@@ -277,4 +299,17 @@ mod tests {
         let provider = Provider::<HttpBin>::new(|_: &HttpBin| "http://httpbin.org".to_string());
         assert_eq!(provider.request_url(&HttpBin::Post), "http://httpbin.org");
     }
+
+    #[test]
+    fn test_authentication() {
+        let provider = Provider::<HttpBin>::default();
+        block_on(async {
+            let response: serde_json::Value = provider
+                .request_json(HttpBin::Bearer)
+                .await
+                .expect("request error");
+
+            assert!(response["authenticated"].as_bool().unwrap());
+        });
+    }
 }

reqwest-enum/src/target.rs

@@ -1,10 +1,17 @@
-use crate::http::{HTTPBody, HTTPMethod};
+use crate::http::{AuthMethod, HTTPBody, HTTPMethod};
 use std::collections::HashMap;
 pub trait Target {
     fn base_url(&self) -> &'static str;
     fn method(&self) -> HTTPMethod;
     fn path(&self) -> &'static str;
     fn query(&self) -> HashMap<&'static str, &'static str>;
     fn headers(&self) -> HashMap<&'static str, &'static str>;
+    fn authentication(&self) -> Option<AuthMethod>;
     fn body(&self) -> HTTPBody;
 }
+
+#[cfg(feature = "jsonrpc")]
+pub trait JsonRpcTarget: Target {
+    fn method_name(&self) -> &'static str;
+    fn params(&self) -> Vec<serde_json::Value>;
+}