Merge pull request #529 from hashgraph/sr/e2e-tests

Author: mehcode

Cargo.lock

@@ -95,7 +95,7 @@ parking_lot = "0.12.0"
 
 [dev-dependencies.tokio]
 version = "1.24.2"
-features = ["rt-multi-thread", "macros"]
+features = ["rt-multi-thread", "macros", "parking_lot"]
 
 [dev-dependencies.env_logger]
 version = "0.10.0"

Cargo.toml

@@ -68,17 +68,6 @@ pub enum Error {
         transaction_id: Box<TransactionId>,
     },
 
-    /// A transaction failed pre-check.
-    ///
-    /// The transaction had no `transaction_id`.
-    ///
-    /// Caused by `status` being an error.
-    #[error("transaction without transaction id failed pre-check with status `{status:?}`")]
-    TransactionNoIdPreCheckStatus {
-        /// The `Status` that caused the [`Transaction`](crate::Transaction) to fail pre-check.
-        status: Status,
-    },
-
     /// A [`Query`](crate::Query) for `transaction_id` failed pre-check.
     ///
     /// Caused by `status` being an error.

src/error.rs

@@ -227,8 +227,8 @@ where
     let mut transaction_id = executable
         .requires_transaction_id()
         .then_some(explicit_transaction_id)
-        .flatten()
-        .or_else(|| ctx.operator_account_id.map(TransactionId::generate));
+        .map(|it| it.or_else(|| ctx.operator_account_id.map(TransactionId::generate)))
+        .flatten();
 
     // if we were explicitly given a list of nodes to use, we iterate through each
     // of the given nodes (in a random order)

src/execute.rs

@@ -200,13 +200,11 @@ where
         status: services::ResponseCodeEnum,
         transaction_id: Option<&TransactionId>,
     ) -> crate::Error {
-        if let Some(transaction_id) = transaction_id {
-            crate::Error::TransactionPreCheckStatus {
-                status,
-                transaction_id: Box::new(*transaction_id),
-            }
-        } else {
-            crate::Error::TransactionNoIdPreCheckStatus { status }
+        crate::Error::TransactionPreCheckStatus {
+            status,
+            transaction_id: Box::new(
+                *transaction_id.expect("transactions must have transaction IDs"),
+            ),
         }
     }
 
@@ -304,13 +302,11 @@ where
         status: services::ResponseCodeEnum,
         transaction_id: Option<&TransactionId>,
     ) -> crate::Error {
-        if let Some(transaction_id) = transaction_id {
-            crate::Error::TransactionPreCheckStatus {
-                status,
-                transaction_id: Box::new(*transaction_id),
-            }
-        } else {
-            crate::Error::TransactionNoIdPreCheckStatus { status }
+        crate::Error::TransactionPreCheckStatus {
+            status,
+            transaction_id: Box::new(
+                *transaction_id.expect("transactions must have transaction IDs"),
+            ),
         }
     }
 

src/transaction/chunked.rs

@@ -232,13 +232,11 @@ where
         status: crate::Status,
         transaction_id: Option<&TransactionId>,
     ) -> crate::Error {
-        if let Some(transaction_id) = transaction_id {
-            crate::Error::TransactionPreCheckStatus {
-                status,
-                transaction_id: Box::new(*transaction_id),
-            }
-        } else {
-            crate::Error::TransactionNoIdPreCheckStatus { status }
+        crate::Error::TransactionPreCheckStatus {
+            status,
+            transaction_id: Box::new(
+                *transaction_id.expect("transactions must have transaction IDs"),
+            ),
         }
     }
 

src/transaction/execute.rs

@@ -0,0 +1,54 @@
+use hedera::{
+    AccountAllowanceApproveTransaction,
+    Hbar,
+    TransactionId,
+    TransferTransaction,
+};
+
+use crate::account::Account;
+use crate::common::{
+    setup_nonfree,
+    TestEnvironment,
+};
+
+#[tokio::test]
+async fn spend() -> anyhow::Result<()> {
+    let Some(TestEnvironment { config: _, client }) = setup_nonfree() else {
+        return Ok(());
+    };
+
+    let (alice, bob) = tokio::try_join!(
+        Account::create(Hbar::new(10), &client),
+        Account::create(Hbar::new(10), &client)
+    )?;
+
+    AccountAllowanceApproveTransaction::new()
+        .approve_hbar_allowance(bob.id, alice.id, Hbar::new(10))
+        .freeze_with(&client)?
+        .sign(bob.key.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    let transfer_record = TransferTransaction::new()
+        .hbar_transfer(client.get_operator_account_id().unwrap(), Hbar::new(5))
+        .approved_hbar_transfer(bob.id, Hbar::new(-5))
+        .transaction_id(TransactionId::generate(alice.id))
+        .freeze_with(&client)?
+        .sign(alice.key.clone())
+        .execute(&client)
+        .await?
+        .get_record(&client)
+        .await?;
+
+    assert!(transfer_record
+        .transfers
+        .iter()
+        .any(|it| it.account_id == client.get_operator_account_id().unwrap()
+            && it.amount == Hbar::new(5)));
+
+    let _ = tokio::try_join!(alice.delete(&client), bob.delete(&client))?;
+
+    Ok(())
+}

tests/e2e/account/allowance_approve.rs

@@ -0,0 +1,202 @@
+// todo(network tls):
+// - canConnectToPreviewnetWithTLS
+// - canConnectToTestnetWithTLS
+// - canConnectToMainnetWithTLS
+// - cannotConnectToPreviewnetWhenNetworkNameIsNullAndCertificateVerificationIsEnabled
+
+use assert_matches::assert_matches;
+use hedera::{
+    AccountBalanceQuery,
+    AccountId,
+    Hbar,
+    Status,
+    TokenBurnTransaction,
+    TokenCreateTransaction,
+    TokenDeleteTransaction,
+};
+use time::{
+    Duration,
+    OffsetDateTime,
+};
+
+use crate::account::Account;
+use crate::common::{
+    setup_global,
+    setup_nonfree,
+    TestEnvironment,
+};
+
+#[tokio::test]
+async fn query() -> anyhow::Result<()> {
+    let TestEnvironment { config, client } = setup_global();
+
+    let Some(op) = &config.operator else {
+        log::debug!("skipping test due to lack of operator");
+
+        return Ok(())
+    };
+
+    let balance = AccountBalanceQuery::new().account_id(op.account_id).execute(&client).await?;
+
+    log::trace!("successfully queried balance: {balance:?}");
+
+    anyhow::ensure!(balance.account_id == op.account_id);
+    anyhow::ensure!(balance.hbars.to_tinybars() > 0);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn query_cost() -> anyhow::Result<()> {
+    let TestEnvironment { config, client } = setup_global();
+
+    let Some(op) = &config.operator else {
+        log::debug!("skipping test due to lack of operator");
+        return Ok(())
+    };
+
+    let mut query = AccountBalanceQuery::new();
+
+    query.account_id(op.account_id).max_payment_amount(Hbar::new(1));
+
+    let cost = query.get_cost(&client).await?;
+
+    assert_eq!(cost, Hbar::ZERO);
+
+    let balance = query.payment_amount(cost).execute(&client).await?;
+
+    anyhow::ensure!(balance.account_id == op.account_id);
+    anyhow::ensure!(balance.hbars.to_tinybars() > 0);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn query_cost_big_max() -> anyhow::Result<()> {
+    let TestEnvironment { config, client } = setup_global();
+
+    let Some(op) = &config.operator else {
+        log::debug!("skipping test due to lack of operator");
+        return Ok(())
+    };
+
+    let mut query = AccountBalanceQuery::new();
+
+    query.account_id(op.account_id).max_payment_amount(Hbar::new(1000000));
+
+    let cost = query.get_cost(&client).await?;
+
+    assert_eq!(cost, Hbar::ZERO);
+
+    let balance = query.payment_amount(cost).execute(&client).await?;
+
+    anyhow::ensure!(balance.account_id == op.account_id);
+    anyhow::ensure!(balance.hbars.to_tinybars() > 0);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn query_cost_small_max() -> anyhow::Result<()> {
+    let TestEnvironment { config, client } = setup_global();
+
+    let Some(op) = &config.operator else {
+        log::debug!("skipping test due to lack of operator");
+        return Ok(())
+    };
+
+    let mut query = AccountBalanceQuery::new();
+
+    query.account_id(op.account_id).max_payment_amount(Hbar::from_tinybars(1));
+
+    let cost = query.get_cost(&client).await?;
+
+    assert_eq!(cost, Hbar::ZERO);
+
+    let balance = query.payment_amount(cost).execute(&client).await?;
+
+    anyhow::ensure!(balance.account_id == op.account_id);
+    anyhow::ensure!(balance.hbars.to_tinybars() > 0);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn invalid_account_id_fails() -> anyhow::Result<()> {
+    let TestEnvironment { config: _, client } = setup_global();
+
+    let res = AccountBalanceQuery::new()
+        .account_id(AccountId {
+            shard: 1,
+            realm: 0,
+            num: 3,
+            alias: None,
+            evm_address: None,
+            checksum: None,
+        })
+        .execute(&client)
+        .await;
+
+    assert_matches!(
+        res,
+        Err(hedera::Error::QueryNoPaymentPreCheckStatus { status: Status::InvalidAccountId })
+    );
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn query_token_balances() -> anyhow::Result<()> {
+    let Some(TestEnvironment { config: _, client }) = setup_nonfree() else {
+        return Ok(())
+    };
+
+    let account = Account::create(Hbar::new(10), &client).await?;
+
+    let token_id = TokenCreateTransaction::new()
+        .name("ffff")
+        .symbol("f")
+        .initial_supply(10000)
+        .decimals(50)
+        .treasury_account_id(account.id)
+        .expiration_time(OffsetDateTime::now_utc() + Duration::minutes(5))
+        .admin_key(account.key.public_key())
+        .supply_key(account.key.public_key())
+        .freeze_default(false)
+        .sign(account.key.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?
+        .token_id
+        .unwrap();
+
+    let balance = AccountBalanceQuery::new().account_id(account.id).execute(&client).await?;
+
+    #[allow(deprecated)]
+    {
+        assert_eq!(balance.tokens.get(&token_id).copied(), Some(10000));
+        assert_eq!(balance.token_decimals.get(&token_id).copied(), Some(50));
+    }
+
+    TokenBurnTransaction::new()
+        .token_id(token_id)
+        .amount(10000_u64)
+        .sign(account.key.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    let _ = TokenDeleteTransaction::new()
+        .token_id(token_id)
+        .sign(account.key.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    account.delete(&client).await?;
+
+    Ok(())
+}