Add tests for add_request_fees and payment_req

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

Author: Nikita Khateev

libnullpay/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["Nikita Khateev <[email protected]>"]
 
 [lib]
 name = "nullpay"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 lazy_static = "1.0"

libnullpay/build.rs

@@ -13,5 +13,7 @@ fn main() {
 
         println!("cargo:rustc-link-lib=dylib=indy.dll");
         println!("cargo:rustc-flags=-L {}", indy_dir);
+    } else {
+        println!("cargo:rustc-link-lib=indy");
     }
 }

libnullpay/tests/payments.rs

@@ -28,8 +28,7 @@ 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 TRUSTEE_SEED: &str = "000000000000000000000000Trustee1";
 static FEES: &str = r#"{"1":1, "101":2}"#;
 
 mod high_cases {
@@ -164,48 +163,102 @@ 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 (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 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 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());
 
-//            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), 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());
 
-//            payments_utils::set_request_fees(wallet_handle, pool_handle, my_did.as_str(), 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 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 (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 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, trustee_did.as_str(), nym_req_with_fees.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();
 
-//            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);
+            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);
+
+            //TODO: check that there is 2 UTXO for the second address and 0 UTXO for the first one
 
             pool::close(pool_handle).unwrap();
             wallet::close_wallet(wallet_handle).unwrap();
             test_utils::cleanup_storage();
         }
     }
 
+    mod payment {
+        use super::*;
+
+        #[test]
+        pub fn payment_request_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 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 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 (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_resp_parsed = payments::parse_payment_response(payment_method.as_str(), payment_resp.as_str()).unwrap();
+
+            let utxos: Vec<UTXOInfo> = serde_json::from_str(payment_resp_parsed.as_str()).unwrap();
+            assert_eq!(utxos.len(), 2);
+
+            let utxos: HashMap<i32, String> = utxos.into_iter().map(|info| (info.amount, info.input)).collect();
+            let payment_utxo = utxos.get(&19).unwrap();
+            let change_utxo = utxos.get(&1).unwrap();
+
+            let payment_utxo_end = payment_utxo.split("_").last().unwrap();
+            assert!(addresses.get(1).unwrap().to_string().ends_with(payment_utxo_end));
+
+            let change_utxo_end = change_utxo.split("_").last().unwrap();
+            assert!(addresses.get(0).unwrap().to_string().ends_with(change_utxo_end));
+        }
+    }
+
     mod fees {
         use super::*;
 

libnullpay/tests/utils/did.rs

@@ -2,16 +2,6 @@ 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();