nits

Signed-off-by: Sam Batschelet <[email protected]>

Author: hexfusion

spacesvm/src/api/client.rs

@@ -28,7 +28,7 @@ use serde::de;
 pub use http::Uri;
 use tokio::sync::RwLock;
 
-/// HTTP client for interacting with the API.
+/// Thread safe HTTP client for interacting with the API.
 pub struct Client<C> {
     inner: Arc<RwLock<ClientInner<C>>>,
 }
@@ -73,18 +73,22 @@ impl Client<HttpConnector> {
     }
 
     /// Returns a serialized json request as string and the request id.
-    pub async fn raw_request(&self, method: &str, params: &Params) -> (Id, String) {
+    pub async fn raw_request(&self, method: &str, params: &Params) -> Result<(Id, String)> {
         let id = self.next_id().await;
         let request = jsonrpc_core::Request::Single(Call::MethodCall(MethodCall {
             jsonrpc: Some(Version::V2),
             method: method.to_owned(),
             params: params.to_owned(),
             id: id.clone(),
         }));
-        (
-            id,
-            serde_json::to_string(&request).expect("jsonrpc request should be serializable"),
-        )
+        let request = serde_json::to_string(&request).map_err(|e| {
+            Error::new(
+                ErrorKind::Other,
+                format!("jsonrpc request should be serializable: {}", e),
+            )
+        })?;
+
+        Ok((id, request))
     }
 
     /// Returns a recoverable signature from 32 byte SHA256 message.
@@ -98,7 +102,7 @@ impl Client<HttpConnector> {
 
     /// Returns a PingResponse from client request.
     pub async fn ping(&self) -> Result<PingResponse> {
-        let (_id, json_request) = self.raw_request("ping", &Params::None).await;
+        let (_id, json_request) = self.raw_request("ping", &Params::None).await?;
         let resp = self.post_de::<PingResponse>(&json_request).await?;
 
         Ok(resp)
@@ -109,7 +113,7 @@ impl Client<HttpConnector> {
         let arg_value = serde_json::to_value(&DecodeTxArgs { tx_data })?;
         let (_id, json_request) = self
             .raw_request("decodeTx", &Params::Array(vec![arg_value]))
-            .await;
+            .await?;
         let resp = self.post_de::<DecodeTxResponse>(&json_request).await?;
 
         Ok(resp)
@@ -127,7 +131,7 @@ impl Client<HttpConnector> {
         })?;
         let (_id, json_request) = self
             .raw_request("issueTx", &Params::Array(vec![arg_value]))
-            .await;
+            .await?;
         let resp = self.post_de::<IssueTxResponse>(&json_request).await?;
 
         Ok(resp)
@@ -141,7 +145,7 @@ impl Client<HttpConnector> {
         })?;
         let (_id, json_request) = self
             .raw_request("resolve", &Params::Array(vec![arg_value]))
-            .await;
+            .await?;
         let resp = self.post_de::<ResolveResponse>(&json_request).await?;
 
         Ok(resp)
@@ -241,9 +245,9 @@ pub fn get_or_create_pk(path: &str) -> Result<key::secp256k1::private_key::Key>
 #[tokio::test]
 async fn test_raw_request() {
     let cli = Client::new(Uri::from_static("http://test.url"));
-    let (id, _) = cli.raw_request("ping", &Params::None).await;
+    let (id, _) = cli.raw_request("ping", &Params::None).await?;
     assert_eq!(id, jsonrpc_core::Id::Num(0));
-    let (id, req) = cli.raw_request("ping", &Params::None).await;
+    let (id, req) = cli.raw_request("ping", &Params::None).await?;
     assert_eq!(id, jsonrpc_core::Id::Num(1));
     assert_eq!(
         req,

spacesvm/tests/vm/mod.rs

@@ -113,7 +113,7 @@ async fn test_api() {
     let client = spacesvm::api::client::Client::new(http::Uri::from_static("http://test.url"));
 
     // ping
-    let (_id, json_str) = client.raw_request("ping", &Params::None).await;
+    let (_id, json_str) = client.raw_request("ping", &Params::None).await?;
     let req = http::request::Builder::new()
         .body(json_str.as_bytes().to_vec())
         .unwrap();
@@ -141,7 +141,7 @@ async fn test_api() {
 
     let (_id, json_str) = client
         .raw_request("decodeTx", &Params::Array(vec![arg_value]))
-        .await;
+        .await?;
     log::info!("decodeTx request: {}", json_str);
     let req = http::request::Builder::new()
         .body(json_str.as_bytes().to_vec())

tests/e2e/src/tests/mod.rs

@@ -217,7 +217,7 @@ async fn e2e() {
         .decode_tx(claim_tx("test"))
         .await
         .expect("decodeTx success");
-    log::info!("decode claim response from {}: {:?}", chain_url, resp);
+    log::info!("decode claim tx response from {}: {:?}", chain_url, resp);
 
     log::info!("issue claim tx request...");
     let resp = scli
@@ -231,14 +231,14 @@ async fn e2e() {
         .decode_tx(set_tx("test", "foo", "bar"))
         .await
         .expect("decodeTx success");
-    log::info!("decode set response from {}: {:?}", chain_url, resp);
+    log::info!("decode set tx response from {}: {:?}", chain_url, resp);
 
     log::info!("issue set tx request...");
     let resp = scli
         .issue_tx(&resp.typed_data)
         .await
         .expect("issue_tx success");
-    log::info!("issue tx tx response from {}: {:?}", chain_url, resp);
+    log::info!("issue set tx response from {}: {:?}", chain_url, resp);
 
     log::info!("issue resolve request...");
     let resp = scli.resolve("test", "foo").await.expect("resolve success");