extend tests

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

Author: hexfusion

scripts/tests.e2e.sh

@@ -1,17 +1,17 @@
 #!/usr/bin/env bash
 set -e
 
-# build spacesvm-rs binary
+# build spacesvm binary
 # ./scripts/build.release.sh
 #
 # download from github, keep network running
-# VM_PLUGIN_PATH=$(pwd)/target/release/spacesvm-rs ./scripts/tests.e2e.sh
+# VM_PLUGIN_PATH=$(pwd)/target/release/spacesvm ./scripts/tests.e2e.sh
 #
 # download from github, shut down network
-# NETWORK_RUNNER_ENABLE_SHUTDOWN=1 VM_PLUGIN_PATH=$(pwd)/target/release/spacesvm-rs ./scripts/tests.e2e.sh
+# NETWORK_RUNNER_ENABLE_SHUTDOWN=1 VM_PLUGIN_PATH=$(pwd)/target/release/spacesvm ./scripts/tests.e2e.sh
 #
 # use custom avalanchego binary
-# VM_PLUGIN_PATH=$(pwd)/target/release/timestampvm ./scripts/tests.e2e.sh ~/go/src/github.com/ava-labs/avalanchego/build/avalanchego
+# VM_PLUGIN_PATH=$(pwd)/target/release/spacesvm ./scripts/tests.e2e.sh ~/go/src/github.com/ava-labs/avalanchego/build/avalanchego
 #
 if ! [[ "$0" =~ scripts/tests.e2e.sh ]]; then
   echo "must be run from repository root"

spaces-cli/src/bin/spaces-cli/main.rs

@@ -43,8 +43,8 @@ struct Cli {
     #[command(subcommand)]
     command: Command,
 }
-
-fn main() -> Result<(), Box<dyn error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn error::Error>> {
     let cli = Cli::parse();
 
     let private_key = get_or_create_pk(&cli.private_key_file)?;

spacesvm/src/api/client.rs

@@ -53,9 +53,8 @@ impl Client<HttpConnector> {
         Id::Num(id)
     }
 
-    pub fn set_endpoint(mut self, endpoint: Uri) -> Self {
+    pub fn set_endpoint(&mut self, endpoint: Uri) {
         self.endpoint = endpoint;
-        self
     }
 
     pub fn set_private_key(mut self, private_key: Key) -> Self {
@@ -81,7 +80,7 @@ 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)?;
+            return pk.sign_digest(dh);
         }
         Err(Error::new(ErrorKind::Other, "private key not set"))
     }
@@ -125,15 +124,14 @@ impl Client<HttpConnector> {
             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 (_id, json_request) = self.raw_request("resolve", &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.endpoint.to_string())
@@ -221,8 +219,8 @@ pub fn get_or_create_pk(path: &str) -> Result<key::secp256k1::private_key::Key>
         .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
 }
 
-#[tokio::test]
-async fn test_raw_request() {
+#[test]
+fn test_raw_request() {
     let mut cli = Client::new(Uri::from_static("http://test.url"));
     let (id, _) = cli.raw_request("ping", &Params::None);
     assert_eq!(id, jsonrpc_core::Id::Num(0));

tests/e2e/src/tests/mod.rs

@@ -1,15 +1,16 @@
 use std::{
     fs,
     path::Path,
+    str::FromStr,
     thread,
     time::{Duration, Instant},
 };
 
 use avalanche_network_runner_sdk::{BlockchainSpec, Client, GlobalConfig, StartRequest};
-use avalanche_types::subnet;
+use avalanche_types::{ids, subnet};
 use spacesvm::{
     self,
-    api::client::{claim_tx, get_or_create_pk, Uri},
+    api::client::{claim_tx, get_or_create_pk, set_tx, Uri},
 };
 
 #[tokio::test]
@@ -33,7 +34,7 @@ async fn e2e() {
     assert!(exists);
     assert!(Path::new(&vm_plugin_path).exists());
 
-    let vm_id = subnet::vm_name_to_id("minikvvm").unwrap();
+    let vm_id = subnet::vm_name_to_id("spacesvm").unwrap();
 
     let (mut avalanchego_exec_path, _) = crate::get_avalanchego_path();
     let plugins_dir = if !avalanchego_exec_path.is_empty() {
@@ -50,7 +51,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;
@@ -180,33 +181,68 @@ async fn e2e() {
         log::info!("{}: {}", node_name, iv.uri);
         rpc_eps.push(iv.uri.clone());
     }
+    let mut blockchain_id = ids::Id::empty();
+    for (k, v) in cluster_info.custom_chains.iter() {
+        log::info!("custom chain info: {}={:?}", k, v);
+        if v.chain_name == "spacesvm" {
+            blockchain_id = ids::Id::from_str(&v.chain_id).unwrap();
+            break;
+        }
+    }
+
+    log::info!("avalanchego RPC endpoints: {:?}", rpc_eps);
 
-    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 chain_url = format!("{}/ext/bc/{}/public", rpc_eps[0], blockchain_id);
+    let mut scli =
+        spacesvm::api::client::Client::new(chain_url.parse::<Uri>().expect("valid endpoint"))
+            .set_private_key(private_key);
+    for ep in rpc_eps.iter() {
+        let chain_url = format!("{}/ext/bc/{}/public", ep, blockchain_id)
+            .parse::<Uri>()
+            .expect("valid endpoint");
+        scli.set_endpoint(chain_url);
+        let resp = scli.ping().await.unwrap();
+        log::info!("ping response from {}: {:?}", ep, resp);
+        assert!(resp.success);
+
+        thread::sleep(Duration::from_millis(300));
+    }
 
-    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);
+    scli.set_endpoint(chain_url.parse::<Uri>().expect("valid endpoint"));
 
     log::info!("decode claim tx request...");
     let resp = scli
         .decode_tx(claim_tx("test"))
         .await
         .expect("decodeTx success");
-    log::info!("decode claim response from {}: {:?}", ep, resp);
+    log::info!("decode claim response from {}: {:?}", chain_url, 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);
+    log::info!("issue claim tx response from {}: {:?}", chain_url, resp);
+
+    log::info!("decode set tx request...");
+    let resp = scli
+        .decode_tx(set_tx("test", "foo", "bar"))
+        .await
+        .expect("decodeTx success");
+    log::info!("decode set 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 resolve request...");
+    let resp = scli.resolve("test", "foo").await.expect("resolve success");
+    log::info!("resolve response from {}: {:?}", chain_url, resp);
+    assert_eq!(std::str::from_utf8(&resp.value).unwrap(), "bar");
 
     if crate::get_network_runner_enable_shutdown() {
         log::info!("shutdown is enabled... stopping...");