Merge pull request #52 from Relayz-io/kyrylo/tests-for-rpc-interface

A further step on improvements of tests for the RPC

near-smartcontracts's PR:
Relayz-io/near-smartcontracts#7

near-client/Cargo.toml

 
 [dev-dependencies]
 anyhow = "1"
+git2 = "0.15.0"
 reqwest = { version = "0.11", features = ["json"] }
 rand = "0.8.5"
 rand_chacha = "0.3"

near-client/tests/rpc.rs

+use git2::{Cred, RemoteCallbacks};
 use itertools::Itertools;
 use near_account_id::AccountId;
 use near_client::{
 use reqwest::Url;
 use serde_json::json;
 use std::{
-    fs::{create_dir, File},
-    io::{copy, Cursor, Read},
+    fs::{create_dir, read, write},
     path::Path,
     str::FromStr,
 };
 use workspaces::{network::Sandbox, types::SecretKey, Worker};
 
 // auxiliary structs and methods
-struct InitMeta {
-    worker: Worker<Sandbox>,
-    client: NearClient,
-    wasm: Vec<u8>,
-    signer_account_id: AccountId,
-}
-
-impl InitMeta {
-    async fn new() -> anyhow::Result<Self> {
-        let worker = workspaces::sandbox().await?;
-        let wasm = download_contract().await?;
-        let rpc_url = Url::parse(format!("http://localhost:{}", worker.rpc_port()).as_str())?;
-        let client = NearClient::new(rpc_url)?;
-        let signer_account_id = AccountId::from_str("alice.test.near")?;
-
-        Ok(InitMeta {
-            worker,
-            client,
-            wasm,
-            signer_account_id,
-        })
-    }
+fn near_client(worker: &Worker<Sandbox>) -> anyhow::Result<NearClient> {
+    let rpc_url = Url::parse(format!("http://localhost:{}", worker.rpc_port()).as_str())?;
+    let client = NearClient::new(rpc_url)?;
+    Ok(client)
 }
 
-async fn create_signer(meta: &InitMeta) -> anyhow::Result<Signer> {
+async fn create_signer(
+    worker: &Worker<Sandbox>,
+    client: &NearClient,
+    signer_acc_id: &AccountId,
+) -> anyhow::Result<Signer> {
     let secret_key = ED25519SecretKey::from_bytes(&random_bits())?;
     let ws_secret_key_str = to_workspaces_sk(&secret_key);
     let pk = ED25519PublicKey::from(&secret_key);
     let ws_sk = SecretKey::from_str(&ws_secret_key_str)?;
-    let _ = meta
-        .worker
-        .create_tla(meta.signer_account_id.clone(), ws_sk)
-        .await?;
+    let _ = worker.create_tla(signer_acc_id.clone(), ws_sk).await?;
 
-    let access_key_nonce = meta
-        .client
-        .view_access_key(&meta.signer_account_id, &pk)
-        .await?
-        .nonce;
+    let access_key_nonce = client.view_access_key(signer_acc_id, &pk).await?.nonce;
 
-    let signer_acc = Signer::new(
-        &ws_secret_key_str,
-        meta.signer_account_id.clone(),
-        access_key_nonce,
-    )?;
+    let signer_acc = Signer::new(&ws_secret_key_str, signer_acc_id.clone(), access_key_nonce)?;
 
     Ok(signer_acc)
 }
     let fname = "contract.wasm";
     let full_dest = format!("{}/{}", target_path, fname);
 
-    if !Path::new(target_path).exists() {
-        create_dir(target_path)?;
-    }
+    let contract_bytes = if !Path::new(&full_dest).exists() {
+        if !Path::new(&target_path).exists() {
+            create_dir(target_path)?;
+        };
 
-    if !Path::new(&full_dest).exists() {
-        let response = reqwest::get(target).await?;
-        let mut file = File::create(&full_dest)?;
-        let mut content = Cursor::new(response.bytes().await?);
-        copy(&mut content, &mut file)?;
-    }
+        let contract_bytes = reqwest::get(target).await?.bytes().await?;
+        write(full_dest, &contract_bytes)?;
+        contract_bytes.to_vec()
+    } else {
+        read(&full_dest)?
+    };
+
+    Ok(contract_bytes)
+}
+
+async fn clone_and_compile_wasm() -> anyhow::Result<Vec<u8>> {
+    let tmp_path = "../target/tmp-contracts";
+    let repo_path = format!("{}/near-smartcontracts", tmp_path);
+    let target_path = format!("{}/test-contract", repo_path);
+    let repo_url = "git@github.com:Relayz-io/near-smartcontracts.git";
+
+    if !Path::new(&target_path).exists() {
+        if !Path::new(&tmp_path).exists() {
+            create_dir(tmp_path)?;
+        }
+
+        // Prepare callbacks.
+        let mut callbacks = RemoteCallbacks::new();
+        callbacks.credentials(|_, username_from_url, _| {
+            let username = username_from_url
+                .ok_or_else(|| git2::Error::from_str("Parsing the given URL is failed"))?;
+            Cred::ssh_key_from_agent(username)
+        });
 
-    let mut file = File::open(full_dest)?;
-    let mut data = Vec::new();
-    file.read_to_end(&mut data)?;
+        // Prepare fetch options.
+        let mut fo = git2::FetchOptions::new();
+        fo.remote_callbacks(callbacks);
 
-    Ok(data)
+        // Prepare builder.
+        let mut builder = git2::build::RepoBuilder::new();
+        builder.fetch_options(fo);
+        builder.branch("main");
+
+        // Clone the project.
+        builder.clone(repo_url, Path::new(&repo_path))?;
+    }
+    let wasm = workspaces::compile_project(&target_path).await?;
+
+    Ok(wasm)
 }
 
 fn random_bits() -> [u8; 32] {
 // tests themselves
 #[tokio::test]
 async fn contract_creation() -> anyhow::Result<()> {
-    let meta = InitMeta::new().await?;
-    let mut signer = create_signer(&meta).await?;
-
-    let call = meta
-        .client
-        .deploy_contract(&mut signer, &meta.signer_account_id, meta.wasm);
+    let worker = workspaces::sandbox().await?;
+    let client = near_client(&worker)?;
+    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
+    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
+    let wasm = download_contract().await?;
 
-    call.commit_empty().await?;
+    client
+        .deploy_contract(&mut signer, &signer_account_id, wasm)
+        .commit_empty()
+        .await?;
 
     Ok(())
 }
 
 #[tokio::test]
 async fn contract_function_call() -> anyhow::Result<()> {
-    let meta = InitMeta::new().await?;
-    let mut signer = create_signer(&meta).await?;
+    let worker = workspaces::sandbox().await?;
+    let client = near_client(&worker)?;
+    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
+    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
+    let wasm = download_contract().await?;
 
-    let call = meta
-        .client
-        .deploy_contract(&mut signer, &meta.signer_account_id, meta.wasm);
-    call.commit_empty().await?;
+    client
+        .deploy_contract(&mut signer, &signer_account_id, wasm)
+        .commit_empty()
+        .await?;
 
-    let call = meta
-        .client
-        .function_call(&mut signer, &meta.signer_account_id, "new_default_meta")
+    client
+        .function_call(&mut signer, &signer_account_id, "new_default_meta")
         .args(json!({
-            "owner_id": &meta.signer_account_id,
+            "owner_id": &signer_account_id,
             "total_supply": "100",
         }))
         .gas(near_units::parse_gas!("300 T") as u64)
-        .build()?;
-    call.commit_empty().await?;
+        .build()?
+        .commit_empty()
+        .await?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn multiple_tests() -> anyhow::Result<()> {
+    let worker = workspaces::sandbox().await?;
+    let client = near_client(&worker)?;
+    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
+    let mut signer = create_signer(&worker, &client, &signer_account_id).await?;
+
+    let wasm = clone_and_compile_wasm().await?;
+
+    init_contract(&client, &signer_account_id, &mut signer, wasm).await?;
+
+    fc_no_params(&client, &signer_account_id, &mut signer).await?;
+    fc_with_one_param_and_result(&client, &signer_account_id, &mut signer).await?;
+    fc_with_param_and_result(&client, &signer_account_id, &mut signer).await?;
+
+    view_no_params(&client, &signer_account_id).await?;
+    view_with_params(&client, &signer_account_id).await?;
+
+    Ok(())
+}
+
+async fn init_contract(
+    client: &NearClient,
+    contract_id: &AccountId,
+    signer: &mut Signer,
+    wasm: Vec<u8>,
+) -> anyhow::Result<()> {
+    client
+        .deploy_contract(signer, contract_id, wasm)
+        .commit_empty()
+        .await?;
+
+    Ok(())
+}
+
+async fn view_no_params(client: &NearClient, contract_id: &AccountId) -> anyhow::Result<()> {
+    client.view::<u64>(contract_id, "show_id", None).await?;
+
+    Ok(())
+}
+
+async fn view_with_params(client: &NearClient, contract_id: &AccountId) -> anyhow::Result<()> {
+    client
+        .view::<String>(contract_id, "show_type", Some(json!({"is_message": true})))
+        .await?;
+
+    Ok(())
+}
+
+// fc = function call
+async fn fc_no_params(
+    client: &NearClient,
+    contract_id: &AccountId,
+    signer: &mut Signer,
+) -> anyhow::Result<()> {
+    client
+        .function_call(signer, contract_id, "increment")
+        .gas(near_units::parse_gas!("300 T") as u64)
+        .build()?
+        .commit_empty()
+        .await?;
+
+    Ok(())
+}
+
+async fn fc_with_one_param_and_result(
+    client: &NearClient,
+    contract_id: &AccountId,
+    signer: &mut Signer,
+) -> anyhow::Result<()> {
+    let expected_result = "change message";
+    let message = client
+        .function_call(signer, contract_id, "change_message")
+        .args(json!({ "message": expected_result }))
+        .gas(near_units::parse_gas!("300 T") as u64)
+        .build()?
+        .commit::<String>()
+        .await?;
+
+    assert_eq!(message, expected_result);
+
+    Ok(())
+}
+
+async fn fc_with_param_and_result(
+    client: &NearClient,
+    contract_id: &AccountId,
+    signer: &mut Signer,
+) -> anyhow::Result<()> {
+    let expected_id = 666u64;
+    let id = client
+        .function_call(signer, contract_id, "change_id")
+        .args(json!({ "id": expected_id }))
+        .gas(near_units::parse_gas!("300 T") as u64)
+        .build()?
+        .commit::<u64>()
+        .await?;
+
+    assert_eq!(id, expected_id);
 
     Ok(())
 }