Add tests for get_utxo and add_request_fees

Signed-off-by: Nikita Khateev <[email protected]>

Author: Nikita Khateev

libnullpay/tests/payments.rs

@@ -72,98 +72,156 @@ mod high_cases {
         }
     }
 
-    mod fees {
+    mod get_utxo {
         use super::*;
 
         #[test]
-        pub fn set_request_fees_works() {
+        pub fn get_utxo_works() {
             test_utils::cleanup_storage();
             plugin::init_plugin();
             let wallet_handle = wallet::create_and_open_wallet(POOL_NAME, None).unwrap();
             let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
 
-            let fees_req = payments::build_set_txn_fees_req(wallet_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES).unwrap();
-            let fees_resp = ledger::submit_request(pool_handle, fees_req.as_str()).unwrap();
+            let addresses = payments_utils::create_addresses(vec!["{}", "{}"], wallet_handle, PAYMENT_METHOD_NAME);
+            let mint: Vec<(String, i32, Option<&str>)> = addresses.clone().into_iter().enumerate().map(|(i, addr)| (addr, (i+1) as i32, None)).collect();
 
-            let fees_stored = payments_utils::get_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME);
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, PAYMENT_METHOD_NAME, SUBMITTER_DID);
 
-            let fee_1 = fees_stored.get("1").unwrap();
-            assert_eq!(fee_1, &1);
-            let fee_2 = fees_stored.get("101").unwrap();
-            assert_eq!(fee_2, &2);
+            let (req_utxo_1, payment_method) = payments::build_get_utxo_request(wallet_handle, SUBMITTER_DID, addresses.get(0).unwrap().as_str()).unwrap();
+            let resp_utxo_1 = ledger::submit_request(pool_handle, req_utxo_1.as_str()).unwrap();
+            let resp_utxo_1 = payments::parse_get_utxo_response(payment_method.as_str(), resp_utxo_1.as_str()).unwrap();
+
+            let (req_utxo_2, payment_method) = payments::build_get_utxo_request(wallet_handle, SUBMITTER_DID, addresses.get(1).unwrap().as_str()).unwrap();
+            let resp_utxo_2 = ledger::submit_request(pool_handle, req_utxo_2.as_str()).unwrap();
+            let resp_utxo_2 = payments::parse_get_utxo_response(payment_method.as_str(), resp_utxo_2.as_str()).unwrap();
+
+            let utxos_1: Vec<UTXOInfo> = serde_json::from_str(resp_utxo_1.as_str()).unwrap();
+            assert_eq!(utxos_1.len(), 1);
+            let utxo_info: &UTXOInfo = utxos_1.get(0).unwrap();
+            assert_eq!(utxo_info.amount, 1);
+
+            let utxos_2: Vec<UTXOInfo> = serde_json::from_str(resp_utxo_2.as_str()).unwrap();
+            assert_eq!(utxos_2.len(), 1);
+            let utxo_info: &UTXOInfo = utxos_2.get(0).unwrap();
+            assert_eq!(utxo_info.amount, 2);
 
             pool::close(pool_handle).unwrap();
             wallet::close_wallet(wallet_handle).unwrap();
             test_utils::cleanup_storage();
         }
+    }
+
+    mod mint {
+        use super::*;
 
         #[test]
-        pub fn get_request_fees_works() {
+        pub fn mint_works() {
             test_utils::cleanup_storage();
             plugin::init_plugin();
             let wallet_handle = wallet::create_and_open_wallet(POOL_NAME, None).unwrap();
             let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
 
-            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES);
+            let addresses = payments_utils::create_addresses(vec!["{}", "{}"], wallet_handle, PAYMENT_METHOD_NAME);
+            let mint: Vec<UTXOOutput> = addresses.clone().into_iter().enumerate().map(|(i, payment_address)| UTXOOutput {
+                payment_address,
+                amount: ((i+1)*10) as i32,
+                extra: None
+            }).collect();
 
-            let req = payments::build_get_txn_fees_req(wallet_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME).unwrap();
-            let resp = ledger::submit_request(pool_handle, req.as_str()).unwrap();
-            let resp = payments::parse_get_utxo_response(PAYMENT_METHOD_NAME, resp.as_str()).unwrap();
-            let map = serde_json::from_str::<HashMap<String, i32>>(resp.as_str()).unwrap();
+            let outputs = serde_json::to_string(&mint).unwrap();
 
-            let fee_1 = map.get("1").unwrap();
-            assert_eq!(fee_1, &1);
-            let fee_2 = map.get("101").unwrap();
-            assert_eq!(fee_2, &2);
+            let (req, payment_method) = payments::build_mint_req(wallet_handle, SUBMITTER_DID, outputs.as_str()).unwrap();
+
+            let mint_resp = ledger::submit_request(pool_handle, req.as_str()).unwrap();
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle,SUBMITTER_DID);
+
+            let utxo_1 = utxos.get(addresses.get(0).unwrap()).unwrap();
+            assert_eq!(utxo_1.len(), 1);
+            let utxo_info: &UTXOInfo = utxo_1.get(0).unwrap();
+            assert_eq!(utxo_info.amount, 10);
+
+            let utxo_2 = utxos.get(addresses.get(1).unwrap()).unwrap();
+            assert_eq!(utxo_2.len(), 1);
+            let utxo_info: &UTXOInfo = utxo_2.get(0).unwrap();
+            assert_eq!(utxo_info.amount, 20);
 
             pool::close(pool_handle).unwrap();
             wallet::close_wallet(wallet_handle).unwrap();
             test_utils::cleanup_storage();
         }
     }
 
-    mod mint {
+    mod add_request_fees {
         use super::*;
 
         #[test]
-        pub fn mint_works() {
+        pub fn add_request_fees_works() {
             test_utils::cleanup_storage();
             plugin::init_plugin();
             let wallet_handle = wallet::create_and_open_wallet(POOL_NAME, None).unwrap();
             let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
 
-            let payment_address_1 = payments::create_payment_address(wallet_handle, PAYMENT_METHOD_NAME, EMPTY_OBJECT).unwrap();
-            let payment_address_2 = payments::create_payment_address(wallet_handle, PAYMENT_METHOD_NAME, EMPTY_OBJECT).unwrap();
+            let addresses = payments_utils::create_addresses(vec!["{}", "{}"], wallet_handle, PAYMENT_METHOD_NAME);
 
-            let mint = vec![UTXOOutput {
-                payment_address: payment_address_1.clone(),
-                amount: 10,
-                extra: None,
-            }, UTXOOutput {
-                payment_address: payment_address_2.clone(),
-                amount: 20,
-                extra: None,
-            }];
+            let mint: Vec<(String, i32, Option<&str>)> = addresses.clone().into_iter().enumerate().map(|(i, addr)| (addr, ((i+2)*10) as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, PAYMENT_METHOD_NAME, SUBMITTER_DID);
 
-            let outputs = serde_json::to_string(&mint).unwrap();
+            let utxos = payments_utils::get_utxos_with_balance(addresses, wallet_handle, pool_handle, SUBMITTER_DID);
 
-            let (req, payment_method) = payments::build_mint_req(wallet_handle, SUBMITTER_DID, outputs.as_str()).unwrap();
+            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES);
 
-            assert_eq!(payment_method, "null");
+            //TODO: add request fees
 
-            let mint_resp = ledger::submit_request(pool_handle, req.as_str()).unwrap();
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+    }
 
-            let utxos = payments_utils::get_utxos_with_balance(vec![payment_address_1.as_str(), payment_address_2.as_str()], wallet_handle, pool_handle,SUBMITTER_DID);
+    mod fees {
+        use super::*;
 
-            let utxo_1 = utxos.get(&payment_address_1).unwrap();
-            assert_eq!(utxo_1.len(), 1);
-            let utxo_info: &UTXOInfo = utxo_1.get(0).unwrap();
-            assert_eq!(utxo_info.amount, 10);
+        #[test]
+        pub fn set_request_fees_works() {
+            test_utils::cleanup_storage();
+            plugin::init_plugin();
+            let wallet_handle = wallet::create_and_open_wallet(POOL_NAME, None).unwrap();
+            let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
 
-            let utxo_2 = utxos.get(&payment_address_2).unwrap();
-            assert_eq!(utxo_2.len(), 1);
-            let utxo_info: &UTXOInfo = utxo_2.get(0).unwrap();
-            assert_eq!(utxo_info.amount, 20);
+            let fees_req = payments::build_set_txn_fees_req(wallet_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES).unwrap();
+            let fees_resp = ledger::submit_request(pool_handle, fees_req.as_str()).unwrap();
+
+            let fees_stored = payments_utils::get_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME);
+
+            let fee_1 = fees_stored.get("1").unwrap();
+            assert_eq!(fee_1, &1);
+            let fee_2 = fees_stored.get("101").unwrap();
+            assert_eq!(fee_2, &2);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+
+        #[test]
+        pub fn get_request_fees_works() {
+            test_utils::cleanup_storage();
+            plugin::init_plugin();
+            let wallet_handle = wallet::create_and_open_wallet(POOL_NAME, None).unwrap();
+            let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
+
+            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES);
+
+            let req = payments::build_get_txn_fees_req(wallet_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME).unwrap();
+            let resp = ledger::submit_request(pool_handle, req.as_str()).unwrap();
+            let resp = payments::parse_get_utxo_response(PAYMENT_METHOD_NAME, resp.as_str()).unwrap();
+            let map = serde_json::from_str::<HashMap<String, i32>>(resp.as_str()).unwrap();
+
+            let fee_1 = map.get("1").unwrap();
+            assert_eq!(fee_1, &1);
+            let fee_2 = map.get("101").unwrap();
+            assert_eq!(fee_2, &2);
 
             pool::close(pool_handle).unwrap();
             wallet::close_wallet(wallet_handle).unwrap();

libnullpay/tests/utils/payments_utils.rs

@@ -5,10 +5,16 @@ use serde_json;
 use utils::ledger;
 use std::collections::HashMap;
 
-pub fn mint_tokens(addresses: Vec<(&str, i32, &str, Option<&str>)>, wallet_handle: i32, pool_handle: i32, payment_method: &str, submitter_did: &str){
-    let mint: Vec<UTXOOutput> = addresses.into_iter().map(|(payment_address, amount, config, extra)| {
+pub fn create_addresses(cfgs: Vec<&str>, wallet_handle: i32, payment_method: &str) -> Vec<String> {
+    cfgs.into_iter().map(|cfg| {
+        payments::create_payment_address(wallet_handle, payment_method, cfg).unwrap()
+    }).collect()
+}
+
+pub fn mint_tokens(addresses: Vec<(String, i32, Option<&str>)>, wallet_handle: i32, pool_handle: i32, payment_method: &str, submitter_did: &str){
+    let mint: Vec<UTXOOutput> = addresses.into_iter().map(|(payment_address, amount, extra)| {
         UTXOOutput {
-            payment_address: payment_address.to_string(),
+            payment_address: payment_address,
             amount,
             extra: extra.map(|s| s.to_string()),
         }
@@ -20,13 +26,13 @@ pub fn mint_tokens(addresses: Vec<(&str, i32, &str, Option<&str>)>, wallet_handl
     let mint_resp = ledger::submit_request(pool_handle, req.as_str()).unwrap();
 }
 
-pub fn get_utxos_with_balance(payment_addresses: Vec<&str>, wallet_handle: i32, pool_handle: i32, submitter_did: &str) -> HashMap<String, Vec<UTXOInfo>> {
+pub fn get_utxos_with_balance(payment_addresses: Vec<String>, wallet_handle: i32, pool_handle: i32, submitter_did: &str) -> HashMap<String, Vec<UTXOInfo>> {
     payment_addresses.into_iter().map(|addr| {
-        let (req_utxo_1, payment_method) = payments::build_get_utxo_request(wallet_handle, submitter_did, addr).unwrap();
-        let resp_utxo_1 = ledger::submit_request(pool_handle, req_utxo_1.as_str()).unwrap();
-        let resp_utxo_1 = payments::parse_get_utxo_response(payment_method.as_str(), resp_utxo_1.as_str()).unwrap();
+        let (req_utxo, payment_method) = payments::build_get_utxo_request(wallet_handle, submitter_did, addr.as_str()).unwrap();
+        let resp_utxo = ledger::submit_request(pool_handle, req_utxo.as_str()).unwrap();
+        let resp_utxo = payments::parse_get_utxo_response(payment_method.as_str(), resp_utxo.as_str()).unwrap();
 
-        (addr.to_string(), serde_json::from_str::<Vec<UTXOInfo>>(resp_utxo_1.as_str()).unwrap())
+        (addr.to_string(), serde_json::from_str::<Vec<UTXOInfo>>(resp_utxo.as_str()).unwrap())
     }).collect()
 }