difftreelog
fix `transfer_nft_item_zero_value` test
in: master
1 file changed
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 nft_approve_and_transfer_from() {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());635636 let origin1 = RuntimeOrigin::signed(1);637 let origin2 = RuntimeOrigin::signed(2);638639 assert_eq!(640 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),641 1642 );643 assert_eq!(644 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),645 true646 );647648 // neg transfer_from649 assert_noop!(650 Unique::transfer_from(651 origin2.clone(),652 account(1),653 account(2),654 CollectionId(1),655 TokenId(1),656 1657 )658 .map_err(|e| e.error),659 CommonError::<Test>::ApprovedValueTooLow660 );661662 // do approve663 assert_ok!(Unique::approve(664 origin1,665 account(2),666 CollectionId(1),667 TokenId(1),668 1669 ));670 assert_eq!(671 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),672 account(2)673 );674675 assert_ok!(Unique::transfer_from(676 origin2,677 account(1),678 account(3),679 CollectionId(1),680 TokenId(1),681 1682 ));683 assert!(684 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()685 );686 });687}688689#[test]690fn nft_approve_and_transfer_from_allow_list() {691 new_test_ext().execute_with(|| {692 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));693694 let origin1 = RuntimeOrigin::signed(1);695 let origin2 = RuntimeOrigin::signed(2);696697 // Create NFT 1 for account 1698 let data = default_nft_data();699 create_test_item(collection_id, &data.clone().into());700 assert_eq!(701 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),702 1703 );704 assert_eq!(705 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),706 true707 );708709 // Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list710 assert_ok!(Unique::set_collection_permissions(711 origin1.clone(),712 CollectionId(1),713 CollectionPermissions {714 mint_mode: Some(true),715 access: Some(AccessMode::AllowList),716 nesting: None,717 }718 ));719 assert_ok!(Unique::add_to_allow_list(720 origin1.clone(),721 CollectionId(1),722 account(1)723 ));724 assert_ok!(Unique::add_to_allow_list(725 origin1.clone(),726 CollectionId(1),727 account(2)728 ));729 assert_ok!(Unique::add_to_allow_list(730 origin1.clone(),731 CollectionId(1),732 account(3)733 ));734735 // Account 1 approves account 2 for NFT 1736 assert_ok!(Unique::approve(737 origin1.clone(),738 account(2),739 CollectionId(1),740 TokenId(1),741 1742 ));743 assert_eq!(744 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),745 account(2)746 );747748 // Account 2 transfers NFT 1 from account 1 to account 3749 assert_ok!(Unique::transfer_from(750 origin2,751 account(1),752 account(3),753 CollectionId(1),754 TokenId(1),755 1756 ));757 assert!(758 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()759 );760 });761}762763#[test]764fn refungible_approve_and_transfer_from() {765 new_test_ext().execute_with(|| {766 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));767768 let origin1 = RuntimeOrigin::signed(1);769 let origin2 = RuntimeOrigin::signed(2);770771 // Create RFT 1 in 1023 pieces for account 1772 let data = default_re_fungible_data();773 create_test_item(collection_id, &data.into());774775 assert_eq!(776 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),777 1778 );779 assert_eq!(780 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),781 1023782 );783 assert_eq!(784 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),785 true786 );787788 // Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list789 assert_ok!(Unique::set_collection_permissions(790 origin1.clone(),791 CollectionId(1),792 CollectionPermissions {793 mint_mode: Some(true),794 access: Some(AccessMode::AllowList),795 nesting: None,796 }797 ));798 assert_ok!(Unique::add_to_allow_list(799 origin1.clone(),800 CollectionId(1),801 account(1)802 ));803 assert_ok!(Unique::add_to_allow_list(804 origin1.clone(),805 CollectionId(1),806 account(2)807 ));808 assert_ok!(Unique::add_to_allow_list(809 origin1.clone(),810 CollectionId(1),811 account(3)812 ));813814 // Account 1 approves account 2 for 1023 pieces of RFT 1815 assert_ok!(Unique::approve(816 origin1,817 account(2),818 CollectionId(1),819 TokenId(1),820 1023821 ));822 assert_eq!(823 <pallet_refungible::Allowance<Test>>::get((824 CollectionId(1),825 TokenId(1),826 account(1),827 account(2)828 )),829 1023830 );831832 // Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3833 assert_ok!(Unique::transfer_from(834 origin2,835 account(1),836 account(3),837 CollectionId(1),838 TokenId(1),839 100840 ));841 assert_eq!(842 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),843 1844 );845 assert_eq!(846 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),847 1848 );849 assert_eq!(850 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),851 923852 );853 assert_eq!(854 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),855 100856 );857 assert_eq!(858 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),859 true860 );861 assert_eq!(862 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),863 true864 );865 assert_eq!(866 <pallet_refungible::Allowance<Test>>::get((867 CollectionId(1),868 TokenId(1),869 account(1),870 account(2)871 )),872 923873 );874 });875}876877#[test]878fn fungible_approve_and_transfer_from() {879 new_test_ext().execute_with(|| {880 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));881882 let data = default_fungible_data();883 create_test_item(collection_id, &data.into());884885 let origin1 = RuntimeOrigin::signed(1);886 let origin2 = RuntimeOrigin::signed(2);887888 assert_ok!(Unique::set_collection_permissions(889 origin1.clone(),890 CollectionId(1),891 CollectionPermissions {892 mint_mode: Some(true),893 access: Some(AccessMode::AllowList),894 nesting: None,895 }896 ));897 assert_ok!(Unique::add_to_allow_list(898 origin1.clone(),899 CollectionId(1),900 account(1)901 ));902 assert_ok!(Unique::add_to_allow_list(903 origin1.clone(),904 CollectionId(1),905 account(2)906 ));907 assert_ok!(Unique::add_to_allow_list(908 origin1.clone(),909 CollectionId(1),910 account(3)911 ));912913 // do approve914 assert_ok!(Unique::approve(915 origin1.clone(),916 account(2),917 CollectionId(1),918 TokenId(0),919 5920 ));921 assert_eq!(922 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),923 5924 );925 assert_ok!(Unique::approve(926 origin1,927 account(3),928 CollectionId(1),929 TokenId(0),930 5931 ));932 assert_eq!(933 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),934 5935 );936 assert_eq!(937 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),938 5939 );940941 assert_ok!(Unique::transfer_from(942 origin2.clone(),943 account(1),944 account(3),945 CollectionId(1),946 TokenId(0),947 4948 ));949950 assert_eq!(951 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),952 1953 );954955 assert_noop!(956 Unique::transfer_from(957 origin2,958 account(1),959 account(3),960 CollectionId(1),961 TokenId(0),962 4963 )964 .map_err(|e| e.error),965 CommonError::<Test>::ApprovedValueTooLow966 );967 });968}969970#[test]971fn change_collection_owner() {972 new_test_ext().execute_with(|| {973 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));974975 let origin1 = RuntimeOrigin::signed(1);976 assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));977 assert_eq!(978 <pallet_common::CollectionById<Test>>::get(collection_id)979 .unwrap()980 .owner,981 2982 );983 });984}985986#[test]987fn destroy_collection() {988 new_test_ext().execute_with(|| {989 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));990991 let origin1 = RuntimeOrigin::signed(1);992 assert_ok!(Unique::destroy_collection(origin1, collection_id));993 });994}995996#[test]997fn burn_nft_item() {998 new_test_ext().execute_with(|| {999 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10001001 let origin1 = RuntimeOrigin::signed(1);10021003 let data = default_nft_data();1004 create_test_item(collection_id, &data.into());10051006 // check balance (collection with id = 1, user id = 1)1007 assert_eq!(1008 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1009 11010 );10111012 // burn item1013 assert_ok!(Unique::burn_item(1014 origin1.clone(),1015 collection_id,1016 TokenId(1),1017 11018 ));1019 assert_eq!(1020 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1021 01022 );1023 });1024}10251026#[test]1027fn burn_same_nft_item_twice() {1028 new_test_ext().execute_with(|| {1029 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10301031 let origin1 = RuntimeOrigin::signed(1);10321033 let data = default_nft_data();1034 create_test_item(collection_id, &data.into());10351036 // check balance (collection with id = 1, user id = 1)1037 assert_eq!(1038 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1039 11040 );10411042 // burn item1043 assert_ok!(Unique::burn_item(1044 origin1.clone(),1045 collection_id,1046 TokenId(1),1047 11048 ));10491050 // burn item again1051 assert_noop!(1052 Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1053 CommonError::<Test>::TokenNotFound1054 );10551056 assert_eq!(1057 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1058 01059 );1060 });1061}10621063#[test]1064fn burn_fungible_item() {1065 new_test_ext().execute_with(|| {1066 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));10671068 let origin1 = RuntimeOrigin::signed(1);1069 assert_ok!(Unique::add_collection_admin(1070 origin1.clone(),1071 collection_id,1072 account(2)1073 ));10741075 let data = default_fungible_data();1076 create_test_item(collection_id, &data.into());10771078 // check balance (collection with id = 1, user id = 1)1079 assert_eq!(1080 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1081 51082 );10831084 // burn item1085 assert_ok!(Unique::burn_item(1086 origin1.clone(),1087 CollectionId(1),1088 TokenId(0),1089 51090 ));1091 assert_noop!(1092 Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1093 CommonError::<Test>::TokenValueTooLow1094 );10951096 assert_eq!(1097 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1098 01099 );1100 });1101}11021103#[test]1104fn burn_fungible_item_with_token_id() {1105 new_test_ext().execute_with(|| {1106 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11071108 let origin1 = RuntimeOrigin::signed(1);1109 assert_ok!(Unique::add_collection_admin(1110 origin1.clone(),1111 collection_id,1112 account(2)1113 ));11141115 let data = default_fungible_data();1116 create_test_item(collection_id, &data.into());11171118 // check balance (collection with id = 1, user id = 1)1119 assert_eq!(1120 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1121 51122 );11231124 // Try to burn item using Token ID1125 assert_noop!(1126 Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1127 <pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1128 );1129 });1130}1131#[test]1132fn burn_refungible_item() {1133 new_test_ext().execute_with(|| {1134 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1135 let origin1 = RuntimeOrigin::signed(1);11361137 assert_ok!(Unique::set_collection_permissions(1138 origin1.clone(),1139 collection_id,1140 CollectionPermissions {1141 mint_mode: Some(true),1142 access: Some(AccessMode::AllowList),1143 nesting: None,1144 }1145 ));1146 assert_ok!(Unique::add_to_allow_list(1147 origin1.clone(),1148 collection_id,1149 account(1)1150 ));11511152 assert_ok!(Unique::add_collection_admin(1153 origin1.clone(),1154 collection_id,1155 account(2)1156 ));11571158 let data = default_re_fungible_data();1159 create_test_item(collection_id, &data.into());11601161 // check balance (collection with id = 1, user id = 2)1162 assert_eq!(1163 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1164 11165 );1166 assert_eq!(1167 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1168 10231169 );11701171 // burn item1172 assert_ok!(Unique::burn_item(1173 origin1.clone(),1174 collection_id,1175 TokenId(1),1176 10231177 ));1178 assert_noop!(1179 Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1180 CommonError::<Test>::TokenValueTooLow1181 );11821183 assert_eq!(1184 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1185 01186 );1187 });1188}11891190#[test]1191fn add_collection_admin() {1192 new_test_ext().execute_with(|| {1193 let collection1_id =1194 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1195 let origin1 = RuntimeOrigin::signed(1);11961197 // Add collection admins1198 assert_ok!(Unique::add_collection_admin(1199 origin1.clone(),1200 collection1_id,1201 account(2)1202 ));1203 assert_ok!(Unique::add_collection_admin(1204 origin1,1205 collection1_id,1206 account(3)1207 ));12081209 // Owner is not an admin by default1210 assert_eq!(1211 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1212 false1213 );1214 assert!(<pallet_common::IsAdmin<Test>>::get((1215 CollectionId(1),1216 account(2)1217 )));1218 assert!(<pallet_common::IsAdmin<Test>>::get((1219 CollectionId(1),1220 account(3)1221 )));1222 });1223}12241225#[test]1226fn remove_collection_admin() {1227 new_test_ext().execute_with(|| {1228 let collection1_id =1229 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1230 let origin1 = RuntimeOrigin::signed(1);12311232 // Add collection admins 2 and 31233 assert_ok!(Unique::add_collection_admin(1234 origin1.clone(),1235 collection1_id,1236 account(2)1237 ));1238 assert_ok!(Unique::add_collection_admin(1239 origin1.clone(),1240 collection1_id,1241 account(3)1242 ));12431244 assert!(<pallet_common::IsAdmin<Test>>::get((1245 CollectionId(1),1246 account(2)1247 )));1248 assert!(<pallet_common::IsAdmin<Test>>::get((1249 CollectionId(1),1250 account(3)1251 )));12521253 // remove admin 31254 assert_ok!(Unique::remove_collection_admin(1255 origin1,1256 CollectionId(1),1257 account(3)1258 ));12591260 // 2 is still admin, 3 is not an admin anymore1261 assert!(<pallet_common::IsAdmin<Test>>::get((1262 CollectionId(1),1263 account(2)1264 )));1265 assert_eq!(1266 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1267 false1268 );1269 });1270}12711272#[test]1273fn balance_of() {1274 new_test_ext().execute_with(|| {1275 let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1276 let fungible_collection_id =1277 create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1278 let re_fungible_collection_id =1279 create_test_collection(&CollectionMode::ReFungible, CollectionId(3));12801281 // check balance before1282 assert_eq!(1283 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1284 01285 );1286 assert_eq!(1287 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1288 01289 );1290 assert_eq!(1291 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1292 01293 );12941295 let nft_data = default_nft_data();1296 create_test_item(nft_collection_id, &nft_data.into());12971298 let fungible_data = default_fungible_data();1299 create_test_item(fungible_collection_id, &fungible_data.into());13001301 let re_fungible_data = default_re_fungible_data();1302 create_test_item(re_fungible_collection_id, &re_fungible_data.into());13031304 // check balance (collection with id = 1, user id = 1)1305 assert_eq!(1306 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1307 11308 );1309 assert_eq!(1310 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1311 51312 );1313 assert_eq!(1314 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1315 11316 );13171318 assert_eq!(1319 <pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1320 true1321 );1322 assert_eq!(1323 <pallet_refungible::Owned<Test>>::get((1324 re_fungible_collection_id,1325 account(1),1326 TokenId(1)1327 )),1328 true1329 );1330 });1331}13321333#[test]1334fn approve() {1335 new_test_ext().execute_with(|| {1336 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13371338 let data = default_nft_data();1339 create_test_item(collection_id, &data.into());13401341 let origin1 = RuntimeOrigin::signed(1);13421343 // approve1344 assert_ok!(Unique::approve(1345 origin1,1346 account(2),1347 CollectionId(1),1348 TokenId(1),1349 11350 ));1351 assert_eq!(1352 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1353 account(2)1354 );1355 });1356}13571358#[test]1359fn transfer_from() {1360 new_test_ext().execute_with(|| {1361 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1362 let origin1 = RuntimeOrigin::signed(1);1363 let origin2 = RuntimeOrigin::signed(2);13641365 let data = default_nft_data();1366 create_test_item(collection_id, &data.into());13671368 // approve1369 assert_ok!(Unique::approve(1370 origin1.clone(),1371 account(2),1372 CollectionId(1),1373 TokenId(1),1374 11375 ));1376 assert_eq!(1377 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1378 account(2)1379 );13801381 assert_ok!(Unique::set_collection_permissions(1382 origin1.clone(),1383 CollectionId(1),1384 CollectionPermissions {1385 mint_mode: Some(true),1386 access: Some(AccessMode::AllowList),1387 nesting: None,1388 }1389 ));1390 assert_ok!(Unique::add_to_allow_list(1391 origin1.clone(),1392 CollectionId(1),1393 account(1)1394 ));1395 assert_ok!(Unique::add_to_allow_list(1396 origin1.clone(),1397 CollectionId(1),1398 account(2)1399 ));1400 assert_ok!(Unique::add_to_allow_list(1401 origin1,1402 CollectionId(1),1403 account(3)1404 ));14051406 assert_ok!(Unique::transfer_from(1407 origin2,1408 account(1),1409 account(2),1410 CollectionId(1),1411 TokenId(1),1412 11413 ));14141415 // after transfer1416 assert_eq!(1417 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1418 01419 );1420 assert_eq!(1421 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1422 11423 );1424 });1425}14261427// #endregion14281429// Coverage tests region1430// #region14311432#[test]1433fn owner_can_add_address_to_allow_list() {1434 new_test_ext().execute_with(|| {1435 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14361437 let origin1 = RuntimeOrigin::signed(1);1438 assert_ok!(Unique::add_to_allow_list(1439 origin1,1440 collection_id,1441 account(2)1442 ));1443 assert!(<pallet_common::Allowlist<Test>>::get((1444 collection_id,1445 account(2)1446 )));1447 });1448}14491450#[test]1451fn admin_can_add_address_to_allow_list() {1452 new_test_ext().execute_with(|| {1453 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1454 let origin1 = RuntimeOrigin::signed(1);1455 let origin2 = RuntimeOrigin::signed(2);14561457 assert_ok!(Unique::add_collection_admin(1458 origin1,1459 collection_id,1460 account(2)1461 ));1462 assert_ok!(Unique::add_to_allow_list(1463 origin2,1464 collection_id,1465 account(3)1466 ));1467 assert!(<pallet_common::Allowlist<Test>>::get((1468 collection_id,1469 account(3)1470 )));1471 });1472}14731474#[test]1475fn nonprivileged_user_cannot_add_address_to_allow_list() {1476 new_test_ext().execute_with(|| {1477 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14781479 let origin2 = RuntimeOrigin::signed(2);1480 assert_noop!(1481 Unique::add_to_allow_list(origin2, collection_id, account(3)),1482 CommonError::<Test>::NoPermission1483 );1484 });1485}14861487#[test]1488fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1489 new_test_ext().execute_with(|| {1490 let origin1 = RuntimeOrigin::signed(1);14911492 assert_noop!(1493 Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1494 CommonError::<Test>::CollectionNotFound1495 );1496 });1497}14981499#[test]1500fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1501 new_test_ext().execute_with(|| {1502 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15031504 let origin1 = RuntimeOrigin::signed(1);1505 assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1506 assert_noop!(1507 Unique::add_to_allow_list(origin1, collection_id, account(2)),1508 CommonError::<Test>::CollectionNotFound1509 );1510 });1511}15121513// If address is already added to allow list, nothing happens1514#[test]1515fn address_is_already_added_to_allow_list() {1516 new_test_ext().execute_with(|| {1517 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1518 let origin1 = RuntimeOrigin::signed(1);15191520 assert_ok!(Unique::add_to_allow_list(1521 origin1.clone(),1522 collection_id,1523 account(2)1524 ));1525 assert_ok!(Unique::add_to_allow_list(1526 origin1,1527 collection_id,1528 account(2)1529 ));1530 assert!(<pallet_common::Allowlist<Test>>::get((1531 collection_id,1532 account(2)1533 )));1534 });1535}15361537#[test]1538fn owner_can_remove_address_from_allow_list() {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::add_to_allow_list(1544 origin1.clone(),1545 collection_id,1546 account(2)1547 ));1548 assert_ok!(Unique::remove_from_allow_list(1549 origin1,1550 collection_id,1551 account(2)1552 ));1553 assert_eq!(1554 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1555 false1556 );1557 });1558}15591560#[test]1561fn admin_can_remove_address_from_allow_list() {1562 new_test_ext().execute_with(|| {1563 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1564 let origin1 = RuntimeOrigin::signed(1);1565 let origin2 = RuntimeOrigin::signed(2);15661567 // Owner adds admin1568 assert_ok!(Unique::add_collection_admin(1569 origin1.clone(),1570 collection_id,1571 account(2)1572 ));15731574 // Owner adds address 3 to allow list1575 assert_ok!(Unique::add_to_allow_list(1576 origin1,1577 collection_id,1578 account(3)1579 ));15801581 // Admin removes address 3 from allow list1582 assert_ok!(Unique::remove_from_allow_list(1583 origin2,1584 collection_id,1585 account(3)1586 ));1587 assert_eq!(1588 <pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1589 false1590 );1591 });1592}15931594#[test]1595fn nonprivileged_user_cannot_remove_address_from_allow_list() {1596 new_test_ext().execute_with(|| {1597 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1598 let origin1 = RuntimeOrigin::signed(1);1599 let origin2 = RuntimeOrigin::signed(2);16001601 assert_ok!(Unique::add_to_allow_list(1602 origin1,1603 collection_id,1604 account(2)1605 ));1606 assert_noop!(1607 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1608 CommonError::<Test>::NoPermission1609 );1610 assert!(<pallet_common::Allowlist<Test>>::get((1611 collection_id,1612 account(2)1613 )));1614 });1615}16161617#[test]1618fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1619 new_test_ext().execute_with(|| {1620 let origin1 = RuntimeOrigin::signed(1);16211622 assert_noop!(1623 Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1624 CommonError::<Test>::CollectionNotFound1625 );1626 });1627}16281629#[test]1630fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1631 new_test_ext().execute_with(|| {1632 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1633 let origin1 = RuntimeOrigin::signed(1);1634 let origin2 = RuntimeOrigin::signed(2);16351636 // Add account 2 to allow list1637 assert_ok!(Unique::add_to_allow_list(1638 origin1.clone(),1639 collection_id,1640 account(2)1641 ));16421643 // Account 2 is in collection allow-list1644 assert!(<pallet_common::Allowlist<Test>>::get((1645 collection_id,1646 account(2)1647 )));16481649 // Destroy collection1650 assert_ok!(Unique::destroy_collection(origin1, collection_id));16511652 // Attempt to remove account 2 from collection allow-list => error1653 assert_noop!(1654 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1655 CommonError::<Test>::CollectionNotFound1656 );16571658 // Account 2 is not found in collection allow-list anyway1659 assert_eq!(1660 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1661 false1662 );1663 });1664}16651666// If address is already removed from allow list, nothing happens1667#[test]1668fn address_is_already_removed_from_allow_list() {1669 new_test_ext().execute_with(|| {1670 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1671 let origin1 = RuntimeOrigin::signed(1);16721673 assert_ok!(Unique::add_to_allow_list(1674 origin1.clone(),1675 collection_id,1676 account(2)1677 ));1678 assert_ok!(Unique::remove_from_allow_list(1679 origin1.clone(),1680 collection_id,1681 account(2)1682 ));1683 assert_eq!(1684 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1685 false1686 );1687 assert_ok!(Unique::remove_from_allow_list(1688 origin1,1689 collection_id,1690 account(2)1691 ));1692 assert_eq!(1693 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1694 false1695 );1696 });1697}16981699// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1700#[test]1701fn allow_list_test_1() {1702 new_test_ext().execute_with(|| {1703 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17041705 let origin1 = RuntimeOrigin::signed(1);17061707 let data = default_nft_data();1708 create_test_item(collection_id, &data.into());17091710 assert_ok!(Unique::set_collection_permissions(1711 origin1.clone(),1712 collection_id,1713 CollectionPermissions {1714 mint_mode: None,1715 access: Some(AccessMode::AllowList),1716 nesting: None,1717 }1718 ));1719 assert_ok!(Unique::add_to_allow_list(1720 origin1.clone(),1721 collection_id,1722 account(2)1723 ));17241725 assert_noop!(1726 Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1727 .map_err(|e| e.error),1728 CommonError::<Test>::AddressNotInAllowlist1729 );1730 });1731}17321733#[test]1734fn allow_list_test_2() {1735 new_test_ext().execute_with(|| {1736 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1737 let origin1 = RuntimeOrigin::signed(1);17381739 let data = default_nft_data();1740 create_test_item(collection_id, &data.into());17411742 assert_ok!(Unique::set_collection_permissions(1743 origin1.clone(),1744 collection_id,1745 CollectionPermissions {1746 mint_mode: None,1747 access: Some(AccessMode::AllowList),1748 nesting: None,1749 }1750 ));1751 assert_ok!(Unique::add_to_allow_list(1752 origin1.clone(),1753 collection_id,1754 account(1)1755 ));1756 assert_ok!(Unique::add_to_allow_list(1757 origin1.clone(),1758 collection_id,1759 account(2)1760 ));17611762 // do approve1763 assert_ok!(Unique::approve(1764 origin1.clone(),1765 account(1),1766 collection_id,1767 TokenId(1),1768 11769 ));1770 assert_eq!(1771 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1772 account(1)1773 );17741775 assert_ok!(Unique::remove_from_allow_list(1776 origin1.clone(),1777 collection_id,1778 account(1)1779 ));17801781 assert_noop!(1782 Unique::transfer_from(1783 origin1,1784 account(1),1785 account(3),1786 CollectionId(1),1787 TokenId(1),1788 11789 )1790 .map_err(|e| e.error),1791 CommonError::<Test>::AddressNotInAllowlist1792 );1793 });1794}17951796// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1797#[test]1798fn allow_list_test_3() {1799 new_test_ext().execute_with(|| {1800 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18011802 let origin1 = RuntimeOrigin::signed(1);18031804 let data = default_nft_data();1805 create_test_item(collection_id, &data.into());18061807 assert_ok!(Unique::set_collection_permissions(1808 origin1.clone(),1809 collection_id,1810 CollectionPermissions {1811 mint_mode: None,1812 access: Some(AccessMode::AllowList),1813 nesting: None,1814 }1815 ));1816 assert_ok!(Unique::add_to_allow_list(1817 origin1.clone(),1818 collection_id,1819 account(1)1820 ));18211822 assert_noop!(1823 Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1824 .map_err(|e| e.error),1825 CommonError::<Test>::AddressNotInAllowlist1826 );1827 });1828}18291830#[test]1831fn allow_list_test_4() {1832 new_test_ext().execute_with(|| {1833 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18341835 let origin1 = RuntimeOrigin::signed(1);18361837 let data = default_nft_data();1838 create_test_item(collection_id, &data.into());18391840 assert_ok!(Unique::set_collection_permissions(1841 origin1.clone(),1842 collection_id,1843 CollectionPermissions {1844 mint_mode: None,1845 access: Some(AccessMode::AllowList),1846 nesting: None,1847 }1848 ));1849 assert_ok!(Unique::add_to_allow_list(1850 origin1.clone(),1851 collection_id,1852 account(1)1853 ));1854 assert_ok!(Unique::add_to_allow_list(1855 origin1.clone(),1856 collection_id,1857 account(2)1858 ));18591860 // do approve1861 assert_ok!(Unique::approve(1862 origin1.clone(),1863 account(1),1864 collection_id,1865 TokenId(1),1866 11867 ));1868 assert_eq!(1869 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1870 account(1)1871 );18721873 assert_ok!(Unique::remove_from_allow_list(1874 origin1.clone(),1875 collection_id,1876 account(2)1877 ));18781879 assert_noop!(1880 Unique::transfer_from(1881 origin1,1882 account(1),1883 account(3),1884 collection_id,1885 TokenId(1),1886 11887 )1888 .map_err(|e| e.error),1889 CommonError::<Test>::AddressNotInAllowlist1890 );1891 });1892}18931894// 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)1895#[test]1896fn allow_list_test_5() {1897 new_test_ext().execute_with(|| {1898 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18991900 let origin1 = RuntimeOrigin::signed(1);19011902 let data = default_nft_data();1903 create_test_item(collection_id, &data.into());19041905 assert_ok!(Unique::set_collection_permissions(1906 origin1.clone(),1907 collection_id,1908 CollectionPermissions {1909 mint_mode: None,1910 access: Some(AccessMode::AllowList),1911 nesting: None,1912 }1913 ));1914 assert_noop!(1915 Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1916 CommonError::<Test>::AddressNotInAllowlist1917 );1918 });1919}19201921// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1922#[test]1923fn allow_list_test_6() {1924 new_test_ext().execute_with(|| {1925 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19261927 let origin1 = RuntimeOrigin::signed(1);19281929 let data = default_nft_data();1930 create_test_item(collection_id, &data.into());19311932 assert_ok!(Unique::set_collection_permissions(1933 origin1.clone(),1934 collection_id,1935 CollectionPermissions {1936 mint_mode: None,1937 access: Some(AccessMode::AllowList),1938 nesting: None,1939 }1940 ));19411942 // do approve1943 assert_noop!(1944 Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1945 .map_err(|e| e.error),1946 CommonError::<Test>::AddressNotInAllowlist1947 );1948 });1949}19501951// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1952// tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1953#[test]1954fn allow_list_test_7() {1955 new_test_ext().execute_with(|| {1956 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19571958 let data = default_nft_data();1959 create_test_item(collection_id, &data.into());19601961 let origin1 = RuntimeOrigin::signed(1);19621963 assert_ok!(Unique::set_collection_permissions(1964 origin1.clone(),1965 collection_id,1966 CollectionPermissions {1967 mint_mode: None,1968 access: Some(AccessMode::AllowList),1969 nesting: None,1970 }1971 ));1972 assert_ok!(Unique::add_to_allow_list(1973 origin1.clone(),1974 collection_id,1975 account(1)1976 ));1977 assert_ok!(Unique::add_to_allow_list(1978 origin1.clone(),1979 collection_id,1980 account(2)1981 ));19821983 assert_ok!(Unique::transfer(1984 origin1,1985 account(2),1986 CollectionId(1),1987 TokenId(1),1988 11989 ));1990 });1991}19921993#[test]1994fn allow_list_test_8() {1995 new_test_ext().execute_with(|| {1996 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19971998 // Create NFT for account 11999 let data = default_nft_data();2000 create_test_item(collection_id, &data.into());20012002 let origin1 = RuntimeOrigin::signed(1);20032004 // Toggle Allow List mode and add accounts 1 and 22005 assert_ok!(Unique::set_collection_permissions(2006 origin1.clone(),2007 collection_id,2008 CollectionPermissions {2009 mint_mode: None,2010 access: Some(AccessMode::AllowList),2011 nesting: None,2012 }2013 ));2014 assert_ok!(Unique::add_to_allow_list(2015 origin1.clone(),2016 collection_id,2017 account(1)2018 ));2019 assert_ok!(Unique::add_to_allow_list(2020 origin1.clone(),2021 collection_id,2022 account(2)2023 ));20242025 // Sself-approve account 1 for NFT 12026 assert_ok!(Unique::approve(2027 origin1.clone(),2028 account(1),2029 CollectionId(1),2030 TokenId(1),2031 12032 ));2033 assert_eq!(2034 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2035 account(1)2036 );20372038 // Transfer from 1 to 22039 assert_ok!(Unique::transfer_from(2040 origin1,2041 account(1),2042 account(2),2043 CollectionId(1),2044 TokenId(1),2045 12046 ));2047 });2048}20492050// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2051#[test]2052fn allow_list_test_9() {2053 new_test_ext().execute_with(|| {2054 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2055 let origin1 = RuntimeOrigin::signed(1);20562057 assert_ok!(Unique::set_collection_permissions(2058 origin1.clone(),2059 collection_id,2060 CollectionPermissions {2061 mint_mode: Some(false),2062 access: Some(AccessMode::AllowList),2063 nesting: None,2064 }2065 ));20662067 let data = default_nft_data();2068 create_test_item(collection_id, &data.into());2069 });2070}20712072// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2073#[test]2074fn allow_list_test_10() {2075 new_test_ext().execute_with(|| {2076 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20772078 let origin1 = RuntimeOrigin::signed(1);2079 let origin2 = RuntimeOrigin::signed(2);20802081 assert_ok!(Unique::set_collection_permissions(2082 origin1.clone(),2083 collection_id,2084 CollectionPermissions {2085 mint_mode: Some(false),2086 access: Some(AccessMode::AllowList),2087 nesting: None,2088 }2089 ));20902091 assert_ok!(Unique::add_collection_admin(2092 origin1,2093 collection_id,2094 account(2)2095 ));20962097 assert_ok!(Unique::create_item(2098 origin2,2099 collection_id,2100 account(2),2101 default_nft_data().into()2102 ));2103 });2104}21052106// 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.2107#[test]2108fn allow_list_test_11() {2109 new_test_ext().execute_with(|| {2110 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21112112 let origin1 = RuntimeOrigin::signed(1);2113 let origin2 = RuntimeOrigin::signed(2);21142115 assert_ok!(Unique::set_collection_permissions(2116 origin1.clone(),2117 collection_id,2118 CollectionPermissions {2119 mint_mode: Some(false),2120 access: Some(AccessMode::AllowList),2121 nesting: None,2122 }2123 ));2124 assert_ok!(Unique::add_to_allow_list(2125 origin1,2126 collection_id,2127 account(2)2128 ));21292130 assert_noop!(2131 Unique::create_item(2132 origin2,2133 CollectionId(1),2134 account(2),2135 default_nft_data().into()2136 )2137 .map_err(|e| e.error),2138 CommonError::<Test>::PublicMintingNotAllowed2139 );2140 });2141}21422143// 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.2144#[test]2145fn allow_list_test_12() {2146 new_test_ext().execute_with(|| {2147 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21482149 let origin1 = RuntimeOrigin::signed(1);2150 let origin2 = RuntimeOrigin::signed(2);21512152 assert_ok!(Unique::set_collection_permissions(2153 origin1.clone(),2154 collection_id,2155 CollectionPermissions {2156 mint_mode: Some(false),2157 access: Some(AccessMode::AllowList),2158 nesting: None,2159 }2160 ));21612162 assert_noop!(2163 Unique::create_item(2164 origin2,2165 CollectionId(1),2166 account(2),2167 default_nft_data().into()2168 )2169 .map_err(|e| e.error),2170 CommonError::<Test>::PublicMintingNotAllowed2171 );2172 });2173}21742175// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2176#[test]2177fn allow_list_test_13() {2178 new_test_ext().execute_with(|| {2179 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21802181 let origin1 = RuntimeOrigin::signed(1);21822183 assert_ok!(Unique::set_collection_permissions(2184 origin1.clone(),2185 collection_id,2186 CollectionPermissions {2187 mint_mode: Some(true),2188 access: Some(AccessMode::AllowList),2189 nesting: None,2190 }2191 ));21922193 let data = default_nft_data();2194 create_test_item(collection_id, &data.into());2195 });2196}21972198// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2199#[test]2200fn allow_list_test_14() {2201 new_test_ext().execute_with(|| {2202 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22032204 let origin1 = RuntimeOrigin::signed(1);2205 let origin2 = RuntimeOrigin::signed(2);22062207 assert_ok!(Unique::set_collection_permissions(2208 origin1.clone(),2209 collection_id,2210 CollectionPermissions {2211 mint_mode: Some(true),2212 access: Some(AccessMode::AllowList),2213 nesting: None,2214 }2215 ));22162217 assert_ok!(Unique::add_collection_admin(2218 origin1,2219 collection_id,2220 account(2)2221 ));22222223 assert_ok!(Unique::create_item(2224 origin2,2225 collection_id,2226 account(2),2227 default_nft_data().into()2228 ));2229 });2230}22312232// 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.2233#[test]2234fn allow_list_test_15() {2235 new_test_ext().execute_with(|| {2236 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22372238 let origin1 = RuntimeOrigin::signed(1);2239 let origin2 = RuntimeOrigin::signed(2);22402241 assert_ok!(Unique::set_collection_permissions(2242 origin1.clone(),2243 collection_id,2244 CollectionPermissions {2245 mint_mode: Some(true),2246 access: Some(AccessMode::AllowList),2247 nesting: None,2248 }2249 ));22502251 assert_noop!(2252 Unique::create_item(2253 origin2,2254 collection_id,2255 account(2),2256 default_nft_data().into()2257 )2258 .map_err(|e| e.error),2259 CommonError::<Test>::AddressNotInAllowlist2260 );2261 });2262}22632264// 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.2265#[test]2266fn allow_list_test_16() {2267 new_test_ext().execute_with(|| {2268 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22692270 let origin1 = RuntimeOrigin::signed(1);2271 let origin2 = RuntimeOrigin::signed(2);22722273 assert_ok!(Unique::set_collection_permissions(2274 origin1.clone(),2275 collection_id,2276 CollectionPermissions {2277 mint_mode: Some(true),2278 access: Some(AccessMode::AllowList),2279 nesting: None,2280 }2281 ));2282 assert_ok!(Unique::add_to_allow_list(2283 origin1,2284 collection_id,2285 account(2)2286 ));22872288 assert_ok!(Unique::create_item(2289 origin2,2290 collection_id,2291 account(2),2292 default_nft_data().into()2293 ));2294 });2295}22962297// Total number of collections. Positive test2298#[test]2299fn total_number_collections_bound() {2300 new_test_ext().execute_with(|| {2301 create_test_collection(&CollectionMode::NFT, CollectionId(1));2302 });2303}23042305#[test]2306fn create_max_collections() {2307 new_test_ext().execute_with(|| {2308 for i in 1..COLLECTION_NUMBER_LIMIT {2309 create_test_collection(&CollectionMode::NFT, CollectionId(i));2310 }2311 });2312}23132314// Total number of collections. Negative test2315#[test]2316fn total_number_collections_bound_neg() {2317 new_test_ext().execute_with(|| {2318 let origin1 = RuntimeOrigin::signed(1);23192320 for i in 1..=COLLECTION_NUMBER_LIMIT {2321 create_test_collection(&CollectionMode::NFT, CollectionId(i));2322 }23232324 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2325 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2326 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23272328 let data: CreateCollectionData<u64> = CreateCollectionData {2329 name: col_name1.try_into().unwrap(),2330 description: col_desc1.try_into().unwrap(),2331 token_prefix: token_prefix1.try_into().unwrap(),2332 mode: CollectionMode::NFT,2333 ..Default::default()2334 };23352336 // 11-th collection in chain. Expects error2337 assert_noop!(2338 Unique::create_collection_ex(origin1, data),2339 CommonError::<Test>::TotalCollectionsLimitExceeded2340 );2341 });2342}23432344// Owned tokens by a single address. Positive test2345#[test]2346fn owned_tokens_bound() {2347 new_test_ext().execute_with(|| {2348 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23492350 let data = default_nft_data();2351 create_test_item(collection_id, &data.clone().into());2352 create_test_item(collection_id, &data.into());2353 });2354}23552356// Owned tokens by a single address. Negotive test2357#[test]2358fn owned_tokens_bound_neg() {2359 new_test_ext().execute_with(|| {2360 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23612362 let origin1 = RuntimeOrigin::signed(1);23632364 for _ in 1..=MAX_TOKEN_OWNERSHIP {2365 let data = default_nft_data();2366 create_test_item(collection_id, &data.clone().into());2367 }23682369 let data = default_nft_data();2370 assert_noop!(2371 Unique::create_item(origin1, CollectionId(1), account(1), data.into())2372 .map_err(|e| e.error),2373 CommonError::<Test>::AccountTokenLimitExceeded2374 );2375 });2376}23772378// Number of collection admins. Positive test2379#[test]2380fn collection_admins_bound() {2381 new_test_ext().execute_with(|| {2382 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23832384 let origin1 = RuntimeOrigin::signed(1);23852386 assert_ok!(Unique::add_collection_admin(2387 origin1.clone(),2388 collection_id,2389 account(2)2390 ));2391 assert_ok!(Unique::add_collection_admin(2392 origin1,2393 collection_id,2394 account(3)2395 ));2396 });2397}23982399// Number of collection admins. Negotive test2400#[test]2401fn collection_admins_bound_neg() {2402 new_test_ext().execute_with(|| {2403 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24042405 let origin1 = RuntimeOrigin::signed(1);24062407 for i in 0..COLLECTION_ADMINS_LIMIT {2408 assert_ok!(Unique::add_collection_admin(2409 origin1.clone(),2410 collection_id,2411 account((2 + i).into())2412 ));2413 }2414 assert_noop!(2415 Unique::add_collection_admin(2416 origin1,2417 collection_id,2418 account((3 + COLLECTION_ADMINS_LIMIT).into())2419 ),2420 CommonError::<Test>::CollectionAdminCountExceeded2421 );2422 });2423}2424// #endregion24252426#[test]2427fn collection_transfer_flag_works() {2428 new_test_ext().execute_with(|| {2429 let origin1 = RuntimeOrigin::signed(1);24302431 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2432 assert_ok!(Unique::set_transfers_enabled_flag(2433 origin1,2434 collection_id,2435 true2436 ));24372438 let data = default_nft_data();2439 create_test_item(collection_id, &data.into());2440 assert_eq!(2441 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2442 12443 );2444 assert_eq!(2445 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2446 true2447 );24482449 let origin1 = RuntimeOrigin::signed(1);24502451 // default scenario2452 assert_ok!(Unique::transfer(2453 origin1,2454 account(2),2455 collection_id,2456 TokenId(1),2457 12458 ));2459 assert_eq!(2460 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2461 false2462 );2463 assert_eq!(2464 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2465 true2466 );2467 assert_eq!(2468 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2469 02470 );2471 assert_eq!(2472 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2473 12474 );2475 });2476}24772478#[test]2479fn collection_transfer_flag_works_neg() {2480 new_test_ext().execute_with(|| {2481 let origin1 = RuntimeOrigin::signed(1);24822483 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2484 assert_ok!(Unique::set_transfers_enabled_flag(2485 origin1,2486 collection_id,2487 false2488 ));24892490 let data = default_nft_data();2491 create_test_item(collection_id, &data.into());2492 assert_eq!(2493 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2494 12495 );2496 assert_eq!(2497 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2498 true2499 );25002501 let origin1 = RuntimeOrigin::signed(1);25022503 // default scenario2504 assert_noop!(2505 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2506 .map_err(|e| e.error),2507 CommonError::<Test>::TransferNotAllowed2508 );2509 assert_eq!(2510 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2511 12512 );2513 assert_eq!(2514 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2515 02516 );2517 assert_eq!(2518 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2519 true2520 );2521 assert_eq!(2522 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2523 false2524 );2525 });2526}25272528#[test]2529fn collection_sponsoring() {2530 new_test_ext().execute_with(|| {2531 // default_limits();2532 let user1 = 1_u64;2533 let user2 = 777_u64;2534 let origin1 = RuntimeOrigin::signed(user1);2535 let origin2 = RuntimeOrigin::signed(user2);2536 let account2 = account(user2);25372538 let collection_id =2539 create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2540 assert_ok!(Unique::set_collection_sponsor(2541 origin1.clone(),2542 collection_id,2543 user12544 ));2545 assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25462547 // Expect error while have no permissions2548 assert!(Unique::create_item(2549 origin2.clone(),2550 collection_id,2551 account2.clone(),2552 default_nft_data().into()2553 )2554 .is_err());25552556 assert_ok!(Unique::set_collection_permissions(2557 origin1.clone(),2558 collection_id,2559 CollectionPermissions {2560 mint_mode: Some(true),2561 access: Some(AccessMode::AllowList),2562 nesting: None,2563 }2564 ));2565 assert_ok!(Unique::add_to_allow_list(2566 origin1.clone(),2567 collection_id,2568 account2.clone()2569 ));25702571 assert_ok!(Unique::create_item(2572 origin2,2573 collection_id,2574 account2,2575 default_nft_data().into()2576 ));2577 });2578}