Merge branch 'feature/nullpay-tests'

Author: Nikita Khateev

libnullpay/src/payment_method.rs

@@ -67,6 +67,10 @@ pub mod add_request_fees {
         let total_payments = _count_total_payments(&outputs_json);
 
         let err = if total_amount >= total_payments + fee {
+            match parse_req_id_from_request(req_json.clone()) {
+                Err(ec) => return ec,
+                _ => ()
+            };
             //we have enough money for this txn, give it back
             let seq_no = payment_ledger::add_txn(inputs_json.clone(), outputs_json.clone());
 

libnullpay/src/services/response_storage.rs

@@ -8,16 +8,19 @@ lazy_static! {
 }
 
 pub fn add_response(request: String, response: String) -> Result<(), ErrorCode> {
-    let val = str_to_val(request.as_str())?;
-    let object = val_to_obj(&val)?;
-    let req_id = get_val_from_obj(object, "reqId")?;
-    let req_id = val_to_u64(req_id)?;
-
+    let req_id = parse_req_id_from_request(request)?;
     let mut responses = RESPONSES.lock().unwrap();
     responses.insert(req_id.to_string(), response);
     Ok(())
 }
 
+pub fn parse_req_id_from_request(request: String) -> Result<u64, ErrorCode> {
+    let val = str_to_val(request.as_str())?;
+    let object = val_to_obj(&val)?;
+    let req_id = get_val_from_obj(object, "reqId")?;
+    val_to_u64(req_id)
+}
+
 pub fn get_response(response: &str) -> Result<String, ErrorCode> {
     let val = str_to_val(response)?;
     let object = val_to_obj(&val)?;

libnullpay/tests/payments.rs

@@ -6,7 +6,6 @@ extern crate nullpay;
 
 #[macro_use]
 extern crate lazy_static;
-#[macro_use]
 extern crate log;
 
 #[macro_use]
@@ -21,6 +20,7 @@ use utils::types::*;
 use utils::ledger;
 use utils::pool;
 use utils::did;
+use nullpay::ErrorCode;
 
 use std::collections::HashMap;
 
@@ -87,7 +87,7 @@ mod high_cases {
             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();
 
-            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, PAYMENT_METHOD_NAME, SUBMITTER_DID);
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, SUBMITTER_DID);
 
             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();
@@ -111,6 +111,24 @@ mod high_cases {
             wallet::close_wallet(wallet_handle).unwrap();
             test_utils::cleanup_storage();
         }
+
+        #[test]
+        pub fn get_utxo_works_for_no_utxo() {
+            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 nonexistant_addr = "pay:null:no-addr";
+            let res = payments_utils::get_utxos_with_balance(vec![nonexistant_addr.to_string()], wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let res_vec = res.get(nonexistant_addr).unwrap();
+            assert_eq!(res_vec.len(), 0);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
     }
 
     mod mint {
@@ -132,9 +150,9 @@ mod high_cases {
 
             let outputs = serde_json::to_string(&mint).unwrap();
 
-            let (req, payment_method) = payments::build_mint_req(wallet_handle, SUBMITTER_DID, outputs.as_str()).unwrap();
+            let (req, _) = payments::build_mint_req(wallet_handle, SUBMITTER_DID, outputs.as_str()).unwrap();
 
-            let mint_resp = ledger::submit_request(pool_handle, req.as_str()).unwrap();
+            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);
 
@@ -171,7 +189,7 @@ mod high_cases {
             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+2)*10) as i32, None)).collect();
-            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, PAYMENT_METHOD_NAME, my_did.as_str());
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, my_did.as_str());
 
             let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, my_did.as_str());
 
@@ -188,7 +206,7 @@ mod high_cases {
             }];
             let outputs = serde_json::to_string(&outputs).unwrap();
 
-            let (nym_req_with_fees, payment_method) = payments::add_request_fees(wallet_handle, my_did.as_str(), nym_req.as_str(), inputs.as_str(), outputs.as_str()).unwrap();
+            let (nym_req_with_fees, _) = payments::add_request_fees(wallet_handle, my_did.as_str(), nym_req.as_str(), inputs.as_str(), outputs.as_str()).unwrap();
 
             let nym_response = ledger::sign_and_submit_request(pool_handle, wallet_handle, trustee_did.as_str(), nym_req_with_fees.as_str()).unwrap();
 
@@ -200,7 +218,14 @@ mod high_cases {
             let new_utxo = created_utxos.get(0).unwrap();
             assert_eq!(new_utxo.amount, 19);
 
-            //TODO: check that there is 2 UTXO for the second address and 0 UTXO for the first one
+            let utxo_map = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+            let utxo_1 = utxo_map.get(addresses.get(0).unwrap()).unwrap();
+            assert!(utxo_1.is_empty());
+            let utxo_2 = utxo_map.get(addresses.get(1).unwrap()).unwrap();
+            assert_eq!(utxo_2.len(), 2);
+            let amounts: Vec<i32> = utxo_2.into_iter().map(|info| info.amount).collect();
+            assert!(amounts.contains(&30));
+            assert!(amounts.contains(&19));
 
             pool::close(pool_handle).unwrap();
             wallet::close_wallet(wallet_handle).unwrap();
@@ -221,7 +246,7 @@ mod high_cases {
             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+2)*10) as i32, None)).collect();
-            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, PAYMENT_METHOD_NAME, SUBMITTER_DID);
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, SUBMITTER_DID);
 
             let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
 
@@ -256,6 +281,22 @@ mod high_cases {
 
             let change_utxo_end = change_utxo.split("_").last().unwrap();
             assert!(addresses.get(0).unwrap().to_string().ends_with(change_utxo_end));
+
+            let utxo_map = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+            let utxo_1 = utxo_map.get(addresses.get(0).unwrap()).unwrap();
+            assert_eq!(utxo_1.len(), 1);
+            let amounts: Vec<i32> = utxo_1.into_iter().map(|info| info.amount).collect();
+            assert!(amounts.contains(&1));
+
+            let utxo_2 = utxo_map.get(addresses.get(1).unwrap()).unwrap();
+            assert_eq!(utxo_2.len(), 2);
+            let amounts: Vec<i32> = utxo_2.into_iter().map(|info| info.amount).collect();
+            assert!(amounts.contains(&19));
+            assert!(amounts.contains(&30));
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
         }
     }
 
@@ -270,7 +311,7 @@ mod high_cases {
             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();
+            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);
 
@@ -308,4 +349,208 @@ mod high_cases {
             test_utils::cleanup_storage();
         }
     }
+}
+
+mod medium_cases {
+    use super::*;
+    
+    mod add_request_fees {
+        use super::*;
+        
+        #[test]
+        pub fn add_request_works_for_insufficient_funds() {
+            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 (trustee_did, _) = did::create_and_store_my_did(wallet_handle, Some(TRUSTEE_SEED)).unwrap();
+            let (my_did, my_vk) = did::create_and_store_my_did(wallet_handle, None).unwrap();
+            let nym_req = ledger::build_nym_request(&trustee_did, &my_did, &my_vk, "aaa", "TRUSTEE").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 as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, my_did.as_str());
+
+            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, r#"{"1": 10, "101": 10}"#);
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let addr_1 = addresses.get(0).unwrap();
+            let utxos_1: Vec<String> = utxos.get(addr_1.as_str()).unwrap().into_iter().map(|info| info.input.clone()).collect();
+            let inputs = serde_json::to_string(&utxos_1).unwrap();
+
+            let outputs = vec![UTXOOutput{
+                payment_address: addresses.get(1).unwrap().to_string(),
+                amount: 19,
+                extra: None
+            }, UTXOOutput {
+                payment_address: addresses.get(0).unwrap().to_string(),
+                amount: 1,
+                extra: None
+            }];
+            let outputs = serde_json::to_string(&outputs).unwrap();
+
+            let (nym_req_with_fees, payment_method) = payments::add_request_fees(wallet_handle, SUBMITTER_DID, nym_req.as_str(), inputs.as_str(), outputs.as_str()).unwrap();
+            let nym_resp = ledger::sign_and_submit_request(pool_handle, wallet_handle, trustee_did.as_str(), nym_req_with_fees.as_str()).unwrap();
+            let nym_resp_parsed_err = payments::parse_response_with_fees(payment_method.as_str(), nym_resp.as_str()).unwrap_err();
+
+            assert_eq!(nym_resp_parsed_err, ErrorCode::PaymentInsufficientFundsError);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+        
+        #[test]
+        pub fn add_request_fees_works_for_request_without_operation() {
+            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 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 as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, SUBMITTER_DID);
+
+            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES);
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let addr_1 = addresses.get(0).unwrap();
+            let utxos_1: Vec<String> = utxos.get(addr_1.as_str()).unwrap().into_iter().map(|info| info.input.clone()).collect();
+            let inputs = serde_json::to_string(&utxos_1).unwrap();
+
+            let outputs = vec![UTXOOutput{
+                payment_address: addresses.get(1).unwrap().to_string(),
+                amount: 19,
+                extra: None
+            }, UTXOOutput {
+                payment_address: addresses.get(0).unwrap().to_string(),
+                amount: 1,
+                extra: None
+            }];
+            let outputs = serde_json::to_string(&outputs).unwrap();
+
+            let nym_req_err = payments::add_request_fees(wallet_handle, SUBMITTER_DID, EMPTY_OBJECT, inputs.as_str(), outputs.as_str()).unwrap_err();
+            assert_eq!(nym_req_err, ErrorCode::CommonInvalidStructure);
+
+            //IMPORTANT: check that utxo cache stays the same
+            let utxos_after = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+            assert_eq!(utxos, utxos_after);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+
+        #[test]
+        pub fn add_request_fees_works_for_request_without_req_id() {
+            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 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 as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, SUBMITTER_DID);
+
+            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES);
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let addr_1 = addresses.get(0).unwrap();
+            let utxos_1: Vec<String> = utxos.get(addr_1.as_str()).unwrap().into_iter().map(|info| info.input.clone()).collect();
+            let inputs = serde_json::to_string(&utxos_1).unwrap();
+
+            let outputs = vec![UTXOOutput{
+                payment_address: addresses.get(1).unwrap().to_string(),
+                amount: 19,
+                extra: None
+            }, UTXOOutput {
+                payment_address: addresses.get(0).unwrap().to_string(),
+                amount: 1,
+                extra: None
+            }];
+            let outputs = serde_json::to_string(&outputs).unwrap();
+
+            let nym_req_err = payments::add_request_fees(wallet_handle, SUBMITTER_DID, r#"{"reqId": 111}"#, inputs.as_str(), outputs.as_str()).unwrap_err();
+            assert_eq!(nym_req_err, ErrorCode::CommonInvalidStructure);
+
+            //IMPORTANT: check that utxo cache stays the same
+            let utxos_after = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+            assert_eq!(utxos, utxos_after);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+    }
+    
+    mod fees {
+        use super::*;
+        
+        #[test]
+        pub fn build_set_txn_fees_works_for_invalid_json() {
+            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 err = payments::build_set_txn_fees_req(wallet_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, "{1}").unwrap_err();
+            assert_eq!(err, ErrorCode::CommonInvalidStructure);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+    }
+    
+    mod payment {
+        use super::*;
+        
+        #[test]
+        pub fn payments_work_for_insufficient_funds() {
+            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 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+2)*10) as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let addr_1 = addresses.get(0).unwrap();
+            let utxos_1: Vec<String> = utxos.get(addr_1.as_str()).unwrap().into_iter().map(|info| info.input.clone()).collect();
+            let inputs = serde_json::to_string(&utxos_1).unwrap();
+
+            let outputs = vec![UTXOOutput{
+                payment_address: addresses.get(1).unwrap().to_string(),
+                amount: 119,
+                extra: None
+            }, UTXOOutput {
+                payment_address: addresses.get(0).unwrap().to_string(),
+                amount: 1,
+                extra: None
+            }];
+            let outputs = serde_json::to_string(&outputs).unwrap();
+
+            let (payment_req, payment_method) = payments::build_payment_req(wallet_handle, SUBMITTER_DID, inputs.as_str(), outputs.as_str()).unwrap();
+            let payment_resp = ledger::submit_request(pool_handle, payment_req.as_str()).unwrap();
+            let payment_err = payments::parse_payment_response(payment_method.as_str(), payment_resp.as_str()).unwrap_err();
+            assert_eq!(payment_err, ErrorCode::PaymentInsufficientFundsError);
+
+            let utxos_after = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+            assert_eq!(utxos, utxos_after);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+    }
+
 }

libnullpay/tests/utils/callbacks.rs

@@ -14,10 +14,6 @@ lazy_static! {
     static ref COMMAND_HANDLE_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
 }
 
-lazy_static! {
-    static ref CLOSURE_CB_MAP: Mutex<HashMap<i32, i32>> = Default::default();
-}
-
 pub fn _closure_to_cb_ec() -> (Receiver<ErrorCode>, i32,
                                Option<extern fn(command_handle: i32,
                                                 err: ErrorCode)>) {