test(erc721): add unit tests

contracts/src/access/control.rs

@@ -384,11 +384,8 @@ impl AccessControl {
 
 #[cfg(all(test, feature = "std"))]
 mod tests {
-    use alloy_primitives::{address, Address, U256};
-    use stylus_sdk::{
-        msg,
-        storage::{StorageMap, StorageType},
-    };
+    use alloy_primitives::{address, Address};
+    use stylus_sdk::msg;
 
     use super::{AccessControl, Error};
 

contracts/src/token/erc20/extensions/capped.rs

@@ -54,8 +54,7 @@ impl Capped {
 
 #[cfg(all(test, feature = "std"))]
 mod tests {
-    use alloy_primitives::{uint, U256};
-    use stylus_sdk::storage::{StorageType, StorageU256};
+    use alloy_primitives::uint;
 
     use super::Capped;
 

contracts/src/token/erc20/mod.rs

@@ -499,7 +499,7 @@ impl Erc20 {
 #[cfg(all(test, feature = "std"))]
 mod tests {
     use alloy_primitives::{address, uint, Address, U256};
-    use stylus_sdk::{msg, storage::StorageType};
+    use stylus_sdk::msg;
 
     use super::{Erc20, Error, IErc20};
 

contracts/src/token/erc721/extensions/burnable.rs

@@ -52,7 +52,8 @@ mod tests {
 
     use super::IErc721Burnable;
     use crate::token::erc721::{
-        tests::random_token_id, Erc721, Error, IErc721,
+        tests::random_token_id, ERC721InsufficientApproval,
+        ERC721NonexistentToken, Erc721, Error, IErc721,
     };
 
     const BOB: Address = address!("F4EaCDAbEf3c8f1EdE91b6f2A6840bc2E4DD3526");
@@ -70,21 +71,94 @@ mod tests {
             .expect("should return the balance of Alice");
 
         let result = contract.burn(token_id);
+        assert!(result.is_ok());
+
         let balance = contract
             .balance_of(alice)
             .expect("should return the balance of Alice");
 
-        let err = contract.owner_of(token_id).unwrap_err();
+        assert_eq!(initial_balance - one, balance);
+
+        let err = contract
+            .owner_of(token_id)
+            .expect_err("should return Error::NonexistentToken");
+
+        assert!(matches!(
+            err,
+            Error::NonexistentToken (ERC721NonexistentToken{
+                token_id: t_id
+            }) if t_id == token_id
+        ));
+    }
+
+    #[motsu::test]
+    fn burns_with_approval(contract: Erc721) {
+        let alice = msg::sender();
+        let token_id = random_token_id();
+
+        contract._mint(BOB, token_id).expect("should mint a token for Bob");
+
+        let initial_balance =
+            contract.balance_of(BOB).expect("should return the balance of Bob");
 
-        assert!(matches!(err, Error::NonexistentToken(_)));
+        contract._token_approvals.setter(token_id).set(alice);
 
+        let result = contract.burn(token_id);
         assert!(result.is_ok());
 
-        assert_eq!(initial_balance - one, balance);
+        let err = contract
+            .owner_of(token_id)
+            .expect_err("should return Error::NonexistentToken");
+
+        assert!(matches!(
+            err,
+            Error::NonexistentToken (ERC721NonexistentToken{
+                token_id: t_id
+            }) if t_id == token_id
+        ));
+
+        let balance =
+            contract.balance_of(BOB).expect("should return the balance of Bob");
+
+        assert_eq!(initial_balance - uint!(1_U256), balance);
     }
 
     #[motsu::test]
-    fn get_approved_errors_when_previous_approval_burned(contract: Erc721) {
+    fn burns_with_approval_for_all(contract: Erc721) {
+        let alice = msg::sender();
+        let token_id = random_token_id();
+
+        contract._mint(BOB, token_id).expect("should mint a token for Bob");
+
+        let initial_balance =
+            contract.balance_of(BOB).expect("should return the balance of Bob");
+
+        // As we cannot change `msg::sender()`, we need to use this workaround.
+        contract._operator_approvals.setter(BOB).setter(alice).set(true);
+
+        let result = contract.burn(token_id);
+
+        assert!(result.is_ok());
+
+        let err = contract
+            .owner_of(token_id)
+            .expect_err("should return Error::NonexistentToken");
+
+        assert!(matches!(
+            err,
+            Error::NonexistentToken (ERC721NonexistentToken{
+                token_id: t_id
+            }) if t_id == token_id
+        ));
+
+        let balance =
+            contract.balance_of(BOB).expect("should return the balance of Bob");
+
+        assert_eq!(initial_balance - uint!(1_U256), balance);
+    }
+
+    #[motsu::test]
+    fn error_when_get_approved_of_previous_approval_burned(contract: Erc721) {
         let alice = msg::sender();
         let token_id = random_token_id();
 
@@ -95,31 +169,50 @@ mod tests {
 
         contract.burn(token_id).expect("should burn previously minted token");
 
-        let err = contract.get_approved(token_id).unwrap_err();
+        let err = contract
+            .get_approved(token_id)
+            .expect_err("should return Error::NonexistentToken");
 
-        assert!(matches!(err, Error::NonexistentToken(_)));
+        assert!(matches!(
+            err,
+            Error::NonexistentToken (ERC721NonexistentToken{
+                token_id: t_id
+            }) if t_id == token_id
+        ));
     }
 
     #[motsu::test]
-    fn burn_errors_when_no_previous_approval(contract: Erc721) {
+    fn error_when_burn_without_approval(contract: Erc721) {
         let token_id = random_token_id();
 
         contract._mint(BOB, token_id).expect("should mint a token for Bob");
 
-        let err = contract.burn(token_id).unwrap_err();
-
-        assert!(matches!(err, Error::InsufficientApproval(_)));
+        let err = contract
+            .burn(token_id)
+            .expect_err("should not burn unapproved token");
+
+        assert!(matches!(
+            err,
+            Error::InsufficientApproval(ERC721InsufficientApproval {
+                    operator,
+                    token_id: t_id,
+            }) if operator == msg::sender() && t_id == token_id
+        ));
     }
 
     #[motsu::test]
-    fn burn_errors_when_unknown_token(contract: Erc721) {
-        let alice = msg::sender();
+    fn error_when_burn_nonexistent_token(contract: Erc721) {
         let token_id = random_token_id();
 
-        contract._mint(alice, token_id).expect("should mint a token for Alice");
-
-        let err = contract.burn(token_id + uint!(1_U256)).unwrap_err();
+        let err = contract
+            .burn(token_id)
+            .expect_err("should return Error::NonexistentToken");
 
-        assert!(matches!(err, Error::NonexistentToken(_)));
+        assert!(matches!(
+            err,
+            Error::NonexistentToken (ERC721NonexistentToken{
+                token_id: t_id
+            }) if t_id == token_id
+        ));
     }
 }

contracts/src/token/erc721/extensions/enumerable.rs

@@ -309,11 +309,7 @@ impl Erc721Enumerable {
 #[cfg(all(test, feature = "std"))]
 mod tests {
     use alloy_primitives::{address, uint, Address, U256};
-    use stylus_sdk::{
-        msg,
-        prelude::StorageType,
-        storage::{StorageMap, StorageVec},
-    };
+    use stylus_sdk::msg;
 
     use super::{Erc721Enumerable, Error, IErc721Enumerable};
     use crate::token::erc721::{tests::random_token_id, Erc721, IErc721};
@@ -326,9 +322,7 @@ mod tests {
     }
 
     #[motsu::test]
-    fn token_by_index_errors_when_index_out_of_bound(
-        contract: Erc721Enumerable,
-    ) {
+    fn error_when_token_by_index_is_out_of_bound(contract: Erc721Enumerable) {
         assert_eq!(U256::ZERO, contract.total_supply());
 
         let token_idx = uint!(2024_U256);
@@ -453,7 +447,9 @@ mod tests {
     }
 
     #[motsu::test]
-    fn token_of_owner_errors_index_out_of_bound(contract: Erc721Enumerable) {
+    fn error_when_token_of_owner_for_index_out_of_bound(
+        contract: Erc721Enumerable,
+    ) {
         let alice = msg::sender();
         let mut erc721 = Erc721::default();
         assert_eq!(
@@ -478,7 +474,7 @@ mod tests {
     }
 
     #[motsu::test]
-    fn token_of_owner_errors_owner_does_not_own_any_token(
+    fn error_when_token_of_owner_does_not_own_any_token(
         contract: Erc721Enumerable,
     ) {
         let erc721 = Erc721::default();

contracts/src/token/erc721/extensions/uri_storage.rs

@@ -66,7 +66,6 @@ impl Erc721UriStorage {
 #[cfg(all(test, feature = "std"))]
 mod tests {
     use alloy_primitives::U256;
-    use stylus_sdk::{prelude::StorageType, storage::StorageMap};
 
     use super::Erc721UriStorage;