Test airdrop

extensive tests on airdrop

Cargo.lock

@@ -1972,6 +1972,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.15"
@@ -3788,6 +3797,7 @@ dependencies = [
  "env_logger",
  "futures",
  "hyper-util",
+ "itertools 0.14.0",
  "log",
  "nanoid",
  "rand 0.8.5",

Cargo.toml

@@ -35,5 +35,6 @@ anyhow = "1.0.98"
 bs58 = "0.5.1"
 ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }
 hyper-util = "0.1.11"
+itertools = "0.14.0"
 rand = "0.8"
 tower = "0.5.2"

tests/grpc_test.rs

@@ -6,10 +6,12 @@ use common::vm_cli_utils::create_new_vm;
 use common::vm_daemon_utils::mock_vm_daemon;
 use detee_shared::common_proto::{Empty, Pubkey};
 use detee_shared::general_proto::brain_general_cli_client::BrainGeneralCliClient;
-use detee_shared::general_proto::ReportNodeReq;
+use detee_shared::general_proto::{AirdropReq, ReportNodeReq};
 use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
 use detee_shared::vm_proto::ListVmContractsReq;
 use futures::StreamExt;
+use itertools::Itertools;
+use std::vec;
 use surreal_brain::constants::VM_NODE;
 use surreal_brain::db::vm::VmNodeWithReports;
 
@@ -35,6 +37,82 @@ async fn test_general_balance() {
     assert_eq!(acc_bal.tmp_locked, 0);
 }
 
+#[tokio::test]
+async fn test_general_airdrop() {
+    // env_logger::builder().filter_level(log::LevelFilter::Trace).init();
+    let _ = prepare_test_db().await;
+
+    const AIRDROP_MULTIPLE: u64 = 1_000_000_000;
+    let airdrop_amount = 10;
+
+    let addr = run_service_in_background().await;
+    let mut client = BrainGeneralCliClient::connect(format!("http://{}", addr)).await.unwrap();
+
+    let admin_keys = vec![Key::new(), Key::new(), Key::new()];
+    let admin_pub_keys = admin_keys.iter().map(|k| k.pubkey.clone()).join(", ");
+    std::env::set_var("ADMIN_PUB_KEYS", admin_pub_keys);
+
+    let user_01_key = Key::new();
+    let user_01_pubkey = user_01_key.pubkey.clone();
+
+    let airdrop_req = AirdropReq { pubkey: user_01_pubkey.clone(), tokens: airdrop_amount };
+
+    // user airdroping himself
+    let err =
+        client.airdrop(user_01_key.sign_request(airdrop_req.clone()).unwrap()).await.err().unwrap();
+    assert_eq!(err.message(), "This operation is reserved to admin accounts");
+
+    // other user airdroping
+    let err =
+        client.airdrop(Key::new().sign_request(airdrop_req.clone()).unwrap()).await.err().unwrap();
+    assert_eq!(err.message(), "This operation is reserved to admin accounts");
+
+    let _ = client.airdrop(admin_keys[0].sign_request(airdrop_req.clone()).unwrap()).await.unwrap();
+
+    let bal_req_data = Pubkey { pubkey: user_01_pubkey };
+    let bal_req = user_01_key.sign_request(bal_req_data.clone()).unwrap();
+    let acc_bal_user_01 = client.get_balance(bal_req).await.unwrap().into_inner();
+
+    assert_eq!(acc_bal_user_01.balance, airdrop_amount * AIRDROP_MULTIPLE);
+    assert_eq!(acc_bal_user_01.tmp_locked, 0);
+
+    // second airdrop from same admin
+    let _ = client.airdrop(admin_keys[0].sign_request(airdrop_req.clone()).unwrap()).await.unwrap();
+
+    let acc_bal_user_01 = client
+        .get_balance(user_01_key.sign_request(bal_req_data.clone()).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
+
+    assert_eq!(acc_bal_user_01.balance, 2 * airdrop_amount * AIRDROP_MULTIPLE);
+
+    // third airdrop from another admin
+    let _ = client.airdrop(admin_keys[1].sign_request(airdrop_req.clone()).unwrap()).await.unwrap();
+
+    let acc_bal_user_01 = client
+        .get_balance(user_01_key.sign_request(bal_req_data).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
+
+    assert_eq!(acc_bal_user_01.balance, 3 * airdrop_amount * AIRDROP_MULTIPLE);
+
+    // self airdrop
+    let airdrop_req = AirdropReq { pubkey: admin_keys[2].pubkey.clone(), tokens: airdrop_amount };
+
+    let _ = client.airdrop(admin_keys[2].sign_request(airdrop_req.clone()).unwrap()).await.unwrap();
+
+    let bal_req_data = Pubkey { pubkey: admin_keys[2].pubkey.clone() };
+    let acc_bal_admin_3 = client
+        .get_balance(admin_keys[2].sign_request(bal_req_data.clone()).unwrap())
+        .await
+        .unwrap()
+        .into_inner();
+
+    assert_eq!(acc_bal_admin_3.balance, airdrop_amount * AIRDROP_MULTIPLE);
+}
+
 #[tokio::test]
 async fn test_vm_creation() {
     let db = prepare_test_db().await;