From 00f66bb222d4b28e4c1b11e26a99acfbc1bb03ed Mon Sep 17 00:00:00 2001 From: Patrik Stas Date: Tue, 26 Jul 2022 18:17:03 +0200 Subject: [PATCH] Narrow down error --- libsovtoken/Cargo.toml | 3 +- libsovtoken/tests/add_fees_for_attrib_test.rs | 369 +++++----- .../tests/add_fees_for_cred_def_test.rs | 216 ------ libsovtoken/tests/add_fees_for_nym.rs | 298 -------- .../tests/add_fees_for_revoke_reg_def.rs | 241 ------- libsovtoken/tests/add_fees_for_schema_test.rs | 188 ----- .../tests/add_request_fees_handler_test.rs | 214 ------ libsovtoken/tests/api_tests.rs | 17 - .../tests/build_fees_txn_handler_test.rs | 252 ------- .../build_get_utxo_request_handler_test.rs | 197 ------ .../tests/build_mint_txn_handler_test.rs | 373 ---------- .../tests/build_payment_req_handler_test.rs | 661 ------------------ libsovtoken/tests/build_verify_req_test.rs | 260 ------- .../create_payment_addres_handler_tests.rs | 123 ---- libsovtoken/tests/create_payment_tests.rs | 162 ----- libsovtoken/tests/payment_chaos_tests.rs | 387 ---------- libsovtoken/tests/sign_with_address_test.rs | 99 --- libsovtoken/tests/utils/mint.rs | 12 +- libsovtoken/tests/utils/setup.rs | 1 + 19 files changed, 203 insertions(+), 3870 deletions(-) delete mode 100644 libsovtoken/tests/add_fees_for_cred_def_test.rs delete mode 100644 libsovtoken/tests/add_fees_for_nym.rs delete mode 100644 libsovtoken/tests/add_fees_for_revoke_reg_def.rs delete mode 100644 libsovtoken/tests/add_fees_for_schema_test.rs delete mode 100644 libsovtoken/tests/add_request_fees_handler_test.rs delete mode 100644 libsovtoken/tests/api_tests.rs delete mode 100644 libsovtoken/tests/build_fees_txn_handler_test.rs delete mode 100644 libsovtoken/tests/build_get_utxo_request_handler_test.rs delete mode 100644 libsovtoken/tests/build_mint_txn_handler_test.rs delete mode 100644 libsovtoken/tests/build_payment_req_handler_test.rs delete mode 100644 libsovtoken/tests/build_verify_req_test.rs delete mode 100644 libsovtoken/tests/create_payment_addres_handler_tests.rs delete mode 100644 libsovtoken/tests/create_payment_tests.rs delete mode 100644 libsovtoken/tests/payment_chaos_tests.rs delete mode 100644 libsovtoken/tests/sign_with_address_test.rs diff --git a/libsovtoken/Cargo.toml b/libsovtoken/Cargo.toml index 78c32694a..675b3cfa3 100644 --- a/libsovtoken/Cargo.toml +++ b/libsovtoken/Cargo.toml @@ -25,7 +25,8 @@ base64 = "0.10.1" hex = "0.2.0" lazy_static = "1.3.0" libc = "0.2.41" -log = "0.4.6" +env_logger = "0.9.0" +log = "0.4.16" openssl = "0.10.20" rand = "0.3" indy-sys = "=1.12.0-rc-96" diff --git a/libsovtoken/tests/add_fees_for_attrib_test.rs b/libsovtoken/tests/add_fees_for_attrib_test.rs index 124e43060..7ffaba3e8 100644 --- a/libsovtoken/tests/add_fees_for_attrib_test.rs +++ b/libsovtoken/tests/add_fees_for_attrib_test.rs @@ -1,166 +1,185 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; extern crate indyrs as indy; +#[macro_use] +extern crate lazy_static; +#[macro_use] +extern crate log; +#[macro_use] +extern crate serde_derive; +#[macro_use] +extern crate serde_json; extern crate sovtoken; +extern crate env_logger; -use indy::future::Future; -mod utils; -use utils::setup::{Setup, SetupConfig}; -use utils::wallet::Wallet; +use std::env; +use env_logger::Builder; + +use indy::future::Future; +use log::LevelFilter; use sovtoken::ErrorCode; use sovtoken::logic::parsers::common::UTXO; use sovtoken::utils::constants::txn_types::ATTRIB; +use utils::setup::{Setup, SetupConfig}; +use utils::wallet::Wallet; +mod utils; pub const ATTRIB_RAW_DATA_2: &'static str = r#"{"endpoint":{"ha":"127.0.0.1:5555"}}"#; pub const ATTRIB_RAW_DATA: &'static str = r#"{"endpoint":{"ha":"127.0.0.1:5555"}}"#; -#[test] -pub fn build_and_submit_attrib_with_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "100": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_resp = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs).unwrap(); - - let parsed_utxos: Vec = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_utxos.len(), 1); - assert_eq!(parsed_utxos[0].amount, 9); - assert_eq!(parsed_utxos[0].recipient, addresses[0]); - - std::thread::sleep(std::time::Duration::from_millis(100)); - - let get_attrib_resp = send_get_attrib_req(&wallet, pool_handle, dids[0], dids[0], Some("endpoint")); - let data = get_data_from_attrib_reply(get_attrib_resp); - assert_eq!(ATTRIB_RAW_DATA, data); -} - -#[test] -pub fn build_and_submit_attrib_with_fees_and_no_change() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "100": 10 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([]).to_string(); - - let parsed_resp = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA_2), wallet.handle, pool_handle, &inputs, &outputs).unwrap(); - - let parsed_utxos: Vec = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_utxos.len(), 0); - - std::thread::sleep(std::time::Duration::from_millis(100)); - - let get_attrib_resp = send_get_attrib_req(&wallet, pool_handle, dids[0], dids[0], Some("endpoint")); - let data = get_data_from_attrib_reply(get_attrib_resp); - assert_eq!(ATTRIB_RAW_DATA_2, data); -} - -#[test] -pub fn build_and_submit_attrib_with_fees_incorrect_funds() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![9]), - fees: Some(json!({ - ATTRIB: 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs_1 = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_err = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs_1).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentInsufficientFundsError); - - let outputs_2 = json!([{ - "recipient": addresses[0], - "amount": 1 - }]).to_string(); - - let parsed_err = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs_2).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentExtraFundsError); -} - -#[test] -pub fn build_and_submit_attrib_with_fees_from_invalid_did_and_check_utxo_remain_unspent() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![9]), - fees: Some(json!({ - ATTRIB: 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let (did_new, _) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_err = _send_attrib_with_fees(&did_new, Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::CommonInvalidStructure); - - let utxo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - assert_eq!(utxo, utxo_2); -} +// #[test] +// pub fn build_and_submit_attrib_with_fees() { +// let wallet = Wallet::new(); +// let setup = Setup::new(&wallet, SetupConfig { +// num_addresses: 1, +// num_trustees: 4, +// num_users: 0, +// mint_tokens: Some(vec![10]), +// fees: Some(json!({ +// "100": 1 +// })), +// }); +// let addresses = &setup.addresses; +// let pool_handle = setup.pool_handle; +// let dids = setup.trustees.dids(); +// +// let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); +// +// let inputs = json!([utxo]).to_string(); +// let outputs = json!([{ +// "recipient": addresses[0], +// "amount": 9 +// }]).to_string(); +// +// let parsed_resp = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs).unwrap(); +// +// let parsed_utxos: Vec = serde_json::from_str(&parsed_resp).unwrap(); +// assert_eq!(parsed_utxos.len(), 1); +// assert_eq!(parsed_utxos[0].amount, 9); +// assert_eq!(parsed_utxos[0].recipient, addresses[0]); +// +// std::thread::sleep(std::time::Duration::from_millis(100)); +// +// let get_attrib_resp = send_get_attrib_req(&wallet, pool_handle, dids[0], dids[0], Some("endpoint")); +// let data = get_data_from_attrib_reply(get_attrib_resp); +// assert_eq!(ATTRIB_RAW_DATA, data); +// } +// +// #[test] +// pub fn build_and_submit_attrib_with_fees_and_no_change() { +// let wallet = Wallet::new(); +// let setup = Setup::new(&wallet, SetupConfig { +// num_addresses: 1, +// num_trustees: 4, +// num_users: 0, +// mint_tokens: Some(vec![10]), +// fees: Some(json!({ +// "100": 10 +// })), +// }); +// let addresses = &setup.addresses; +// let pool_handle = setup.pool_handle; +// let dids = setup.trustees.dids(); +// +// let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); +// +// let inputs = json!([utxo]).to_string(); +// let outputs = json!([]).to_string(); +// +// let parsed_resp = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA_2), wallet.handle, pool_handle, &inputs, &outputs).unwrap(); +// +// let parsed_utxos: Vec = serde_json::from_str(&parsed_resp).unwrap(); +// assert_eq!(parsed_utxos.len(), 0); +// +// std::thread::sleep(std::time::Duration::from_millis(100)); +// +// let get_attrib_resp = send_get_attrib_req(&wallet, pool_handle, dids[0], dids[0], Some("endpoint")); +// let data = get_data_from_attrib_reply(get_attrib_resp); +// assert_eq!(ATTRIB_RAW_DATA_2, data); +// } +// +// #[test] +// pub fn build_and_submit_attrib_with_fees_incorrect_funds() { +// let wallet = Wallet::new(); +// let setup = Setup::new(&wallet, SetupConfig { +// num_addresses: 1, +// num_trustees: 4, +// num_users: 0, +// mint_tokens: Some(vec![9]), +// fees: Some(json!({ +// ATTRIB: 1 +// })), +// }); +// let addresses = &setup.addresses; +// let pool_handle = setup.pool_handle; +// let dids = setup.trustees.dids(); +// +// let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); +// +// let inputs = json!([utxo]).to_string(); +// let outputs_1 = json!([{ +// "recipient": addresses[0], +// "amount": 9 +// }]).to_string(); +// +// let parsed_err = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs_1).unwrap_err(); +// assert_eq!(parsed_err.error_code, ErrorCode::PaymentInsufficientFundsError); +// +// let outputs_2 = json!([{ +// "recipient": addresses[0], +// "amount": 1 +// }]).to_string(); +// +// let parsed_err = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs_2).unwrap_err(); +// assert_eq!(parsed_err.error_code, ErrorCode::PaymentExtraFundsError); +// } +// +// #[test] +// pub fn build_and_submit_attrib_with_fees_from_invalid_did_and_check_utxo_remain_unspent() { +// let wallet = Wallet::new(); +// let setup = Setup::new(&wallet, SetupConfig { +// num_addresses: 1, +// num_trustees: 4, +// num_users: 0, +// mint_tokens: Some(vec![9]), +// fees: Some(json!({ +// ATTRIB: 1 +// })), +// }); +// let addresses = &setup.addresses; +// let pool_handle = setup.pool_handle; +// let dids = setup.trustees.dids(); +// +// let (did_new, _) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); +// +// let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); +// +// let inputs = json!([utxo]).to_string(); +// let outputs = json!([{ +// "recipient": addresses[0], +// "amount": 9 +// }]).to_string(); +// +// let parsed_err = _send_attrib_with_fees(&did_new, Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs).unwrap_err(); +// assert_eq!(parsed_err.error_code, ErrorCode::CommonInvalidStructure); +// +// let utxo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); +// assert_eq!(utxo, utxo_2); +// } #[test] pub fn build_and_submit_attrib_with_fees_double_spend() { + let pattern = env::var("RUST_LOG").ok().unwrap_or("debug".to_string()); + Builder::new() + // .format(formatter) + .filter(None, LevelFilter::Off) + .parse_filters(&pattern) + .try_init() + .unwrap(); + let wallet = Wallet::new(); + info!("Start"); let setup = Setup::new(&wallet, SetupConfig { num_addresses: 1, num_trustees: 4, @@ -170,38 +189,38 @@ pub fn build_and_submit_attrib_with_fees_double_spend() { ATTRIB: 1 })), }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_resp = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs).unwrap(); - - let parsed_utxos: Vec = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_utxos.len(), 1); - assert_eq!(parsed_utxos[0].amount, 9); - assert_eq!(parsed_utxos[0].recipient, addresses[0]); - - std::thread::sleep(std::time::Duration::from_millis(100)); - - let get_attrib_resp = send_get_attrib_req(&wallet, pool_handle, dids[0], dids[0], Some("endpoint")); - let data = get_data_from_attrib_reply(get_attrib_resp); - assert_eq!(ATTRIB_RAW_DATA, data); - - let parsed_err = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA_2), wallet.handle, pool_handle, &inputs, &outputs).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentSourceDoesNotExistError); + // let addresses = &setup.addresses; + // let pool_handle = setup.pool_handle; + // let dids = setup.trustees.dids(); + // + // + // let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); + // + // let inputs = json!([utxo]).to_string(); + // let outputs = json!([{ + // "recipient": addresses[0], + // "amount": 9 + // }]).to_string(); + // + // let parsed_resp = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA), wallet.handle, pool_handle, &inputs, &outputs).unwrap(); + // + // let parsed_utxos: Vec = serde_json::from_str(&parsed_resp).unwrap(); + // assert_eq!(parsed_utxos.len(), 1); + // assert_eq!(parsed_utxos[0].amount, 9); + // assert_eq!(parsed_utxos[0].recipient, addresses[0]); + // + // std::thread::sleep(std::time::Duration::from_millis(100)); + // + // let get_attrib_resp = send_get_attrib_req(&wallet, pool_handle, dids[0], dids[0], Some("endpoint")); + // let data = get_data_from_attrib_reply(get_attrib_resp); + // assert_eq!(ATTRIB_RAW_DATA, data); + // + // let parsed_err = _send_attrib_with_fees(dids[0], Some(ATTRIB_RAW_DATA_2), wallet.handle, pool_handle, &inputs, &outputs).unwrap_err(); + // assert_eq!(parsed_err.error_code, ErrorCode::PaymentSourceDoesNotExistError); } fn _send_attrib_with_fees(did: &str, data: Option<&str>, wallet_handle: i32, pool_handle: i32, inputs: &str, outputs: &str) -> Result { - let attrib_req = indy::ledger::build_attrib_request(did, did, None, data, None).wait().unwrap(); + let attrib_req = indy::ledger::build_attrib_request(did, did, None, data, None).wait().unwrap(); let attrib_req_signed = indy::ledger::sign_request(wallet_handle, did, &attrib_req).wait().unwrap(); let (attrib_req_with_fees, pm) = indy::payments::add_request_fees(wallet_handle, Some(did), &attrib_req_signed, inputs, outputs, None).wait().unwrap(); let attrib_resp = indy::ledger::submit_request(pool_handle, &attrib_req_with_fees).wait().unwrap(); diff --git a/libsovtoken/tests/add_fees_for_cred_def_test.rs b/libsovtoken/tests/add_fees_for_cred_def_test.rs deleted file mode 100644 index 6a18d4a72..000000000 --- a/libsovtoken/tests/add_fees_for_cred_def_test.rs +++ /dev/null @@ -1,216 +0,0 @@ -#[macro_use] -extern crate serde_json; -#[macro_use] -extern crate serde_derive; -#[macro_use] -extern crate lazy_static; -extern crate indyrs as indy; -extern crate sovtoken; - -use std::{thread, time}; -use std::collections::HashMap; - -use indy::future::Future; - -use sovtoken::ErrorCode; -use sovtoken::utils::random::rand_string; -mod utils; -use utils::setup::{Setup, SetupConfig}; -use utils::wallet::Wallet; - -fn send_cred_def_with_fees(did: &str, - name: &str, - version: &str, - attrs: &str, - wallet_handle: i32, - pool_handle: i32, - inputs_json: &str, - outputs_json: &str, - extra: Option<&str>, - schema: Option) -> Result<(String, String, String), indy::IndyError> { - let schema = schema.unwrap_or_else(|| create_schema_json(did, name, version, attrs, wallet_handle, pool_handle)); - - let tag = rand_string(7); - let (cred_def_id, cred_def_json) = indy::anoncreds::issuer_create_and_store_credential_def( - wallet_handle, - did, - &schema, - &tag, - None, - &json!({"support_revocation": false}).to_string() - ).wait().unwrap(); - - let cred_def_req = indy::ledger::build_cred_def_request(did, &cred_def_json).wait().unwrap(); - let cred_def_req_signed = indy::ledger::sign_request(wallet_handle, did, &cred_def_req).wait().unwrap(); - let (cred_def_req_with_fees, pm) = indy::payments::add_request_fees( - wallet_handle, - Some(did), - &cred_def_req_signed, - inputs_json, - outputs_json, - extra - ).wait().unwrap(); - let cred_def_response_with_fees = indy::ledger::submit_request(pool_handle, &cred_def_req_with_fees).wait().unwrap(); - - indy::payments::parse_response_with_fees(&pm, &cred_def_response_with_fees).map(|s| (s, cred_def_id, cred_def_json)).wait() -} - -fn create_schema_json(did: &str, - name: &str, - version: &str, - attrs: &str, - wallet_handle: i32, - pool_handle: i32) -> String { - let (schema_id, schema_json) = indy::anoncreds::issuer_create_schema(did, name, version, attrs).wait().unwrap(); - let schema_req = indy::ledger::build_schema_request(did, &schema_json).wait().unwrap(); - let schema_resp = indy::ledger::sign_and_submit_request(pool_handle, wallet_handle, did, &schema_req).wait().unwrap(); - thread::sleep(time::Duration::from_millis(100)); - let get_schema_req = indy::ledger::build_get_schema_request(Some(did), &schema_id).wait().unwrap(); - let get_schema_req_signed = indy::ledger::sign_request(wallet_handle, did, &get_schema_req).wait().unwrap(); - let get_schema_resp = utils::ledger::submit_request_with_retries(pool_handle, &get_schema_req_signed, &schema_resp).unwrap(); - let (_, schema_json) = indy::ledger::parse_get_schema_response(&get_schema_resp).wait().unwrap(); - schema_json -} - -pub const SCHEMA_VERSION: &'static str = "1.0"; -pub const GVT_SCHEMA_ATTRIBUTES: &'static str = r#"["name", "age", "sex", "height"]"#; - -#[test] -pub fn build_and_submit_cred_def_with_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "102": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (parsed_resp, cred_def_id, _) = send_cred_def_with_fees(dids[0], rand_string(5).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None, None).unwrap(); - - let parsed_resp_json: Vec> = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_resp_json.len(), 1); - assert_eq!(parsed_resp_json[0].get("amount").unwrap().as_u64().unwrap(), 9); - assert_eq!(parsed_resp_json[0].get("recipient").unwrap().as_str().unwrap(), addresses[0]); - - thread::sleep(time::Duration::from_millis(100)); - - let get_cred_def_req = indy::ledger::build_get_cred_def_request(Some(dids[0]), &cred_def_id).wait().unwrap(); - let get_cred_def_resp = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_cred_def_req).wait().unwrap(); - let (cred_def_id_get, _) = indy::ledger::parse_get_cred_def_response(&get_cred_def_resp).wait().unwrap(); - assert_eq!(cred_def_id, cred_def_id_get); -} - -#[test] -pub fn build_and_submit_cred_def_with_fees_insufficient_funds() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![9]), - fees: Some(json!({ - "102": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs_1 = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_err = send_cred_def_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs_1, None, None).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentInsufficientFundsError); - - let outputs_2 = json!([{ - "recipient": addresses[0], - "amount": 1 - }]).to_string(); - - let parsed_err = send_cred_def_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs_2, None, None).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentExtraFundsError); -} - -#[test] -pub fn build_and_submit_cred_def_with_fees_double_spend() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "102": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - send_cred_def_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None, None).unwrap(); - - let parsed_err = send_cred_def_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None, None).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentSourceDoesNotExistError); -} - -#[test] -pub fn build_and_submit_cred_def_with_fees_twice_and_check_utxo_remain_unspent() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "102": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - let (did_new, _) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let schema = Some(create_schema_json(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle)); - let parsed_err = send_cred_def_with_fees(&did_new, rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None, schema).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::CommonInvalidStructure); - - let utxo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - assert_eq!(utxo, utxo_2); -} \ No newline at end of file diff --git a/libsovtoken/tests/add_fees_for_nym.rs b/libsovtoken/tests/add_fees_for_nym.rs deleted file mode 100644 index d375c0003..000000000 --- a/libsovtoken/tests/add_fees_for_nym.rs +++ /dev/null @@ -1,298 +0,0 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; -extern crate indyrs as indy; -extern crate sovtoken; - -use std::collections::HashMap; - -use indy::future::Future; - -use sovtoken::ErrorCode; - -mod utils; - -use utils::payment::get_utxo; -use utils::setup::{Setup, SetupConfig}; -use utils::wallet::Wallet; - -#[test] -pub fn build_and_submit_nym_with_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_signed, &inputs, &outputs, None).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_with_fees).wait().unwrap(); - let parsed_resp = indy::payments::parse_response_with_fees(&pm, &nym_resp).wait().unwrap(); - - let parsed_resp_json: Vec> = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_resp_json.len(), 1); - assert_eq!(parsed_resp_json[0].get("amount").unwrap().as_u64().unwrap(), 9); - assert_eq!(parsed_resp_json[0].get("recipient").unwrap().as_str().unwrap(), addresses[0]); - - let get_nym_req = indy::ledger::build_get_nym_request(Some(dids[0]), &did_new).wait().unwrap(); - let get_nym_resp = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_nym_req).wait().unwrap(); - let get_nym_resp_json: serde_json::Value = serde_json::from_str(&get_nym_resp).unwrap(); - assert!(get_nym_resp_json.as_object().unwrap().get("result").unwrap().as_object().unwrap().get("data").is_some()); -} - -#[test] -pub fn build_and_submit_nym_with_fees_insufficient_funds() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 2 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_signed, &inputs, &outputs, None).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_with_fees).wait().unwrap(); - let err = indy::payments::parse_response_with_fees(&pm, &nym_resp).wait().unwrap_err(); - assert_eq!(err.error_code, ErrorCode::PaymentInsufficientFundsError); -} - -#[test] -pub fn build_and_submit_nym_with_no_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 0, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_signed).wait().unwrap(); - let resp = indy::payments::parse_response_with_fees("sov", &nym_resp).wait().unwrap(); - assert_eq!(resp, json!([]).to_string()); -} - -#[test] -pub fn build_and_submit_nym_with_fees_utxo_already_spent() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_signed, &inputs, &outputs, None).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_with_fees).wait().unwrap(); - indy::payments::parse_response_with_fees(&pm, &nym_resp).wait().unwrap(); - - let (did_new_2, verkey_new_2) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new_2, Some(&verkey_new_2), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_signed, &inputs, &outputs, None).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_with_fees).wait().unwrap(); - let err = indy::payments::parse_response_with_fees(&pm, &nym_resp).wait().unwrap_err(); - assert_eq!(err.error_code, ErrorCode::PaymentSourceDoesNotExistError); -} - -#[test] -pub fn build_and_submit_nym_with_fees_and_get_utxo() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_signed, &inputs, &outputs, None).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_with_fees).wait().unwrap(); - let parsed_resp = indy::payments::parse_response_with_fees(&pm, &nym_resp).wait().unwrap(); - - let parsed_resp_json: Vec> = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_resp_json.len(), 1); - assert_eq!(parsed_resp_json[0].get("amount").unwrap().as_u64().unwrap(), 9); - assert_eq!(parsed_resp_json[0].get("recipient").unwrap().as_str().unwrap(), addresses[0]); - - let (utxos, next) = get_utxo::send_get_utxo_request(&wallet, pool_handle, dids[0], &addresses[0], None); - let utxo = &utxos[0]; - - assert_eq!(utxos.len(), 1); - assert_eq!(utxo.payment_address, addresses[0]); - assert_eq!(utxo.amount, 9); - assert_eq!(next, None); -} - -#[test] -pub fn build_and_submit_nym_with_fees_from_invalid_did_and_check_utxo_remain_unspent() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - let (did_new_2, _) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(&did_new_2, &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req, &inputs, &outputs, None).wait().unwrap(); - let resp = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &nym_req_with_fees).wait().unwrap(); - let err = indy::payments::parse_response_with_fees(&pm, &resp).wait().unwrap_err(); - assert_eq!(err.error_code, ErrorCode::CommonInvalidStructure); - - let utxo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - assert_eq!(utxo, utxo_2); -} - -/// This test reproduces bug described in https://evernym.atlassian.net/browse/TOK-252 -#[test] -pub fn build_and_submit_nym_with_fees_from_other_nym_txn() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - // We have a user and a malicious node - // Both of them generate a nym write request - // User 1 generates fees for his nym and sends it to the ledger - // Malicious node gets the request from user, fetches fees from it and sends its own nym with that fees - // It should not be accepted by other nodes and nym from user should be written - let (did_new_1, verkey_new_1) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - let (did_new_2, verkey_new_2) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req_1 = indy::ledger::build_nym_request(dids[0], &did_new_1, Some(&verkey_new_1), None, None).wait().unwrap(); - let nym_req_2 = indy::ledger::build_nym_request(dids[1], &did_new_2, Some(&verkey_new_2), None, None).wait().unwrap(); - - let (nym_req_with_fees_1, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_1, &inputs, &outputs, None).wait().unwrap(); - - let nym_req_with_fees_1_parsed = serde_json::from_str::>(&nym_req_with_fees_1).unwrap(); - let fees: &serde_json::Value = nym_req_with_fees_1_parsed.get("fees").unwrap(); - - let mut nym_req_without_fees: serde_json::Map = serde_json::from_str(&nym_req_2).unwrap(); - nym_req_without_fees.insert("fees".to_string(), fees.clone()); - let nym_req_with_fees_2 = serde_json::to_string(&nym_req_without_fees).unwrap(); - - let resp = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[1], &nym_req_with_fees_2).wait().unwrap(); - let err = indy::payments::parse_response_with_fees(&pm, &resp).wait().unwrap_err(); - assert_eq!(err.error_code, ErrorCode::CommonInvalidStructure); - - let resp = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &nym_req_with_fees_1).wait().unwrap(); - indy::payments::parse_response_with_fees(&pm, &resp).wait().unwrap(); -} diff --git a/libsovtoken/tests/add_fees_for_revoke_reg_def.rs b/libsovtoken/tests/add_fees_for_revoke_reg_def.rs deleted file mode 100644 index 5352b9a5a..000000000 --- a/libsovtoken/tests/add_fees_for_revoke_reg_def.rs +++ /dev/null @@ -1,241 +0,0 @@ -#[macro_use] -extern crate serde_json; -#[macro_use] -extern crate serde_derive; -#[macro_use] -extern crate lazy_static; -extern crate sovtoken; -extern crate indyrs as indy; - -use std::{thread, time}; -use std::collections::HashMap; - -use indy::future::Future; - -use sovtoken::ErrorCode; -use sovtoken::utils::random::rand_string; -use utils::wallet::Wallet; -use utils::setup::{Setup, SetupConfig}; -mod utils; - -pub const SCHEMA_VERSION: &'static str = "1.0"; -pub const GVT_SCHEMA_ATTRIBUTES: &'static str = r#"["name", "age", "sex", "height"]"#; - -fn send_revoc_reg_def_with_fees(issuer_did: &str, - name: &str, - version: &str, - tag: &str, - attrs: &str, - inputs_json: &str, - outputs_json: &str, - extra: Option<&str>, - wallet_handle: i32, - pool_handle: i32, - cred_def_id: Option) -> Result { - let cred_def_id = cred_def_id.unwrap_or_else(|| { - let (_, id, _) = create_cred_def(issuer_did, - name, - version, - attrs, - wallet_handle, - pool_handle, - None); - id - }); - - let tails_writer_config = utils::anoncreds::tails_writer_config(); - let tails_writer_handle = indy::blob_storage::open_writer("default", &tails_writer_config).wait().unwrap(); - - let it: Option = None; - let (_rev_reg_id, revoc_reg_def_json, _rev_reg_entry_json) = - indy::anoncreds::issuer_create_and_store_revoc_reg(wallet_handle, - issuer_did, - None, - tag, - &cred_def_id, - &json!({ "max_cred_num": Some(5), "issuance_type": it }).to_string(), - tails_writer_handle).wait().unwrap(); - - let req = indy::ledger::build_revoc_reg_def_request(issuer_did, &revoc_reg_def_json).wait().unwrap(); - let (req_with_fees, pm) = - indy::payments::add_request_fees( - wallet_handle, - Some(issuer_did), - &req, - inputs_json, - outputs_json, - extra).wait().unwrap(); - let response = indy::ledger::sign_and_submit_request(pool_handle, wallet_handle, issuer_did, &req_with_fees).wait().unwrap(); - indy::payments::parse_response_with_fees(&pm, &response).wait() -} - -fn create_cred_def(did: &str, - name: &str, - version: &str, - attrs: &str, - wallet_handle: i32, - pool_handle: i32, - schema: Option) -> (String, String, String) { - let schema = schema.unwrap_or_else(|| create_schema_json(did, name, version, attrs, wallet_handle, pool_handle)); - - let tag = rand_string(7); - let (cred_def_id, cred_def_json) = indy::anoncreds::issuer_create_and_store_credential_def( - wallet_handle, - did, - &schema, - &tag, - None, - &json!({"support_revocation": true}).to_string() - ).wait().unwrap(); - - let cred_def_req = indy::ledger::build_cred_def_request(did, &cred_def_json).wait().unwrap(); - let cred_def_req_signed = indy::ledger::sign_request(wallet_handle, did, &cred_def_req).wait().unwrap(); - indy::ledger::submit_request(pool_handle, &cred_def_req_signed).wait().unwrap(); - - (schema, cred_def_id, cred_def_json) -} - -fn create_schema_json(did: &str, - name: &str, - version: &str, - attrs: &str, - wallet_handle: i32, - pool_handle: i32) -> String { - let (schema_id, schema_json) = indy::anoncreds::issuer_create_schema(did, name, version, attrs).wait().unwrap(); - let schema_req = indy::ledger::build_schema_request(did, &schema_json).wait().unwrap(); - let schema_resp = indy::ledger::sign_and_submit_request(pool_handle, wallet_handle, did, &schema_req).wait().unwrap(); - thread::sleep(time::Duration::from_millis(100)); - let get_schema_req = indy::ledger::build_get_schema_request(Some(did), &schema_id).wait().unwrap(); - let get_schema_req_signed = indy::ledger::sign_request(wallet_handle, did, &get_schema_req).wait().unwrap(); - let get_schema_resp = utils::ledger::submit_request_with_retries(pool_handle, &get_schema_req_signed, &schema_resp).unwrap(); - let (_, schema_json) = indy::ledger::parse_get_schema_response(&get_schema_resp).wait().unwrap(); - schema_json -} - -#[test] -pub fn build_and_submit_revoc_reg_def_works_with_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "113": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_resp = send_revoc_reg_def_with_fees(dids[0], - rand_string(5).as_str(), - SCHEMA_VERSION, - rand_string(7).as_str(), - GVT_SCHEMA_ATTRIBUTES, - &inputs, - &outputs, - None, - wallet.handle, - pool_handle, - None).unwrap(); - - let parsed_resp_json: Vec> = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_resp_json.len(), 1); - assert_eq!(parsed_resp_json[0].get("amount").unwrap().as_u64().unwrap(), 9); - assert_eq!(parsed_resp_json[0].get("recipient").unwrap().as_str().unwrap(), addresses[0]); -} - -#[test] -pub fn build_and_submit_revoc_reg_def_works_with_fees_and_spent_utxo() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "113": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 10 - }]).to_string(); - - let (req, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &inputs, &outputs, None).wait().unwrap(); - indy::ledger::submit_request(pool_handle, &req).wait().unwrap(); - - let outputs_2 = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_err = send_revoc_reg_def_with_fees(dids[0], - rand_string(5).as_str(), - SCHEMA_VERSION, - rand_string(7).as_str(), - GVT_SCHEMA_ATTRIBUTES, - &inputs, - &outputs_2, - None, - wallet.handle, - pool_handle, - None).unwrap_err(); - - assert_eq!(parsed_err.error_code, ErrorCode::PaymentSourceDoesNotExistError); -} - -#[test] -pub fn build_and_submit_revoc_reg_def_works_with_fees_and_insufficient_funds() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "113": 11 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_err = send_revoc_reg_def_with_fees(dids[0], - rand_string(5).as_str(), - SCHEMA_VERSION, - rand_string(7).as_str(), - GVT_SCHEMA_ATTRIBUTES, - &inputs, - &outputs, - None, - wallet.handle, - pool_handle, - None).unwrap_err(); - - assert_eq!(parsed_err.error_code, ErrorCode::PaymentInsufficientFundsError); -} diff --git a/libsovtoken/tests/add_fees_for_schema_test.rs b/libsovtoken/tests/add_fees_for_schema_test.rs deleted file mode 100644 index 1b6b7fb3e..000000000 --- a/libsovtoken/tests/add_fees_for_schema_test.rs +++ /dev/null @@ -1,188 +0,0 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; -extern crate indyrs as indy; -extern crate sovtoken; - -use std::{thread, time}; -use std::collections::HashMap; - -use indy::future::Future; - -use sovtoken::ErrorCode; -use sovtoken::utils::random::rand_string; -use utils::setup::{Setup, SetupConfig}; -use utils::wallet::Wallet; -mod utils; - -fn send_schema_with_fees(did: &str, - name: &str, - version: &str, - attrs: &str, - wallet_handle: i32, - pool_handle: i32, - inputs_json: &str, - outputs_json: &str, - extra: Option<&str>) -> Result<(String, String, String, String), indy::IndyError> { - let (schema_id, schema_json) = indy::anoncreds::issuer_create_schema(did, name, version, attrs).wait().unwrap(); - let schema_req = indy::ledger::build_schema_request(did, &schema_json).wait().unwrap(); - let schema_req_signed = indy::ledger::sign_request(wallet_handle, did, &schema_req).wait().unwrap(); - let (schema_req_with_fees, pm) = indy::payments::add_request_fees(wallet_handle, Some(did), &schema_req_signed, inputs_json, outputs_json, extra).wait().unwrap(); - let schema_resp = indy::ledger::submit_request(pool_handle, &schema_req_with_fees).wait().unwrap(); - indy::payments::parse_response_with_fees(&pm, &schema_resp).wait().map(|s| (s, schema_id, schema_json, schema_resp)) -} - -pub const SCHEMA_VERSION: &'static str = "1.0"; -pub const GVT_SCHEMA_ATTRIBUTES: &'static str = r#"["name", "age", "sex", "height"]"#; - -#[test] -pub fn build_and_submit_schema_with_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "101": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let (parsed_resp, schema_id, _, schema_resp) = send_schema_with_fees(dids[0], rand_string(5).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None).unwrap(); - - let parsed_resp_json: Vec> = serde_json::from_str(&parsed_resp).unwrap(); - assert_eq!(parsed_resp_json.len(), 1); - assert_eq!(parsed_resp_json[0].get("amount").unwrap().as_u64().unwrap(), 9); - assert_eq!(parsed_resp_json[0].get("recipient").unwrap().as_str().unwrap(), addresses[0]); - - thread::sleep(time::Duration::from_millis(100)); - - let get_schema_req = indy::ledger::build_get_schema_request(Some(dids[0]), &schema_id).wait().unwrap(); - let get_schema_req_signed = indy::ledger::sign_request( wallet.handle, dids[0], &get_schema_req).wait().unwrap(); - let get_schema_resp = utils::ledger::submit_request_with_retries(pool_handle, &get_schema_req_signed, &schema_resp).unwrap(); - let (schema_id_get, _) = indy::ledger::parse_get_schema_response(&get_schema_resp).wait().unwrap(); - assert_eq!(schema_id, schema_id_get); -} - -#[test] -pub fn build_and_submit_schema_with_fees_insufficient_funds() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![9]), - fees: Some(json!({ - "101": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs_1 = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let parsed_err = send_schema_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs_1, None).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentInsufficientFundsError); - - let outputs_2 = json!([{ - "recipient": addresses[0], - "amount": 1 - }]).to_string(); - - let parsed_err = send_schema_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs_2, None).unwrap_err(); - assert_eq!(parsed_err.error_code, ErrorCode::PaymentExtraFundsError); -} - -#[test] -pub fn build_and_submit_schema_with_fees_double_spend() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "101": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - send_schema_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None).unwrap(); - - let err = send_schema_with_fees(dids[0], rand_string(3).as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None).unwrap_err(); - assert_eq!(err.error_code, ErrorCode::PaymentSourceDoesNotExistError); -} - - -#[test] -pub fn build_and_submit_schema_with_fees_twice_and_check_utxo_remain_unspent() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "101": 1 - })), - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 9 - }]).to_string(); - - let name = rand_string(3); - send_schema_with_fees(dids[0], name.as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None).unwrap(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[0], - "amount": 8 - }]).to_string(); - - let err = send_schema_with_fees(dids[0], name.as_str(), SCHEMA_VERSION, GVT_SCHEMA_ATTRIBUTES, wallet.handle, pool_handle, &inputs, &outputs, None).unwrap_err(); - - assert_eq!(err.error_code, ErrorCode::CommonInvalidStructure); - - let utxo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - assert_eq!(utxo, utxo_2) -} \ No newline at end of file diff --git a/libsovtoken/tests/add_request_fees_handler_test.rs b/libsovtoken/tests/add_request_fees_handler_test.rs deleted file mode 100644 index 7d21fe9b3..000000000 --- a/libsovtoken/tests/add_request_fees_handler_test.rs +++ /dev/null @@ -1,214 +0,0 @@ -#[macro_use] -extern crate serde_json; -#[macro_use] -extern crate serde_derive; -extern crate sovtoken; -extern crate indyrs as indy; -#[macro_use] -extern crate lazy_static; - -pub mod utils; - -use sovtoken::utils::results::ResultHandler; -use sovtoken::utils::test::callbacks; -use sovtoken::logic::parsers::common::TXO; -use sovtoken::utils::ffi_support::c_pointer_from_string; -use sovtoken::utils::ffi_support::c_pointer_from_str; -use sovtoken::{ErrorCode, IndyHandle}; -use utils::wallet::Wallet; - - -fn call_add_request_fees(wallet_handle: IndyHandle, inputs: String, outputs: String, extra: Option, request: String) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let did = "mydid1"; - let extra = extra.map(c_pointer_from_string).unwrap_or(std::ptr::null()); - let error_code = sovtoken::api::add_request_fees_handler( - command_handle, - wallet_handle, - c_pointer_from_str(did), - c_pointer_from_string(request), - c_pointer_from_string(inputs), - c_pointer_from_string(outputs), - extra, - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -fn init_wallet_with_address() -> (utils::wallet::Wallet, String) { - sovtoken::api::sovtoken_init(); - - let wallet = Wallet::new(); - let seed = str::repeat("2", 32); - - let input_address = utils::payment::address::generate(&wallet, Some(&seed)); - return (wallet, input_address); -} - -#[test] -fn test_add_fees_to_request_valid() { - let (wallet, input_address) = init_wallet_with_address(); - - let fake_request = json!({ - "operation": { - "type": "3" - } - }); - - let txo = TXO { address: input_address, seq_no: 1 }; - - let inputs = json!([txo.to_libindy_string().unwrap()]); - - let outputs = json!([{ - "recipient": "pay:sov:dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", - "amount": 20, - }]); - - let expected_fees_request = json!({ - "fees": [ - [ - { - "address": "iTQzpdRdugkJ2gLD5vW5c159dncSL9jbAtu3WfPcb8qWD9bUd", - "seqNo": 1 - } - ], - [ - { - "address": "dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", - "amount": 20 - } - ], - ["64wPLDPMjGxgqTdrNTZFa9CK4NtvBx7eLJkgnjW3JchRGyMUr29tjkAiHCTnhLtkdW81k5BtBiiqM2tkaMB2eouv"] - ], - "operation": { - "type": "3" - } - }); - - let result = call_add_request_fees( - wallet.handle, - inputs.to_string(), - outputs.to_string(), - None, - fake_request.to_string() - ).unwrap(); - - assert_eq!(expected_fees_request.to_string(), result); -} - -#[test] -fn test_add_fees_to_request_works_for_invalid_request() { - let (wallet, input_address) = init_wallet_with_address(); - - let fake_request = "INVALID REQUEST"; - - let txo = TXO { address: input_address, seq_no: 1 }; - - let inputs = json!([txo.to_libindy_string().unwrap()]); - - let outputs = json!([{ - "recipient": "pay:sov:dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", - "amount": 20, - }]); - - let err = call_add_request_fees( - wallet.handle, - inputs.to_string(), - outputs.to_string(), - None, - fake_request.to_string() - ).unwrap_err(); - - assert_eq!(err, ErrorCode::CommonInvalidStructure) -} - -#[test] -fn build_add_fees_to_request_works_for_invalid_utxo() { - sovtoken::api::sovtoken_init(); - let wallet = Wallet::new(); - - let fake_request = json!({ - "operation": { - "type": "3" - } - }).to_string(); - - let inputs = json!(["txo:sov:1234"]).to_string(); - - let outputs = json!([{ - "recipient": "pay:sov:dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", - "amount": 20, - }]).to_string(); - - let err = call_add_request_fees( - wallet.handle, - inputs.to_string(), - outputs.to_string(), - None, - fake_request.to_string() - ).unwrap_err(); - - assert_eq!(err, ErrorCode::CommonInvalidStructure) -} - -#[test] -fn test_add_fees_to_request_works_for_invalid_receipt() { - let (wallet, input_address) = init_wallet_with_address(); - - let fake_request = json!({ - "operation": { - "type": "3" - } - }); - - let txo = TXO { address: input_address, seq_no: 1 }; - - let inputs = json!([txo.to_libindy_string().unwrap()]); - - let outputs = json!([{ - "recipient": "pay:sov:1234", - "amount": 20, - }]); - - let err = call_add_request_fees( - wallet.handle, - inputs.to_string(), - outputs.to_string(), - None, - fake_request.to_string() - ).unwrap_err(); - - assert_eq!(err, ErrorCode::CommonInvalidStructure) -} - -#[test] -fn test_add_fees_to_request_works_for_invalid_amount() { - let (wallet, input_address) = init_wallet_with_address(); - - let fake_request = json!({ - "operation": { - "type": "3" - } - }); - - let txo = TXO { address: input_address, seq_no: 1 }; - - let inputs = json!([txo.to_libindy_string().unwrap()]); - - let outputs = json!([{ - "recipient": "pay:sov:1234", - "amount": -20, - }]); - - let err = call_add_request_fees( - wallet.handle, - inputs.to_string(), - outputs.to_string(), - None, - fake_request.to_string() - ).unwrap_err(); - - assert_eq!(err, ErrorCode::CommonInvalidStructure) -} \ No newline at end of file diff --git a/libsovtoken/tests/api_tests.rs b/libsovtoken/tests/api_tests.rs deleted file mode 100644 index aa285ee53..000000000 --- a/libsovtoken/tests/api_tests.rs +++ /dev/null @@ -1,17 +0,0 @@ -//! -//! tests for API related functions - -extern crate sovtoken; - -use sovtoken::api::sovtoken_init; -use sovtoken::ErrorCode; - - -#[test] -fn sovtoken_init_executes_successfully() { - - let err : i32 = sovtoken_init(); - - assert_eq!(err, ErrorCode::Success as i32, "sovtoken_init did not return ErrorCode::Success"); - -} \ No newline at end of file diff --git a/libsovtoken/tests/build_fees_txn_handler_test.rs b/libsovtoken/tests/build_fees_txn_handler_test.rs deleted file mode 100644 index d309d115a..000000000 --- a/libsovtoken/tests/build_fees_txn_handler_test.rs +++ /dev/null @@ -1,252 +0,0 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; -extern crate libc; -extern crate sovtoken; -extern crate indyrs as indy; // lib-sdk project -extern crate bs58; - - -use libc::c_char; -use std::ffi::CString; -use std::ptr; - -use sovtoken::ErrorCode; -use sovtoken::utils::ffi_support; -use sovtoken::utils::test::callbacks; -use sovtoken::utils::results::ResultHandler; - -mod utils; - -use utils::setup::{Setup, SetupConfig}; -use utils::wallet::Wallet; -use utils::payment::fees; - -// ***** HELPER METHODS ***** -fn build_set_fees(wallet_handle: i32, did: Option<&str>, fees_json: &str) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let did = did.map(ffi_support::c_pointer_from_str).unwrap_or(std::ptr::null()); - let fees = ffi_support::c_pointer_from_str(fees_json); - - let ec = sovtoken::api::build_set_txn_fees_handler(command_handle, wallet_handle, did, fees, cb); - - return ResultHandler::one(ErrorCode::from(ec), receiver); -} - -fn build_get_fees(wallet_handle: i32, did: Option<&str>) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let did = did.map(ffi_support::c_pointer_from_str).unwrap_or(std::ptr::null()); - - let ec = sovtoken::api::build_get_txn_fees_handler(command_handle, wallet_handle, did, cb); - - return ResultHandler::one(ErrorCode::from(ec), receiver); -} - -// ***** HELPER TEST DATA ***** -const COMMAND_HANDLE: i32 = 10; -const WALLET_ID: i32 = 10; -static INVALID_OUTPUT_JSON: &'static str = r#"{"totally" : "Not a Number", "bobby" : "DROP ALL TABLES"}"#; -const CB: Option i32> = Some(utils::callbacks::empty_callback); -static FAKE_DID: &'static str = "Enfru5LNlA2CnA5n4Hfze"; - - -// the build_fees_txn_handler requires a callback and this test ensures that we -// receive an error when no callback is provided -#[test] -fn add_fees_errors_with_no_call_back() { - let return_error = sovtoken::api::build_set_txn_fees_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), ptr::null(), None); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Callback for 'build_fees_txn_handler'"); -} - -// the build fees txn handler method requires an outputs_json parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn add_fees_errors_with_no_fees_json() { - let return_error = sovtoken::api::build_set_txn_fees_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), ptr::null(), CB); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting outputs_json for 'build_fees_txn_handler'"); -} - -#[test] -fn add_fees_errors_with_invalid_fees_json() { - let fees_str = CString::new(INVALID_OUTPUT_JSON).unwrap(); - let fees_str_ptr = fees_str.as_ptr(); - let return_error = sovtoken::api::build_set_txn_fees_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), fees_str_ptr, CB); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Valid JSON for 'build_fees_txn_handler'"); -} - -#[test] -fn add_fees_invalid_did() { - let fees = json!({ - "1000": 4, - "20001": 13, - }).to_string(); - - let err = build_set_fees(WALLET_ID, Some(FAKE_DID), &fees).unwrap_err(); - assert_eq!(ErrorCode::CommonInvalidStructure, err); -} - -#[test] -fn add_fees_invalid_fees() { - let fees = "1000"; - let did = bs58::encode("1234567890123456").into_string(); - let err = build_set_fees(WALLET_ID, Some(&did), fees).unwrap_err(); - assert_eq!(ErrorCode::CommonInvalidStructure, err); -} - -#[test] -fn add_fees_json() { - let fees = json!({ - "3": 6, - "20001": 12 - }); - let expected_operation = json!({ - "type": "20000", - "fees": fees, - }); - - let did = bs58::encode("1234567890123456").into_string(); - let fees_request = build_set_fees(WALLET_ID, Some(&did), &fees.to_string()).unwrap(); - - let request_value: serde_json::value::Value = serde_json::from_str(&fees_request).unwrap(); - - assert_eq!(&expected_operation, request_value.get("operation").unwrap()); -} - -#[test] -fn build_get_fees_req() { - let expected_operation = json!({ - "type": "20001", - }); - - let did = bs58::encode("1234567890123456").into_string(); - let get_fees_request = build_get_fees(WALLET_ID, Some(&did)).unwrap(); - - let request_value: serde_json::value::Value = serde_json::from_str(&get_fees_request).unwrap(); - - assert_eq!(&expected_operation, request_value.get("operation").unwrap()); -} - -#[test] -fn add_fees_json_for_any_key() { - sovtoken::api::sovtoken_init(); - let wallet = Wallet::new(); - let fees = json!({ - "3": 6, - "TXN_ALIAS": 12, - "TXN ALIAS WITH SPACE": 12, - }); - let expected_operation = json!({ - "type": "20000", - "fees": fees, - }); - - let did = bs58::encode("1234567890123456").into_string(); - let fees_request = build_set_fees(wallet.handle, Some(&did), &fees.to_string()).unwrap(); - - let request_value: serde_json::value::Value = serde_json::from_str(&fees_request).unwrap(); - assert_eq!(&expected_operation, request_value.get("operation").unwrap()); -} - -#[test] -pub fn build_and_submit_set_fees() { - let payment_method = sovtoken::utils::constants::general::PAYMENT_METHOD_NAME; - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 0, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let fees = json!({ - "100": 1, - "101": 2 - }).to_string(); - - fees::set_fees(pool_handle, wallet.handle, &payment_method, &fees, &dids, Some(dids[0])); - let current_fees = fees::get_fees(&wallet, pool_handle, Some(dids[0])); - let current_fees_value: serde_json::Value = serde_json::from_str(¤t_fees).unwrap(); - - assert_eq!(current_fees_value["101"].as_u64().unwrap(), 2); - assert_eq!(current_fees_value["100"].as_u64().unwrap(), 1); - - let fees = json!({ - "100": 0, - "101": 0 - }).to_string(); - - fees::set_fees(pool_handle, wallet.handle, &payment_method, &fees, &dids, Some(dids[0])); -} - -#[test] -pub fn build_and_submit_set_fees_with_names() { - let payment_method = sovtoken::utils::constants::general::PAYMENT_METHOD_NAME; - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 0, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let fees = json!({ - "NYM": 1, - "ATTRIB": 2 - }).to_string(); - - fees::set_fees(pool_handle, wallet.handle, &payment_method, &fees, &dids, Some(dids[0])); - let current_fees = fees::get_fees(&wallet, pool_handle, Some(dids[0])); - let current_fees_value: serde_json::Value = serde_json::from_str(¤t_fees).unwrap(); - - assert_eq!(current_fees_value["NYM"].as_u64().unwrap(), 1); - assert_eq!(current_fees_value["ATTRIB"].as_u64().unwrap(), 2); - - let fees = json!({ - "NYM": 0, - "ATTRIB": 0 - }).to_string(); - - fees::set_fees(pool_handle, wallet.handle, &payment_method, &fees, &dids, Some(dids[0])); -} - -#[test] -pub fn build_and_submit_get_fees_with_empty_did() { - let payment_method = sovtoken::utils::constants::general::PAYMENT_METHOD_NAME; - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 0, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let fees = json!({ - "NYM": 1, - "ATTRIB": 2 - }).to_string(); - - fees::set_fees(pool_handle, wallet.handle, &payment_method, &fees, &dids, Some(dids[0])); - let current_fees = fees::get_fees(&wallet, pool_handle, None); - let current_fees_value: serde_json::Value = serde_json::from_str(¤t_fees).unwrap(); - - assert_eq!(current_fees_value["NYM"].as_u64().unwrap(), 1); - assert_eq!(current_fees_value["ATTRIB"].as_u64().unwrap(), 2); - - let fees = json!({ - "NYM": 0, - "ATTRIB": 0 - }).to_string(); - - fees::set_fees(pool_handle, wallet.handle, &payment_method, &fees, &dids, Some(dids[0])); -} \ No newline at end of file diff --git a/libsovtoken/tests/build_get_utxo_request_handler_test.rs b/libsovtoken/tests/build_get_utxo_request_handler_test.rs deleted file mode 100644 index 6555944c4..000000000 --- a/libsovtoken/tests/build_get_utxo_request_handler_test.rs +++ /dev/null @@ -1,197 +0,0 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; -extern crate sovtoken; -extern crate indyrs as indy; -extern crate libc; -extern crate bs58; - -use libc::c_char; -use std::ptr; - -use indy::future::Future; - -pub mod utils; - -use utils::wallet::Wallet; -use utils::setup::{Setup, SetupConfig}; -use sovtoken::logic::address::strip_qualifier_from_address; -use sovtoken::logic::address::verkey_from_unqualified_address; -use sovtoken::utils::results::ResultHandler; -use sovtoken::utils::test::callbacks; -use sovtoken::utils::ffi_support::c_pointer_from_str; -use sovtoken::{ErrorCode, IndyHandle}; - -// ***** HELPER METHODS ***** -fn build_get_payment_sources_request(wallet_handle: IndyHandle, did: &str, payment_address: &str, from:Option) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let error_code = sovtoken::api::build_get_utxo_request_handler( - command_handle, - wallet_handle, - c_pointer_from_str(did), - c_pointer_from_str(payment_address), - from.map(|a| a as i64).unwrap_or(-1), - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -fn parse_get_payment_sources_response(res: &str) -> Result<(String, Option), ErrorCode> { - let (receiver, command_handle, cb) = callbacks::cb_ec_string_i64(); - - let error_code = sovtoken::api::parse_get_utxo_response_handler( - command_handle, - c_pointer_from_str(res), - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver) - .map(|(arg1, arg2)| (arg1, if arg2 == -1 {None} else {Some(arg2 as u64)})); -} - -// ***** HELPER TEST DATA ***** -const COMMAND_HANDLE: i32 = 10; -const WALLET_ID: i32 = 10; -const CB: Option i32> = Some(utils::callbacks::empty_callback); -const ADDRESS: &str = "pay:sov:dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q"; - - -// the build_fees_txn_handler requires a callback and this test ensures that we -// receive an error when no callback is provided -#[test] -fn get_utxo_errors_with_no_call_back() { - let return_error = sovtoken::api::build_get_utxo_request_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), ptr::null(), -1, None); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Callback for 'build_get_utxo_request_handler'"); -} - -// the build fees txn handler method requires an outputs_json parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn get_utxo_errors_with_no_payment_address() { - let return_error = sovtoken::api::build_get_utxo_request_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), ptr::null(), -1,CB); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting outputs_json for 'build_fees_txn_handler'"); -} - -#[test] -fn build_get_utxo_json() { - let did = bs58::encode("1234567890123456").into_string(); - let expected_operation = json!({ - "type": "10002", - "address": "dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q" - }); - - let request = build_get_payment_sources_request(WALLET_ID, &did, &ADDRESS, None).unwrap(); - - let request_value: serde_json::value::Value = serde_json::from_str(&request).unwrap(); - - assert_eq!(&expected_operation, request_value.get("operation").unwrap()); -} - -#[test] -fn build_get_utxo_json_with_from() { - let did = bs58::encode("1234567890123456").into_string(); - let expected_operation = json!({ - "type": "10002", - "address": "dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", - "from": 1 - }); - - let request = build_get_payment_sources_request(WALLET_ID, &did, &ADDRESS, Some(1)).unwrap(); - - let request_value: serde_json::value::Value = serde_json::from_str(&request).unwrap(); - - assert_eq!(&expected_operation, request_value.get("operation").unwrap()); -} - -#[test] -pub fn build_and_submit_get_utxo_request() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: None - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let get_utxo_req = build_get_payment_sources_request(wallet.handle, dids[0], &payment_addresses[0], None).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let (res, next) = parse_get_payment_sources_response(&res).unwrap(); - - let res_parsed: Vec = serde_json::from_str(&res).unwrap(); - assert_eq!(res_parsed.len(), 1); - let utxo = res_parsed.get(0).unwrap().as_object().unwrap(); - assert_eq!(utxo.get("paymentAddress").unwrap().as_str().unwrap(), payment_addresses[0]); - assert_eq!(utxo.get("amount").unwrap().as_u64().unwrap(), 10); - assert!(next.is_none()); -} - -#[test] -pub fn build_and_submit_get_utxo_request_negative() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: None - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let get_utxo_req = build_get_payment_sources_request(wallet.handle, dids[0], &payment_addresses[0], Some(-15)).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let res = parse_get_payment_sources_response(&res); - assert_eq!(res.unwrap_err(), ErrorCode::CommonInvalidStructure); -} - -#[test] -pub fn build_and_submit_get_utxo_request_no_utxo() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let get_utxo_req = build_get_payment_sources_request(wallet.handle, dids[0], &payment_addresses[0], None).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let (res, next) = parse_get_payment_sources_response(&res).unwrap(); - - let res_parsed: Vec = serde_json::from_str(&res).unwrap(); - assert_eq!(res_parsed.len(), 0); - assert_eq!(next, None); -} - -#[test] -pub fn payment_address_is_identifier() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let payment_addresses = &setup.addresses; - let dids = setup.trustees.dids(); - - let get_utxo_req = build_get_payment_sources_request(wallet.handle, dids[0], &payment_addresses[0], None).unwrap(); - let req: serde_json::Value = serde_json::from_str(&get_utxo_req).unwrap(); - let identifier = req.as_object().unwrap().get("identifier").unwrap().as_str().unwrap(); - let unqualified_addr = strip_qualifier_from_address(&payment_addresses[0]); - let unqualified_addr = verkey_from_unqualified_address(&unqualified_addr).unwrap(); - assert_eq!(identifier, unqualified_addr); - assert_ne!(identifier, dids[0]); -} \ No newline at end of file diff --git a/libsovtoken/tests/build_mint_txn_handler_test.rs b/libsovtoken/tests/build_mint_txn_handler_test.rs deleted file mode 100644 index bc7c39c99..000000000 --- a/libsovtoken/tests/build_mint_txn_handler_test.rs +++ /dev/null @@ -1,373 +0,0 @@ -extern crate libc; - -extern crate sovtoken; -#[macro_use] -extern crate serde_derive; -extern crate indyrs as indy; // lib-sdk project -#[macro_use] -extern crate serde_json; -#[macro_use] -extern crate log; -#[macro_use] -extern crate lazy_static; - -use libc::c_char; -use std::ptr; -use std::ffi::CString; - -use indy::future::Future; - -use sovtoken::{ErrorCode, IndyHandle}; -use sovtoken::utils::ffi_support::{str_from_char_ptr, c_pointer_from_str}; -use sovtoken::utils::constants::txn_types::MINT_PUBLIC; -use sovtoken::utils::constants::txn_fields::OUTPUTS; -use sovtoken::logic::parsers::common::ResponseOperations; -use sovtoken::utils::json_conversion::JsonDeserialize; -use sovtoken::logic::config::output_mint_config::MintRequest; -use sovtoken::logic::request::Request; -use sovtoken::utils::results::ResultHandler; -use sovtoken::utils::test::callbacks; - -mod utils; - -use utils::wallet::Wallet; -use utils::parse_mint_response::ParseMintResponse; -use utils::setup::{Setup, SetupConfig}; - -// ***** HELPER METHODS ***** -fn build_mint_req(wallet_handle: IndyHandle, did: Option<&str>, outputs: &str, extra: Option<&str>) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let did = did.map(c_pointer_from_str).unwrap_or(std::ptr::null()); - let extra = extra.map(c_pointer_from_str).unwrap_or(std::ptr::null()); - - let error_code = sovtoken::api::build_mint_txn_handler( - command_handle, - wallet_handle, - did, - c_pointer_from_str(outputs), - extra, - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -// ***** HELPER TEST DATA ***** - -const COMMAND_HANDLE: i32 = 10; -static INVALID_OUTPUT_JSON: &'static str = r#"{"totally" : "Not a Number", "bobby" : "DROP ALL TABLES"}"#; -static VALID_OUTPUT_JSON: &'static str = r#"[{"recipient":"pay:sov:dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", "amount":10}]"#; - -// ***** UNIT TESTS **** - -// the build_mint_txn_handler requires a callback and this test ensures that we -// receive an error when no callback is provided -#[test] -fn errors_with_no_call_back() { - let return_error = sovtoken::api::build_mint_txn_handler(COMMAND_HANDLE, 1, ptr::null(), ptr::null(), ptr::null(), None); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Callback for 'build_mint_txn_handler'"); -} - -// the build mint txn handler method requires an outputs_json parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn errors_with_no_outputs_json() { - static mut CALLBACK_CALLED: bool = false; - extern "C" fn cb_no_json(_: i32, error_code: i32, _: *const c_char) -> i32 { - unsafe { CALLBACK_CALLED = true; } - assert_eq!(error_code, ErrorCode::CommonInvalidStructure as i32); - return ErrorCode::Success as i32; - } - - let return_error = sovtoken::api::build_mint_txn_handler(COMMAND_HANDLE, 1, ptr::null(), ptr::null(), ptr::null(), Some(cb_no_json)); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting outputs_json for 'build_mint_txn_handler'"); - unsafe { assert!(!CALLBACK_CALLED) } -} - -// // the mint txn handler method requires a valid JSON format (format is described -// in build_mint_fees_handler description). Expecting error when invalid json is inputted -#[test] -fn errors_with_invalid_outputs_json() { - static mut CALLBACK_CALLED: bool = false; - extern "C" fn cb_invalid_json(_: i32, error_code: i32, _: *const c_char) -> i32 { - unsafe { CALLBACK_CALLED = true; } - assert_eq!(error_code, ErrorCode::CommonInvalidStructure as i32); - return ErrorCode::Success as i32; - } - - let outputs_str = CString::new(INVALID_OUTPUT_JSON).unwrap(); - let outputs_str_ptr = outputs_str.as_ptr(); - let return_error = sovtoken::api::build_mint_txn_handler(COMMAND_HANDLE, 1, ptr::null(), outputs_str_ptr, ptr::null(), Some(cb_invalid_json)); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Valid JSON for 'build_mint_txn_handler'"); - unsafe { assert!(!CALLBACK_CALLED) } -} - -#[test] -fn valid_output_json() { - sovtoken::api::sovtoken_init(); - static mut CALLBACK_CALLED: bool = false; - extern "C" fn valid_output_json_cb(command_handle: i32, error_code: i32, mint_request: *const c_char) -> i32 { - unsafe { CALLBACK_CALLED = true; } - assert_eq!(command_handle, COMMAND_HANDLE); - assert_eq!(error_code, ErrorCode::Success as i32); - let mint_request_json_string = str_from_char_ptr(mint_request).unwrap(); - let mint_request_json_value: serde_json::Value = serde_json::from_str(mint_request_json_string).unwrap(); - let mint_operation = mint_request_json_value - .get("operation") - .unwrap(); - - let expected = json!({ - "type": MINT_PUBLIC, - OUTPUTS: [ - { - "address": "dctKSXBbv2My3TGGUgTFjkxu1A9JM3Sscd5FydY4dkxnfwA7q", - "amount": 10 - } - ] - }); - assert_eq!(mint_operation, &expected); - return ErrorCode::Success as i32; - } - - let did = c_pointer_from_str("Th7MpTaRZVRYnPiabds81Y"); - let outputs_str = CString::new(VALID_OUTPUT_JSON).unwrap(); - let outputs_str_ptr = outputs_str.as_ptr(); - let return_error = sovtoken::api::build_mint_txn_handler( - COMMAND_HANDLE, - 1, - did, - outputs_str_ptr, - ptr::null(), - Some(valid_output_json_cb) - ); - - assert_eq!(return_error, ErrorCode::Success as i32, "Expecting Valid JSON for 'build_mint_txn_handler'"); - unsafe { - assert!(CALLBACK_CALLED); - } -} - -#[test] -pub fn build_and_submit_mint_txn_works() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 3, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 5, - }, - { - "recipient": payment_addresses[1], - "amount": 10, - }, - { - "recipient": payment_addresses[2], - "amount": 15, - } - ]).to_string(); - - let mint_req = build_mint_req( - wallet.handle, - Some(dids[0]), - &output_json, - None, - ).unwrap(); - - trace!("{:?}", &mint_req); - - let mint_req = Request::::multi_sign_request( - wallet.handle, - &mint_req, - dids.clone() - ).unwrap(); - - trace!("{:?}", &mint_req); - - let result = indy::ledger::submit_request(pool_handle, &mint_req).wait().unwrap(); - let response = ParseMintResponse::from_json(&result).unwrap(); - assert_eq!(response.op, ResponseOperations::REPLY); - let (utxos, next) = utils::payment::get_utxo::send_get_utxo_request(&wallet, pool_handle, &dids[0], &payment_addresses[0], None); - assert_eq!(utxos[0].amount, 5); - assert_eq!(utxos[0].payment_address, payment_addresses[0]); - assert_eq!(next, None); -} - -#[test] -pub fn build_and_submit_mint_txn_works_with_empty_did() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 3, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 5, - }, - { - "recipient": payment_addresses[1], - "amount": 10, - }, - { - "recipient": payment_addresses[2], - "amount": 15, - } - ]).to_string(); - - let mint_req = build_mint_req( - wallet.handle, - Some(&dids[0]), - &output_json, - None, - ).unwrap(); - - trace!("{:?}", &mint_req); - - let mint_req = Request::::multi_sign_request( - wallet.handle, - &mint_req, - dids.clone() - ).unwrap(); - - trace!("{:?}", &mint_req); - - let result = indy::ledger::submit_request(pool_handle, &mint_req).wait().unwrap(); - let response = ParseMintResponse::from_json(&result).unwrap(); - assert_eq!(response.op, ResponseOperations::REPLY); - let (utxos, next) = utils::payment::get_utxo::send_get_utxo_request(&wallet, pool_handle, &dids[0], &payment_addresses[0], None); - assert_eq!(utxos[0].amount, 5); - assert_eq!(utxos[0].payment_address, payment_addresses[0]); - assert!(next.is_none()) -} - -#[test] -pub fn build_and_submit_mint_txn_works_for_double_send_mint() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 3, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 5, - }, - { - "recipient": payment_addresses[1], - "amount": 10, - }, - { - "recipient": payment_addresses[2], - "amount": 15, - } - ]).to_string(); - - let mint_req = build_mint_req( - wallet.handle, - Some(dids[0]), - &output_json, - None - ).unwrap(); - - trace!("{:?}", &mint_req); - - let mint_req = Request::::multi_sign_request( - wallet.handle, - &mint_req, - dids.clone() - ).unwrap(); - - trace!("{:?}", &mint_req); - - let result = indy::ledger::submit_request(pool_handle, &mint_req).wait().unwrap(); - let response = ParseMintResponse::from_json(&result).unwrap(); - assert_eq!(response.op, ResponseOperations::REPLY); - let result = indy::ledger::submit_request(pool_handle, &mint_req).wait().unwrap(); - let response = ParseMintResponse::from_json(&result).unwrap(); - assert_eq!(response.op, ResponseOperations::REPLY); - let (utxos, next) = utils::payment::get_utxo::send_get_utxo_request(&wallet, pool_handle, &dids[0], &payment_addresses[0], None); - assert_eq!(utxos.len(), 1); - assert_eq!(utxos[0].amount, 5); - assert_eq!(utxos[0].payment_address, payment_addresses[0]); - assert!(next.is_none()); -} - -#[test] -/* Confirm 10 billion tokens can be minted */ -fn mint_10_billion_tokens() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // 10 billion tokens - let tokens = 10u64.pow(18); - - let output_json = json!([{ - "recipient": payment_addresses[0], - "amount": tokens, - }]).to_string(); - - let mint_req = build_mint_req( - wallet.handle, - Some(dids[0]), - &output_json, - None - ).unwrap(); - - trace!("{:?}", &mint_req); - - let mint_req = Request::::multi_sign_request( - wallet.handle, - &mint_req, - dids.clone() - ).unwrap(); - - trace!("{:?}", &mint_req); - - let result = indy::ledger::submit_request(pool_handle, &mint_req).wait().unwrap(); - let response = ParseMintResponse::from_json(&result).unwrap(); - - trace!("{:?}", &response); - - assert_eq!(response.op, ResponseOperations::REPLY); - let (utxos, next) = utils::payment::get_utxo::send_get_utxo_request(&wallet, pool_handle, &dids[0], &payment_addresses[0], None); - assert_eq!(utxos[0].amount, tokens); - assert_eq!(utxos[0].payment_address, payment_addresses[0]); - assert_eq!(next, None); -} diff --git a/libsovtoken/tests/build_payment_req_handler_test.rs b/libsovtoken/tests/build_payment_req_handler_test.rs deleted file mode 100644 index 5744827db..000000000 --- a/libsovtoken/tests/build_payment_req_handler_test.rs +++ /dev/null @@ -1,661 +0,0 @@ -extern crate libc; -extern crate sovtoken; -extern crate indyrs as indy; // lib-sdk project -extern crate bs58; - -#[macro_use] extern crate log; -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; - -use std::ptr; -use std::ffi::CString; -use std::os::raw::c_char; - -use indy::future::Future; - -use sovtoken::logic::address; -use sovtoken::logic::parsers::common::TXO; -use sovtoken::{ErrorCode, IndyHandle}; -use sovtoken::utils::constants::txn_types::XFER_PUBLIC; -use sovtoken::utils::results::ResultHandler; -use sovtoken::utils::ffi_support::{c_pointer_from_string, c_pointer_from_str}; -use sovtoken::utils::test::callbacks; - -mod utils; -use utils::wallet::Wallet; -use utils::setup::{SetupConfig, Setup}; - - -// ***** HELPER TEST DATA ***** - -const COMMAND_HANDLE:i32 = 10; -static INVALID_OUTPUT_JSON: &'static str = r#"{"totally" : "Not a Number", "bobby" : "DROP ALL TABLES"}"#; -static VALID_OUTPUT_JSON: &'static str = r#"{"outputs":[["AesjahdahudgaiuNotARealAKeyygigfuigraiudgfasfhja",10]]}"#; -const WALLET_HANDLE:i32 = 0; -const CB : Option i32 > = Some(utils::callbacks::empty_callback); - -// ***** HELPER METHODS ***** -fn build_payment_req(wallet_handle: IndyHandle, did: &str, inputs: &str, outputs: &str, extra: Option) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let extra = extra.map(c_pointer_from_string).unwrap_or(std::ptr::null()); - - let error_code = sovtoken::api::build_payment_req_handler( - command_handle, - wallet_handle, - c_pointer_from_str(did), - c_pointer_from_str(inputs), - c_pointer_from_str(outputs), - extra, - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -fn parse_payment_response(response: &str) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let error_code = sovtoken::api::parse_payment_response_handler( - command_handle, - c_pointer_from_str(response), - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -fn generate_payment_addresses(wallet: &Wallet) -> (Vec, Vec) { - let seeds = vec![ - str::repeat("2", 32), - str::repeat("3", 32), - str::repeat("4", 32), - str::repeat("1", 32), - ]; - - let payment_addresses = utils::payment::address::generate_n_seeded(wallet, seeds); - - payment_addresses - .iter() - .enumerate() - .for_each(|(idx, address)| debug!("payment_address[{:?}] = {:?}", idx, address)); - - let addresses = payment_addresses - .iter() - .map(|address| address::unqualified_address_from_address(&address).unwrap()) - .collect(); - - return (payment_addresses, addresses); -} - -fn get_resp_for_payment_req(pool_handle: i32, wallet_handle: i32, did: &str, - inputs: &str, outputs: &str, extra: Option) -> Result { - let req = build_payment_req(wallet_handle, did, inputs, outputs, extra).unwrap(); - let res = indy::ledger::submit_request(pool_handle, &req).wait().unwrap(); - parse_payment_response(&res) -} - -// ***** UNIT TESTS **** - -// the build_mint_txn_handler requires a callback and this test ensures that we -// receive an error when no callback is provided -#[test] -fn errors_with_no_call_back() { - let return_error = sovtoken::api::build_payment_req_handler(COMMAND_HANDLE, - WALLET_HANDLE, - ptr::null(), - ptr::null(), - ptr::null(), - ptr::null(), - None); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Callback for 'build_payment_req_handler'"); -} - -// the build payment req handler method requires an inputs_json parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn errors_with_no_inputs_json() { - let return_error = sovtoken::api::build_payment_req_handler(COMMAND_HANDLE, - WALLET_HANDLE, - ptr::null(), - ptr::null(), - ptr::null(), - ptr::null(), - CB); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting inputs_json for 'build_payment_req_handler'"); -} - -// the build payment req handler method requires an outputs_json parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn errors_with_no_outputs_json() { - let input_json :CString = CString::new(INVALID_OUTPUT_JSON).unwrap(); - let input_json_ptr = input_json.as_ptr(); - let return_error = sovtoken::api::build_payment_req_handler(COMMAND_HANDLE, - WALLET_HANDLE, - ptr::null(), - input_json_ptr, - ptr::null(), - ptr::null(), - CB); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting outputs_json for 'build_payment_req_handler'"); -} - -// the build payment req handler method requires an submitter_did parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn errors_with_no_submitter_did_json() { - let input_json :CString = CString::new(INVALID_OUTPUT_JSON).unwrap(); - let input_json_ptr = input_json.as_ptr(); - let output_json :CString = CString::new(VALID_OUTPUT_JSON).unwrap(); - let output_json_ptr = output_json.as_ptr(); - - let return_error = sovtoken::api::build_payment_req_handler(COMMAND_HANDLE, - WALLET_HANDLE, - ptr::null(), - input_json_ptr, - output_json_ptr, - ptr::null(), - CB); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting outputs_json for 'build_payment_req_handler'"); -} - -#[test] -fn success_signed_request() { - sovtoken::api::sovtoken_init(); - - let did = String::from("V4SGRU86Z58d6TV7PBUe6f"); - - let wallet = Wallet::new(); - debug!("wallet id = {:?}", wallet.handle); - - let (payment_addresses, addresses) = generate_payment_addresses(&wallet); - let txo_1 = TXO { address: payment_addresses[0].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - let txo_2 = TXO { address: payment_addresses[1].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - - let inputs = json!([ - txo_1, txo_2 - ]); - - let outputs = json!([ - { - "recipient": payment_addresses[2], - "amount": 10 - }, - { - "recipient": payment_addresses[3], - "amount": 22 - } - ]); - - let expected_operation = json!({ - "type": XFER_PUBLIC, - "inputs": [ - {"address": addresses[0], "seqNo": 1}, - {"address": addresses[1], "seqNo": 1} - ], - "outputs": [ - {"address": addresses[2], "amount": 10}, - {"address": addresses[3], "amount": 22}, - ], - "signatures": [ - "bnuZUPAq5jgpqvaQBzXKBQ973yCpjL1pkqJjiBtVPybpzzKGnPv3uE3VufBVZtR6hq2y55b8MSJpPFVMqskBy3m", - "4HpwuknWrSpJCs2qXEMZA1kbAsP9WxJFaoHq1cH7W3yxLg5R2fHV8QPdY5Hz2bgDmGkRitLaPa3HbF65kTxNpNTe" - ] - }); - - trace!("Calling build_payment_req"); - - let request_string = build_payment_req( - wallet.handle, - &did, - &inputs.to_string(), - &outputs.to_string(), - None - ).unwrap(); - - let request: serde_json::value::Value = serde_json::from_str(&request_string).unwrap(); - debug!("Received request {:?}", request); - - assert_eq!(&expected_operation, request.get("operation").unwrap()); - assert_eq!(&did, request.get("identifier").unwrap().as_str().unwrap()); - assert!(request.get("reqId").is_some()); - -} - -#[test] // TODO: look carefully on changes -fn success_signed_request_from_libindy_no_identifier() { - - sovtoken::api::sovtoken_init(); - - let wallet = Wallet::new(); - debug!("wallet id = {:?}", wallet.handle); - - let (payment_addresses, addresses) = generate_payment_addresses(&wallet); - - let txo_1 = TXO { address: payment_addresses[0].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - let txo_2 = TXO { address: payment_addresses[1].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - - let inputs = json!([ - txo_1, txo_2 - ]); - - let outputs = json!([ - { - "recipient": payment_addresses[2], - "amount": 10 - }, - { - "recipient": payment_addresses[3], - "amount": 22 - } - ]); - - let expected_operation = json!({ - "type": XFER_PUBLIC, - "inputs": [ - {"address": addresses[0], "seqNo": 1}, - {"address": addresses[1], "seqNo": 1}, - ], - "outputs": [ - {"address": addresses[2], "amount": 10}, - {"address": addresses[3], "amount": 22}, - ], - "signatures": [ - "bnuZUPAq5jgpqvaQBzXKBQ973yCpjL1pkqJjiBtVPybpzzKGnPv3uE3VufBVZtR6hq2y55b8MSJpPFVMqskBy3m", - "4HpwuknWrSpJCs2qXEMZA1kbAsP9WxJFaoHq1cH7W3yxLg5R2fHV8QPdY5Hz2bgDmGkRitLaPa3HbF65kTxNpNTe" - ] - }); - - trace!("Calling build_payment_req"); - - let (request_string, _) = indy::payments::build_payment_req( - wallet.handle, - None, - &inputs.to_string(), - &outputs.to_string(), - None, - ).wait().unwrap(); - - let request: serde_json::value::Value = serde_json::from_str(&request_string).unwrap(); - debug!("Received request {:?}", request); - - assert_eq!(&expected_operation, request.get("operation").unwrap()); - let ident = bs58::decode(&addresses[0]).with_check(None).into_vec().unwrap(); - let ident = bs58::encode(ident).into_string(); - assert_eq!(&ident, request.get("identifier").unwrap().as_str().unwrap()); - assert!(request.get("reqId").is_some()); -} - -#[test] -pub fn build_and_submit_payment_req() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 2, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![30]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([ - { - "recipient": payment_addresses[1], - "amount": 20 - }, - { - "recipient": payment_addresses[0], - "amount": 10 - } - ]).to_string(); - let res = get_resp_for_payment_req(pool_handle, wallet.handle, dids[0], &inputs, &outputs, None).unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - let utxos = res_parsed.as_array().unwrap(); - assert_eq!(utxos.len(), 2); - - let value = utxos.get(0).unwrap().as_object().unwrap(); - let pa1_rc = value.get("recipient").unwrap().as_str().unwrap(); - if pa1_rc == payment_addresses[0] { - assert_eq!(value.get("amount").unwrap().as_i64().unwrap(), 10); - } else if pa1_rc == payment_addresses[1] { - assert_eq!(value.get("amount").unwrap().as_i64().unwrap(), 20); - } else { - assert!(false); - } - - let value = utxos.get(1).unwrap().as_object().unwrap(); - let pa1_rc = value.get("recipient").unwrap().as_str().unwrap(); - if pa1_rc == payment_addresses[0] { - assert_eq!(value.get("amount").unwrap().as_i64().unwrap(), 10); - } else if pa1_rc == payment_addresses[1] { - assert_eq!(value.get("amount").unwrap().as_i64().unwrap(), 20); - } else { - assert!(false); - } -} - -#[test] -pub fn build_and_submit_payment_req_incorrect_funds() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 2, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![30]), - fees: None, - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, - pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs_1 = json!([ - { - "recipient": addresses[1], - "amount": 20 - }, - { - "recipient": addresses[0], - "amount": 20 - } - ]).to_string(); - let res = get_resp_for_payment_req(pool_handle, wallet.handle, dids[0], - &inputs, &outputs_1, None).unwrap_err(); - assert_eq!(res, ErrorCode::PaymentInsufficientFundsError); - - let outputs_2 = json!([ - { - "recipient": addresses[1], - "amount": 1 - }, - { - "recipient": addresses[0], - "amount": 1 - } - ]).to_string(); - let res = get_resp_for_payment_req(pool_handle, wallet.handle, dids[0], - &inputs, &outputs_2, None).unwrap_err(); - assert_eq!(res, ErrorCode::PaymentExtraFundsError); -} - -#[test] -pub fn build_and_submit_payment_req_with_spent_utxo() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 3, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![30, 10]), - fees: None, - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[0]); - let utxo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &addresses[1]); - - let inputs = json!([utxo_2]).to_string(); - let outputs = json!([ - { - "recipient": addresses[0], - "amount": 10 - } - ]).to_string(); - get_resp_for_payment_req(pool_handle, wallet.handle, dids[0], &inputs, &outputs, None).unwrap(); - - //lets try to spend spent utxo while there are enough funds on the unspent one - let inputs = json!([utxo_2, utxo]).to_string(); - let outputs = json!([{ - "recipient": addresses[2], - "amount": 20 - }]).to_string(); - let err = get_resp_for_payment_req(pool_handle, wallet.handle, dids[0], &inputs, &outputs, None).unwrap_err(); - assert_eq!(err, ErrorCode::PaymentSourceDoesNotExistError); - - //utxo should stay unspent! - let (utxos, next) = utils::payment::get_utxo::send_get_utxo_request(&wallet, pool_handle, dids[0], &addresses[0], None); - assert_eq!(next, None); - assert_eq!(utxos.len(), 2); - let first_old = utxos[0].source == utxo; - let second_old = utxos[1].source == utxo; - assert!(first_old || second_old); -} - -#[test] -pub fn build_payment_with_invalid_utxo() { - sovtoken::api::sovtoken_init(); - let wallet = Wallet::new(); - let (did, _) = indy::did::create_and_store_my_did(wallet.handle, &json!({"seed": "000000000000000000000000Trustee1"}).to_string()).wait().unwrap(); - - let inputs = json!(["txo:sov:1234"]).to_string(); - let outputs = json!([ - { - "recipient": "pay:sov:1234", - "amount": 10 - } - ]).to_string(); - - let err = build_payment_req(wallet.handle, &did, &inputs, &outputs, None).unwrap_err(); - assert_eq!(err, ErrorCode::CommonInvalidStructure); -} - -pub fn build_payment_req_for_not_owned_payment_address() { - let wallet_1 = Wallet::new(); - let wallet_2 = Wallet::new(); - - let setup = Setup::new(&wallet_1, SetupConfig { - num_addresses: 2, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![30]), - fees: None, - }); - let addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet_1, pool_handle, dids[0], &addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([ - { - "recipient": addresses[1], - "amount": 30 - } - ]).to_string(); - - let err = indy::payments::build_payment_req(wallet_2.handle, Some(dids[0]), &inputs, &outputs, None).wait().unwrap_err(); - assert_eq!(err.error_code, ErrorCode::WalletItemNotFound); -} - -#[test] -pub fn build_payment_req_with_taa_acceptance() { - sovtoken::api::sovtoken_init(); - - let did = String::from("Th7MpTaRZVRYnPiabds81Y"); - - let wallet = Wallet::new(); - debug!("wallet id = {:?}", wallet.handle); - - let (payment_addresses, addresses) = generate_payment_addresses(&wallet); - let txo_1 = TXO { address: payment_addresses[0].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - let txo_2 = TXO { address: payment_addresses[1].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - - let inputs = json!([ - txo_1, txo_2 - ]); - - let outputs = json!([ - { - "recipient": payment_addresses[2], - "amount": 10 - }, - { - "recipient": payment_addresses[3], - "amount": 22 - } - ]); - - let taa_acceptance = json!({ - "mechanism": "acceptance type 1", - "taaDigest": "050e52a57837fff904d3d059c8a123e3a04177042bf467db2b2c27abd8045d5e", - "time": 123456789, - }); - - let extra = json!({ - "taaAcceptance": taa_acceptance.clone() - }); - - let expected_operation = json!({ - "type": XFER_PUBLIC, - "inputs": [ - {"address": addresses[0], "seqNo": 1}, - {"address": addresses[1], "seqNo": 1} - ], - "outputs": [ - {"address": addresses[2], "amount": 10}, - {"address": addresses[3], "amount": 22}, - ], - "signatures": [ - "39qpBrMNPsf8MVz8KfnipRjBTGp6zV5pqkdkN36eVXW6F7XFESZwEvpqYDAvmiejSJMhqRJRcigWns2weQ6J9KuA", - "3Q4pVUGPNADdJT273zpHA4hRnGRAsnRG1BBow5UktVxK8ZTKfw9M9FMkHJDv4ERgRqJx1Wtwfd5Rv3QvuMXon8iN" - ] - }); - - let (req, _) = indy::payments::build_payment_req(wallet.handle, - Some(&did), &inputs.to_string(), &outputs.to_string(), Some(&extra.to_string())).wait().unwrap(); - - let req_parsed: serde_json::Value = serde_json::from_str(&req).unwrap(); - - assert!(req_parsed["taaAcceptance"].as_object().is_some()); - assert_eq!(req_parsed["taaAcceptance"], taa_acceptance); - - assert_eq!(expected_operation, req_parsed["operation"]); -} - -#[test] -pub fn build_payment_req_with_taa_acceptance_and_additional_extra() { - sovtoken::api::sovtoken_init(); - - let did = String::from("Th7MpTaRZVRYnPiabds81Y"); - - let wallet = Wallet::new(); - debug!("wallet id = {:?}", wallet.handle); - - let (payment_addresses, addresses) = generate_payment_addresses(&wallet); - let txo_1 = TXO { address: payment_addresses[0].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - let txo_2 = TXO { address: payment_addresses[1].clone(), seq_no: 1 }.to_libindy_string().unwrap(); - - let inputs = json!([ - txo_1, txo_2 - ]); - - let outputs = json!([ - { - "recipient": payment_addresses[2], - "amount": 10 - }, - { - "recipient": payment_addresses[3], - "amount": 22 - } - ]); - - let taa_acceptance = json!({ - "mechanism": "acceptance type 1", - "taaDigest": "050e52a57837fff904d3d059c8a123e3a04177042bf467db2b2c27abd8045d5e", - "time": 123456789, - }); - - let extra = json!({ - "data": "some extra data", - "taaAcceptance": taa_acceptance.clone() - }); - - let expected_operation = json!({ - "type": XFER_PUBLIC, - "inputs": [ - {"address": addresses[0], "seqNo": 1}, - {"address": addresses[1], "seqNo": 1} - ], - "outputs": [ - {"address": addresses[2], "amount": 10}, - {"address": addresses[3], "amount": 22}, - ], - "signatures": [ - "4FLEt14msxsfWoLe58ASjxh7M1h7CFwDFE7U3RMgBm6JGVqWYQ4GwMEkXL8G2WqhKF8TG61R7GMmpx3VP5op2uJ6", - "5EGxtU9THegBbQqKXDTv71VBcNRJQNS9N2HWS267dhRSorpQkJHPbnknHfLRxqnZJynVEZ9FpuzDRW4EtAQJDy5r" - ], - "extra": { - "data": "some extra data" - }, - }); - - let (req, _) = indy::payments::build_payment_req(wallet.handle, - Some(&did), &inputs.to_string(), &outputs.to_string(), Some(&extra.to_string())).wait().unwrap(); - - let req_parsed: serde_json::Value = serde_json::from_str(&req).unwrap(); - - assert!(req_parsed["taaAcceptance"].as_object().is_some()); - assert_eq!(req_parsed["taaAcceptance"], taa_acceptance); - - assert_eq!(expected_operation, req_parsed["operation"]); -} - -#[test] -pub fn build_and_submit_payment_req_for_extra() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![20]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - for extra in ["some extra_json data as string", r#"{"data":"some extra data as string"}"#].iter() - { - let utxo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let inputs = json!([utxo]).to_string(); - let outputs = json!([ - { - "recipient": payment_addresses[0], - "amount": 20 - } - ]).to_string(); - - let res = get_resp_for_payment_req(pool_handle, wallet.handle, dids[0], &inputs, &outputs, Some(extra.to_string())).unwrap(); - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - let utxos = res_parsed.as_array().unwrap(); - assert_eq!(utxos.len(), 1); - assert_eq!(*extra, utxos[0].clone()["extra"].as_str().unwrap()); - - let value = utxos.get(0).unwrap().as_object().unwrap(); - let r_1 = value.get("receipt").unwrap().as_str().unwrap(); - assert_eq!(value.get("amount").unwrap().as_i64().unwrap(), 20); - - let (req, _) = indy::payments::build_verify_payment_req(wallet.handle, None, &r_1).wait().unwrap(); - let res = indy::ledger::submit_request(pool_handle, &req).wait().unwrap(); - let res = indy::payments::parse_verify_payment_response("sov", &res).wait().unwrap(); - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - assert_eq!(*extra, res_parsed["extra"].as_str().unwrap()); - } -} \ No newline at end of file diff --git a/libsovtoken/tests/build_verify_req_test.rs b/libsovtoken/tests/build_verify_req_test.rs deleted file mode 100644 index 7e92cb498..000000000 --- a/libsovtoken/tests/build_verify_req_test.rs +++ /dev/null @@ -1,260 +0,0 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; -extern crate sovtoken; -extern crate indyrs as indy; - -use std::{thread, time}; - -use indy::future::Future; - -mod utils; - -use sovtoken::{ErrorCode, IndyHandle}; -use sovtoken::logic::parsers::common::TXO; -use sovtoken::utils::results::ResultHandler; -use sovtoken::utils::test::callbacks; -use sovtoken::utils::ffi_support::c_pointer_from_str; -use utils::wallet::Wallet; - -use utils::setup::{Setup, SetupConfig}; - -fn sleep(msec: u64) { - let ms = time::Duration::from_millis(msec); - thread::sleep(ms); -} - -fn build_verify_payment_req(wallet_handle: IndyHandle, did: Option<&str>, txo: &str) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let did = did.map(c_pointer_from_str).unwrap_or(std::ptr::null()); - - let error_code = sovtoken::api::build_verify_req_handler( - command_handle, - wallet_handle, - did, - c_pointer_from_str(txo), - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -fn parse_verify_payment_response(response: &str) -> Result { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let error_code = sovtoken::api::parse_verify_response_handler( - command_handle, - c_pointer_from_str(response), - cb - ); - - return ResultHandler::one(ErrorCode::from(error_code), receiver); -} - -#[test] -fn build_verify_payment_request() { - let txo = "txo:sov:3x42qH8UkJac1BuorqjSEvuVjvYkXk8sUAqoVPn1fGCwjLPquu4CndzBHBQ5hX6RSmDVnXGdMPrnWDUN5S1ty4YQP87hW8ubMSzu9M56z1FbAQV6aMSX5h"; - let expected_operation = json!({ - "type": "3", - "ledgerId": 1001, - "data": 28 - }); - - let request = build_verify_payment_req(1, None, txo).unwrap(); - - let request_value: serde_json::value::Value = serde_json::from_str(&request).unwrap(); - - assert_eq!(&expected_operation, request_value.get("operation").unwrap()); -} - -#[test] -fn build_verify_payment_for_invalid_txo() { - let txo = "txo:sov:3x42qH8"; - let res = build_verify_payment_req(1, None, txo).unwrap_err(); - assert_eq!(ErrorCode::CommonInvalidStructure, res); -} - -#[test] -pub fn build_and_submit_verify_on_mint() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: None - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - let txo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - //We need to wait a little before trying to verify txn - sleep(1000); - - let get_utxo_req = build_verify_payment_req(wallet.handle, Some(dids[0]), &txo).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let res = parse_verify_payment_response(&res).unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - assert!(res_parsed.as_object().unwrap().get("sources").unwrap().as_array().unwrap().is_empty()); - assert_eq!(res_parsed.as_object().unwrap().get("receipts").unwrap().as_array().unwrap().get(0).unwrap().as_object().unwrap().get("receipt").unwrap().as_str().unwrap(), txo); -} - -#[test] -pub fn build_and_submit_verify_on_mint_with_empty_did() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: None - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - let txo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - //We need to wait a little before trying to verify txn - sleep(1000); - - let get_utxo_req = build_verify_payment_req(wallet.handle, None, &txo).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let res = parse_verify_payment_response(&res).unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - assert!(res_parsed.as_object().unwrap().get("sources").unwrap().as_array().unwrap().is_empty()); - assert_eq!(res_parsed.as_object().unwrap().get("receipts").unwrap().as_array().unwrap().get(0).unwrap().as_object().unwrap().get("receipt").unwrap().as_str().unwrap(), txo); -} - -#[test] -pub fn build_and_submit_verify_on_xfer() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 2, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: None - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - let txo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let inputs = json!([txo]).to_string(); - let outputs = json!([ - { - "recipient": payment_addresses[1], - "amount": 10 - } - ]).to_string(); - let (req, method) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &inputs, &outputs, None).wait().unwrap(); - let res = indy::ledger::submit_request(pool_handle, &req).wait().unwrap(); - let res = indy::payments::parse_payment_response(&method, &res).wait().unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - let utxos = res_parsed.as_array().unwrap(); - let value = utxos.get(0).unwrap().as_object().unwrap(); - let new_utxo = value.get("receipt").unwrap().as_str().unwrap(); - - //We need to wait a little before trying to verify txn - sleep(1000); - - let get_utxo_req = build_verify_payment_req(wallet.handle, Some(dids[0]), &new_utxo).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let res = parse_verify_payment_response(&res).unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - assert_eq!(res_parsed.as_object().unwrap().get("sources").unwrap().as_array().unwrap().get(0).unwrap().as_str().unwrap(), txo); - assert_eq!(res_parsed.as_object().unwrap().get("receipts").unwrap().as_array().unwrap().get(0).unwrap().as_object().unwrap().get("receipt").unwrap().as_str().unwrap(), new_utxo); -} - -#[test] -pub fn build_and_submit_verify_on_fees() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![10]), - fees: Some(json!({ - "1": 1 - })), - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - let txo = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let inputs = json!([txo]).to_string(); - let outputs = json!([{ - "recipient": payment_addresses[0], - "amount": 9 - }]).to_string(); - - let (did_new, verkey_new) = indy::did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - - let nym_req = indy::ledger::build_nym_request(dids[0], &did_new, Some(&verkey_new), None, None).wait().unwrap(); - let nym_req_signed = indy::ledger::sign_request(wallet.handle, dids[0], &nym_req).wait().unwrap(); - let (nym_req_with_fees, pm) = indy::payments::add_request_fees(wallet.handle, Some(dids[0]), &nym_req_signed, &inputs, &outputs, None).wait().unwrap(); - let nym_resp = indy::ledger::submit_request(pool_handle, &nym_req_with_fees).wait().unwrap(); - let res = indy::payments::parse_response_with_fees(&pm, &nym_resp).wait().unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - let utxos = res_parsed.as_array().unwrap(); - let value = utxos.get(0).unwrap().as_object().unwrap(); - let new_utxo = value.get("receipt").unwrap().as_str().unwrap(); - - //We need to wait a little before trying to verify txn - sleep(1000); - - let get_utxo_req = build_verify_payment_req(wallet.handle, Some(dids[0]), &new_utxo).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let res = parse_verify_payment_response(&res).unwrap(); - - let res_parsed: serde_json::Value = serde_json::from_str(&res).unwrap(); - assert_eq!(res_parsed.as_object().unwrap().get("sources").unwrap().as_array().unwrap().get(0).unwrap().as_str().unwrap(), txo); - assert_eq!(res_parsed.as_object().unwrap().get("receipts").unwrap().as_array().unwrap().get(0).unwrap().as_object().unwrap().get("receipt").unwrap().as_str().unwrap(), new_utxo); -} - -#[test] -pub fn build_and_submit_verify_req_for_unexistant_utxo() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: None, - fees: None, - }); - - let pool_handle = setup.pool_handle; - let payment_addresses = &setup.addresses; - let dids = setup.trustees.dids(); - let txo = TXO { address: payment_addresses[0].to_string(), seq_no: 999999 }.to_libindy_string().unwrap(); - - //We need to wait a little before trying to verify txn - sleep(1000); - - let get_utxo_req = build_verify_payment_req(wallet.handle, Some(dids[0]), &txo).unwrap(); - let res = indy::ledger::sign_and_submit_request(pool_handle, wallet.handle, dids[0], &get_utxo_req).wait().unwrap(); - let err = parse_verify_payment_response(&res).unwrap_err(); - - assert_eq!(err, ErrorCode::PaymentSourceDoesNotExistError); -} - -#[test] -fn build_verify_req_works_for_invalid_utxo() { - sovtoken::api::sovtoken_init(); - let wallet = Wallet::new(); - let (did, _) = indy::did::create_and_store_my_did(wallet.handle, &json!({"seed": "000000000000000000000000Trustee1"}).to_string()).wait().unwrap(); - - let receipt = "txo:sov:1234"; - - let err = build_verify_payment_req(wallet.handle, Some(&did), receipt).unwrap_err(); - - assert_eq!(err, ErrorCode::CommonInvalidStructure) -} \ No newline at end of file diff --git a/libsovtoken/tests/create_payment_addres_handler_tests.rs b/libsovtoken/tests/create_payment_addres_handler_tests.rs deleted file mode 100644 index b748c814c..000000000 --- a/libsovtoken/tests/create_payment_addres_handler_tests.rs +++ /dev/null @@ -1,123 +0,0 @@ -//! -//! tests for Payment related functions - - -extern crate bs58; -extern crate libc; - -#[macro_use] extern crate log; -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; - -extern crate indyrs as indy; // lib-sdk project -extern crate sovtoken; - -use std::ptr; -use std::ffi::CString; -use std::time::Duration; - -use sovtoken::logic::config::payment_address_config::PaymentAddressConfig; -use sovtoken::logic::address::unqualified_address_from_address; -use sovtoken::utils::test::callbacks; -use sovtoken::ErrorCode; - -mod utils; - -// ***** HELPER TEST DATA ***** -const WALLET_ID: i32 = 99; -const COMMAND_HANDLE: i32 = 1; -const TIMEOUT_SECONDS: u64 = 20; -static INVALID_CONFIG_JSON: &'static str = r#"{ "horrible" : "only on tuedays"}"#; - - -// ***** HELPER METHODS ***** - -fn create_payment_address(wallet: &utils::wallet::Wallet, config: PaymentAddressConfig) -> String { - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let config_str = config.serialize_to_cstring().unwrap(); - let config_str_ptr = config_str.as_ptr(); - - let return_error = sovtoken::api::create_payment_address_handler(command_handle, wallet.handle, config_str_ptr, cb); - - assert_eq!(ErrorCode::Success, ErrorCode::from(return_error), "api call to create_payment_address_handler failed"); - - let (err, payment_address) = receiver.recv_timeout(Duration::from_secs(TIMEOUT_SECONDS)).unwrap(); - - assert_eq!(ErrorCode::Success, err, "Expected Success"); - - return payment_address; -} - - -// ***** UNIT TESTS ***** - -// the create payment requires a callback and this test ensures we have -// receive error when no callback is provided -#[test] -fn errors_with_no_callback() { - let return_error = sovtoken::api::create_payment_address_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), None); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Callback for 'create_payment_address_handler'"); -} - - -// the create payment method requires a config parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn errors_with_no_config() { - let return_error = sovtoken::api::create_payment_address_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), Some(utils::callbacks::empty_callback)); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Config for 'create_payment_address_handler'"); -} - - -// the create payment method requires a valid JSON format (format is described -// in create_payment_address_handler description). When invalid json is sent, -// default empty is used instead -#[test] -fn success_with_invalid_config_json() { - let config_str = CString::new(INVALID_CONFIG_JSON).unwrap(); - let config_str_ptr = config_str.as_ptr(); - - let return_error = sovtoken::api::create_payment_address_handler(COMMAND_HANDLE, WALLET_ID, config_str_ptr, Some(utils::callbacks::empty_callback)); - - assert_eq!(return_error, ErrorCode::Success as i32, "Expecting Valid JSON for 'create_payment_address_handler'"); -} - -// this test passes valid parameters. The callback is invoked and a valid payment address -// is returned in the call back. The payment address format is described in -// create_payment_address_handler -#[test] -fn successfully_creates_payment_address_with_no_seed() { - debug!("logging started for successfully_creates_payment_address_with_no_seed"); - - let wallet = utils::wallet::Wallet::new(); - - let config: PaymentAddressConfig = PaymentAddressConfig { seed: String::new() }; - - let payment_address = create_payment_address(&wallet, config); - - debug!("******* got address of {}", payment_address); - let unqual_address = unqualified_address_from_address(&payment_address).unwrap(); - assert_eq!(bs58::decode(unqual_address).into_vec().unwrap().len(), 36); -} - -// this test passes a valid seed value for the key. The callback is invoked and an expected valid -// payment address is returned in the call back. The payment address format is described in -// create_payment_address_handler -#[test] -fn successfully_creates_payment_address_with_seed() { - trace!("logging started for successfully_creates_payment_address_with_seed"); - - let config: PaymentAddressConfig = PaymentAddressConfig { seed: "00000000000000000000000000000000".to_string() }; - - let wallet = utils::wallet::Wallet::new(); - - let payment_address = create_payment_address(&wallet, config); - - let expected_payment_address = "pay:sov:DB3eBYTCr9NvNVZNp1GwV12iDfqftoGrDKqBedRZV4SgdeTbi"; - - debug!("******* got address of {}", payment_address); - - assert_eq!(expected_payment_address, payment_address, "callback did not receive expected payment address"); -} \ No newline at end of file diff --git a/libsovtoken/tests/create_payment_tests.rs b/libsovtoken/tests/create_payment_tests.rs deleted file mode 100644 index af794072a..000000000 --- a/libsovtoken/tests/create_payment_tests.rs +++ /dev/null @@ -1,162 +0,0 @@ -//! -//! tests for Payment related functions - - -extern crate bs58; -extern crate libc; -extern crate rand; - -#[macro_use] extern crate log; -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; - -extern crate indyrs as indy; // lib-sdk project -extern crate sovtoken; - -use libc::c_char; -use rand::Rng; -use std::ptr; -use std::ffi::CString; -use std::time::Duration; - -use indy::future::Future; - -use sovtoken::logic::config::payment_address_config::PaymentAddressConfig; -use sovtoken::logic::address::unqualified_address_from_address; -use sovtoken::utils::test::callbacks; -use sovtoken::ErrorCode; -mod utils; - -// ***** HELPER TEST DATA ***** -const WALLET_ID: i32 = 99; -const COMMAND_HANDLE: i32 = 1; -const TIMEOUT_SECONDS: u64 = 20; -static VALID_SEED_LEN: usize = 32; -static INVALID_CONFIG_JSON: &'static str = r#"{ "horrible" : "only on tuedays"}"#; -static VALID_CONFIG_EMPTY_SEED_JSON: &'static str = r#"{}"#; - - -// ***** HELPER METHODS ***** -// helper methods -fn rand_string(length : usize) -> String { - let s = rand::thread_rng() - .gen_ascii_chars() - .take(length) - .collect::(); - - return s; -} - -extern "C" fn empty_create_payment_callback(_command_handle: i32, _err: i32, _payment_address: *const c_char) -> i32 { - return ErrorCode::Success as i32; -} - - -// ***** UNIT TESTS ***** - -// the create payment requires a callback and this test ensures we have -// receive error when no callback is provided -#[test] -fn errors_with_no_callback () { - let return_error = sovtoken::api::create_payment_address_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), None); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Callback for 'create_payment_address_handler'"); -} - - -// the create payment method requires a config parameter and this test ensures that -// a error is returned when no config is provided -#[test] -fn errors_with_no_config() { - let cb : Option i32> = Some(empty_create_payment_callback); - let return_error = sovtoken::api::create_payment_address_handler(COMMAND_HANDLE, WALLET_ID, ptr::null(), cb); - assert_eq!(return_error, ErrorCode::CommonInvalidStructure as i32, "Expecting Config for 'create_payment_address_handler'"); -} - - -// the create payment method requires a valid JSON format (format is described -// in create_payment_address_handler description). When invalid json is sent, -// default empty is used instead -#[test] -fn success_with_invalid_config_json() { - - let config_str = CString::new(INVALID_CONFIG_JSON).unwrap(); - let config_str_ptr = config_str.as_ptr(); - - let cb : Option i32> = Some(empty_create_payment_callback); - let return_error = sovtoken::api::create_payment_address_handler(COMMAND_HANDLE, WALLET_ID, config_str_ptr, cb); - - assert_eq!(return_error, ErrorCode::Success as i32, "Expecting Valid JSON for 'create_payment_address_handler'"); -} - - -// this test passes valid parameters. The callback is invoked and a valid payment address -// is returned in the call back. The payment address format is described in -// create_payment_address_handler -#[test] -fn successfully_creates_payment_address_with_no_seed() { - - debug!("logging started for successfully_creates_payment_address_with_no_seed"); - - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let config_str = CString::new(VALID_CONFIG_EMPTY_SEED_JSON).unwrap(); - let config_str_ptr = config_str.as_ptr(); - - let wallet = utils::wallet::Wallet::new(); - - let return_error = sovtoken::api::create_payment_address_handler(command_handle, wallet.handle, config_str_ptr, cb); - - assert_eq!(ErrorCode::Success, ErrorCode::from(return_error), "api call to create_payment_address_handler failed"); - - let (err, payment_address) = receiver.recv_timeout(Duration::from_secs(TIMEOUT_SECONDS)).unwrap(); - - debug!("******* got address of {}", payment_address); - let unqual_address = unqualified_address_from_address(&payment_address).unwrap(); - assert_eq!(bs58::decode(unqual_address).into_vec().unwrap().len(), 36); - assert_eq!(ErrorCode::Success, err, "Expected Success"); -} - - -// this test passes valid parameters including a seed value for the key. The callback is invoked and a valid payment address -// is returned in the call back. The payment address format is described in -// create_payment_address_handler -#[test] -fn success_callback_is_called() { - - trace!("logging started for success_callback_is_called"); - - let (receiver, command_handle, cb) = callbacks::cb_ec_string(); - - let seed = rand_string(VALID_SEED_LEN); - let config: PaymentAddressConfig = PaymentAddressConfig { seed, }; - - let config_str = config.serialize_to_cstring().unwrap(); - let config_str_ptr = config_str.as_ptr(); - - let wallet = utils::wallet::Wallet::new(); - - let return_error = sovtoken::api::create_payment_address_handler(command_handle, wallet.handle, config_str_ptr, cb); - assert_eq!(ErrorCode::Success, ErrorCode::from(return_error), "api call to create_payment_address_handler failed"); - - let (err, payment_address) = receiver.recv_timeout(Duration::from_secs(TIMEOUT_SECONDS)).unwrap(); - - debug!("******* got address of {}", payment_address); - let unqual_address = unqualified_address_from_address(&payment_address).unwrap(); - assert_eq!(bs58::decode(unqual_address).into_vec().unwrap().len(), 36, "callback did not receive valid payment address"); - assert_eq!(ErrorCode::Success, err, "Expected Success"); - -} - -#[test] -pub fn create_address_two_times_with_the_same_seed() { - sovtoken::api::sovtoken_init(); - let wallet = utils::wallet::Wallet::new(); - - let seed = json!({"seed": "00000000000000000000000000000000"}).to_string(); - - let _pa1 = indy::payments::create_payment_address(wallet.handle, "sov", &seed).wait().unwrap(); - let err = indy::payments::create_payment_address(wallet.handle, "sov", &seed).wait().unwrap_err(); - - assert_eq!(err.error_code, ErrorCode::WalletItemAlreadyExists); -} \ No newline at end of file diff --git a/libsovtoken/tests/payment_chaos_tests.rs b/libsovtoken/tests/payment_chaos_tests.rs deleted file mode 100644 index 7bf931c0e..000000000 --- a/libsovtoken/tests/payment_chaos_tests.rs +++ /dev/null @@ -1,387 +0,0 @@ -extern crate libc; -extern crate sovtoken; -extern crate indyrs as indy; // lib-sdk project - -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate serde_json; -#[macro_use] extern crate lazy_static; - -use indy::future::Future; - -use sovtoken::ErrorCode; - -pub mod utils; -use utils::setup::{Setup, SetupConfig}; -use utils::wallet::Wallet; - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_without_outputs_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- create payment request with empty output json - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let pay_input_json = json!([ - txo_1 - ]).to_string(); - - let pay_output_json = json!([ - ]).to_string(); - - let ec = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap_err(); - assert_eq!(ec.error_code, ErrorCode::CommonInvalidStructure); - -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_without_inputs_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let dids = setup.trustees.dids(); - - // ---- create payment request with empty input json - let pay_input_json = json!([ - - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 50 - } - ]).to_string(); - - let ec = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap_err(); - assert_eq!(ec.error_code, ErrorCode::CommonInvalidStructure); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_from_non_existent_payment_source_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let dids = setup.trustees.dids(); - - // ---- spend tokens from a valid address that is not in the wallet - - let pay_input_json = json!([ - "txo:sov:3x42qH8UkJac1BuorqjSEvuVjvYkXk8sUAqoVPn1fGCwjLPquu4CndzBHBQ5hX6RSmDVnXGdMPrnWDUN5S1ty4YQP87hW8ubMSzu9M56z1FbAQV6aMSX5h" - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 50 - } - ]).to_string(); - - let ec = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap_err(); - assert_eq!(ec.error_code, ErrorCode::WalletItemNotFound); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_from_existent_and_non_existent_payment_source_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend tokens from inputs with both an address in the wallet and one address that is not in the wallet - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let pay_input_json = json!([ - txo_1, "txo:sov:3x42qH8UkJac1BuorqjSEvuVjvYkXk8sUAqoVPn1fGCwjLPquu4CndzBHBQ5hX6RSmDVnXGdMPrnWDUN5S1ty4YQP87hW8ubMSzu9M56z1FbAQV6aMSX5h" - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 50 - } - ]).to_string(); - - let ec = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap_err(); - assert_eq!(ec.error_code, ErrorCode::WalletItemNotFound); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_with_insufficent_funds_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend more tokens than we minted - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let pay_input_json = json!([ - txo_1 - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 90 - } - ]).to_string(); - - let (payment_request, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap(); - - let payment_result = indy::ledger::submit_request(pool_handle, &payment_request).wait().unwrap(); - - assert!(payment_result.contains("InsufficientFundsError"), "Expected InsufficientFundsError"); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_with_insufficent_funds_with_several_output_addresses_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 2, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50, 1]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend more tokens than we minted sending the outputs (spending) to several addresses - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let pay_input_json = json!([ - txo_1 - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 45 - }, - { - "recipient": payment_addresses[1], - "amount": 45 - } - ]).to_string(); - - let (payment_request, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap(); - - let payment_result = indy::ledger::submit_request(pool_handle, &payment_request).wait().unwrap(); - - assert!(payment_result.contains("InsufficientFundsError"), "Expected InsufficientFundsError"); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_with_insufficent_funds_with_several_txo_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 3, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![30, 10, 10]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend more tokens than we minted - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - let txo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[1]); - let txo_3 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[2]); - - let pay_input_json = json!([ - txo_1, txo_2, txo_3 - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 90 - } - ]).to_string(); - - let (payment_request, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap(); - - let payment_result = indy::ledger::submit_request(pool_handle, &payment_request).wait().unwrap(); - - assert!(payment_result.contains("InsufficientFundsError"), "Expected InsufficientFundsError"); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_with_funds_remaining_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend more tokens than we minted - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let pay_input_json = json!([ - txo_1 - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 25 - } - ]).to_string(); - - let (payment_request, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap(); - - let payment_result = indy::ledger::submit_request(pool_handle, &payment_request).wait().unwrap(); - - assert!(payment_result.contains("ExtraFundsError"), "Expected ExtraFundsError"); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_with_funds_remaining_with_several_outputs_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 2, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![50]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend less tokens than we minted - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - - let pay_input_json = json!([ - txo_1 - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 15 - }, - { - "recipient": payment_addresses[1], - "amount": 5 - } - ]).to_string(); - - let (payment_request, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap(); - - let payment_result = indy::ledger::submit_request(pool_handle, &payment_request).wait().unwrap(); - - assert!(payment_result.contains("ExtraFundsError"), "Expected ExtraFundsError"); -} - -// ------------------------------------------------------------------------------------------------ -#[test] -pub fn pay_with_funds_remaining_with_several_txo_fails() { - - // ---- setup - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 3, - num_trustees: 4, - num_users: 0, - mint_tokens: Some(vec![30, 10, 10]), - fees: None, - }); - let payment_addresses = &setup.addresses; - let pool_handle = setup.pool_handle; - let dids = setup.trustees.dids(); - - // ---- spend less tokens than we minted - let txo_1 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[0]); - let txo_2 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[1]); - let txo_3 = utils::payment::get_utxo::get_first_utxo_txo_for_payment_address(&wallet, pool_handle, dids[0], &payment_addresses[2]); - - let pay_input_json = json!([ - txo_1, txo_2, txo_3 - ]).to_string(); - - let pay_output_json = json!([ - { - "recipient": payment_addresses[0], - "amount": 25 - } - ]).to_string(); - - let (payment_request, _) = indy::payments::build_payment_req(wallet.handle, Some(dids[0]), &pay_input_json, &pay_output_json, None).wait().unwrap(); - - let payment_result = indy::ledger::submit_request(pool_handle, &payment_request).wait().unwrap(); - - assert!(payment_result.contains("ExtraFundsError"), "Expected ExtraFundsError"); -} \ No newline at end of file diff --git a/libsovtoken/tests/sign_with_address_test.rs b/libsovtoken/tests/sign_with_address_test.rs deleted file mode 100644 index ce0a0eab5..000000000 --- a/libsovtoken/tests/sign_with_address_test.rs +++ /dev/null @@ -1,99 +0,0 @@ -#[macro_use] extern crate serde_json; -#[macro_use] extern crate serde_derive; -#[macro_use] extern crate lazy_static; -extern crate libc; -extern crate sovtoken; -extern crate indyrs as indy; // lib-sdk project -extern crate bs58; - -mod utils; -use indy::future::Future; -use utils::wallet::Wallet; -use utils::setup::{Setup, SetupConfig}; -use indy::payments::{sign_with_address, verify_with_address}; -use indy::ErrorCode; - -#[test] -pub fn sign_with_address_works() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - - let addr = setup.addresses.get(0).unwrap(); - let msg = vec![1, 2, 3, 4]; - let sig = sign_with_address(wallet.handle, addr, msg.as_slice()).wait().unwrap(); - assert!(verify_with_address(addr, msg.as_slice(), sig.as_slice()).wait().unwrap()); -} - -#[test] -pub fn sign_with_address_fails_for_incorrect_signature() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - - let addr = setup.addresses.get(0).unwrap(); - let msg = vec![1, 2, 3, 4]; - let sig = sign_with_address(wallet.handle, addr, msg.as_slice()).wait().unwrap(); - assert_eq!(verify_with_address(addr, msg.as_slice(), &sig[..sig.len()-1]).wait().unwrap_err().error_code, ErrorCode::CommonInvalidStructure); -} - -#[test] -pub fn sign_with_address_fails_for_invalid_addr() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - - let addr = setup.addresses.get(0).unwrap(); - let msg = vec![1, 2, 3, 4]; - assert_eq!(sign_with_address(wallet.handle, &addr[..addr.len()-1], msg.as_slice()).wait().unwrap_err().error_code, ErrorCode::CommonInvalidStructure); -} - -#[test] -pub fn sign_with_address_fails_for_no_such_addr_in_wallet() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - let wallet_2 = Wallet::new(); - - let addr = setup.addresses.get(0).unwrap(); - let msg = vec![1, 2, 3, 4]; - //TODO: Should be WalletItemNotFound - assert_eq!(sign_with_address(wallet_2.handle, &addr[..addr.len()-1], msg.as_slice()).wait().unwrap_err().error_code, ErrorCode::CommonInvalidStructure); -} - -#[test] -pub fn verify_with_address_fails_for_invalid_address() { - let wallet = Wallet::new(); - let setup = Setup::new(&wallet, SetupConfig { - num_addresses: 1, - num_trustees: 1, - num_users: 0, - mint_tokens: None, - fees: None, - }); - - let addr = setup.addresses.get(0).unwrap(); - let msg = vec![1, 2, 3, 4]; - let sig = sign_with_address(wallet.handle, addr, msg.as_slice()).wait().unwrap(); - assert_eq!(verify_with_address(&addr[..addr.len()-1], msg.as_slice(), &sig[..sig.len()-1]).wait().unwrap_err().error_code, ErrorCode::CommonInvalidStructure); -} diff --git a/libsovtoken/tests/utils/mint.rs b/libsovtoken/tests/utils/mint.rs index 2bac40837..87fae2a6d 100644 --- a/libsovtoken/tests/utils/mint.rs +++ b/libsovtoken/tests/utils/mint.rs @@ -4,17 +4,16 @@ extern crate serde_json; use std::collections::HashMap; use std::str::FromStr; +use indy::future::Future; use sovtoken::ErrorCode; -use sovtoken::utils::json_conversion::JsonDeserialize; -use sovtoken::logic::request::Request; use sovtoken::logic::config::output_mint_config::MintRequest; +use sovtoken::logic::request::Request; +use sovtoken::utils::json_conversion::JsonDeserialize; use utils; -use indy::future::Future; - pub fn mint_tokens(cfg: HashMap, pool_handle: i32, wallet_handle: i32, trustee_dids: &Vec<&str>) -> Result { - let vec_outputs:Vec> = cfg.iter().map(|(pa, am)| { + let vec_outputs: Vec> = cfg.iter().map(|(pa, am)| { let mut map = HashMap::new(); map.insert("recipient", serde_json::Value::String(pa.clone())); map.insert("amount", serde_json::Value::Number(serde_json::Number::from_str(&am.to_string()).unwrap())); @@ -29,8 +28,9 @@ pub fn mint_tokens(cfg: HashMap, pool_handle: i32, wallet_handle: i let mint_req = Request::::multi_sign_request(wallet_handle, &mint_req, trustee_dids.to_vec()).unwrap(); + info!("Mint request: {}", mint_req); let result = indy::ledger::submit_request(pool_handle, &mint_req).wait().unwrap(); - + info!("Mint result: {}", result); utils::parse_mint_response::ParseMintResponse::from_json(&result).map_err(|_| ErrorCode::CommonInvalidStructure) } diff --git a/libsovtoken/tests/utils/setup.rs b/libsovtoken/tests/utils/setup.rs index 70c57f671..af129082b 100644 --- a/libsovtoken/tests/utils/setup.rs +++ b/libsovtoken/tests/utils/setup.rs @@ -14,6 +14,7 @@ use utils::pool; use utils::wallet::Wallet; use serde_json; + const PROTOCOL_VERSION: usize = 2; /**