diff --git a/src/accounts/mod.rs b/src/accounts/mod.rs index 444e850..b6233d9 100644 --- a/src/accounts/mod.rs +++ b/src/accounts/mod.rs @@ -70,3 +70,101 @@ pub mod prelude { pub use super::response::*; pub use super::single_account_request::*; } + +#[cfg(test)] +pub mod test { + + use super::prelude::*; + use crate::horizon_client::HorizonClient; + + static SEQUENCE: &str = "131988639973376"; + static ACCOUNT_ID: &str = "GCAHCEGRUI7FFAQE3DBQWV7ULMQHFBUIVRZC4R2VISREAY6D52Z2NODN"; + static LAST_MODIFIED_TIME: &str = "2024-02-08T14:25:14Z"; + static LAST_MODIFIED_LEDGER: u64 = 30731; + + #[tokio::test] + async fn test_get_account_list() { + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + // construct request + let accounts_request = AccountsRequest::new() + .set_signer_filter(ACCOUNT_ID) + .unwrap() + .set_limit(10) + .unwrap(); + + // call the get_account_list method to retrieve the account list response + let accounts_response: Result = + horizon_client.get_account_list(&accounts_request).await; + + assert!(accounts_response.is_ok()); + let binding = accounts_response.unwrap(); + let response = &binding.embedded().records()[0]; + assert_eq!(response.account_id(), ACCOUNT_ID); + assert_eq!(response.id(), ACCOUNT_ID); + assert_eq!(response.sequence(), SEQUENCE); + assert_eq!(response.subentry_count(), &0); + assert_eq!(response.last_modified_ledger(), &LAST_MODIFIED_LEDGER); + assert_eq!(response.last_modified_time(), LAST_MODIFIED_TIME); + assert_eq!(response.thresholds().low_threshold(), &0); + assert_eq!(response.thresholds().med_threshold(), &0); + assert_eq!(response.thresholds().high_threshold(), &0); + assert_eq!(response.flags().auth_required(), &false); + assert_eq!(response.flags().auth_revocable(), &false); + assert_eq!(response.flags().auth_immutable(), &false); + assert_eq!(response.flags().auth_clawback_enabled(), &false); + assert_eq!(response.balances()[0].balance(), "10000.0000000"); + assert_eq!(response.balances()[0].asset_type(), "native"); + assert_eq!(response.balances()[0].buying_liabilities(), "0.0000000"); + assert_eq!(response.balances()[0].selling_liabilities(), "0.0000000"); + assert_eq!(response.signers()[0].key(), ACCOUNT_ID); + assert_eq!(response.signers()[0].weight(), &1); + assert_eq!(response.signers()[0].singer_type(), "ed25519_public_key"); + assert_eq!(response.num_sponsoring(), &0); + assert_eq!(response.num_sponsored(), &0); + assert_eq!(response.paging_token(), ACCOUNT_ID); + } + + #[tokio::test] + async fn test_get_single_account() { + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + // construct request + let single_account_request = SingleAccountRequest::new() + .set_account_id(ACCOUNT_ID.to_string()) + .unwrap(); + + let single_account_response = horizon_client + .get_single_account(&single_account_request) + .await; + + assert!(single_account_response.is_ok()); + let response = single_account_response.unwrap(); + assert_eq!(response.account_id().to_string(), ACCOUNT_ID); + assert_eq!(response.sequence().to_string(), SEQUENCE); + assert_eq!(response.subentry_count(), &0); + assert_eq!(response.last_modified_ledger(), &LAST_MODIFIED_LEDGER); + assert_eq!(response.last_modified_time(), LAST_MODIFIED_TIME); + assert_eq!(response.thresholds().low_threshold(), &0); + assert_eq!(response.thresholds().med_threshold(), &0); + assert_eq!(response.thresholds().high_threshold(), &0); + assert_eq!(response.flags().auth_required(), &false); + assert_eq!(response.flags().auth_revocable(), &false); + assert_eq!(response.flags().auth_immutable(), &false); + assert_eq!(response.flags().auth_clawback_enabled(), &false); + assert_eq!(response.balances()[0].balance(), "10000.0000000"); + assert_eq!(response.balances()[0].asset_type(), "native"); + assert_eq!(response.balances()[0].buying_liabilities(), "0.0000000"); + assert_eq!(response.balances()[0].selling_liabilities(), "0.0000000"); + assert_eq!(response.signers()[0].key(), ACCOUNT_ID); + assert_eq!(response.signers()[0].weight(), &1); + assert_eq!(response.signers()[0].singer_type(), "ed25519_public_key"); + assert_eq!(response.num_sponsoring(), &0); + assert_eq!(response.num_sponsored(), &0); + assert_eq!(response.paging_token(), ACCOUNT_ID); + } +} diff --git a/src/assets/mod.rs b/src/assets/mod.rs index 9122d03..6789d0b 100644 --- a/src/assets/mod.rs +++ b/src/assets/mod.rs @@ -72,3 +72,68 @@ pub mod prelude { pub use super::all_assets_request::*; pub use super::response::*; } + +#[cfg(test)] +pub mod test { + + use super::prelude::*; + use crate::horizon_client::HorizonClient; + + #[tokio::test] + async fn test_get_all_assets() { + let asset_type = "credit_alphanum4"; + let asset_code = "0"; + let asset_issuer = "GAGNEED7RUE6PNAB3AKXFU6QZF4EUSVTICHE7YRHB53KDOEHGKWBL6BE"; + let paging_token = + "0_GAGNEED7RUE6PNAB3AKXFU6QZF4EUSVTICHE7YRHB53KDOEHGKWBL6BE_credit_alphanum4"; + let num_accounts = 0; + let amount = "0.0000000"; + let num_authorized = 0; + let num_unauthorized = 0; + let balances_authorized = "0.0000000"; + let balances_unauthorized = "0.0000000"; + + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + // construct request + let all_assets_request: AllAssetsRequest = AllAssetsRequest::new().set_limit(1).unwrap(); + + let response = horizon_client.get_all_assets(&all_assets_request).await; + + assert!(response.is_ok()); + let binding = response.unwrap(); + let response = &binding.embedded().records()[0]; + assert_eq!(response.asset_type(), asset_type); + assert_eq!(response.asset_code(), asset_code); + assert_eq!(response.asset_issuer(), asset_issuer); + assert_eq!(response.paging_token(), paging_token); + assert_eq!( + response.paging_token(), + &format!("{}_{}_{}", asset_code, asset_issuer, asset_type) + ); + assert_eq!(response.num_accounts(), &num_accounts); + assert_eq!(response.num_claimable_balances(), &0); + assert_eq!(response.num_liquidity_pools(), &0); + assert_eq!(response.amount(), amount); + assert_eq!(response.accounts().authorized(), &num_authorized); + assert_eq!(response.accounts().authorized_to_maintain_liabilities(), &2); + assert_eq!(response.accounts().unauthorized(), &num_unauthorized); + assert_eq!(response.claimable_balances_amount(), "0.0000000"); + assert_eq!(response.liquidity_pools_amount(), "0.0000000"); + assert_eq!(response.contracts_amount(), "0.0000000"); + assert_eq!(response.balances().authorized(), balances_authorized); + assert_eq!( + response.balances().authorized_to_maintain_liabilities(), + "1.0000000" + ); + assert_eq!(response.balances().unauthorized(), balances_unauthorized); + + let auth_required = true; + assert_eq!(response.flags().auth_required(), &auth_required); + assert_eq!(response.flags().auth_revocable(), &true); + assert_eq!(response.flags().auth_immutable(), &false); + assert_eq!(response.flags().auth_clawback_enabled(), &true); + } +} diff --git a/src/claimable_balances/mod.rs b/src/claimable_balances/mod.rs index f4e4429..3737a90 100644 --- a/src/claimable_balances/mod.rs +++ b/src/claimable_balances/mod.rs @@ -102,6 +102,7 @@ pub mod prelude { mod tests { use super::parse_epoch; use super::prelude::*; + use crate::horizon_client::HorizonClient; use chrono::DateTime; use chrono::{TimeZone, Utc}; use lazy_static::lazy_static; @@ -153,4 +154,128 @@ mod tests { fn test_parse_epoch() { assert_eq!(parse_epoch(&EPOCH_STR.to_string()), *DATE); } + + #[tokio::test] + async fn test_get_all_claimable_balances() { + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + // construct request + let all_claimable_balances_request = + AllClaimableBalancesRequest::new().set_limit(4).unwrap(); + + let all_claimable_balances_response = horizon_client + .get_all_claimable_balances(&all_claimable_balances_request) + .await; + + assert!(all_claimable_balances_response.is_ok()); + + let binding = all_claimable_balances_response.unwrap(); + let predicate = binding.embedded().records()[1].claimants()[0].predicate(); + + let jan_first_2024 = Utc::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(); + let valid_date = Utc::with_ymd_and_hms(&Utc, 2024, 2, 10, 0, 0, 0).unwrap(); + + assert_eq!(predicate.is_valid(jan_first_2024), true); + assert_eq!(predicate.is_valid(valid_date), true); + let record = &binding.embedded().records()[0]; + + assert_eq!( + record.id(), + "000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" + ); + + assert_eq!( + record.asset(), + "USDC:GAKNDFRRWA3RPWNLTI3G4EBSD3RGNZZOY5WKWYMQ6CQTG3KIEKPYWAYC" + ); + + assert_eq!(record.amount(), "0.0010000"); + + assert_eq!( + record.sponsor(), + "GCENYNAX2UCY5RFUKA7AYEXKDIFITPRAB7UYSISCHVBTIAKPU2YO57OA" + ); + + assert_eq!(record.last_modified_ledger(), &591); + + assert_eq!( + record.last_modified_time().to_string(), + "2024-02-06T18:25:07Z" + ); + + assert_eq!(record.flags().clawback_enabled(), &false); + } + + #[tokio::test] + async fn test_get_single_claimable_balance() { + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + let single_claimable_balance_request = SingleClaimableBalanceRequest::new() + .set_claimable_balance_id( + "000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" + .to_string(), + ); + + let single_claimable_balance_response = horizon_client + .get_single_claimable_balance(&single_claimable_balance_request) + .await; + + assert!(single_claimable_balance_response.is_ok()); + + let binding = single_claimable_balance_response.clone().unwrap(); + let predicate = binding.claimants()[0].predicate(); + + let jan_first_2024 = Utc::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(); + let valid_date = Utc::with_ymd_and_hms(&Utc, 2024, 2, 10, 0, 0, 0).unwrap(); + + assert_eq!(predicate.is_valid(jan_first_2024), true); + assert_eq!(predicate.is_valid(valid_date), true); + + let single_claimable_balance_response = single_claimable_balance_response.unwrap(); + assert_eq!( + single_claimable_balance_response.id().to_string(), + "000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" + ); + + assert_eq!( + single_claimable_balance_response.asset().to_string(), + "USDC:GAKNDFRRWA3RPWNLTI3G4EBSD3RGNZZOY5WKWYMQ6CQTG3KIEKPYWAYC" + ); + + assert_eq!( + single_claimable_balance_response.amount().to_string(), + "0.0010000" + ); + + assert_eq!( + single_claimable_balance_response.sponsor().to_string(), + "GCENYNAX2UCY5RFUKA7AYEXKDIFITPRAB7UYSISCHVBTIAKPU2YO57OA" + ); + + assert_eq!( + single_claimable_balance_response.last_modified_ledger(), + &591 + ); + + assert_eq!( + single_claimable_balance_response + .last_modified_time() + .to_string(), + "2024-02-06T18:25:07Z" + ); + + assert_eq!( + single_claimable_balance_response.flags().clawback_enabled(), + &false + ); + + assert_eq!( + single_claimable_balance_response.paging_token().to_string(), + "591-000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" + ); + } } diff --git a/src/effects/mod.rs b/src/effects/mod.rs index 5756aaa..d0c73d6 100644 --- a/src/effects/mod.rs +++ b/src/effects/mod.rs @@ -16,10 +16,163 @@ pub mod prelude { #[cfg(test)] mod tests { - use super::*; + use super::prelude::*; + use crate::horizon_client::HorizonClient; - #[test] - fn dummy_test() { - assert_eq!(EFFECTS_PATH, "effects"); + #[tokio::test] + async fn test_get_all_effects() { + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + let num_records_to_fetch = 2; + + let all_effects_request = AllEffectsRequest::new() + .set_limit(num_records_to_fetch) + .unwrap(); + let _all_effects_response = horizon_client.get_all_effects(&all_effects_request).await; + + assert!(_all_effects_response.clone().is_ok()); + + // make sure there are actually 2 records + assert_eq!( + _all_effects_response + .clone() + .unwrap() + .embedded() + .records() + .len() as u8, + num_records_to_fetch + ); + + // test first record retrieved + assert_eq!( + _all_effects_response.clone().unwrap().embedded().records()[0].type_i, + 0 + ); + + // test second record retrieved + assert_eq!( + _all_effects_response.clone().unwrap().embedded().records()[1].type_i, + 3 + ); + } + + #[tokio::test] + async fn test_get_effects_for_account() { + const ID: &str = "0000000459561504769-0000000001"; + const PAGING_TOKEN: &str = "459561504769-1"; + const ACCOUNT: &str = "GAIH3ULLFQ4DGSECF2AR555KZ4KNDGEKN4AFI4SU2M7B43MGK3QJZNSR"; + const RECORD_TYPE: &str = "account_created"; + const TYPE_I: u32 = 0; + const CREATED_AT: &str = "2024-02-06T17:42:48Z"; + const STARTING_BALANCE: &str = "10000000000.0000000"; + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + let effects_for_account_request = EffectsForAccountRequest::new().set_limit(2).unwrap(); + + let effects_for_account_response = horizon_client + .get_effects_for_account(&effects_for_account_request) + .await; + + assert!(&effects_for_account_response.is_ok()); + let binding = effects_for_account_response.clone().unwrap(); + let record = &binding.embedded().records()[0]; + + assert_eq!(record.id(), ID); + assert_eq!(record.paging_token(), PAGING_TOKEN); + assert_eq!(record.account(), ACCOUNT); + assert_eq!(record.effect_type(), RECORD_TYPE); + assert_eq!(record.type_i(), &TYPE_I); + assert_eq!(record.created_at(), CREATED_AT); + assert_eq!( + record.starting_balance().as_ref().unwrap(), + &STARTING_BALANCE + ); + } + + #[tokio::test] + async fn get_effects_for_liquidity_pools() { + const ID: &str = "0000000459561504769-0000000001"; + const PAGING_TOKEN: &str = "459561504769-1"; + const ACCOUNT: &str = "GAIH3ULLFQ4DGSECF2AR555KZ4KNDGEKN4AFI4SU2M7B43MGK3QJZNSR"; + const RECORD_TYPE: &str = "account_created"; + const TYPE_I: u32 = 0; + const CREATED_AT: &str = "2024-02-06T17:42:48Z"; + const STARTING_BALANCE: &str = "10000000000.0000000"; + + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + let effects_for_liquidity_pools_request = + EffectsForLiquidityPoolRequest::new().set_limit(2).unwrap(); + let effects_for_liquidity_pools_response = horizon_client + .get_effects_for_liquidity_pools(&effects_for_liquidity_pools_request) + .await; + + assert!(effects_for_liquidity_pools_response.is_ok()); + let binding = effects_for_liquidity_pools_response.clone().unwrap(); + let record = &binding.embedded().records()[0]; + + assert_eq!(record.id(), ID); + assert_eq!(record.paging_token(), PAGING_TOKEN); + assert_eq!(record.account(), ACCOUNT); + assert_eq!(record.effect_type(), RECORD_TYPE); + assert_eq!(record.type_i(), &TYPE_I); + assert_eq!(record.created_at(), CREATED_AT); + assert_eq!( + record.starting_balance().as_ref().unwrap(), + &STARTING_BALANCE + ); + + // TODO: LEONARD FIX + let _effects_for_liquidity_pools_request_with_id = EffectsForLiquidityPoolRequest::new() + .set_limit(2) + .expect("REASON") + .set_liquidity_pool_id("0000000459561504769-0000000001".to_string()); + let effects_for_liquidity_pools_response = horizon_client + .get_effects_for_liquidity_pools(&effects_for_liquidity_pools_request) + .await; + + assert!(effects_for_liquidity_pools_response.clone().is_ok()); + assert_eq!(record.id(), ID); + } + + #[tokio::test] + async fn test_get_effects_for_ledger() { + // found by trial and error in the Stellar laboratory + let ledger_sequence = 125; + + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + let effects_for_ledger_request = + EffectsForLedgerRequest::new().set_sequence(ledger_sequence); + let effects_for_ledger_response = horizon_client + .get_effects_for_ledger(&effects_for_ledger_request) + .await; + + assert!(effects_for_ledger_response.is_ok()); + + assert_eq!( + effects_for_ledger_response + .clone() + .unwrap() + .embedded() + .records()[0] + .id, + "0000000536870916097-0000000001" + ); + + assert_eq!( + effects_for_ledger_response + .clone() + .unwrap() + .embedded() + .records()[1] + .effect_type, + "account_debited" + ); } } diff --git a/src/horizon_client.rs b/src/horizon_client.rs index 1d31c8f..0d11526 100644 --- a/src/horizon_client.rs +++ b/src/horizon_client.rs @@ -759,27 +759,9 @@ fn url_validate(url: &str) -> Result<(), String> { } #[cfg(test)] -mod tests { - use base64::{engine::general_purpose, Engine}; - use chrono::{TimeZone, Utc}; - - use crate::{ - accounts::prelude::AccountsRequest, - assets::prelude::AllAssetsRequest, - claimable_balances::prelude::SingleClaimableBalanceRequest, - effects::{ - effects_for_ledger_request::EffectsForLedgerRequest, prelude::EffectsForAccountRequest, - }, - ledgers::prelude::SingleLedgerRequest, - }; - +pub mod tests { use super::*; - static ACCOUNT_ID: &str = "GCAHCEGRUI7FFAQE3DBQWV7ULMQHFBUIVRZC4R2VISREAY6D52Z2NODN"; - static SEQUENCE: &str = "131988639973376"; - static LAST_MODIFIED_TIME: &str = "2024-02-08T14:25:14Z"; - static LAST_MODIFIED_LEDGER: u64 = 30731; - #[test] fn test_url_validate_invalid_url() { let result = url_validate("horizon-testnet.stellar.org"); @@ -795,563 +777,4 @@ mod tests { let result = url_validate("https://horizon-testnet.stellar.org"); assert!(result.is_ok()); } - - #[tokio::test] - async fn test_get_account_list() { - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - // construct request - let accounts_request = AccountsRequest::new() - .set_signer_filter(ACCOUNT_ID) - .unwrap() - .set_limit(10) - .unwrap(); - - // call the get_account_list method to retrieve the account list response - let accounts_response: Result = - horizon_client.get_account_list(&accounts_request).await; - - assert!(accounts_response.is_ok()); - let binding = accounts_response.unwrap(); - let response = &binding.embedded().records()[0]; - assert_eq!(response.account_id(), ACCOUNT_ID); - assert_eq!(response.id(), ACCOUNT_ID); - assert_eq!(response.sequence(), SEQUENCE); - assert_eq!(response.subentry_count(), &0); - assert_eq!(response.last_modified_ledger(), &LAST_MODIFIED_LEDGER); - assert_eq!(response.last_modified_time(), LAST_MODIFIED_TIME); - assert_eq!(response.thresholds().low_threshold(), &0); - assert_eq!(response.thresholds().med_threshold(), &0); - assert_eq!(response.thresholds().high_threshold(), &0); - assert_eq!(response.flags().auth_required(), &false); - assert_eq!(response.flags().auth_revocable(), &false); - assert_eq!(response.flags().auth_immutable(), &false); - assert_eq!(response.flags().auth_clawback_enabled(), &false); - assert_eq!(response.balances()[0].balance(), "10000.0000000"); - assert_eq!(response.balances()[0].asset_type(), "native"); - assert_eq!(response.balances()[0].buying_liabilities(), "0.0000000"); - assert_eq!(response.balances()[0].selling_liabilities(), "0.0000000"); - assert_eq!(response.signers()[0].key(), ACCOUNT_ID); - assert_eq!(response.signers()[0].weight(), &1); - assert_eq!(response.signers()[0].singer_type(), "ed25519_public_key"); - assert_eq!(response.num_sponsoring(), &0); - assert_eq!(response.num_sponsored(), &0); - assert_eq!(response.paging_token(), ACCOUNT_ID); - } - - #[tokio::test] - async fn test_get_single_account() { - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - // construct request - let single_account_request = SingleAccountRequest::new() - .set_account_id(ACCOUNT_ID.to_string()) - .unwrap(); - - let single_account_response = horizon_client - .get_single_account(&single_account_request) - .await; - - assert!(single_account_response.is_ok()); - let response = single_account_response.unwrap(); - assert_eq!(response.account_id().to_string(), ACCOUNT_ID); - assert_eq!(response.sequence().to_string(), SEQUENCE); - assert_eq!(response.subentry_count(), &0); - assert_eq!(response.last_modified_ledger(), &LAST_MODIFIED_LEDGER); - assert_eq!(response.last_modified_time(), LAST_MODIFIED_TIME); - assert_eq!(response.thresholds().low_threshold(), &0); - assert_eq!(response.thresholds().med_threshold(), &0); - assert_eq!(response.thresholds().high_threshold(), &0); - assert_eq!(response.flags().auth_required(), &false); - assert_eq!(response.flags().auth_revocable(), &false); - assert_eq!(response.flags().auth_immutable(), &false); - assert_eq!(response.flags().auth_clawback_enabled(), &false); - assert_eq!(response.balances()[0].balance(), "10000.0000000"); - assert_eq!(response.balances()[0].asset_type(), "native"); - assert_eq!(response.balances()[0].buying_liabilities(), "0.0000000"); - assert_eq!(response.balances()[0].selling_liabilities(), "0.0000000"); - assert_eq!(response.signers()[0].key(), ACCOUNT_ID); - assert_eq!(response.signers()[0].weight(), &1); - assert_eq!(response.signers()[0].singer_type(), "ed25519_public_key"); - assert_eq!(response.num_sponsoring(), &0); - assert_eq!(response.num_sponsored(), &0); - assert_eq!(response.paging_token(), ACCOUNT_ID); - } - - #[tokio::test] - async fn test_get_all_assets() { - let asset_type = "credit_alphanum4"; - let asset_code = "0"; - let asset_issuer = "GAGNEED7RUE6PNAB3AKXFU6QZF4EUSVTICHE7YRHB53KDOEHGKWBL6BE"; - let paging_token = - "0_GAGNEED7RUE6PNAB3AKXFU6QZF4EUSVTICHE7YRHB53KDOEHGKWBL6BE_credit_alphanum4"; - let num_accounts = 0; - let amount = "0.0000000"; - let num_authorized = 0; - let num_unauthorized = 0; - let balances_authorized = "0.0000000"; - let balances_unauthorized = "0.0000000"; - - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - // construct request - let all_assets_request: AllAssetsRequest = AllAssetsRequest::new().set_limit(1).unwrap(); - - let response = horizon_client.get_all_assets(&all_assets_request).await; - - assert!(response.is_ok()); - let binding = response.unwrap(); - let response = &binding.embedded().records()[0]; - - assert_eq!(response.asset_type(), asset_type); - - assert_eq!(response.asset_code(), asset_code); - - assert_eq!(response.asset_issuer(), asset_issuer); - - assert_eq!(response.paging_token(), paging_token); - - assert_eq!( - response.paging_token(), - &format!("{}_{}_{}", asset_code, asset_issuer, asset_type) - ); - - assert_eq!(response.num_accounts(), &num_accounts); - - assert_eq!(response.num_claimable_balances(), &0); - - assert_eq!(response.num_liquidity_pools(), &0); - - assert_eq!(response.amount(), amount); - - assert_eq!(response.accounts().authorized(), &num_authorized); - - assert_eq!(response.accounts().authorized_to_maintain_liabilities(), &2); - - assert_eq!(response.accounts().unauthorized(), &num_unauthorized); - - assert_eq!(response.claimable_balances_amount(), "0.0000000"); - - assert_eq!(response.liquidity_pools_amount(), "0.0000000"); - - assert_eq!(response.contracts_amount(), "0.0000000"); - - assert_eq!(response.balances().authorized(), balances_authorized); - - assert_eq!( - response.balances().authorized_to_maintain_liabilities(), - "1.0000000" - ); - - assert_eq!(response.balances().unauthorized(), balances_unauthorized); - - let auth_required = true; - assert_eq!(response.flags().auth_required(), &auth_required); - - assert_eq!(response.flags().auth_revocable(), &true); - - assert_eq!(response.flags().auth_immutable(), &false); - - assert_eq!(response.flags().auth_clawback_enabled(), &true); - } - - #[tokio::test] - async fn test_get_all_ledgers() { - let hash = "f96c4021adc1ae496c662f4f97143e499a9548f541c64bb2401a1b1701de5150"; - let prev_hash = "63d98f536ee68d1b27b5b89f23af5311b7569a24faf1403ad0b52b633b07be99"; - - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - // construct request - let all_ledgers_request = LedgersRequest::new().set_limit(2).unwrap(); - - let all_ledgers_response = horizon_client.get_all_ledgers(&all_ledgers_request).await; - assert!(all_ledgers_response.is_ok()); - - let binding = all_ledgers_response.unwrap(); - let all_ledgers_response = &binding.embedded().records()[0]; - - assert_eq!(all_ledgers_response.hash(), hash); - assert_eq!(all_ledgers_response.prev_hash(), prev_hash); - assert_eq!(all_ledgers_response.sequence(), &2); - assert_eq!(all_ledgers_response.successful_transaction_count(), &0); - assert_eq!(all_ledgers_response.paging_token(), "8589934592"); - } - - #[tokio::test] - async fn test_get_single_ledger() { - let id = "f96c4021adc1ae496c662f4f97143e499a9548f541c64bb2401a1b1701de5150"; - let hash = "f96c4021adc1ae496c662f4f97143e499a9548f541c64bb2401a1b1701de5150"; - let prev_hash = "63d98f536ee68d1b27b5b89f23af5311b7569a24faf1403ad0b52b633b07be99"; - let closed_at = "2024-02-06T17:32:26Z"; - let closed_at_timepoint = 1707240746; - - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - // construct request - let single_ledger_request = SingleLedgerRequest::new().set_sequence(2).unwrap(); - - let single_ledger_response = horizon_client - .get_single_ledger(&single_ledger_request) - .await; - - assert!(single_ledger_response.is_ok()); - let single_ledger_response = single_ledger_response.unwrap(); - assert_eq!(single_ledger_response.id(), id); - assert_eq!(single_ledger_response.paging_token(), "8589934592"); - assert_eq!(single_ledger_response.hash(), hash); - assert_eq!(single_ledger_response.prev_hash(), prev_hash); - assert_eq!(single_ledger_response.sequence(), &2); - assert_eq!(single_ledger_response.successful_transaction_count(), &0); - assert_eq!(single_ledger_response.failed_transaction_count(), &0); - assert_eq!(single_ledger_response.operation_count(), &0); - assert_eq!(single_ledger_response.tx_set_operation_count(), &0); - assert_eq!(single_ledger_response.closed_at(), closed_at); - assert_eq!(single_ledger_response.total_coins(), "100000000000.0000000"); - assert_eq!(single_ledger_response.fee_pool(), "0.0000000"); - assert_eq!(single_ledger_response.base_fee_in_stroops(), &100); - assert_eq!(single_ledger_response.base_reserve_in_stroops(), &100000000); - assert_eq!(single_ledger_response.max_tx_set_size(), &100); - assert_eq!(single_ledger_response.protocol_version(), &0); - - let decoded_xdr_header = single_ledger_response.decoded_header_xdr().unwrap(); - - assert_eq!( - decoded_xdr_header.bucket_list_hash.to_string(), - "735227ed398461291237687b08446aa2c9b096e0c98a462dadda569f05dd2484" - ); - - assert_eq!(decoded_xdr_header.ledger_seq, 2); - assert_eq!(decoded_xdr_header.total_coins, 1000000000000000000); - assert_eq!(decoded_xdr_header.fee_pool, 0); - assert_eq!(decoded_xdr_header.inflation_seq, 0); - assert_eq!(decoded_xdr_header.id_pool, 0); - assert_eq!(decoded_xdr_header.base_fee, 100); - assert_eq!(decoded_xdr_header.base_reserve, 100000000); - assert_eq!(decoded_xdr_header.max_tx_set_size, 100); - - let tx_set_hash = decoded_xdr_header.scp_value.tx_set_hash.to_string(); - let tx_set_hash_bytes = hex::decode(tx_set_hash.clone()).expect("Failed to decode hex"); - let tx_set_hash_base64 = general_purpose::STANDARD.encode(tx_set_hash_bytes.clone()); - - assert_eq!( - tx_set_hash_base64, - "uZRHr9UdXKbTKiclfOjy72YZFJUkJPVcKT5htvorm1Q=" - ); - - assert_eq!( - decoded_xdr_header.scp_value.close_time, - stellar_xdr::curr::TimePoint(closed_at_timepoint) - ); - - assert_eq!( - decoded_xdr_header.ext, - stellar_xdr::curr::LedgerHeaderExt::V0 - ); - for decoded in decoded_xdr_header.skip_list { - assert_eq!( - decoded.to_string(), - "0000000000000000000000000000000000000000000000000000000000000000" - ); - } - } - - #[tokio::test] - async fn test_get_all_claimable_balances() { - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - // construct request - let all_claimable_balances_request = - AllClaimableBalancesRequest::new().set_limit(4).unwrap(); - - let all_claimable_balances_response = horizon_client - .get_all_claimable_balances(&all_claimable_balances_request) - .await; - - assert!(all_claimable_balances_response.is_ok()); - - let binding = all_claimable_balances_response.unwrap(); - let predicate = binding.embedded().records()[1].claimants()[0].predicate(); - - let jan_first_2024 = Utc::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(); - let valid_date = Utc::with_ymd_and_hms(&Utc, 2024, 2, 10, 0, 0, 0).unwrap(); - - assert_eq!(predicate.is_valid(jan_first_2024), true); - assert_eq!(predicate.is_valid(valid_date), true); - let record = &binding.embedded().records()[0]; - - assert_eq!( - record.id(), - "000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" - ); - - assert_eq!( - record.asset(), - "USDC:GAKNDFRRWA3RPWNLTI3G4EBSD3RGNZZOY5WKWYMQ6CQTG3KIEKPYWAYC" - ); - - assert_eq!(record.amount(), "0.0010000"); - - assert_eq!( - record.sponsor(), - "GCENYNAX2UCY5RFUKA7AYEXKDIFITPRAB7UYSISCHVBTIAKPU2YO57OA" - ); - - assert_eq!(record.last_modified_ledger(), &591); - - assert_eq!( - record.last_modified_time().to_string(), - "2024-02-06T18:25:07Z" - ); - - assert_eq!(record.flags().clawback_enabled(), &false); - } - - #[tokio::test] - async fn test_get_single_claimable_balance() { - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - let single_claimable_balance_request = SingleClaimableBalanceRequest::new() - .set_claimable_balance_id( - "000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" - .to_string(), - ); - - let single_claimable_balance_response = horizon_client - .get_single_claimable_balance(&single_claimable_balance_request) - .await; - - assert!(single_claimable_balance_response.is_ok()); - - let binding = single_claimable_balance_response.clone().unwrap(); - let predicate = binding.claimants()[0].predicate(); - - let jan_first_2024 = Utc::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(); - let valid_date = Utc::with_ymd_and_hms(&Utc, 2024, 2, 10, 0, 0, 0).unwrap(); - - assert_eq!(predicate.is_valid(jan_first_2024), true); - assert_eq!(predicate.is_valid(valid_date), true); - - let single_claimable_balance_response = single_claimable_balance_response.unwrap(); - assert_eq!( - single_claimable_balance_response.id().to_string(), - "000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" - ); - - assert_eq!( - single_claimable_balance_response.asset().to_string(), - "USDC:GAKNDFRRWA3RPWNLTI3G4EBSD3RGNZZOY5WKWYMQ6CQTG3KIEKPYWAYC" - ); - - assert_eq!( - single_claimable_balance_response.amount().to_string(), - "0.0010000" - ); - - assert_eq!( - single_claimable_balance_response.sponsor().to_string(), - "GCENYNAX2UCY5RFUKA7AYEXKDIFITPRAB7UYSISCHVBTIAKPU2YO57OA" - ); - - assert_eq!( - single_claimable_balance_response.last_modified_ledger(), - &591 - ); - - assert_eq!( - single_claimable_balance_response - .last_modified_time() - .to_string(), - "2024-02-06T18:25:07Z" - ); - - assert_eq!( - single_claimable_balance_response.flags().clawback_enabled(), - &false - ); - - assert_eq!( - single_claimable_balance_response.paging_token().to_string(), - "591-000000000a12cd57c169a34e7794bdcdf2d093fab135c59ea599e2d1233d7a53f26c1464" - ); - } - - #[tokio::test] - async fn test_get_all_effects() { - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - let num_records_to_fetch = 2; - - let all_effects_request = AllEffectsRequest::new() - .set_limit(num_records_to_fetch) - .unwrap(); - let _all_effects_response = horizon_client.get_all_effects(&all_effects_request).await; - - assert!(_all_effects_response.clone().is_ok()); - - // make sure there are actually 2 records - assert_eq!( - _all_effects_response - .clone() - .unwrap() - .embedded() - .records() - .len() as u8, - num_records_to_fetch - ); - - // test first record retrieved - assert_eq!( - _all_effects_response.clone().unwrap().embedded().records()[0].type_i, - 0 - ); - - // test second record retrieved - assert_eq!( - _all_effects_response.clone().unwrap().embedded().records()[1].type_i, - 3 - ); - } - - #[tokio::test] - async fn test_get_effects_for_account() { - const ID: &str = "0000000459561504769-0000000001"; - const PAGING_TOKEN: &str = "459561504769-1"; - const ACCOUNT: &str = "GAIH3ULLFQ4DGSECF2AR555KZ4KNDGEKN4AFI4SU2M7B43MGK3QJZNSR"; - const RECORD_TYPE: &str = "account_created"; - const TYPE_I: u32 = 0; - const CREATED_AT: &str = "2024-02-06T17:42:48Z"; - const STARTING_BALANCE: &str = "10000000000.0000000"; - // Initialize horizon client - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - let effects_for_account_request = EffectsForAccountRequest::new().set_limit(2).unwrap(); - - let effects_for_account_response = horizon_client - .get_effects_for_account(&effects_for_account_request) - .await; - - assert!(&effects_for_account_response.is_ok()); - let binding = effects_for_account_response.clone().unwrap(); - let record = &binding.embedded().records()[0]; - - assert_eq!(record.id(), ID); - assert_eq!(record.paging_token(), PAGING_TOKEN); - assert_eq!(record.account(), ACCOUNT); - assert_eq!(record.effect_type(), RECORD_TYPE); - assert_eq!(record.type_i(), &TYPE_I); - assert_eq!(record.created_at(), CREATED_AT); - assert_eq!( - record.starting_balance().as_ref().unwrap(), - &STARTING_BALANCE - ); - } - - #[tokio::test] - async fn get_effects_for_liquidity_pools() { - const ID: &str = "0000000459561504769-0000000001"; - const PAGING_TOKEN: &str = "459561504769-1"; - const ACCOUNT: &str = "GAIH3ULLFQ4DGSECF2AR555KZ4KNDGEKN4AFI4SU2M7B43MGK3QJZNSR"; - const RECORD_TYPE: &str = "account_created"; - const TYPE_I: u32 = 0; - const CREATED_AT: &str = "2024-02-06T17:42:48Z"; - const STARTING_BALANCE: &str = "10000000000.0000000"; - - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - let effects_for_liquidity_pools_request = - EffectsForLiquidityPoolRequest::new().set_limit(2).unwrap(); - let effects_for_liquidity_pools_response = horizon_client - .get_effects_for_liquidity_pools(&effects_for_liquidity_pools_request) - .await; - - assert!(effects_for_liquidity_pools_response.is_ok()); - let binding = effects_for_liquidity_pools_response.clone().unwrap(); - let record = &binding.embedded().records()[0]; - - assert_eq!(record.id(), ID); - assert_eq!(record.paging_token(), PAGING_TOKEN); - assert_eq!(record.account(), ACCOUNT); - assert_eq!(record.effect_type(), RECORD_TYPE); - assert_eq!(record.type_i(), &TYPE_I); - assert_eq!(record.created_at(), CREATED_AT); - assert_eq!( - record.starting_balance().as_ref().unwrap(), - &STARTING_BALANCE - ); - - // TODO: LEONARD FIX - let _effects_for_liquidity_pools_request_with_id = EffectsForLiquidityPoolRequest::new() - .set_limit(2) - .expect("REASON") - .set_liquidity_pool_id("0000000459561504769-0000000001".to_string()); - let effects_for_liquidity_pools_response = horizon_client - .get_effects_for_liquidity_pools(&effects_for_liquidity_pools_request) - .await; - - assert!(effects_for_liquidity_pools_response.clone().is_ok()); - assert_eq!( - effects_for_liquidity_pools_response - .clone() - .unwrap() - .embedded() - .records()[0] - .id(), - ID - ); - } - - #[tokio::test] - async fn test_get_effects_for_ledger() { - // found by trial and error in the Stellar laboratory - let ledger_sequence = 125; - - let horizon_client = - HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); - - let effects_for_ledger_request = - EffectsForLedgerRequest::new().set_sequence(ledger_sequence); - let effects_for_ledger_response = horizon_client - .get_effects_for_ledger(&effects_for_ledger_request) - .await; - - assert!(effects_for_ledger_response.is_ok()); - - assert_eq!( - effects_for_ledger_response - .clone() - .unwrap() - .embedded() - .records()[0] - .id, - "0000000536870916097-0000000001" - ); - - assert_eq!( - effects_for_ledger_response - .clone() - .unwrap() - .embedded() - .records()[1] - .effect_type, - "account_debited" - ); - } } diff --git a/src/ledgers/mod.rs b/src/ledgers/mod.rs index ecdc63b..394c4af 100644 --- a/src/ledgers/mod.rs +++ b/src/ledgers/mod.rs @@ -82,3 +82,115 @@ pub mod prelude { pub use super::single_ledger_request::*; } +#[cfg(test)] +pub mod tests { + use super::prelude::*; + use crate::horizon_client::HorizonClient; + use base64::{engine::general_purpose, Engine}; + + #[tokio::test] + async fn test_get_all_ledgers() { + let hash = "f96c4021adc1ae496c662f4f97143e499a9548f541c64bb2401a1b1701de5150"; + let prev_hash = "63d98f536ee68d1b27b5b89f23af5311b7569a24faf1403ad0b52b633b07be99"; + + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + // construct request + let all_ledgers_request = LedgersRequest::new().set_limit(2).unwrap(); + + let all_ledgers_response = horizon_client.get_all_ledgers(&all_ledgers_request).await; + assert!(all_ledgers_response.is_ok()); + + let binding = all_ledgers_response.unwrap(); + let all_ledgers_response = &binding.embedded().records()[0]; + + assert_eq!(all_ledgers_response.hash(), hash); + assert_eq!(all_ledgers_response.prev_hash(), prev_hash); + assert_eq!(all_ledgers_response.sequence(), &2); + assert_eq!(all_ledgers_response.successful_transaction_count(), &0); + assert_eq!(all_ledgers_response.paging_token(), "8589934592"); + } + + #[tokio::test] + async fn test_get_single_ledger() { + let id = "f96c4021adc1ae496c662f4f97143e499a9548f541c64bb2401a1b1701de5150"; + let hash = "f96c4021adc1ae496c662f4f97143e499a9548f541c64bb2401a1b1701de5150"; + let prev_hash = "63d98f536ee68d1b27b5b89f23af5311b7569a24faf1403ad0b52b633b07be99"; + let closed_at = "2024-02-06T17:32:26Z"; + let closed_at_timepoint = 1707240746; + + // Initialize horizon client + let horizon_client = + HorizonClient::new("https://horizon-testnet.stellar.org".to_string()).unwrap(); + + // construct request + let single_ledger_request = SingleLedgerRequest::new().set_sequence(2).unwrap(); + + let single_ledger_response = horizon_client + .get_single_ledger(&single_ledger_request) + .await; + + assert!(single_ledger_response.is_ok()); + let single_ledger_response = single_ledger_response.unwrap(); + assert_eq!(single_ledger_response.id(), id); + assert_eq!(single_ledger_response.paging_token(), "8589934592"); + assert_eq!(single_ledger_response.hash(), hash); + assert_eq!(single_ledger_response.prev_hash(), prev_hash); + assert_eq!(single_ledger_response.sequence(), &2); + assert_eq!(single_ledger_response.successful_transaction_count(), &0); + assert_eq!(single_ledger_response.failed_transaction_count(), &0); + assert_eq!(single_ledger_response.operation_count(), &0); + assert_eq!(single_ledger_response.tx_set_operation_count(), &0); + assert_eq!(single_ledger_response.closed_at(), closed_at); + assert_eq!(single_ledger_response.total_coins(), "100000000000.0000000"); + assert_eq!(single_ledger_response.fee_pool(), "0.0000000"); + assert_eq!(single_ledger_response.base_fee_in_stroops(), &100); + assert_eq!(single_ledger_response.base_reserve_in_stroops(), &100000000); + assert_eq!(single_ledger_response.max_tx_set_size(), &100); + assert_eq!(single_ledger_response.protocol_version(), &0); + + let decoded_xdr_header = single_ledger_response.decoded_header_xdr().unwrap(); + + assert_eq!( + decoded_xdr_header.bucket_list_hash.to_string(), + "735227ed398461291237687b08446aa2c9b096e0c98a462dadda569f05dd2484" + ); + + assert_eq!(decoded_xdr_header.ledger_seq, 2); + assert_eq!(decoded_xdr_header.total_coins, 1000000000000000000); + assert_eq!(decoded_xdr_header.fee_pool, 0); + assert_eq!(decoded_xdr_header.inflation_seq, 0); + assert_eq!(decoded_xdr_header.id_pool, 0); + assert_eq!(decoded_xdr_header.base_fee, 100); + assert_eq!(decoded_xdr_header.base_reserve, 100000000); + assert_eq!(decoded_xdr_header.max_tx_set_size, 100); + + let tx_set_hash = decoded_xdr_header.scp_value.tx_set_hash.to_string(); + let tx_set_hash_bytes = hex::decode(tx_set_hash.clone()).expect("Failed to decode hex"); + let tx_set_hash_base64 = general_purpose::STANDARD.encode(tx_set_hash_bytes.clone()); + + assert_eq!( + tx_set_hash_base64, + "uZRHr9UdXKbTKiclfOjy72YZFJUkJPVcKT5htvorm1Q=" + ); + + assert_eq!( + decoded_xdr_header.scp_value.close_time, + stellar_xdr::curr::TimePoint(closed_at_timepoint) + ); + + assert_eq!( + decoded_xdr_header.ext, + stellar_xdr::curr::LedgerHeaderExt::V0 + ); + for decoded in decoded_xdr_header.skip_list { + assert_eq!( + decoded.to_string(), + "0000000000000000000000000000000000000000000000000000000000000000" + ); + } + } +} + diff --git a/src/lib.rs b/src/lib.rs index e7ebba7..22f302f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -372,4 +372,3 @@ impl BuildQueryParametersExt> for Vec> { } } } -