Merge pull request #565 from hashgraph/sr/more-e2e-tests

Author: mehcode

src/token/custom_fees/mod.rs

@@ -63,14 +63,22 @@ pub struct CustomFee<Fee> {
     /// The account to receive the custom fee.
     pub fee_collector_account_id: Option<AccountId>,
 
+    /// If true, fee fcollectors are not charged this fee for transfers.
     pub all_collectors_are_exempt: bool,
 }
 
 impl AnyCustomFee {
+    /// Create `AnyCustomFee` from protobuf-encoded `bytes`.
+    ///
+    /// # Errors
+    /// - [`Error::FromProtobuf`](crate::Error::FromProtobuf) if decoding the bytes fails to produce a valid protobuf.
+    /// - [`Error::FromProtobuf`](crate::Error::FromProtobuf) if decoding the protobuf fails.
     pub fn from_bytes(bytes: &[u8]) -> crate::Result<Self> {
         FromProtobuf::from_bytes(bytes)
     }
 
+    /// Convert `self` to a protobuf-encoded [`Vec<u8>`].
+    #[must_use]
     pub fn to_bytes(&self) -> Vec<u8> {
         ToProtobuf::to_bytes(self)
     }
@@ -206,30 +214,26 @@ pub struct FixedFeeData {
 
     /// The denomination of the fee; taken as hbar if left unset and, in a TokenCreate, taken as the id
     /// of the newly created token if set to the sentinel value of 0.0.0
-    pub denominating_token_id: TokenId,
+    pub denominating_token_id: Option<TokenId>,
 }
 
 impl FixedFeeData {
     #[must_use]
     pub fn from_hbar(amount: Hbar) -> Self {
-        Self {
-            amount: amount.to_tinybars(),
-            denominating_token_id: TokenId { shard: 0, realm: 0, num: 0, checksum: None },
-        }
+        Self { amount: amount.to_tinybars(), denominating_token_id: None }
     }
 
     #[must_use]
     pub fn get_hbar(&self) -> Option<Hbar> {
-        (self.denominating_token_id == TokenId { shard: 0, realm: 0, num: 0, checksum: None })
-            .then(|| Hbar::from_tinybars(self.amount))
+        self.denominating_token_id.is_none().then(|| Hbar::from_tinybars(self.amount))
     }
 }
 
 impl FromProtobuf<services::FixedFee> for FixedFeeData {
     fn from_protobuf(pb: services::FixedFee) -> crate::Result<Self> {
         Ok(Self {
             amount: pb.amount,
-            denominating_token_id: TokenId::from_protobuf(pb_getf!(pb, denominating_token_id)?)?,
+            denominating_token_id: Option::from_protobuf(pb.denominating_token_id)?,
         })
     }
 }
@@ -240,7 +244,7 @@ impl ToProtobuf for FixedFeeData {
     fn to_protobuf(&self) -> Self::Protobuf {
         Self::Protobuf {
             amount: self.amount,
-            denominating_token_id: Some(self.denominating_token_id.to_protobuf()),
+            denominating_token_id: self.denominating_token_id.to_protobuf(),
         }
     }
 }

src/token/custom_fees/tests.rs

@@ -20,7 +20,7 @@ use crate::{
 fn custom_fee_can_convert_to_protobuf() -> anyhow::Result<()> {
     let custom_fee = AnyCustomFee {
         fee_collector_account_id: Some(AccountId::from(1)),
-        fee: FixedFeeData { denominating_token_id: TokenId::from(2), amount: 1000 }.into(),
+        fee: FixedFeeData { denominating_token_id: Some(TokenId::from(2)), amount: 1000 }.into(),
         all_collectors_are_exempt: true,
     };
 
@@ -61,7 +61,7 @@ fn custom_fixed_fee_can_be_created_from_protobuf() -> anyhow::Result<()> {
 #[test]
 fn fee_can_convert_to_protobuf() -> anyhow::Result<()> {
     let amount = 1000;
-    let fee = Fee::Fixed(FixedFeeData { amount, denominating_token_id: TokenId::from(1) });
+    let fee = Fee::Fixed(FixedFeeData { amount, denominating_token_id: Some(TokenId::from(1)) });
 
     let fee_proto = fee.to_protobuf();
 
@@ -98,7 +98,7 @@ fn fee_can_be_created_from_protobuf() -> anyhow::Result<()> {
 #[test]
 fn fixed_fee_can_convert_to_protobuf() -> anyhow::Result<()> {
     let amount = 1000;
-    let fixed_fee = FixedFeeData { amount, denominating_token_id: TokenId::from(2) };
+    let fixed_fee = FixedFeeData { amount, denominating_token_id: Some(TokenId::from(2)) };
 
     let fixed_fee_proto = fixed_fee.to_protobuf();
 
@@ -169,7 +169,7 @@ fn fractional_fee_can_be_created_from_protobuf() -> anyhow::Result<()> {
 
 #[test]
 fn royalty_fee_can_convert_to_protobuf() -> anyhow::Result<()> {
-    let fallback_fee = FixedFeeData { denominating_token_id: TokenId::from(1), amount: 1000 };
+    let fallback_fee = FixedFeeData { denominating_token_id: Some(TokenId::from(1)), amount: 1000 };
     let exchange_value_fraction: Fraction = (1, 2).into();
 
     let royalty_fee =

tests/e2e/account/mod.rs

@@ -11,6 +11,7 @@ use hedera::{
     PrivateKey,
 };
 
+#[derive(Clone)]
 pub struct Account {
     pub key: PrivateKey,
     pub id: AccountId,

tests/e2e/token/associate.rs

@@ -0,0 +1,109 @@
+use assert_matches::assert_matches;
+use hedera::{
+    Hbar,
+    Status,
+    TokenAssociateTransaction,
+};
+
+use crate::account::Account;
+use crate::common::{
+    setup_nonfree,
+    TestEnvironment,
+};
+
+#[tokio::test]
+async fn basic() -> anyhow::Result<()> {
+    let Some(TestEnvironment { config: _, client }) = setup_nonfree() else {
+        return Ok(())
+    };
+
+    let (alice, bob) = tokio::try_join!(
+        Account::create(Hbar::new(0), &client),
+        Account::create(Hbar::new(0), &client)
+    )?;
+
+    let token = super::FungibleToken::create(&client, &alice, 0).await?;
+
+    TokenAssociateTransaction::new()
+        .account_id(bob.id)
+        .token_ids([token.id])
+        .freeze_with(&client)?
+        .sign(bob.key.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    token.delete(&client).await?;
+
+    tokio::try_join!(alice.delete(&client), bob.delete(&client))?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn missing_token_id() -> anyhow::Result<()> {
+    let Some(TestEnvironment { config, client }) = setup_nonfree() else {
+        return Ok(())
+    };
+
+    let Some(op) = &config.operator else {
+        log::debug!("skipping test due to lack of operator");
+        return Ok(())
+    };
+
+    TokenAssociateTransaction::new()
+        .account_id(op.account_id)
+        .freeze_with(&client)?
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn missing_account_id_fails() -> anyhow::Result<()> {
+    let Some(TestEnvironment { config: _, client }) = setup_nonfree() else {
+        return Ok(())
+    };
+
+    let res = TokenAssociateTransaction::new().execute(&client).await;
+
+    assert_matches!(
+        res,
+        Err(hedera::Error::TransactionPreCheckStatus {
+            status: Status::InvalidAccountId,
+            transaction_id: _
+        })
+    );
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn missing_signature_fails() -> anyhow::Result<()> {
+    let Some(TestEnvironment { config: _, client }) = setup_nonfree() else {
+        return Ok(())
+    };
+
+    let account = Account::create(Hbar::new(0), &client).await?;
+
+    let res = TokenAssociateTransaction::new()
+        .account_id(account.id)
+        .freeze_with(&client)?
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await;
+
+    assert_matches!(
+        res,
+        Err(hedera::Error::ReceiptStatus { status: Status::InvalidSignature, transaction_id: _ })
+    );
+
+    account.delete(&client).await?;
+
+    Ok(())
+}