Add tests for add_request_fees

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

Author: Nikita Khateev

libindy/src/services/payments.rs

@@ -206,18 +206,22 @@ impl PaymentsService {
         let inputs: Vec<&str> = serde_json::from_str(inputs).map_err(|_| PaymentsError::CommonError(CommonError::InvalidStructure("Unable to parse inputs".to_string())))?;
         let inputs_len = inputs.len();
         if inputs_len == 0 {
+            error!("No inputs for transaction");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("No inputs for transaction".to_string())));
         }
         let input_set: HashSet<&str> = inputs.into_iter().collect();
         if inputs_len != input_set.len() {
+            error!("Several equal inputs");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("Several equal inputs".to_string())));
         }
         let input_methods: Vec<Option<String>> = input_set.into_iter().map(|s| self._parse_method_from_payment_address(s)).collect();
         if input_methods.contains(&None) {
+            error!("Some payment addresses are incorrectly formed");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("Some payment addresses are incorrectly formed".to_string())));
         }
         let input_methods_set: HashSet<String> = input_methods.into_iter().map(|s| s.unwrap()).collect();
         if input_methods_set.len() != 1 {
+            error!("Unable to identify payment method from inputs");
             return Err(PaymentsError::IncompatiblePaymentError("Unable to identify payment method from inputs".to_string()));
         }
         Ok(input_methods_set.into_iter().next().unwrap())
@@ -227,21 +231,25 @@ impl PaymentsService {
         let outputs: Vec<Output> = serde_json::from_str(outputs).map_err(|_| PaymentsError::CommonError(CommonError::InvalidStructure("Unable to parse outputs".to_string())))?;
         let outputs_len = outputs.len();
         if outputs_len == 0 {
+            error!("No outputs for transaction");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("No outputs for transaction".to_string())));
         }
 
         let payment_address_set: HashSet<String> = outputs.into_iter().map(|s| s.payment_address).collect();
         if payment_address_set.len() != outputs_len {
+            error!("Several equal payment addresses");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("Several equal payment addresses".to_string())));
         }
 
         let payment_methods: Vec<Option<String>> = payment_address_set.into_iter().map(|s| self._parse_method_from_payment_address(s.as_str())).collect();
         if payment_methods.contains(&None) {
+            error!("Some payment addresses are incorrectly formed");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("Some payment addresses are incorrectly formed".to_string())));
         }
 
         let payment_method_set: HashSet<String> = payment_methods.into_iter().map(|s| s.unwrap()).collect();
         if payment_method_set.len() != 1 {
+            error!("Unable to identify payment method from outputs");
             return Err(PaymentsError::IncompatiblePaymentError("Unable to identify payment method from outputs".to_string()));
         }
 

libnullpay/src/payment_method.rs

@@ -166,6 +166,7 @@ pub mod build_payment_req {
 
                         _save_response(infos, res.clone())
                     } else {
+                        _add_response(res.clone(), "INSUFFICIENT_FUNDS".to_string());
                         ErrorCode::Success
                     }
                 } else {

libnullpay/tests/payments.rs

@@ -20,13 +20,16 @@ use utils::test_utils;
 use utils::types::*;
 use utils::ledger;
 use utils::pool;
+use utils::did;
 
 use std::collections::HashMap;
 
 static EMPTY_OBJECT: &str = "{}";
 static PAYMENT_METHOD_NAME: &str = "null";
 static POOL_NAME: &str = "pool_1";
 static SUBMITTER_DID: &str = "Th7MpTaRZVRYnPiabds81Y";
+static DEST: &str = "FYmoFw55GeQH7SRFa37dkx1d2dZ3zUF8ckg7wmL7ofN4";
+static VERKEY: &str = "CnEDk9HrMnmiHXEV1WFgbVCRteYnPqsJwrTdcZaNhFVW";
 static FEES: &str = r#"{"1":1, "101":2}"#;
 
 mod high_cases {
@@ -161,17 +164,41 @@ mod high_cases {
             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 (my_did, verkey) = did::create_store_and_publish_my_did_from_trustee(wallet_handle, pool_handle).unwrap();
 
-            let addresses = payments_utils::create_addresses(vec!["{}", "{}"], wallet_handle, PAYMENT_METHOD_NAME);
+//            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);
+//            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());
 
-            let utxos = payments_utils::get_utxos_with_balance(addresses, wallet_handle, pool_handle, SUBMITTER_DID);
+//            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, my_did.as_str());
 
-            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, FEES);
+//            payments_utils::set_request_fees(wallet_handle, pool_handle, my_did.as_str(), PAYMENT_METHOD_NAME, FEES);
+
+            let nym_req = ledger::build_nym_request(my_did.as_str(), DEST, VERKEY, "aaa", "").unwrap();
+
+//            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
+//            }];
+//            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_response = ledger::sign_and_submit_request(pool_handle, wallet_handle, my_did.as_str(), nym_req.as_str()).unwrap();
+            trace!("nym response {}", nym_response);
+            let nym_response_parsed = payments::parse_response_with_fees(PAYMENT_METHOD_NAME, nym_response.as_str()).unwrap();
 
-            //TODO: add request fees
+//            let created_utxos: Vec<UTXOInfo> = serde_json::from_str(nym_response_parsed.as_str()).unwrap();
+//
+//            assert_eq!(created_utxos.len(), 1);
+//            let new_utxo = created_utxos.get(0).unwrap();
+//            assert_eq!(new_utxo.amount, 19);
 
             pool::close(pool_handle).unwrap();
             wallet::close_wallet(wallet_handle).unwrap();

libnullpay/tests/utils/did.rs

@@ -0,0 +1,37 @@
+use nullpay::ErrorCode;
+use std::ffi::CString;
+use std::os::raw::c_char;
+
+pub const TRUSTEE_SEED: &'static str = "000000000000000000000000Trustee1";
+
+pub fn create_store_and_publish_my_did_from_trustee(wallet_handle: i32, pool_handle: i32) -> Result<(String, String), ErrorCode> {
+    let (trustee_did, _) = create_and_store_my_did(wallet_handle, Some(TRUSTEE_SEED))?;
+    let (my_did, my_vk) = create_and_store_my_did(wallet_handle, None)?;
+    let nym = super::ledger::build_nym_request(&trustee_did, &my_did, &my_vk, "", "TRUSTEE")?;
+    super::ledger::sign_and_submit_request(pool_handle, wallet_handle, &trustee_did, &nym)?; //TODO check response type
+    Ok((my_did, my_vk))
+}
+
+pub fn create_and_store_my_did(wallet_handle: i32, seed: Option<&str>) -> Result<(String, String), ErrorCode> {
+    let (receiver, command_handle, cb) = super::callbacks::_closure_to_cb_ec_string_string();
+
+    let my_did_json = seed.map_or("{}".to_string(), |seed| format!("{{\"seed\":\"{}\" }}", seed));
+    let my_did_json = CString::new(my_did_json).unwrap();
+
+    let err = unsafe {
+        indy_create_and_store_my_did(command_handle, wallet_handle, my_did_json.as_ptr(), cb)
+    };
+
+    super::results::result_to_string_string(err, receiver)
+}
+
+extern {
+    #[no_mangle]
+    fn indy_create_and_store_my_did(command_handle: i32,
+                                    wallet_handle: i32,
+                                    did_json: *const c_char,
+                                    cb: Option<extern fn(xcommand_handle: i32,
+                                                         err: ErrorCode,
+                                                         did: *const c_char,
+                                                         verkey: *const c_char)>) -> ErrorCode;
+}

libnullpay/tests/utils/ledger.rs

@@ -7,7 +7,47 @@ pub fn submit_request(pool_handle: i32, request_json: &str) -> Result<String, Er
 
     let request_json = CString::new(request_json).unwrap();
 
-    let err = unsafe {indy_submit_request(command_handle, pool_handle, request_json.as_ptr(), cb)};
+    let err = unsafe { indy_submit_request(command_handle, pool_handle, request_json.as_ptr(), cb) };
+
+    super::results::result_to_string(err, receiver)
+}
+
+pub fn sign_and_submit_request(pool_handle: i32, wallet_handle: i32, submitter_did: &str, request_json: &str) -> Result<String, ErrorCode> {
+    let (receiver, command_handle, cb) = super::callbacks::_closure_to_cb_ec_string();
+
+    let submitter_did = CString::new(submitter_did).unwrap();
+    let request_json = CString::new(request_json).unwrap();
+
+    let err = unsafe {
+        indy_sign_and_submit_request(command_handle,
+                                     pool_handle,
+                                     wallet_handle,
+                                     submitter_did.as_ptr(),
+                                     request_json.as_ptr(),
+                                     cb)
+    };
+
+    super::results::result_to_string(err, receiver)
+}
+
+pub fn build_nym_request(submitter_did: &str, target_did: &str, verkey: &str, alias: &str, role: &str) -> Result<String, ErrorCode> {
+    let (receiver, command_handle, cb) = super::callbacks::_closure_to_cb_ec_string();
+
+    let submitter_did = CString::new(submitter_did).unwrap();
+    let target_did = CString::new(target_did).unwrap();
+    let verkey = CString::new(verkey).unwrap();
+    let alias = CString::new(alias).unwrap();
+    let role = CString::new(role).unwrap();
+
+    let err = unsafe {
+        indy_build_nym_request(command_handle,
+                               submitter_did.as_ptr(),
+                               target_did.as_ptr(),
+                               verkey.as_ptr(),
+                               alias.as_ptr(),
+                               role.as_ptr(),
+                               cb)
+    };
 
     super::results::result_to_string(err, receiver)
 }
@@ -20,4 +60,25 @@ extern {
                            cb: Option<extern fn(xcommand_handle: i32,
                                                 err: ErrorCode,
                                                 request_result_json: *const c_char)>) -> ErrorCode;
+
+    #[no_mangle]
+    fn indy_build_nym_request(command_handle: i32,
+                              submitter_did: *const c_char,
+                              target_did: *const c_char,
+                              verkey: *const c_char,
+                              alias: *const c_char,
+                              role: *const c_char,
+                              cb: Option<extern fn(xcommand_handle: i32,
+                                                   err: ErrorCode,
+                                                   request_json: *const c_char)>) -> ErrorCode;
+    #[no_mangle]
+    fn indy_sign_and_submit_request(command_handle: i32,
+                                               pool_handle: i32,
+                                               wallet_handle: i32,
+                                               submitter_did: *const c_char,
+                                               request_json: *const c_char,
+                                               cb: Option<extern fn(xcommand_handle: i32,
+                                                                    err: ErrorCode,
+                                                                    request_result_json: *const c_char)>) -> ErrorCode;
+
 }

libnullpay/tests/utils/mod.rs

@@ -1,6 +1,7 @@
 extern crate libc;
 extern crate nullpay;
 
+pub mod did;
 pub mod payments;
 pub mod plugin;
 pub mod wallet;

libnullpay/tests/utils/payments.rs

@@ -53,6 +53,23 @@ pub fn add_request_fees(wallet_handle: i32, submitter_did: &str, req_json: &str,
     super::results::result_to_string_string(err, receiver)
 }
 
+pub fn parse_response_with_fees(payment_method: &str, resp_json: &str) -> Result<String, ErrorCode> {
+    let (receiver, command_handle, cb) =
+        super::callbacks::_closure_to_cb_ec_string();
+
+    let payment_method = CString::new(payment_method).unwrap();
+    let resp_json = CString::new(resp_json).unwrap();
+
+    let err = unsafe {
+        indy_parse_response_with_fees(command_handle,
+                                     payment_method.as_ptr(),
+                                     resp_json.as_ptr(),
+                                     cb)
+    };
+
+    super::results::result_to_string(err, receiver)
+}
+
 pub fn build_get_utxo_request(wallet_handle: i32, submitter_did: &str, payment_address: &str) -> Result<(String, String), ErrorCode> {
     let (receiver, command_handle, cb) =
         super::callbacks::_closure_to_cb_ec_string_string();
@@ -207,14 +224,14 @@ extern {
                                    config: *const c_char,
                                    cb: Option<extern fn(command_handle_: i32,
                                                         err: ErrorCode,
-                                                        payment_address: *const c_char)>) -> ErrorCode ;
+                                                        payment_address: *const c_char)>) -> ErrorCode;
 
     #[no_mangle]
     fn indy_list_payment_addresses(command_handle: i32,
                                    wallet_handle: i32,
                                    cb: Option<extern fn(command_handle_: i32,
-                                                err: ErrorCode,
-                                                payment_addresses_json: *const c_char)>) -> ErrorCode;
+                                                        err: ErrorCode,
+                                                        payment_addresses_json: *const c_char)>) -> ErrorCode;
 
     #[no_mangle]
     fn indy_add_request_fees(command_handle: i32,
@@ -228,6 +245,14 @@ extern {
                                                   req_with_fees_json: *const c_char,
                                                   payment_method: *const c_char)>) -> ErrorCode;
 
+    #[no_mangle]
+    fn indy_parse_response_with_fees(command_handle: i32,
+                                     payment_method: *const c_char,
+                                     resp_json: *const c_char,
+                                     cb: Option<extern fn(command_handle_: i32,
+                                                          err: ErrorCode,
+                                                          utxo_json: *const c_char)>) -> ErrorCode;
+
     #[no_mangle]
     fn indy_build_get_utxo_request(command_handle: i32,
                                    wallet_handle: i32,