Merge pull request hyperledger-indy#787 from KitHat/master

Add negative tests for libnullpay

Author: Vyacheslav

libnullpay/src/payment_method.rs

@@ -67,21 +67,25 @@ 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) {
+                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());
 
-            _process_inputs(inputs_json);
-            let infos: Vec<UTXOInfo> = _process_outputs(outputs_json, seq_no);
+            _process_inputs(&inputs_json);
+            let infos: Vec<UTXOInfo> = _process_outputs(&outputs_json, seq_no);
 
-            _save_response(infos, req_json.clone())
+            _save_response(&infos, &req_json)
         } else {
             //we don't have enough money, send GET_TXN transaction to callback and in response PaymentsInsufficientFundsError will be returned
             ledger::build_get_txn_request(
                 submitter_did.as_str(),
                 1,
                 Box::new(move |ec, res| {
                     let ec = if ec == ErrorCode::Success {
-                        _add_response(res.clone(), "INSUFFICIENT_FUNDS".to_string())
+                        _add_response(&res, "INSUFFICIENT_FUNDS")
                     } else { ec };
                     trace!("libnullpay::add_request_fees::handle >>");
                     _process_callback(cmd_handle, ec, res, cb);
@@ -117,9 +121,9 @@ pub mod build_get_utxo_request {
             1,
             Box::new(move |ec, res| {
                 let ec = if ec == ErrorCode::Success {
-                    let utxos = utxo_cache::get_utxos_by_payment_address(payment_address.clone());
-                    let infos: Vec<UTXOInfo> = utxos.into_iter().filter_map(|utxo| payment_ledger::get_utxo_info(utxo)).collect();
-                    _save_response(infos, res.clone())
+                    let utxos = utxo_cache::get_utxos_by_payment_address(&payment_address);
+                    let infos: Vec<UTXOInfo> = utxos.into_iter().filter_map(payment_ledger::get_utxo_info).collect();
+                    _save_response(&infos, &res)
                 } else { ec };
 
                 trace!("libnullpay::build_get_utxo_request::handle >>");
@@ -161,12 +165,12 @@ pub mod build_payment_req {
                     if total_balance >= total_payments {
                         let seq_no = payment_ledger::add_txn(inputs_json.clone(), outputs_json.clone());
 
-                        _process_inputs(inputs_json.clone());
-                        let infos = _process_outputs(outputs_json.clone(), seq_no);
+                        _process_inputs(&inputs_json);
+                        let infos = _process_outputs(&outputs_json, seq_no);
 
-                        _save_response(infos, res.clone())
+                        _save_response(&infos, &res)
                     } else {
-                        _add_response(res.clone(), "INSUFFICIENT_FUNDS".to_string());
+                        _add_response(&res, "INSUFFICIENT_FUNDS");
                         ErrorCode::Success
                     }
                 } else {
@@ -206,7 +210,7 @@ pub mod build_mint_req {
                                               let seq_no = payment_ledger::add_txn(vec![], outputs_json.clone());
 
                                               outputs_json.clone().into_iter().for_each(|output| {
-                                                  utxo_cache::add_utxo(output.payment_address, seq_no, output.amount);
+                                                  utxo_cache::add_utxo(&output.payment_address, seq_no, output.amount);
                                               });
                                           }
 
@@ -255,7 +259,7 @@ pub mod build_get_txn_fees_req {
                                               let info = config_ledger::get_all_fees();
 
                                               match to_string(&info).map_err(|_| ErrorCode::CommonInvalidState) {
-                                                  Ok(str) => _add_response(res.clone(), str),
+                                                  Ok(str) => _add_response(&res, &str),
                                                   Err(ec) => ec
                                               }
                                           } else { ec };
@@ -295,40 +299,40 @@ fn _process_callback(cmd_handle: i32, err: ErrorCode, response: String, cb: Opti
     }
 }
 
-fn _process_outputs(outputs: Vec<UTXOOutput>, seq_no: i32) -> Vec<UTXOInfo> {
+fn _process_outputs(outputs: &Vec<UTXOOutput>, seq_no: i32) -> Vec<UTXOInfo> {
     outputs.into_iter().map(|out| {
-        match utxo_cache::add_utxo(out.payment_address, seq_no, out.amount)
+        match utxo_cache::add_utxo(&out.payment_address, seq_no, out.amount)
             .map(|utxo| payment_ledger::get_utxo_info(utxo)) {
             Some(Some(utxo_info)) => utxo_info,
             _ => panic!("Some UTXO was not processed!")
         }
     }).collect()
 }
 
-fn _process_inputs(inputs: Vec<String>) {
+fn _process_inputs(inputs: &Vec<String>) {
     inputs.into_iter().for_each(|s| {
         utxo_cache::remove_utxo(s);
     });
 }
 
-fn _save_response(infos: Vec<UTXOInfo>, request: String) -> ErrorCode {
-    match serialize_infos(infos) {
-        Ok(str) => _add_response(request, str),
+fn _save_response(infos: &Vec<UTXOInfo>, request: &str) -> ErrorCode {
+    match serialize_infos(&infos) {
+        Ok(str) => _add_response(request, &str),
         Err(ec) => ec
     }
 }
 
-fn _add_response(request: String, response: String) -> ErrorCode {
+fn _add_response(request: &str, response: &str) -> ErrorCode {
     match add_response(request, response) {
         Err(ec) => ec,
         _ => ErrorCode::Success
     }
 }
 
 fn _count_total_inputs(inputs: &Vec<String>) -> i32 {
-    inputs.clone().into_iter().filter_map(utxo_cache::get_balanse_of_utxo).fold(0, |acc, next| acc + next)
+    inputs.into_iter().filter_map(utxo_cache::get_balanse_of_utxo).fold(0, |acc, next| acc + next)
 }
 
 fn _count_total_payments(outputs: &Vec<UTXOOutput>) -> i32 {
-    outputs.clone().into_iter().fold(0, |acc, next| acc + next.amount)
+    outputs.into_iter().fold(0, |acc, next| acc + next.amount)
 }

libnullpay/src/services/response_storage.rs

@@ -7,17 +7,20 @@ lazy_static! {
     static ref RESPONSES: Mutex<HashMap<String, String>> = Default::default();
 }
 
-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)?;
-
+pub fn add_response(request: &str, response: &str) -> Result<(), ErrorCode> {
+    let req_id = parse_req_id_from_request(request)?;
     let mut responses = RESPONSES.lock().unwrap();
-    responses.insert(req_id.to_string(), response);
+    responses.insert(req_id.to_string(), response.to_string());
     Ok(())
 }
 
+pub fn parse_req_id_from_request(request: &str) -> Result<u64, ErrorCode> {
+    let val = str_to_val(request)?;
+    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/src/services/utxo_cache.rs

@@ -8,25 +8,25 @@ lazy_static! {
     static ref BALANCES: Mutex<HashMap<String, i32>> = Default::default();
 }
 
-pub fn get_utxos_by_payment_address(payment_address: String) -> Vec<String> {
+pub fn get_utxos_by_payment_address(payment_address: &str) -> Vec<String> {
     let utxos = UTXOS.lock().unwrap();
-    match utxos.get(&payment_address) {
+    match utxos.get(payment_address) {
         Some(v) => v.clone(),
         None => Vec::new()
     }
 }
 
-pub fn get_balanse_of_utxo(utxo: String) -> Option<i32> {
+pub fn get_balanse_of_utxo(utxo: &String) -> Option<i32> {
     let balances = BALANCES.lock().unwrap();
-    balances.get(&utxo).map(|a| a.clone())
+    balances.get(utxo).map(|a| a.clone())
 }
 
-pub fn add_utxo(payment_address: String, seq_no: i32, balance: i32) -> Option<String> {
-    to_utxo(payment_address.as_str(), seq_no).map(|utxo| {
+pub fn add_utxo(payment_address: &str, seq_no: i32, balance: i32) -> Option<String> {
+    to_utxo(payment_address, seq_no).map(|utxo| {
         let mut balances = BALANCES.lock().unwrap();
         let mut utxos = UTXOS.lock().unwrap();
         balances.insert(utxo.clone(), balance);
-        let vec = utxos.remove(&payment_address);
+        let vec = utxos.remove(payment_address);
         let vec = match vec {
             Some(v) => {
                 let mut v = Vec::from(v);
@@ -35,22 +35,22 @@ pub fn add_utxo(payment_address: String, seq_no: i32, balance: i32) -> Option<St
             }
             None => vec![utxo.clone()]
         };
-        utxos.insert(payment_address, vec);
+        utxos.insert(payment_address.to_string(), vec);
         utxo
     })
 }
 
-pub fn remove_utxo(utxo: String) {
-    let res = from_utxo(utxo.as_str());
+pub fn remove_utxo(utxo: &str) {
+    let res = from_utxo(utxo);
     match res {
         Some((_,payment_address)) => {
             let mut balances = BALANCES.lock().unwrap();
             let mut utxos = UTXOS.lock().unwrap();
-            balances.remove(&utxo);
+            balances.remove(utxo);
             match utxos.remove(&payment_address)
                 .map(|vs|
                     vs.into_iter()
-                        .filter(|v| v.to_string() != utxo)
+                        .filter(|v| v != utxo)
                         .collect::<Vec<String>>()
                 ) {
                 Some(ref v) if !v.is_empty() => {utxos.insert(payment_address, v.to_vec());},

libnullpay/src/utils/json_helper.rs

@@ -15,7 +15,7 @@ pub fn parse_operation_from_request (req: &str) -> Result<String, ErrorCode> {
     }
 }
 
-pub fn serialize_infos(infos: Vec<UTXOInfo>) -> Result<String, ErrorCode> {
+pub fn serialize_infos(infos: &Vec<UTXOInfo>) -> Result<String, ErrorCode> {
     to_string(&infos).map_err(|_| {
         error!("Can't deserialize UTXO Info");
         ErrorCode::CommonInvalidState