e2e: add client tests

hexfusion · hexfusion · commit bd42bdf26f79 · 2022-11-25T08:54:54.000-05:00
Signed-off-by: Sam Batschelet &lt;sam.batschelet@avalabs.org&gt;
diff --git a/spaces-cli/src/bin/spaces-cli/main.rs b/spaces-cli/src/bin/spaces-cli/main.rs
@@ -3,11 +3,8 @@ use std::error;
 use clap::{Parser, Subcommand};
 use jsonrpc_core::futures;
 use spacesvm::{
-    api::{
-        client::{claim_tx, delete_tx, get_or_create_pk, set_tx, Client, Uri},
-        DecodeTxArgs, IssueTxArgs, ResolveArgs,
-    },
-    chain::tx::{decoder, unsigned::TransactionData},
+    api::client::{claim_tx, delete_tx, get_or_create_pk, set_tx, Client, Uri},
+    chain::tx::unsigned::TransactionData,
 };
 
 #[derive(Subcommand, Debug)]
@@ -47,20 +44,16 @@ struct Cli {
     command: Command,
 }
 
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn error::Error>> {
+fn main() -> Result<(), Box<dyn error::Error>> {
     let cli = Cli::parse();
 
-    let secret_key = get_or_create_pk(&cli.private_key_file)?;
+    let private_key = get_or_create_pk(&cli.private_key_file)?;
     let uri = cli.endpoint.parse::<Uri>()?;
-    let mut client = Client::new(uri);
+    let mut client = Client::new(uri).set_private_key(private_key);
 
     if let Command::Get { space, key } = &cli.command {
-        let resp = futures::executor::block_on(client.resolve(ResolveArgs {
-            space: space.as_bytes().to_vec(),
-            key: key.as_bytes().to_vec(),
-        }))
-        .map_err(|e| e.to_string())?;
+        let resp =
+            futures::executor::block_on(client.resolve(space, key)).map_err(|e| e.to_string())?;
         log::debug!("resolve response: {:?}", resp);
 
         println!("{}", serde_json::to_string(&resp)?);
@@ -76,21 +69,13 @@ async fn main() -> Result<(), Box<dyn error::Error>> {
 
     // decode tx
     let tx_data = command_to_tx(cli.command)?;
-    let resp = futures::executor::block_on(client.decode_tx(DecodeTxArgs { tx_data }))
-        .map_err(|e| e.to_string())?;
+    let resp = futures::executor::block_on(client.decode_tx(tx_data)).map_err(|e| e.to_string())?;
 
     let typed_data = &resp.typed_data;
 
-    // create signature
-    let dh = decoder::hash_structured_data(typed_data)?;
-    let sig = secret_key.sign_digest(&dh.as_bytes())?;
-
     // issue tx
-    let resp = futures::executor::block_on(client.issue_tx(IssueTxArgs {
-        typed_data: resp.typed_data,
-        signature: sig.to_bytes().to_vec(),
-    }))
-    .map_err(|e| e.to_string())?;
+    let resp =
+        futures::executor::block_on(client.issue_tx(typed_data)).map_err(|e| e.to_string())?;
     println!("{}", serde_json::to_string(&resp)?);
 
     Ok(())
diff --git a/spacesvm/src/api/client.rs b/spacesvm/src/api/client.rs
@@ -1,6 +1,6 @@
 use std::{
     fs::File,
-    io::{Result, Write},
+    io::{Error, ErrorKind, Result, Write},
     path::Path,
 };
 
@@ -9,12 +9,19 @@ use crate::{
         DecodeTxArgs, DecodeTxResponse, IssueTxArgs, IssueTxResponse, PingResponse, ResolveArgs,
         ResolveResponse,
     },
-    chain::tx::{tx::TransactionType, unsigned::TransactionData},
+    chain::tx::{
+        decoder::{self, TypedData},
+        tx::TransactionType,
+        unsigned::TransactionData,
+    },
+};
+use avalanche_types::key::{
+    self,
+    secp256k1::{private_key::Key, signature::Sig},
 };
-use avalanche_types::key;
 use http::{Method, Request};
 use hyper::{body, client::HttpConnector, Body, Client as HyperClient};
-use jsonrpc_core::{Call, Id, MethodCall, Params, Version};
+use jsonrpc_core::{Call, Id, MethodCall, Params, Value, Version};
 use serde::de;
 
 pub use http::Uri;
@@ -23,13 +30,19 @@ pub use http::Uri;
 pub struct Client<C> {
     id: u64,
     client: HyperClient<C>,
-    pub uri: Uri,
+    endpoint: Uri,
+    private_key: Option<Key>,
 }
 
 impl Client<HttpConnector> {
-    pub fn new(uri: Uri) -> Self {
+    pub fn new(endpoint: Uri) -> Self {
         let client = HyperClient::new();
-        Self { id: 0, client, uri }
+        Self {
+            id: 0,
+            client,
+            endpoint,
+            private_key: None,
+        }
     }
 }
 
@@ -40,6 +53,16 @@ impl Client<HttpConnector> {
         Id::Num(id)
     }
 
+    pub fn set_endpoint(mut self, endpoint: Uri) -> Self {
+        self.endpoint = endpoint;
+        self
+    }
+
+    pub fn set_private_key(mut self, private_key: Key) -> Self {
+        self.private_key = Some(private_key);
+        self
+    }
+
     /// Returns a serialized json request as string and the request id.
     pub fn raw_request(&mut self, method: &str, params: &Params) -> (Id, String) {
         let id = self.next_id();
@@ -55,6 +78,14 @@ impl Client<HttpConnector> {
         )
     }
 
+    /// Returns a recoverable signature from bytes.
+    pub fn sign_digest(&self, dh: &[u8]) -> Result<Sig> {
+        if let Some(pk) = &self.private_key {
+            pk.sign_digest(dh)?;
+        }
+        Err(Error::new(ErrorKind::Other, "private key not set"))
+    }
+
     /// Returns a PingResponse from client request.
     pub async fn ping(&mut self) -> Result<PingResponse> {
         let (_id, json_request) = self.raw_request("ping", &Params::None);
@@ -64,40 +95,48 @@ impl Client<HttpConnector> {
     }
 
     /// Returns a DecodeTxResponse from client request.
-    pub async fn decode_tx(&mut self, args: DecodeTxArgs) -> Result<DecodeTxResponse> {
-        let arg_bytes = serde_json::to_vec(&args)?;
-        let params: Params = serde_json::from_slice(&arg_bytes)?;
-        let (_id, json_request) = self.raw_request("decodeTx", &params);
+    pub async fn decode_tx(&mut self, tx_data: TransactionData) -> Result<DecodeTxResponse> {
+        let arg_value = serde_json::to_value(&DecodeTxArgs { tx_data })?;
+        let (_id, json_request) = self.raw_request("decodeTx", &Params::Array(vec![arg_value]));
         let resp = self.post_de::<DecodeTxResponse>(&json_request).await?;
 
         Ok(resp)
     }
 
     /// Returns a IssueTxResponse from client request.
-    pub async fn issue_tx(&mut self, args: IssueTxArgs) -> Result<IssueTxResponse> {
-        let arg_bytes = serde_json::to_vec(&args)?;
-        let params: Params = serde_json::from_slice(&arg_bytes)?;
-        let (_id, json_request) = self.raw_request("issueTx", &params);
+    pub async fn issue_tx(&mut self, typed_data: &TypedData) -> Result<IssueTxResponse> {
+        let dh = decoder::hash_structured_data(typed_data)?;
+        let sig = self.sign_digest(&dh.as_bytes())?.to_bytes().to_vec();
+        log::debug!("signature: {:?}", sig);
+
+        let arg_value = serde_json::to_value(&IssueTxArgs {
+            typed_data: typed_data.to_owned(),
+            signature: sig,
+        })?;
+        let (_id, json_request) = self.raw_request("issueTx", &Params::Array(vec![arg_value]));
         let resp = self.post_de::<IssueTxResponse>(&json_request).await?;
 
         Ok(resp)
     }
 
     /// Returns a ResolveResponse from client request.
-    pub async fn resolve(&mut self, args: ResolveArgs) -> Result<ResolveResponse> {
-        let arg_bytes = serde_json::to_vec(&args)?;
-        let params: Params = serde_json::from_slice(&arg_bytes)?;
-        let (_id, json_request) = self.raw_request("resolve", &params);
+    pub async fn resolve(&mut self, space: &str, key: &str) -> Result<ResolveResponse> {
+        let arg_value = serde_json::to_value(&ResolveArgs {
+            space: space.as_bytes().to_vec(),
+            key: key.as_bytes().to_vec(),
+        })?;
+        let (_id, json_request) = self.raw_request("issueTx", &Params::Array(vec![arg_value]));
         let resp = self.post_de::<ResolveResponse>(&json_request).await?;
 
         Ok(resp)
     }
 
     /// Returns a deserialized response from client request.
     pub async fn post_de<T: de::DeserializeOwned>(&self, json: &str) -> Result<T> {
+        println!("json: {}", json);
         let req = Request::builder()
             .method(Method::POST)
-            .uri(self.uri.to_string())
+            .uri(self.endpoint.to_string())
             .header("content-type", "application/json-rpc")
             .body(Body::from(json.to_owned()))
             .map_err(|e| {
@@ -107,20 +146,30 @@ impl Client<HttpConnector> {
                 )
             })?;
 
-        let resp = self.client.request(req).await.map_err(|e| {
+        let mut resp = self.client.request(req).await.map_err(|e| {
             std::io::Error::new(
                 std::io::ErrorKind::Other,
                 format!("client post request failed: {}", e),
             )
         })?;
 
-        let bytes = body::to_bytes(resp.into_body())
+        let bytes = body::to_bytes(resp.body_mut())
             .await
             .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
-        let resp = serde_json::from_slice(&bytes).map_err(|e| {
+
+        // deserialize bytes to value
+        let v: Value = serde_json::from_slice(&bytes).map_err(|e| {
+            std::io::Error::new(
+                std::io::ErrorKind::Other,
+                format!("failed to deserialize response to value: {}", e),
+            )
+        })?;
+
+        // deserialize result to T
+        let resp = serde_json::from_value(v["result"].to_owned()).map_err(|e| {
             std::io::Error::new(
                 std::io::ErrorKind::Other,
-                format!("failed to create client request: {}", e),
+                format!("failed to deserialize response: {}", e),
             )
         })?;
 
diff --git a/spacesvm/tests/vm/mod.rs b/spacesvm/tests/vm/mod.rs
@@ -139,9 +139,10 @@ async fn test_api() {
     log::info!("ping response {}", body);
 
     let tx_data = claim_tx("test_claim".to_owned());
-    let arg_bytes = serde_json::to_value(&DecodeTxArgs { tx_data }).unwrap();
+    let arg_value = serde_json::to_value(&DecodeTxArgs { tx_data }).unwrap();
 
-    let (_id, json_str) = client.raw_request("decodeTx", &Params::Array(vec![arg_bytes]));
+    let (_id, json_str) = client.raw_request("decodeTx", &Params::Array(vec![arg_value]));
+    log::info!("decodeTx request: {}", json_str);
     let req = http::request::Builder::new()
         .body(json_str.as_bytes().to_vec())
         .unwrap();
diff --git a/tests/e2e/src/tests/mod.rs b/tests/e2e/src/tests/mod.rs
@@ -7,7 +7,13 @@ use std::{
 
 use avalanche_network_runner_sdk::{BlockchainSpec, Client, GlobalConfig, StartRequest};
 use avalanche_types::subnet;
-use spacesvm;
+use spacesvm::{
+    self,
+    api::{
+        client::{claim_tx, get_or_create_pk, Uri},
+        DecodeTxArgs,
+    },
+};
 
 #[tokio::test]
 async fn e2e() {
@@ -47,7 +53,7 @@ async fn e2e() {
         // keep this in sync with "proto" crate
         // ref. https://github.com/ava-labs/avalanchego/blob/v1.9.2/version/constants.go#L15-L17
         let (exec_path, plugins_dir) =
-            avalanche_installer::avalanchego::download(None, None, Some("v1.9.2".to_string()))
+            avalanche_installer::avalanchego::download(None, None, Some("v1.9.3".to_string()))
                 .await
                 .unwrap();
         avalanchego_exec_path = exec_path;
@@ -92,7 +98,7 @@ async fn e2e() {
                 .unwrap(),
             ),
             blockchain_specs: vec![BlockchainSpec {
-                vm_name: String::from("minikvvm"),
+                vm_name: String::from("spacesvm"),
                 genesis: genesis_file_path.to_string(),
                 ..Default::default()
             }],
@@ -178,6 +184,35 @@ async fn e2e() {
         rpc_eps.push(iv.uri.clone());
     }
 
+    let ep = format!(
+        "{}/{}",
+        rpc_eps[0].to_owned(),
+        spacesvm::vm::PUBLIC_API_ENDPOINT
+    );
+    let private_key = get_or_create_pk("/tmp/.spacesvm-cli-pk").expect("generate new private key");
+
+    let mut scli = spacesvm::api::client::Client::new(ep.parse::<Uri>().expect("valid endpoint"))
+        .set_private_key(private_key);
+    log::info!("ping request...");
+    let resp = scli.ping().await.expect("ping success");
+    log::info!("ping response from {}: {:?}", ep, resp);
+
+    log::info!("decode claim tx request...");
+    let resp = scli
+        .decode_tx(DecodeTxArgs {
+            tx_data: claim_tx("test".to_owned()),
+        })
+        .await
+        .expect("decodeTx success");
+    log::info!("decode claim response from {}: {:?}", ep, resp);
+
+    log::info!("issue claim tx request...");
+    let resp = scli
+        .issue_tx(&resp.typed_data)
+        .await
+        .expect("issue_tx success");
+    log::info!("issue claim tx response from {}: {:?}", ep, resp);
+
     if crate::get_network_runner_enable_shutdown() {
         log::info!("shutdown is enabled... stopping...");
         let _resp = cli.stop().await.expect("failed stop");
