Cargo fmt

Author: elizabethengelman

cmd/crates/soroban-test/tests/it/integration.rs

@@ -6,8 +6,8 @@ mod dotenv;
 mod hello_world;
 mod init;
 mod keys;
-mod secure_store;
 mod ledger;
+mod secure_store;
 mod snapshot;
 mod tx;
 mod util;

cmd/crates/soroban-test/tests/it/integration/ledger/entry.rs

@@ -1,20 +1,21 @@
-use soroban_test::AssertExt;
-use soroban_test::TestEnv;
-use soroban_rpc::FullLedgerEntries;
-use soroban_cli::xdr::{LedgerKey, LedgerKeyTrustLine, LedgerKeyAccount, PublicKey, Uint256, AccountId, LedgerKeyData, LedgerEntryData, AssetCode4, AlphaNum4, TrustLineAsset, LedgerKeyContractData, ScVal, ScAddress, StringM, String64, Hash,  ContractDataDurability, WriteXdr, Limits, LedgerKeyContractCode, ConfigSettingId, LedgerKeyConfigSetting};
-use stellar_strkey::{
-    ed25519::PublicKey as StrkeyPublicKeyEd25519,
-    Contract
+use soroban_cli::xdr::{
+    AccountId, AlphaNum4, AssetCode4, ConfigSettingId, ContractDataDurability, Hash,
+    LedgerEntryData, LedgerKey, LedgerKeyAccount, LedgerKeyConfigSetting, LedgerKeyContractCode,
+    LedgerKeyContractData, LedgerKeyData, LedgerKeyTrustLine, Limits, PublicKey, ScAddress, ScVal,
+    String64, StringM, TrustLineAsset, Uint256, WriteXdr,
 };
+use soroban_rpc::FullLedgerEntries;
 use soroban_spec_tools::utils::padded_hex_from_str;
+use soroban_test::AssertExt;
+use soroban_test::TestEnv;
+use stellar_strkey::{ed25519::PublicKey as StrkeyPublicKeyEd25519, Contract};
 
-use crate::integration::util::{deploy_contract, test_address, HELLO_WORLD, DeployOptions};
-
+use crate::integration::util::{deploy_contract, test_address, DeployOptions, HELLO_WORLD};
 
 // account data tests
 // todo: test with--offer,
 #[tokio::test]
-async fn ledger_entry_account_only(){
+async fn ledger_entry_account_only() {
     let sandbox = &TestEnv::new();
     let account_alias = "new_account";
     let new_account_addr = new_account(sandbox, account_alias);
@@ -35,11 +36,14 @@ async fn ledger_entry_account_only(){
 
     assert!(!parsed.entries.is_empty());
     assert_eq!(parsed.entries[0].key, expected_key);
-    assert!(matches!(parsed.entries[0].val, LedgerEntryData::Account { .. }));
+    assert!(matches!(
+        parsed.entries[0].val,
+        LedgerEntryData::Account { .. }
+    ));
 }
 
 #[tokio::test]
-async fn ledger_entry_account_asset_xlm(){
+async fn ledger_entry_account_asset_xlm() {
     let sandbox = &TestEnv::new();
     let account_alias = "new_account";
     let new_account_addr = new_account(sandbox, account_alias);
@@ -53,7 +57,7 @@ async fn ledger_entry_account_asset_xlm(){
         .arg(account_alias)
         .arg("--asset")
         // though xlm does not have, nor need, a trustline, "xlm" is a valid argument to `--asset`
-        // this test is including it to make sure that the account ledger entry is still included in the output 
+        // this test is including it to make sure that the account ledger entry is still included in the output
         .arg("xlm")
         .assert()
         .success()
@@ -64,11 +68,14 @@ async fn ledger_entry_account_asset_xlm(){
     let parsed: FullLedgerEntries = serde_json::from_str(&output).expect("Failed to parse JSON");
     assert!(!parsed.entries.is_empty());
     assert_eq!(parsed.entries[0].key, expected_key);
-    assert!(matches!(parsed.entries[0].val, LedgerEntryData::Account { .. }));
+    assert!(matches!(
+        parsed.entries[0].val,
+        LedgerEntryData::Account { .. }
+    ));
 }
 
 #[tokio::test]
-async fn ledger_entry_account_asset_usdc(){
+async fn ledger_entry_account_asset_usdc() {
     let sandbox = &TestEnv::new();
     let test_account_alias = "test";
     let test_account_address = test_address(sandbox);
@@ -77,7 +84,14 @@ async fn ledger_entry_account_asset_usdc(){
     let asset = &format!("usdc:{issuer_address}");
     let limit = 100_000;
     let initial_balance = 100;
-    issue_asset(sandbox, &test_account_address, asset, limit, initial_balance).await;
+    issue_asset(
+        sandbox,
+        &test_account_address,
+        asset,
+        limit,
+        initial_balance,
+    )
+    .await;
 
     let output = sandbox
         .new_assert_cmd("ledger")
@@ -93,7 +107,8 @@ async fn ledger_entry_account_asset_usdc(){
         .success()
         .stdout_as_str();
 
-    let (account_id, expected_account_key) = expected_account_ledger_key(&test_account_address).await;
+    let (account_id, expected_account_key) =
+        expected_account_ledger_key(&test_account_address).await;
     let (issuer_account_id, _) = expected_account_ledger_key(&issuer_address).await;
 
     let trustline_asset = TrustLineAsset::CreditAlphanum4(AlphaNum4 {
@@ -110,7 +125,10 @@ async fn ledger_entry_account_asset_usdc(){
 
     let trustline_entry = &parsed.entries[0];
     assert_eq!(trustline_entry.key, expected_trustline_key);
-    assert!(matches!(trustline_entry.val, LedgerEntryData::Trustline { .. }));
+    assert!(matches!(
+        trustline_entry.val,
+        LedgerEntryData::Trustline { .. }
+    ));
 
     let account_entry = &parsed.entries[1];
     assert_eq!(account_entry.key, expected_account_key);
@@ -124,7 +142,7 @@ async fn ledger_entry_account_data() {
     let new_account_addr = new_account(sandbox, account_alias);
     let data_name = "test_data_key";
     add_account_data(sandbox, account_alias, data_name, "abcdef").await;
- 
+
     let output = sandbox
         .new_assert_cmd("ledger")
         .arg("entry")
@@ -170,10 +188,13 @@ async fn ledger_entry_contract_data() {
             deployer: Some(test_account_alias.to_string()),
             ..Default::default()
         },
-    ).await;
+    )
+    .await;
 
     let storage_key = "COUNTER";
-    let storage_key_xdr = ScVal::Symbol(storage_key.try_into().unwrap()).to_xdr_base64(Limits::none()).unwrap();
+    let storage_key_xdr = ScVal::Symbol(storage_key.try_into().unwrap())
+        .to_xdr_base64(Limits::none())
+        .unwrap();
 
     // update contract storage
     sandbox
@@ -195,9 +216,10 @@ async fn ledger_entry_contract_data() {
         .assert()
         .success()
         .stdout_as_str();
-    let parsed_key_output: FullLedgerEntries = serde_json::from_str(&key_output).expect("Failed to parse JSON");
+    let parsed_key_output: FullLedgerEntries =
+        serde_json::from_str(&key_output).expect("Failed to parse JSON");
     assert!(!parsed_key_output.entries.is_empty());
-    
+
     // get entry by key xdr
     let key_xdr_output = sandbox
         .new_assert_cmd("ledger")
@@ -213,22 +235,31 @@ async fn ledger_entry_contract_data() {
         .success()
         .stdout_as_str();
 
-    let parsed_key_xdr_output: FullLedgerEntries = serde_json::from_str(&key_xdr_output).expect("Failed to parse JSON");
+    let parsed_key_xdr_output: FullLedgerEntries =
+        serde_json::from_str(&key_xdr_output).expect("Failed to parse JSON");
     assert!(!parsed_key_xdr_output.entries.is_empty());
 
     let expected_contract_data_key = expected_contract_ledger_key(&contract_id, storage_key).await;
 
     assert_eq!(parsed_key_output.entries[0].key, expected_contract_data_key);
-    assert!(matches!(parsed_key_output.entries[0].val, LedgerEntryData::ContractData{ .. }));
+    assert!(matches!(
+        parsed_key_output.entries[0].val,
+        LedgerEntryData::ContractData { .. }
+    ));
+
+    assert_eq!(
+        parsed_key_xdr_output.entries[0].key,
+        expected_contract_data_key
+    );
+    assert!(matches!(
+        parsed_key_xdr_output.entries[0].val,
+        LedgerEntryData::ContractData { .. }
+    ));
 
-    assert_eq!(parsed_key_xdr_output.entries[0].key, expected_contract_data_key);
-    assert!(matches!(parsed_key_xdr_output.entries[0].val, LedgerEntryData::ContractData{ .. }));
-    
     // the output should be the same regardless of key format
     assert_eq!(parsed_key_output.entries, parsed_key_xdr_output.entries);
 }
 
-
 // top level test
 // todo: test --ttl, --claimable-id, --pool-id,
 #[tokio::test]
@@ -237,7 +268,8 @@ async fn ledger_entry_wasm_hash() {
     let test_account_alias = "test";
     let wasm = HELLO_WORLD;
     let wasm_path = wasm.path();
-    let contract_wasm_hash = sandbox.new_assert_cmd("contract")
+    let contract_wasm_hash = sandbox
+        .new_assert_cmd("contract")
         .arg("upload")
         .arg("--wasm")
         .arg(wasm_path)
@@ -252,7 +284,8 @@ async fn ledger_entry_wasm_hash() {
             deployer: Some(test_account_alias.to_string()),
             ..Default::default()
         },
-    ).await;
+    )
+    .await;
 
     // get the contract's wasm bytecode
     let output = sandbox
@@ -266,21 +299,28 @@ async fn ledger_entry_wasm_hash() {
         .assert()
         .success()
         .stdout_as_str();
-    let parsed_output: FullLedgerEntries = serde_json::from_str(&output).expect("Failed to parse JSON");
+    let parsed_output: FullLedgerEntries =
+        serde_json::from_str(&output).expect("Failed to parse JSON");
     assert!(!parsed_output.entries.is_empty());
-    
-    let hash = Hash(padded_hex_from_str(&contract_wasm_hash, 32).unwrap().try_into().unwrap());
-    let expected_contract_key = LedgerKey::ContractCode(LedgerKeyContractCode {
-        hash
-    });
+
+    let hash = Hash(
+        padded_hex_from_str(&contract_wasm_hash, 32)
+            .unwrap()
+            .try_into()
+            .unwrap(),
+    );
+    let expected_contract_key = LedgerKey::ContractCode(LedgerKeyContractCode { hash });
 
     assert_eq!(parsed_output.entries[0].key, expected_contract_key);
-    assert!(matches!(parsed_output.entries[0].val, LedgerEntryData::ContractCode{ .. }));
+    assert!(matches!(
+        parsed_output.entries[0].val,
+        LedgerEntryData::ContractCode { .. }
+    ));
     // key: ContractCode(LedgerKeyContractCode { hash: Hash(74a0a58bee2730d38dfaa547c0f3e64b1b76cf7d7e430373a9bf7aad122aff9f) }
 
     // assert_eq!(parsed_key_xdr_output.entries[0].key, expected_contract_data_key);
     // assert!(matches!(parsed_key_xdr_output.entries[0].val, LedgerEntryData::ContractData{ .. }));
-    
+
     // // the output should be the same regardless of key format
     // assert_eq!(parsed_key_output.entries, parsed_key_xdr_output.entries);
 }
@@ -301,21 +341,22 @@ async fn ledger_entry_config_setting_id() {
             .arg((config_setting_variant as i32).to_string())
             .assert()
             .success()
-            .stdout_as_str(); 
-        let parsed_output: FullLedgerEntries = serde_json::from_str(&output).expect("Failed to parse JSON");
+            .stdout_as_str();
+        let parsed_output: FullLedgerEntries =
+            serde_json::from_str(&output).expect("Failed to parse JSON");
         assert!(!parsed_output.entries.is_empty());
 
-        let expected_key = LedgerKey::ConfigSetting(
-            LedgerKeyConfigSetting{
-                config_setting_id: config_setting_variant,
-            }
-        );
+        let expected_key = LedgerKey::ConfigSetting(LedgerKeyConfigSetting {
+            config_setting_id: config_setting_variant,
+        });
         assert_eq!(parsed_output.entries[0].key, expected_key);
-        assert!(matches!(parsed_output.entries[0].val, LedgerEntryData::ConfigSetting{ .. }));
+        assert!(matches!(
+            parsed_output.entries[0].val,
+            LedgerEntryData::ConfigSetting { .. }
+        ));
     }
 }
 
-
 #[ignore]
 #[tokio::test]
 async fn ledger_entry_ttl() {
@@ -328,10 +369,13 @@ async fn ledger_entry_ttl() {
             deployer: Some(test_account_alias.to_string()),
             ..Default::default()
         },
-    ).await;
+    )
+    .await;
 
     let storage_key = "COUNTER";
-    let storage_key_xdr = ScVal::Symbol(storage_key.try_into().unwrap()).to_xdr_base64(Limits::none()).unwrap();
+    let storage_key_xdr = ScVal::Symbol(storage_key.try_into().unwrap())
+        .to_xdr_base64(Limits::none())
+        .unwrap();
     println!("storage key: {}", storage_key_xdr);
 
     // update contract storage
@@ -352,9 +396,10 @@ async fn ledger_entry_ttl() {
         .assert()
         .success()
         .stdout_as_str();
-    let parsed_output: FullLedgerEntries = serde_json::from_str(&output).expect("Failed to parse JSON");
+    let parsed_output: FullLedgerEntries =
+        serde_json::from_str(&output).expect("Failed to parse JSON");
     assert!(!parsed_output.entries.is_empty());
-    
+
     // let parsed_key_xdr_output: FullLedgerEntries = serde_json::from_str(&key_xdr_output).expect("Failed to parse JSON");
     // assert!(!parsed_key_xdr_output.entries.is_empty());
 
@@ -365,7 +410,7 @@ async fn ledger_entry_ttl() {
 
     // assert_eq!(parsed_key_xdr_output.entries[0].key, expected_contract_data_key);
     // assert!(matches!(parsed_key_xdr_output.entries[0].val, LedgerEntryData::ContractData{ .. }));
-    
+
     // // the output should be the same regardless of key format
     // assert_eq!(parsed_key_output.entries, parsed_key_xdr_output.entries);
 }
@@ -374,7 +419,7 @@ async fn ledger_entry_ttl() {
 fn new_account(sandbox: &TestEnv, name: &str) -> String {
     sandbox.generate_account(name, None).assert().success();
     sandbox.fund_account(name).success();
-    
+
     sandbox
         .new_assert_cmd("keys")
         .args(["address", name])
@@ -442,39 +487,41 @@ async fn issue_asset(sandbox: &TestEnv, test: &str, asset: &str, limit: u64, ini
         .success();
 }
 
-async fn expected_account_ledger_key(account_addr: &str) -> (AccountId, LedgerKey){
+async fn expected_account_ledger_key(account_addr: &str) -> (AccountId, LedgerKey) {
     let strkey = StrkeyPublicKeyEd25519::from_string(account_addr).unwrap().0;
 
     let uint256 = Uint256(strkey);
     let pk = PublicKey::PublicKeyTypeEd25519(uint256);
     let account_id = AccountId(pk);
-    let ledger_key = LedgerKey::Account(LedgerKeyAccount { account_id: account_id.clone() });
+    let ledger_key = LedgerKey::Account(LedgerKeyAccount {
+        account_id: account_id.clone(),
+    });
     (account_id, ledger_key)
 }
 
-async fn expected_contract_ledger_key(contract_id: &str, storage_key: &str) -> LedgerKey{
+async fn expected_contract_ledger_key(contract_id: &str, storage_key: &str) -> LedgerKey {
     let contract_bytes: [u8; 32] = Contract::from_string(contract_id).unwrap().0;
     let contract_id = Hash(contract_bytes);
-    LedgerKey::ContractData(LedgerKeyContractData { 
+    LedgerKey::ContractData(LedgerKeyContractData {
         contract: ScAddress::Contract(contract_id),
         key: ScVal::Symbol(storage_key.try_into().unwrap()),
-        durability: ContractDataDurability::Persistent}
-    )
+        durability: ContractDataDurability::Persistent,
+    })
 }
 
 async fn add_account_data(sandbox: &TestEnv, account_alias: &str, key: &str, value: &str) {
     sandbox
-    .new_assert_cmd("tx")
-    .args([
-        "new",
-        "manage-data",
-        "--data-name",
-        key,
-        "--data-value",
-        value,
-        "--source",
-        account_alias,
-    ])
-    .assert()
-    .success(); 
-}
+        .new_assert_cmd("tx")
+        .args([
+            "new",
+            "manage-data",
+            "--data-name",
+            key,
+            "--data-value",
+            value,
+            "--source",
+            account_alias,
+        ])
+        .assert()
+        .success();
+}