difftreelog
change error type for `ensure_single_owner`
in: master
2 files changed
pallets/refungible/src/erc.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -512,7 +512,7 @@
if owner_balance == 0 {
return Err(dispatch_to_evm::<T>(
- <CommonError<T>>::TokenValueTooLow.into(),
+ <CommonError<T>>::MustBeTokenOwner.into(),
));
}
runtime/tests/src/tests.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Tests to be written here18use crate::{Test, TestCrossAccountId, CollectionCreationPrice, RuntimeOrigin, Unique, new_test_ext};19use up_data_structs::{20 COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData,21 CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, TokenId,22 MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionMode, AccessMode, CollectionPermissions,23 PropertyKeyPermission, PropertyPermission, Property, CollectionPropertiesVec,24 CollectionPropertiesPermissionsVec,25};26use frame_support::{assert_noop, assert_ok, assert_err};27use sp_std::convert::TryInto;28use pallet_evm::account::CrossAccountId;29use pallet_common::Error as CommonError;30use pallet_unique::Error as UniqueError;3132fn add_balance(user: u64, value: u64) {33 const DONOR_USER: u64 = 999;34 assert_ok!(<pallet_balances::Pallet<Test>>::set_balance(35 RuntimeOrigin::root(),36 DONOR_USER,37 value,38 039 ));40 assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(41 RuntimeOrigin::root(),42 DONOR_USER,43 user,44 value45 ));46}4748fn default_nft_data() -> CreateNftData {49 CreateNftData {50 properties: vec![Property {51 key: b"test-prop".to_vec().try_into().unwrap(),52 value: b"test-nft-prop".to_vec().try_into().unwrap(),53 }]54 .try_into()55 .unwrap(),56 }57}5859fn default_fungible_data() -> CreateFungibleData {60 CreateFungibleData { value: 5 }61}6263fn default_re_fungible_data() -> CreateReFungibleData {64 CreateReFungibleData {65 pieces: 1023,66 properties: vec![Property {67 key: b"test-prop".to_vec().try_into().unwrap(),68 value: b"test-nft-prop".to_vec().try_into().unwrap(),69 }]70 .try_into()71 .unwrap(),72 }73}7475fn create_test_collection_for_owner(76 mode: &CollectionMode,77 owner: u64,78 id: CollectionId,79) -> CollectionId {80 add_balance(owner, CollectionCreationPrice::get() as u64 + 1);8182 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();83 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();84 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();85 let token_property_permissions: CollectionPropertiesPermissionsVec =86 vec![PropertyKeyPermission {87 key: b"test-prop".to_vec().try_into().unwrap(),88 permission: PropertyPermission {89 mutable: true,90 collection_admin: false,91 token_owner: true,92 },93 }]94 .try_into()95 .unwrap();96 let properties: CollectionPropertiesVec = vec![Property {97 key: b"test-collection-prop".to_vec().try_into().unwrap(),98 value: b"test-collection-value".to_vec().try_into().unwrap(),99 }]100 .try_into()101 .unwrap();102103 let data: CreateCollectionData<u64> = CreateCollectionData {104 name: col_name1.try_into().unwrap(),105 description: col_desc1.try_into().unwrap(),106 token_prefix: token_prefix1.try_into().unwrap(),107 mode: mode.clone(),108 token_property_permissions: token_property_permissions.clone(),109 properties: properties.clone(),110 ..Default::default()111 };112113 let origin1 = RuntimeOrigin::signed(owner);114 assert_ok!(Unique::create_collection_ex(origin1, data));115116 let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();117 let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();118 let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();119 assert_eq!(120 <pallet_common::CollectionById<Test>>::get(id)121 .unwrap()122 .owner,123 owner124 );125 assert_eq!(126 <pallet_common::CollectionById<Test>>::get(id).unwrap().name,127 saved_col_name128 );129 assert_eq!(130 <pallet_common::CollectionById<Test>>::get(id).unwrap().mode,131 *mode132 );133 assert_eq!(134 <pallet_common::CollectionById<Test>>::get(id)135 .unwrap()136 .description,137 saved_description138 );139 assert_eq!(140 <pallet_common::CollectionById<Test>>::get(id)141 .unwrap()142 .token_prefix,143 saved_prefix144 );145 assert_eq!(146 get_collection_property_permissions(id).as_slice(),147 token_property_permissions.as_slice()148 );149 assert_eq!(150 get_collection_properties(id).as_slice(),151 properties.as_slice()152 );153 id154}155156fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {157 <pallet_common::Pallet<Test>>::property_permissions(collection_id)158 .into_iter()159 .map(|(key, permission)| PropertyKeyPermission { key, permission })160 .collect()161}162163fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {164 <pallet_common::Pallet<Test>>::collection_properties(collection_id)165 .into_iter()166 .map(|(key, value)| Property { key, value })167 .collect()168}169170fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {171 <pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))172 .into_iter()173 .map(|(key, value)| Property { key, value })174 .collect()175}176177fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {178 create_test_collection_for_owner(&mode, 1, id)179}180181fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {182 let origin1 = RuntimeOrigin::signed(1);183 assert_ok!(Unique::create_item(184 origin1,185 collection_id,186 account(1),187 data.clone()188 ));189}190191fn account(sub: u64) -> TestCrossAccountId {192 TestCrossAccountId::from_sub(sub)193}194195// Use cases tests region196// #region197198#[test]199fn check_not_sufficient_founds() {200 new_test_ext().execute_with(|| {201 let acc: u64 = 1;202 <pallet_balances::Pallet<Test>>::set_balance(RuntimeOrigin::root(), acc, 0, 0).unwrap();203204 let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();205 let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();206 let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();207208 let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =209 CreateCollectionData {210 name: name.try_into().unwrap(),211 description: description.try_into().unwrap(),212 token_prefix: token_prefix.try_into().unwrap(),213 mode: CollectionMode::NFT,214 ..Default::default()215 };216217 let result = Unique::create_collection_ex(RuntimeOrigin::signed(acc), data);218 assert_err!(result, <CommonError<Test>>::NotSufficientFounds);219 });220}221222#[test]223fn create_fungible_collection_fails_with_large_decimal_numbers() {224 new_test_ext().execute_with(|| {225 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();226 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();227 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();228229 let data: CreateCollectionData<u64> = CreateCollectionData {230 name: col_name1.try_into().unwrap(),231 description: col_desc1.try_into().unwrap(),232 token_prefix: token_prefix1.try_into().unwrap(),233 mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),234 ..Default::default()235 };236237 let origin1 = RuntimeOrigin::signed(1);238 assert_noop!(239 Unique::create_collection_ex(origin1, data),240 UniqueError::<Test>::CollectionDecimalPointLimitExceeded241 );242 });243}244245#[test]246fn create_nft_item() {247 new_test_ext().execute_with(|| {248 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));249250 let data = default_nft_data();251 create_test_item(collection_id, &data.clone().into());252253 assert_eq!(254 get_token_properties(collection_id, TokenId(1)).as_slice(),255 data.properties.as_slice(),256 );257 });258}259260// Use cases tests region261// #region262#[test]263fn create_nft_multiple_items() {264 new_test_ext().execute_with(|| {265 create_test_collection(&CollectionMode::NFT, CollectionId(1));266267 let origin1 = RuntimeOrigin::signed(1);268269 let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];270271 assert_ok!(Unique::create_multiple_items(272 origin1,273 CollectionId(1),274 account(1),275 items_data276 .clone()277 .into_iter()278 .map(|d| { d.into() })279 .collect()280 ));281 for (index, data) in items_data.into_iter().enumerate() {282 assert_eq!(283 get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),284 data.properties.as_slice()285 );286 }287 });288}289290#[test]291fn create_refungible_item() {292 new_test_ext().execute_with(|| {293 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));294295 let data = default_re_fungible_data();296 create_test_item(collection_id, &data.clone().into());297 let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));298 let balance =299 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));300 assert_eq!(balance, 1023);301 });302}303304#[test]305fn create_multiple_refungible_items() {306 new_test_ext().execute_with(|| {307 create_test_collection(&CollectionMode::ReFungible, CollectionId(1));308309 let origin1 = RuntimeOrigin::signed(1);310311 let items_data = vec![312 default_re_fungible_data(),313 default_re_fungible_data(),314 default_re_fungible_data(),315 ];316317 assert_ok!(Unique::create_multiple_items(318 origin1,319 CollectionId(1),320 account(1),321 items_data322 .clone()323 .into_iter()324 .map(|d| { d.into() })325 .collect()326 ));327 for (index, data) in items_data.into_iter().enumerate() {328 let item = <pallet_refungible::TokenData<Test>>::get((329 CollectionId(1),330 TokenId((index + 1) as u32),331 ));332 let balance =333 <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));334 assert_eq!(balance, 1023);335 }336 });337}338339#[test]340fn create_fungible_item() {341 new_test_ext().execute_with(|| {342 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));343344 let data = default_fungible_data();345 create_test_item(collection_id, &data.into());346347 assert_eq!(348 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),349 5350 );351 });352}353354//#[test]355// fn create_multiple_fungible_items() {356// new_test_ext().execute_with(|| {357// default_limits();358359// create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));360361// let origin1 = RuntimeOrigin::signed(1);362363// let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];364365// assert_ok!(Unique::create_multiple_items(366// origin1.clone(),367// 1,368// 1,369// items_data.clone().into_iter().map(|d| { d.into() }).collect()370// ));371372// for (index, _) in items_data.iter().enumerate() {373// assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);374// }375// assert_eq!(Unique::balance_count(1, 1), 3000);376// assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);377// });378// }379380#[test]381fn transfer_fungible_item() {382 new_test_ext().execute_with(|| {383 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));384385 let origin1 = RuntimeOrigin::signed(1);386 let origin2 = RuntimeOrigin::signed(2);387388 let data = default_fungible_data();389 create_test_item(collection_id, &data.into());390391 assert_eq!(392 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),393 5394 );395396 // change owner scenario397 assert_ok!(Unique::transfer(398 origin1,399 account(2),400 CollectionId(1),401 TokenId(0),402 5403 ));404 assert_eq!(405 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),406 0407 );408409 // split item scenario410 assert_ok!(Unique::transfer(411 origin2.clone(),412 account(3),413 CollectionId(1),414 TokenId(0),415 3416 ));417418 // split item and new owner has account scenario419 assert_ok!(Unique::transfer(420 origin2,421 account(3),422 CollectionId(1),423 TokenId(0),424 1425 ));426 assert_eq!(427 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),428 1429 );430 assert_eq!(431 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),432 4433 );434 });435}436437#[test]438fn transfer_refungible_item() {439 new_test_ext().execute_with(|| {440 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));441442 // Create RFT 1 in 1023 pieces for account 1443 let data = default_re_fungible_data();444 create_test_item(collection_id, &data.clone().into());445 let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));446 assert_eq!(447 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),448 1449 );450 assert_eq!(451 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),452 1023453 );454 assert_eq!(455 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),456 true457 );458459 // Account 1 transfers all 1023 pieces of RFT 1 to account 2460 let origin1 = RuntimeOrigin::signed(1);461 let origin2 = RuntimeOrigin::signed(2);462 assert_ok!(Unique::transfer(463 origin1,464 account(2),465 CollectionId(1),466 TokenId(1),467 1023468 ));469 assert_eq!(470 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),471 1023472 );473 assert_eq!(474 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),475 0476 );477 assert_eq!(478 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),479 1480 );481 assert_eq!(482 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),483 false484 );485 assert_eq!(486 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),487 true488 );489490 // Account 2 transfers 500 pieces of RFT 1 to account 3491 assert_ok!(Unique::transfer(492 origin2.clone(),493 account(3),494 CollectionId(1),495 TokenId(1),496 500497 ));498 assert_eq!(499 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),500 523501 );502 assert_eq!(503 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),504 500505 );506 assert_eq!(507 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),508 1509 );510 assert_eq!(511 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),512 1513 );514 assert_eq!(515 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),516 true517 );518 assert_eq!(519 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),520 true521 );522523 // Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance524 assert_ok!(Unique::transfer(525 origin2,526 account(3),527 CollectionId(1),528 TokenId(1),529 200530 ));531 assert_eq!(532 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),533 323534 );535 assert_eq!(536 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),537 700538 );539 assert_eq!(540 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),541 1542 );543 assert_eq!(544 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),545 1546 );547 assert_eq!(548 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),549 true550 );551 assert_eq!(552 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),553 true554 );555 });556}557558#[test]559fn transfer_nft_item() {560 new_test_ext().execute_with(|| {561 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));562563 let data = default_nft_data();564 create_test_item(collection_id, &data.into());565 assert_eq!(566 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),567 1568 );569 assert_eq!(570 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),571 true572 );573574 let origin1 = RuntimeOrigin::signed(1);575 // default scenario576 assert_ok!(Unique::transfer(577 origin1,578 account(2),579 CollectionId(1),580 TokenId(1),581 1582 ));583 assert_eq!(584 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),585 0586 );587 assert_eq!(588 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),589 1590 );591 assert_eq!(592 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),593 false594 );595 assert_eq!(596 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),597 true598 );599 });600}601602#[test]603fn transfer_nft_item_wrong_value() {604 new_test_ext().execute_with(|| {605 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));606607 let data = default_nft_data();608 create_test_item(collection_id, &data.into());609 assert_eq!(610 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),611 1612 );613 assert_eq!(614 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),615 true616 );617618 let origin1 = RuntimeOrigin::signed(1);619620 assert_noop!(621 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)622 .map_err(|e| e.error),623 <pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount624 );625 });626}627628#[test]629fn transfer_nft_item_zero_value() {630 new_test_ext().execute_with(|| {631 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));632633 let data = default_nft_data();634 create_test_item(collection_id, &data.into());635 assert_eq!(636 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),637 1638 );639 assert_eq!(640 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),641 true642 );643644 let origin1 = RuntimeOrigin::signed(1);645646 // Transferring 0 amount works on NFT...647 assert_ok!(Unique::transfer(648 origin1,649 account(2),650 CollectionId(1),651 TokenId(1),652 0653 ));654 // ... and results in no transfer655 assert_eq!(656 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),657 1658 );659 assert_eq!(660 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),661 true662 );663 });664}665666#[test]667fn nft_approve_and_transfer_from() {668 new_test_ext().execute_with(|| {669 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));670671 let data = default_nft_data();672 create_test_item(collection_id, &data.into());673674 let origin1 = RuntimeOrigin::signed(1);675 let origin2 = RuntimeOrigin::signed(2);676677 assert_eq!(678 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),679 1680 );681 assert_eq!(682 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),683 true684 );685686 // neg transfer_from687 assert_noop!(688 Unique::transfer_from(689 origin2.clone(),690 account(1),691 account(2),692 CollectionId(1),693 TokenId(1),694 1695 )696 .map_err(|e| e.error),697 CommonError::<Test>::ApprovedValueTooLow698 );699700 // do approve701 assert_ok!(Unique::approve(702 origin1,703 account(2),704 CollectionId(1),705 TokenId(1),706 1707 ));708 assert_eq!(709 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),710 account(2)711 );712713 assert_ok!(Unique::transfer_from(714 origin2,715 account(1),716 account(3),717 CollectionId(1),718 TokenId(1),719 1720 ));721 assert!(722 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()723 );724 });725}726727#[test]728fn nft_approve_and_transfer_from_allow_list() {729 new_test_ext().execute_with(|| {730 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));731732 let origin1 = RuntimeOrigin::signed(1);733 let origin2 = RuntimeOrigin::signed(2);734735 // Create NFT 1 for account 1736 let data = default_nft_data();737 create_test_item(collection_id, &data.clone().into());738 assert_eq!(739 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),740 1741 );742 assert_eq!(743 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),744 true745 );746747 // Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list748 assert_ok!(Unique::set_collection_permissions(749 origin1.clone(),750 CollectionId(1),751 CollectionPermissions {752 mint_mode: Some(true),753 access: Some(AccessMode::AllowList),754 nesting: None,755 }756 ));757 assert_ok!(Unique::add_to_allow_list(758 origin1.clone(),759 CollectionId(1),760 account(1)761 ));762 assert_ok!(Unique::add_to_allow_list(763 origin1.clone(),764 CollectionId(1),765 account(2)766 ));767 assert_ok!(Unique::add_to_allow_list(768 origin1.clone(),769 CollectionId(1),770 account(3)771 ));772773 // Account 1 approves account 2 for NFT 1774 assert_ok!(Unique::approve(775 origin1.clone(),776 account(2),777 CollectionId(1),778 TokenId(1),779 1780 ));781 assert_eq!(782 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),783 account(2)784 );785786 // Account 2 transfers NFT 1 from account 1 to account 3787 assert_ok!(Unique::transfer_from(788 origin2,789 account(1),790 account(3),791 CollectionId(1),792 TokenId(1),793 1794 ));795 assert!(796 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()797 );798 });799}800801#[test]802fn refungible_approve_and_transfer_from() {803 new_test_ext().execute_with(|| {804 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));805806 let origin1 = RuntimeOrigin::signed(1);807 let origin2 = RuntimeOrigin::signed(2);808809 // Create RFT 1 in 1023 pieces for account 1810 let data = default_re_fungible_data();811 create_test_item(collection_id, &data.into());812813 assert_eq!(814 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),815 1816 );817 assert_eq!(818 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),819 1023820 );821 assert_eq!(822 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),823 true824 );825826 // Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list827 assert_ok!(Unique::set_collection_permissions(828 origin1.clone(),829 CollectionId(1),830 CollectionPermissions {831 mint_mode: Some(true),832 access: Some(AccessMode::AllowList),833 nesting: None,834 }835 ));836 assert_ok!(Unique::add_to_allow_list(837 origin1.clone(),838 CollectionId(1),839 account(1)840 ));841 assert_ok!(Unique::add_to_allow_list(842 origin1.clone(),843 CollectionId(1),844 account(2)845 ));846 assert_ok!(Unique::add_to_allow_list(847 origin1.clone(),848 CollectionId(1),849 account(3)850 ));851852 // Account 1 approves account 2 for 1023 pieces of RFT 1853 assert_ok!(Unique::approve(854 origin1,855 account(2),856 CollectionId(1),857 TokenId(1),858 1023859 ));860 assert_eq!(861 <pallet_refungible::Allowance<Test>>::get((862 CollectionId(1),863 TokenId(1),864 account(1),865 account(2)866 )),867 1023868 );869870 // Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3871 assert_ok!(Unique::transfer_from(872 origin2,873 account(1),874 account(3),875 CollectionId(1),876 TokenId(1),877 100878 ));879 assert_eq!(880 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),881 1882 );883 assert_eq!(884 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),885 1886 );887 assert_eq!(888 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),889 923890 );891 assert_eq!(892 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),893 100894 );895 assert_eq!(896 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),897 true898 );899 assert_eq!(900 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),901 true902 );903 assert_eq!(904 <pallet_refungible::Allowance<Test>>::get((905 CollectionId(1),906 TokenId(1),907 account(1),908 account(2)909 )),910 923911 );912 });913}914915#[test]916fn fungible_approve_and_transfer_from() {917 new_test_ext().execute_with(|| {918 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));919920 let data = default_fungible_data();921 create_test_item(collection_id, &data.into());922923 let origin1 = RuntimeOrigin::signed(1);924 let origin2 = RuntimeOrigin::signed(2);925926 assert_ok!(Unique::set_collection_permissions(927 origin1.clone(),928 CollectionId(1),929 CollectionPermissions {930 mint_mode: Some(true),931 access: Some(AccessMode::AllowList),932 nesting: None,933 }934 ));935 assert_ok!(Unique::add_to_allow_list(936 origin1.clone(),937 CollectionId(1),938 account(1)939 ));940 assert_ok!(Unique::add_to_allow_list(941 origin1.clone(),942 CollectionId(1),943 account(2)944 ));945 assert_ok!(Unique::add_to_allow_list(946 origin1.clone(),947 CollectionId(1),948 account(3)949 ));950951 // do approve952 assert_ok!(Unique::approve(953 origin1.clone(),954 account(2),955 CollectionId(1),956 TokenId(0),957 5958 ));959 assert_eq!(960 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),961 5962 );963 assert_ok!(Unique::approve(964 origin1,965 account(3),966 CollectionId(1),967 TokenId(0),968 5969 ));970 assert_eq!(971 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),972 5973 );974 assert_eq!(975 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),976 5977 );978979 assert_ok!(Unique::transfer_from(980 origin2.clone(),981 account(1),982 account(3),983 CollectionId(1),984 TokenId(0),985 4986 ));987988 assert_eq!(989 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),990 1991 );992993 assert_noop!(994 Unique::transfer_from(995 origin2,996 account(1),997 account(3),998 CollectionId(1),999 TokenId(0),1000 41001 )1002 .map_err(|e| e.error),1003 CommonError::<Test>::ApprovedValueTooLow1004 );1005 });1006}10071008#[test]1009fn change_collection_owner() {1010 new_test_ext().execute_with(|| {1011 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10121013 let origin1 = RuntimeOrigin::signed(1);1014 assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1015 assert_eq!(1016 <pallet_common::CollectionById<Test>>::get(collection_id)1017 .unwrap()1018 .owner,1019 21020 );1021 });1022}10231024#[test]1025fn destroy_collection() {1026 new_test_ext().execute_with(|| {1027 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10281029 let origin1 = RuntimeOrigin::signed(1);1030 assert_ok!(Unique::destroy_collection(origin1, collection_id));1031 });1032}10331034#[test]1035fn burn_nft_item() {1036 new_test_ext().execute_with(|| {1037 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10381039 let origin1 = RuntimeOrigin::signed(1);10401041 let data = default_nft_data();1042 create_test_item(collection_id, &data.into());10431044 // check balance (collection with id = 1, user id = 1)1045 assert_eq!(1046 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1047 11048 );10491050 // burn item1051 assert_ok!(Unique::burn_item(1052 origin1.clone(),1053 collection_id,1054 TokenId(1),1055 11056 ));1057 assert_eq!(1058 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1059 01060 );1061 });1062}10631064#[test]1065fn burn_same_nft_item_twice() {1066 new_test_ext().execute_with(|| {1067 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10681069 let origin1 = RuntimeOrigin::signed(1);10701071 let data = default_nft_data();1072 create_test_item(collection_id, &data.into());10731074 // check balance (collection with id = 1, user id = 1)1075 assert_eq!(1076 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1077 11078 );10791080 // burn item1081 assert_ok!(Unique::burn_item(1082 origin1.clone(),1083 collection_id,1084 TokenId(1),1085 11086 ));10871088 // burn item again1089 assert_noop!(1090 Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1091 CommonError::<Test>::TokenNotFound1092 );10931094 assert_eq!(1095 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1096 01097 );1098 });1099}11001101#[test]1102fn burn_fungible_item() {1103 new_test_ext().execute_with(|| {1104 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11051106 let origin1 = RuntimeOrigin::signed(1);1107 assert_ok!(Unique::add_collection_admin(1108 origin1.clone(),1109 collection_id,1110 account(2)1111 ));11121113 let data = default_fungible_data();1114 create_test_item(collection_id, &data.into());11151116 // check balance (collection with id = 1, user id = 1)1117 assert_eq!(1118 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1119 51120 );11211122 // burn item1123 assert_ok!(Unique::burn_item(1124 origin1.clone(),1125 CollectionId(1),1126 TokenId(0),1127 51128 ));1129 assert_noop!(1130 Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1131 CommonError::<Test>::TokenValueTooLow1132 );11331134 assert_eq!(1135 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1136 01137 );1138 });1139}11401141#[test]1142fn burn_fungible_item_with_token_id() {1143 new_test_ext().execute_with(|| {1144 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11451146 let origin1 = RuntimeOrigin::signed(1);1147 assert_ok!(Unique::add_collection_admin(1148 origin1.clone(),1149 collection_id,1150 account(2)1151 ));11521153 let data = default_fungible_data();1154 create_test_item(collection_id, &data.into());11551156 // check balance (collection with id = 1, user id = 1)1157 assert_eq!(1158 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1159 51160 );11611162 // Try to burn item using Token ID1163 assert_noop!(1164 Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1165 <pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1166 );1167 });1168}1169#[test]1170fn burn_refungible_item() {1171 new_test_ext().execute_with(|| {1172 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1173 let origin1 = RuntimeOrigin::signed(1);11741175 assert_ok!(Unique::set_collection_permissions(1176 origin1.clone(),1177 collection_id,1178 CollectionPermissions {1179 mint_mode: Some(true),1180 access: Some(AccessMode::AllowList),1181 nesting: None,1182 }1183 ));1184 assert_ok!(Unique::add_to_allow_list(1185 origin1.clone(),1186 collection_id,1187 account(1)1188 ));11891190 assert_ok!(Unique::add_collection_admin(1191 origin1.clone(),1192 collection_id,1193 account(2)1194 ));11951196 let data = default_re_fungible_data();1197 create_test_item(collection_id, &data.into());11981199 // check balance (collection with id = 1, user id = 2)1200 assert_eq!(1201 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1202 11203 );1204 assert_eq!(1205 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1206 10231207 );12081209 // burn item1210 assert_ok!(Unique::burn_item(1211 origin1.clone(),1212 collection_id,1213 TokenId(1),1214 10231215 ));1216 assert_noop!(1217 Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1218 CommonError::<Test>::TokenValueTooLow1219 );12201221 assert_eq!(1222 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1223 01224 );1225 });1226}12271228#[test]1229fn add_collection_admin() {1230 new_test_ext().execute_with(|| {1231 let collection1_id =1232 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1233 let origin1 = RuntimeOrigin::signed(1);12341235 // Add collection admins1236 assert_ok!(Unique::add_collection_admin(1237 origin1.clone(),1238 collection1_id,1239 account(2)1240 ));1241 assert_ok!(Unique::add_collection_admin(1242 origin1,1243 collection1_id,1244 account(3)1245 ));12461247 // Owner is not an admin by default1248 assert_eq!(1249 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1250 false1251 );1252 assert!(<pallet_common::IsAdmin<Test>>::get((1253 CollectionId(1),1254 account(2)1255 )));1256 assert!(<pallet_common::IsAdmin<Test>>::get((1257 CollectionId(1),1258 account(3)1259 )));1260 });1261}12621263#[test]1264fn remove_collection_admin() {1265 new_test_ext().execute_with(|| {1266 let collection1_id =1267 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1268 let origin1 = RuntimeOrigin::signed(1);12691270 // Add collection admins 2 and 31271 assert_ok!(Unique::add_collection_admin(1272 origin1.clone(),1273 collection1_id,1274 account(2)1275 ));1276 assert_ok!(Unique::add_collection_admin(1277 origin1.clone(),1278 collection1_id,1279 account(3)1280 ));12811282 assert!(<pallet_common::IsAdmin<Test>>::get((1283 CollectionId(1),1284 account(2)1285 )));1286 assert!(<pallet_common::IsAdmin<Test>>::get((1287 CollectionId(1),1288 account(3)1289 )));12901291 // remove admin 31292 assert_ok!(Unique::remove_collection_admin(1293 origin1,1294 CollectionId(1),1295 account(3)1296 ));12971298 // 2 is still admin, 3 is not an admin anymore1299 assert!(<pallet_common::IsAdmin<Test>>::get((1300 CollectionId(1),1301 account(2)1302 )));1303 assert_eq!(1304 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1305 false1306 );1307 });1308}13091310#[test]1311fn balance_of() {1312 new_test_ext().execute_with(|| {1313 let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1314 let fungible_collection_id =1315 create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1316 let re_fungible_collection_id =1317 create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13181319 // check balance before1320 assert_eq!(1321 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1322 01323 );1324 assert_eq!(1325 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1326 01327 );1328 assert_eq!(1329 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1330 01331 );13321333 let nft_data = default_nft_data();1334 create_test_item(nft_collection_id, &nft_data.into());13351336 let fungible_data = default_fungible_data();1337 create_test_item(fungible_collection_id, &fungible_data.into());13381339 let re_fungible_data = default_re_fungible_data();1340 create_test_item(re_fungible_collection_id, &re_fungible_data.into());13411342 // check balance (collection with id = 1, user id = 1)1343 assert_eq!(1344 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1345 11346 );1347 assert_eq!(1348 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1349 51350 );1351 assert_eq!(1352 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1353 11354 );13551356 assert_eq!(1357 <pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1358 true1359 );1360 assert_eq!(1361 <pallet_refungible::Owned<Test>>::get((1362 re_fungible_collection_id,1363 account(1),1364 TokenId(1)1365 )),1366 true1367 );1368 });1369}13701371#[test]1372fn approve() {1373 new_test_ext().execute_with(|| {1374 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13751376 let data = default_nft_data();1377 create_test_item(collection_id, &data.into());13781379 let origin1 = RuntimeOrigin::signed(1);13801381 // approve1382 assert_ok!(Unique::approve(1383 origin1,1384 account(2),1385 CollectionId(1),1386 TokenId(1),1387 11388 ));1389 assert_eq!(1390 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1391 account(2)1392 );1393 });1394}13951396#[test]1397fn transfer_from() {1398 new_test_ext().execute_with(|| {1399 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1400 let origin1 = RuntimeOrigin::signed(1);1401 let origin2 = RuntimeOrigin::signed(2);14021403 let data = default_nft_data();1404 create_test_item(collection_id, &data.into());14051406 // approve1407 assert_ok!(Unique::approve(1408 origin1.clone(),1409 account(2),1410 CollectionId(1),1411 TokenId(1),1412 11413 ));1414 assert_eq!(1415 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1416 account(2)1417 );14181419 assert_ok!(Unique::set_collection_permissions(1420 origin1.clone(),1421 CollectionId(1),1422 CollectionPermissions {1423 mint_mode: Some(true),1424 access: Some(AccessMode::AllowList),1425 nesting: None,1426 }1427 ));1428 assert_ok!(Unique::add_to_allow_list(1429 origin1.clone(),1430 CollectionId(1),1431 account(1)1432 ));1433 assert_ok!(Unique::add_to_allow_list(1434 origin1.clone(),1435 CollectionId(1),1436 account(2)1437 ));1438 assert_ok!(Unique::add_to_allow_list(1439 origin1,1440 CollectionId(1),1441 account(3)1442 ));14431444 assert_ok!(Unique::transfer_from(1445 origin2,1446 account(1),1447 account(2),1448 CollectionId(1),1449 TokenId(1),1450 11451 ));14521453 // after transfer1454 assert_eq!(1455 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1456 01457 );1458 assert_eq!(1459 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1460 11461 );1462 });1463}14641465// #endregion14661467// Coverage tests region1468// #region14691470#[test]1471fn owner_can_add_address_to_allow_list() {1472 new_test_ext().execute_with(|| {1473 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14741475 let origin1 = RuntimeOrigin::signed(1);1476 assert_ok!(Unique::add_to_allow_list(1477 origin1,1478 collection_id,1479 account(2)1480 ));1481 assert!(<pallet_common::Allowlist<Test>>::get((1482 collection_id,1483 account(2)1484 )));1485 });1486}14871488#[test]1489fn admin_can_add_address_to_allow_list() {1490 new_test_ext().execute_with(|| {1491 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1492 let origin1 = RuntimeOrigin::signed(1);1493 let origin2 = RuntimeOrigin::signed(2);14941495 assert_ok!(Unique::add_collection_admin(1496 origin1,1497 collection_id,1498 account(2)1499 ));1500 assert_ok!(Unique::add_to_allow_list(1501 origin2,1502 collection_id,1503 account(3)1504 ));1505 assert!(<pallet_common::Allowlist<Test>>::get((1506 collection_id,1507 account(3)1508 )));1509 });1510}15111512#[test]1513fn nonprivileged_user_cannot_add_address_to_allow_list() {1514 new_test_ext().execute_with(|| {1515 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15161517 let origin2 = RuntimeOrigin::signed(2);1518 assert_noop!(1519 Unique::add_to_allow_list(origin2, collection_id, account(3)),1520 CommonError::<Test>::NoPermission1521 );1522 });1523}15241525#[test]1526fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1527 new_test_ext().execute_with(|| {1528 let origin1 = RuntimeOrigin::signed(1);15291530 assert_noop!(1531 Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1532 CommonError::<Test>::CollectionNotFound1533 );1534 });1535}15361537#[test]1538fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1539 new_test_ext().execute_with(|| {1540 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15411542 let origin1 = RuntimeOrigin::signed(1);1543 assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1544 assert_noop!(1545 Unique::add_to_allow_list(origin1, collection_id, account(2)),1546 CommonError::<Test>::CollectionNotFound1547 );1548 });1549}15501551// If address is already added to allow list, nothing happens1552#[test]1553fn address_is_already_added_to_allow_list() {1554 new_test_ext().execute_with(|| {1555 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1556 let origin1 = RuntimeOrigin::signed(1);15571558 assert_ok!(Unique::add_to_allow_list(1559 origin1.clone(),1560 collection_id,1561 account(2)1562 ));1563 assert_ok!(Unique::add_to_allow_list(1564 origin1,1565 collection_id,1566 account(2)1567 ));1568 assert!(<pallet_common::Allowlist<Test>>::get((1569 collection_id,1570 account(2)1571 )));1572 });1573}15741575#[test]1576fn owner_can_remove_address_from_allow_list() {1577 new_test_ext().execute_with(|| {1578 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15791580 let origin1 = RuntimeOrigin::signed(1);1581 assert_ok!(Unique::add_to_allow_list(1582 origin1.clone(),1583 collection_id,1584 account(2)1585 ));1586 assert_ok!(Unique::remove_from_allow_list(1587 origin1,1588 collection_id,1589 account(2)1590 ));1591 assert_eq!(1592 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1593 false1594 );1595 });1596}15971598#[test]1599fn admin_can_remove_address_from_allow_list() {1600 new_test_ext().execute_with(|| {1601 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1602 let origin1 = RuntimeOrigin::signed(1);1603 let origin2 = RuntimeOrigin::signed(2);16041605 // Owner adds admin1606 assert_ok!(Unique::add_collection_admin(1607 origin1.clone(),1608 collection_id,1609 account(2)1610 ));16111612 // Owner adds address 3 to allow list1613 assert_ok!(Unique::add_to_allow_list(1614 origin1,1615 collection_id,1616 account(3)1617 ));16181619 // Admin removes address 3 from allow list1620 assert_ok!(Unique::remove_from_allow_list(1621 origin2,1622 collection_id,1623 account(3)1624 ));1625 assert_eq!(1626 <pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1627 false1628 );1629 });1630}16311632#[test]1633fn nonprivileged_user_cannot_remove_address_from_allow_list() {1634 new_test_ext().execute_with(|| {1635 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1636 let origin1 = RuntimeOrigin::signed(1);1637 let origin2 = RuntimeOrigin::signed(2);16381639 assert_ok!(Unique::add_to_allow_list(1640 origin1,1641 collection_id,1642 account(2)1643 ));1644 assert_noop!(1645 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1646 CommonError::<Test>::NoPermission1647 );1648 assert!(<pallet_common::Allowlist<Test>>::get((1649 collection_id,1650 account(2)1651 )));1652 });1653}16541655#[test]1656fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1657 new_test_ext().execute_with(|| {1658 let origin1 = RuntimeOrigin::signed(1);16591660 assert_noop!(1661 Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1662 CommonError::<Test>::CollectionNotFound1663 );1664 });1665}16661667#[test]1668fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1669 new_test_ext().execute_with(|| {1670 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1671 let origin1 = RuntimeOrigin::signed(1);1672 let origin2 = RuntimeOrigin::signed(2);16731674 // Add account 2 to allow list1675 assert_ok!(Unique::add_to_allow_list(1676 origin1.clone(),1677 collection_id,1678 account(2)1679 ));16801681 // Account 2 is in collection allow-list1682 assert!(<pallet_common::Allowlist<Test>>::get((1683 collection_id,1684 account(2)1685 )));16861687 // Destroy collection1688 assert_ok!(Unique::destroy_collection(origin1, collection_id));16891690 // Attempt to remove account 2 from collection allow-list => error1691 assert_noop!(1692 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1693 CommonError::<Test>::CollectionNotFound1694 );16951696 // Account 2 is not found in collection allow-list anyway1697 assert_eq!(1698 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1699 false1700 );1701 });1702}17031704// If address is already removed from allow list, nothing happens1705#[test]1706fn address_is_already_removed_from_allow_list() {1707 new_test_ext().execute_with(|| {1708 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1709 let origin1 = RuntimeOrigin::signed(1);17101711 assert_ok!(Unique::add_to_allow_list(1712 origin1.clone(),1713 collection_id,1714 account(2)1715 ));1716 assert_ok!(Unique::remove_from_allow_list(1717 origin1.clone(),1718 collection_id,1719 account(2)1720 ));1721 assert_eq!(1722 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1723 false1724 );1725 assert_ok!(Unique::remove_from_allow_list(1726 origin1,1727 collection_id,1728 account(2)1729 ));1730 assert_eq!(1731 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1732 false1733 );1734 });1735}17361737// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1738#[test]1739fn allow_list_test_1() {1740 new_test_ext().execute_with(|| {1741 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17421743 let origin1 = RuntimeOrigin::signed(1);17441745 let data = default_nft_data();1746 create_test_item(collection_id, &data.into());17471748 assert_ok!(Unique::set_collection_permissions(1749 origin1.clone(),1750 collection_id,1751 CollectionPermissions {1752 mint_mode: None,1753 access: Some(AccessMode::AllowList),1754 nesting: None,1755 }1756 ));1757 assert_ok!(Unique::add_to_allow_list(1758 origin1.clone(),1759 collection_id,1760 account(2)1761 ));17621763 assert_noop!(1764 Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1765 .map_err(|e| e.error),1766 CommonError::<Test>::AddressNotInAllowlist1767 );1768 });1769}17701771#[test]1772fn allow_list_test_2() {1773 new_test_ext().execute_with(|| {1774 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1775 let origin1 = RuntimeOrigin::signed(1);17761777 let data = default_nft_data();1778 create_test_item(collection_id, &data.into());17791780 assert_ok!(Unique::set_collection_permissions(1781 origin1.clone(),1782 collection_id,1783 CollectionPermissions {1784 mint_mode: None,1785 access: Some(AccessMode::AllowList),1786 nesting: None,1787 }1788 ));1789 assert_ok!(Unique::add_to_allow_list(1790 origin1.clone(),1791 collection_id,1792 account(1)1793 ));1794 assert_ok!(Unique::add_to_allow_list(1795 origin1.clone(),1796 collection_id,1797 account(2)1798 ));17991800 // do approve1801 assert_ok!(Unique::approve(1802 origin1.clone(),1803 account(1),1804 collection_id,1805 TokenId(1),1806 11807 ));1808 assert_eq!(1809 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1810 account(1)1811 );18121813 assert_ok!(Unique::remove_from_allow_list(1814 origin1.clone(),1815 collection_id,1816 account(1)1817 ));18181819 assert_noop!(1820 Unique::transfer_from(1821 origin1,1822 account(1),1823 account(3),1824 CollectionId(1),1825 TokenId(1),1826 11827 )1828 .map_err(|e| e.error),1829 CommonError::<Test>::AddressNotInAllowlist1830 );1831 });1832}18331834// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1835#[test]1836fn allow_list_test_3() {1837 new_test_ext().execute_with(|| {1838 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18391840 let origin1 = RuntimeOrigin::signed(1);18411842 let data = default_nft_data();1843 create_test_item(collection_id, &data.into());18441845 assert_ok!(Unique::set_collection_permissions(1846 origin1.clone(),1847 collection_id,1848 CollectionPermissions {1849 mint_mode: None,1850 access: Some(AccessMode::AllowList),1851 nesting: None,1852 }1853 ));1854 assert_ok!(Unique::add_to_allow_list(1855 origin1.clone(),1856 collection_id,1857 account(1)1858 ));18591860 assert_noop!(1861 Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1862 .map_err(|e| e.error),1863 CommonError::<Test>::AddressNotInAllowlist1864 );1865 });1866}18671868#[test]1869fn allow_list_test_4() {1870 new_test_ext().execute_with(|| {1871 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18721873 let origin1 = RuntimeOrigin::signed(1);18741875 let data = default_nft_data();1876 create_test_item(collection_id, &data.into());18771878 assert_ok!(Unique::set_collection_permissions(1879 origin1.clone(),1880 collection_id,1881 CollectionPermissions {1882 mint_mode: None,1883 access: Some(AccessMode::AllowList),1884 nesting: None,1885 }1886 ));1887 assert_ok!(Unique::add_to_allow_list(1888 origin1.clone(),1889 collection_id,1890 account(1)1891 ));1892 assert_ok!(Unique::add_to_allow_list(1893 origin1.clone(),1894 collection_id,1895 account(2)1896 ));18971898 // do approve1899 assert_ok!(Unique::approve(1900 origin1.clone(),1901 account(1),1902 collection_id,1903 TokenId(1),1904 11905 ));1906 assert_eq!(1907 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1908 account(1)1909 );19101911 assert_ok!(Unique::remove_from_allow_list(1912 origin1.clone(),1913 collection_id,1914 account(2)1915 ));19161917 assert_noop!(1918 Unique::transfer_from(1919 origin1,1920 account(1),1921 account(3),1922 collection_id,1923 TokenId(1),1924 11925 )1926 .map_err(|e| e.error),1927 CommonError::<Test>::AddressNotInAllowlist1928 );1929 });1930}19311932// If Public Access mode is set to AllowList, tokens can’t be destroyed by a non-allowlisted address (even if it owned them before enabling AllowList mode)1933#[test]1934fn allow_list_test_5() {1935 new_test_ext().execute_with(|| {1936 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19371938 let origin1 = RuntimeOrigin::signed(1);19391940 let data = default_nft_data();1941 create_test_item(collection_id, &data.into());19421943 assert_ok!(Unique::set_collection_permissions(1944 origin1.clone(),1945 collection_id,1946 CollectionPermissions {1947 mint_mode: None,1948 access: Some(AccessMode::AllowList),1949 nesting: None,1950 }1951 ));1952 assert_noop!(1953 Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1954 CommonError::<Test>::AddressNotInAllowlist1955 );1956 });1957}19581959// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1960#[test]1961fn allow_list_test_6() {1962 new_test_ext().execute_with(|| {1963 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19641965 let origin1 = RuntimeOrigin::signed(1);19661967 let data = default_nft_data();1968 create_test_item(collection_id, &data.into());19691970 assert_ok!(Unique::set_collection_permissions(1971 origin1.clone(),1972 collection_id,1973 CollectionPermissions {1974 mint_mode: None,1975 access: Some(AccessMode::AllowList),1976 nesting: None,1977 }1978 ));19791980 // do approve1981 assert_noop!(1982 Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1983 .map_err(|e| e.error),1984 CommonError::<Test>::AddressNotInAllowlist1985 );1986 });1987}19881989// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1990// tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1991#[test]1992fn allow_list_test_7() {1993 new_test_ext().execute_with(|| {1994 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19951996 let data = default_nft_data();1997 create_test_item(collection_id, &data.into());19981999 let origin1 = RuntimeOrigin::signed(1);20002001 assert_ok!(Unique::set_collection_permissions(2002 origin1.clone(),2003 collection_id,2004 CollectionPermissions {2005 mint_mode: None,2006 access: Some(AccessMode::AllowList),2007 nesting: None,2008 }2009 ));2010 assert_ok!(Unique::add_to_allow_list(2011 origin1.clone(),2012 collection_id,2013 account(1)2014 ));2015 assert_ok!(Unique::add_to_allow_list(2016 origin1.clone(),2017 collection_id,2018 account(2)2019 ));20202021 assert_ok!(Unique::transfer(2022 origin1,2023 account(2),2024 CollectionId(1),2025 TokenId(1),2026 12027 ));2028 });2029}20302031#[test]2032fn allow_list_test_8() {2033 new_test_ext().execute_with(|| {2034 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20352036 // Create NFT for account 12037 let data = default_nft_data();2038 create_test_item(collection_id, &data.into());20392040 let origin1 = RuntimeOrigin::signed(1);20412042 // Toggle Allow List mode and add accounts 1 and 22043 assert_ok!(Unique::set_collection_permissions(2044 origin1.clone(),2045 collection_id,2046 CollectionPermissions {2047 mint_mode: None,2048 access: Some(AccessMode::AllowList),2049 nesting: None,2050 }2051 ));2052 assert_ok!(Unique::add_to_allow_list(2053 origin1.clone(),2054 collection_id,2055 account(1)2056 ));2057 assert_ok!(Unique::add_to_allow_list(2058 origin1.clone(),2059 collection_id,2060 account(2)2061 ));20622063 // Sself-approve account 1 for NFT 12064 assert_ok!(Unique::approve(2065 origin1.clone(),2066 account(1),2067 CollectionId(1),2068 TokenId(1),2069 12070 ));2071 assert_eq!(2072 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2073 account(1)2074 );20752076 // Transfer from 1 to 22077 assert_ok!(Unique::transfer_from(2078 origin1,2079 account(1),2080 account(2),2081 CollectionId(1),2082 TokenId(1),2083 12084 ));2085 });2086}20872088// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2089#[test]2090fn allow_list_test_9() {2091 new_test_ext().execute_with(|| {2092 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2093 let origin1 = RuntimeOrigin::signed(1);20942095 assert_ok!(Unique::set_collection_permissions(2096 origin1.clone(),2097 collection_id,2098 CollectionPermissions {2099 mint_mode: Some(false),2100 access: Some(AccessMode::AllowList),2101 nesting: None,2102 }2103 ));21042105 let data = default_nft_data();2106 create_test_item(collection_id, &data.into());2107 });2108}21092110// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2111#[test]2112fn allow_list_test_10() {2113 new_test_ext().execute_with(|| {2114 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21152116 let origin1 = RuntimeOrigin::signed(1);2117 let origin2 = RuntimeOrigin::signed(2);21182119 assert_ok!(Unique::set_collection_permissions(2120 origin1.clone(),2121 collection_id,2122 CollectionPermissions {2123 mint_mode: Some(false),2124 access: Some(AccessMode::AllowList),2125 nesting: None,2126 }2127 ));21282129 assert_ok!(Unique::add_collection_admin(2130 origin1,2131 collection_id,2132 account(2)2133 ));21342135 assert_ok!(Unique::create_item(2136 origin2,2137 collection_id,2138 account(2),2139 default_nft_data().into()2140 ));2141 });2142}21432144// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and allow listed address.2145#[test]2146fn allow_list_test_11() {2147 new_test_ext().execute_with(|| {2148 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21492150 let origin1 = RuntimeOrigin::signed(1);2151 let origin2 = RuntimeOrigin::signed(2);21522153 assert_ok!(Unique::set_collection_permissions(2154 origin1.clone(),2155 collection_id,2156 CollectionPermissions {2157 mint_mode: Some(false),2158 access: Some(AccessMode::AllowList),2159 nesting: None,2160 }2161 ));2162 assert_ok!(Unique::add_to_allow_list(2163 origin1,2164 collection_id,2165 account(2)2166 ));21672168 assert_noop!(2169 Unique::create_item(2170 origin2,2171 CollectionId(1),2172 account(2),2173 default_nft_data().into()2174 )2175 .map_err(|e| e.error),2176 CommonError::<Test>::PublicMintingNotAllowed2177 );2178 });2179}21802181// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-allow listed address.2182#[test]2183fn allow_list_test_12() {2184 new_test_ext().execute_with(|| {2185 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21862187 let origin1 = RuntimeOrigin::signed(1);2188 let origin2 = RuntimeOrigin::signed(2);21892190 assert_ok!(Unique::set_collection_permissions(2191 origin1.clone(),2192 collection_id,2193 CollectionPermissions {2194 mint_mode: Some(false),2195 access: Some(AccessMode::AllowList),2196 nesting: None,2197 }2198 ));21992200 assert_noop!(2201 Unique::create_item(2202 origin2,2203 CollectionId(1),2204 account(2),2205 default_nft_data().into()2206 )2207 .map_err(|e| e.error),2208 CommonError::<Test>::PublicMintingNotAllowed2209 );2210 });2211}22122213// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2214#[test]2215fn allow_list_test_13() {2216 new_test_ext().execute_with(|| {2217 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22182219 let origin1 = RuntimeOrigin::signed(1);22202221 assert_ok!(Unique::set_collection_permissions(2222 origin1.clone(),2223 collection_id,2224 CollectionPermissions {2225 mint_mode: Some(true),2226 access: Some(AccessMode::AllowList),2227 nesting: None,2228 }2229 ));22302231 let data = default_nft_data();2232 create_test_item(collection_id, &data.into());2233 });2234}22352236// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2237#[test]2238fn allow_list_test_14() {2239 new_test_ext().execute_with(|| {2240 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22412242 let origin1 = RuntimeOrigin::signed(1);2243 let origin2 = RuntimeOrigin::signed(2);22442245 assert_ok!(Unique::set_collection_permissions(2246 origin1.clone(),2247 collection_id,2248 CollectionPermissions {2249 mint_mode: Some(true),2250 access: Some(AccessMode::AllowList),2251 nesting: None,2252 }2253 ));22542255 assert_ok!(Unique::add_collection_admin(2256 origin1,2257 collection_id,2258 account(2)2259 ));22602261 assert_ok!(Unique::create_item(2262 origin2,2263 collection_id,2264 account(2),2265 default_nft_data().into()2266 ));2267 });2268}22692270// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-allow listed address.2271#[test]2272fn allow_list_test_15() {2273 new_test_ext().execute_with(|| {2274 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22752276 let origin1 = RuntimeOrigin::signed(1);2277 let origin2 = RuntimeOrigin::signed(2);22782279 assert_ok!(Unique::set_collection_permissions(2280 origin1.clone(),2281 collection_id,2282 CollectionPermissions {2283 mint_mode: Some(true),2284 access: Some(AccessMode::AllowList),2285 nesting: None,2286 }2287 ));22882289 assert_noop!(2290 Unique::create_item(2291 origin2,2292 collection_id,2293 account(2),2294 default_nft_data().into()2295 )2296 .map_err(|e| e.error),2297 CommonError::<Test>::AddressNotInAllowlist2298 );2299 });2300}23012302// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by non-privileged and allow listed address.2303#[test]2304fn allow_list_test_16() {2305 new_test_ext().execute_with(|| {2306 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23072308 let origin1 = RuntimeOrigin::signed(1);2309 let origin2 = RuntimeOrigin::signed(2);23102311 assert_ok!(Unique::set_collection_permissions(2312 origin1.clone(),2313 collection_id,2314 CollectionPermissions {2315 mint_mode: Some(true),2316 access: Some(AccessMode::AllowList),2317 nesting: None,2318 }2319 ));2320 assert_ok!(Unique::add_to_allow_list(2321 origin1,2322 collection_id,2323 account(2)2324 ));23252326 assert_ok!(Unique::create_item(2327 origin2,2328 collection_id,2329 account(2),2330 default_nft_data().into()2331 ));2332 });2333}23342335// Total number of collections. Positive test2336#[test]2337fn total_number_collections_bound() {2338 new_test_ext().execute_with(|| {2339 create_test_collection(&CollectionMode::NFT, CollectionId(1));2340 });2341}23422343#[test]2344fn create_max_collections() {2345 new_test_ext().execute_with(|| {2346 for i in 1..COLLECTION_NUMBER_LIMIT {2347 create_test_collection(&CollectionMode::NFT, CollectionId(i));2348 }2349 });2350}23512352// Total number of collections. Negative test2353#[test]2354fn total_number_collections_bound_neg() {2355 new_test_ext().execute_with(|| {2356 let origin1 = RuntimeOrigin::signed(1);23572358 for i in 1..=COLLECTION_NUMBER_LIMIT {2359 create_test_collection(&CollectionMode::NFT, CollectionId(i));2360 }23612362 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2363 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2364 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23652366 let data: CreateCollectionData<u64> = CreateCollectionData {2367 name: col_name1.try_into().unwrap(),2368 description: col_desc1.try_into().unwrap(),2369 token_prefix: token_prefix1.try_into().unwrap(),2370 mode: CollectionMode::NFT,2371 ..Default::default()2372 };23732374 // 11-th collection in chain. Expects error2375 assert_noop!(2376 Unique::create_collection_ex(origin1, data),2377 CommonError::<Test>::TotalCollectionsLimitExceeded2378 );2379 });2380}23812382// Owned tokens by a single address. Positive test2383#[test]2384fn owned_tokens_bound() {2385 new_test_ext().execute_with(|| {2386 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23872388 let data = default_nft_data();2389 create_test_item(collection_id, &data.clone().into());2390 create_test_item(collection_id, &data.into());2391 });2392}23932394// Owned tokens by a single address. Negotive test2395#[test]2396fn owned_tokens_bound_neg() {2397 new_test_ext().execute_with(|| {2398 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23992400 let origin1 = RuntimeOrigin::signed(1);24012402 for _ in 1..=MAX_TOKEN_OWNERSHIP {2403 let data = default_nft_data();2404 create_test_item(collection_id, &data.clone().into());2405 }24062407 let data = default_nft_data();2408 assert_noop!(2409 Unique::create_item(origin1, CollectionId(1), account(1), data.into())2410 .map_err(|e| e.error),2411 CommonError::<Test>::AccountTokenLimitExceeded2412 );2413 });2414}24152416// Number of collection admins. Positive test2417#[test]2418fn collection_admins_bound() {2419 new_test_ext().execute_with(|| {2420 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24212422 let origin1 = RuntimeOrigin::signed(1);24232424 assert_ok!(Unique::add_collection_admin(2425 origin1.clone(),2426 collection_id,2427 account(2)2428 ));2429 assert_ok!(Unique::add_collection_admin(2430 origin1,2431 collection_id,2432 account(3)2433 ));2434 });2435}24362437// Number of collection admins. Negotive test2438#[test]2439fn collection_admins_bound_neg() {2440 new_test_ext().execute_with(|| {2441 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24422443 let origin1 = RuntimeOrigin::signed(1);24442445 for i in 0..COLLECTION_ADMINS_LIMIT {2446 assert_ok!(Unique::add_collection_admin(2447 origin1.clone(),2448 collection_id,2449 account((2 + i).into())2450 ));2451 }2452 assert_noop!(2453 Unique::add_collection_admin(2454 origin1,2455 collection_id,2456 account((3 + COLLECTION_ADMINS_LIMIT).into())2457 ),2458 CommonError::<Test>::CollectionAdminCountExceeded2459 );2460 });2461}2462// #endregion24632464#[test]2465fn collection_transfer_flag_works() {2466 new_test_ext().execute_with(|| {2467 let origin1 = RuntimeOrigin::signed(1);24682469 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2470 assert_ok!(Unique::set_transfers_enabled_flag(2471 origin1,2472 collection_id,2473 true2474 ));24752476 let data = default_nft_data();2477 create_test_item(collection_id, &data.into());2478 assert_eq!(2479 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2480 12481 );2482 assert_eq!(2483 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2484 true2485 );24862487 let origin1 = RuntimeOrigin::signed(1);24882489 // default scenario2490 assert_ok!(Unique::transfer(2491 origin1,2492 account(2),2493 collection_id,2494 TokenId(1),2495 12496 ));2497 assert_eq!(2498 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2499 false2500 );2501 assert_eq!(2502 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2503 true2504 );2505 assert_eq!(2506 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2507 02508 );2509 assert_eq!(2510 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2511 12512 );2513 });2514}25152516#[test]2517fn collection_transfer_flag_works_neg() {2518 new_test_ext().execute_with(|| {2519 let origin1 = RuntimeOrigin::signed(1);25202521 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2522 assert_ok!(Unique::set_transfers_enabled_flag(2523 origin1,2524 collection_id,2525 false2526 ));25272528 let data = default_nft_data();2529 create_test_item(collection_id, &data.into());2530 assert_eq!(2531 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2532 12533 );2534 assert_eq!(2535 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2536 true2537 );25382539 let origin1 = RuntimeOrigin::signed(1);25402541 // default scenario2542 assert_noop!(2543 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2544 .map_err(|e| e.error),2545 CommonError::<Test>::TransferNotAllowed2546 );2547 assert_eq!(2548 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2549 12550 );2551 assert_eq!(2552 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2553 02554 );2555 assert_eq!(2556 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2557 true2558 );2559 assert_eq!(2560 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2561 false2562 );2563 });2564}25652566#[test]2567fn collection_sponsoring() {2568 new_test_ext().execute_with(|| {2569 // default_limits();2570 let user1 = 1_u64;2571 let user2 = 777_u64;2572 let origin1 = RuntimeOrigin::signed(user1);2573 let origin2 = RuntimeOrigin::signed(user2);2574 let account2 = account(user2);25752576 let collection_id =2577 create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2578 assert_ok!(Unique::set_collection_sponsor(2579 origin1.clone(),2580 collection_id,2581 user12582 ));2583 assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25842585 // Expect error while have no permissions2586 assert!(Unique::create_item(2587 origin2.clone(),2588 collection_id,2589 account2.clone(),2590 default_nft_data().into()2591 )2592 .is_err());25932594 assert_ok!(Unique::set_collection_permissions(2595 origin1.clone(),2596 collection_id,2597 CollectionPermissions {2598 mint_mode: Some(true),2599 access: Some(AccessMode::AllowList),2600 nesting: None,2601 }2602 ));2603 assert_ok!(Unique::add_to_allow_list(2604 origin1.clone(),2605 collection_id,2606 account2.clone()2607 ));26082609 assert_ok!(Unique::create_item(2610 origin2,2611 collection_id,2612 account2,2613 default_nft_data().into()2614 ));2615 });2616}