difftreelog
test fix refungible construction
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, Origin, 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 Origin::root(),36 DONOR_USER,37 value,38 039 ));40 assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(41 Origin::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 const_data: vec![1, 2, 3].try_into().unwrap(),66 pieces: 1023,67 }68}6970fn create_test_collection_for_owner(71 mode: &CollectionMode,72 owner: u64,73 id: CollectionId,74) -> CollectionId {75 add_balance(owner, CollectionCreationPrice::get() as u64 + 1);7677 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();78 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();79 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();80 let token_property_permissions: CollectionPropertiesPermissionsVec =81 vec![PropertyKeyPermission {82 key: b"test-prop".to_vec().try_into().unwrap(),83 permission: PropertyPermission {84 mutable: true,85 collection_admin: false,86 token_owner: true,87 },88 }]89 .try_into()90 .unwrap();91 let properties: CollectionPropertiesVec = vec![Property {92 key: b"test-collection-prop".to_vec().try_into().unwrap(),93 value: b"test-collection-value".to_vec().try_into().unwrap(),94 }]95 .try_into()96 .unwrap();9798 let data: CreateCollectionData<u64> = CreateCollectionData {99 name: col_name1.try_into().unwrap(),100 description: col_desc1.try_into().unwrap(),101 token_prefix: token_prefix1.try_into().unwrap(),102 mode: mode.clone(),103 token_property_permissions: token_property_permissions.clone(),104 properties: properties.clone(),105 ..Default::default()106 };107108 let origin1 = Origin::signed(owner);109 assert_ok!(Unique::create_collection_ex(origin1, data));110111 let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();112 let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();113 let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();114 assert_eq!(115 <pallet_common::CollectionById<Test>>::get(id)116 .unwrap()117 .owner,118 owner119 );120 assert_eq!(121 <pallet_common::CollectionById<Test>>::get(id).unwrap().name,122 saved_col_name123 );124 assert_eq!(125 <pallet_common::CollectionById<Test>>::get(id).unwrap().mode,126 *mode127 );128 assert_eq!(129 <pallet_common::CollectionById<Test>>::get(id)130 .unwrap()131 .description,132 saved_description133 );134 assert_eq!(135 <pallet_common::CollectionById<Test>>::get(id)136 .unwrap()137 .token_prefix,138 saved_prefix139 );140 assert_eq!(141 get_collection_property_permissions(id).as_slice(),142 token_property_permissions.as_slice()143 );144 assert_eq!(145 get_collection_properties(id).as_slice(),146 properties.as_slice()147 );148 id149}150151fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {152 <pallet_common::Pallet<Test>>::property_permissions(collection_id)153 .into_iter()154 .map(|(key, permission)| PropertyKeyPermission { key, permission })155 .collect()156}157158fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {159 <pallet_common::Pallet<Test>>::collection_properties(collection_id)160 .into_iter()161 .map(|(key, value)| Property { key, value })162 .collect()163}164165fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {166 <pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))167 .into_iter()168 .map(|(key, value)| Property { key, value })169 .collect()170}171172fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {173 create_test_collection_for_owner(&mode, 1, id)174}175176fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {177 let origin1 = Origin::signed(1);178 assert_ok!(Unique::create_item(179 origin1,180 collection_id,181 account(1),182 data.clone()183 ));184}185186fn account(sub: u64) -> TestCrossAccountId {187 TestCrossAccountId::from_sub(sub)188}189190// Use cases tests region191// #region192193#[test]194fn check_not_sufficient_founds() {195 new_test_ext().execute_with(|| {196 let acc: u64 = 1;197 <pallet_balances::Pallet<Test>>::set_balance(Origin::root(), acc, 0, 0).unwrap();198199 let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();200 let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();201 let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();202203 let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =204 CreateCollectionData {205 name: name.try_into().unwrap(),206 description: description.try_into().unwrap(),207 token_prefix: token_prefix.try_into().unwrap(),208 mode: CollectionMode::NFT,209 ..Default::default()210 };211212 let result = Unique::create_collection_ex(Origin::signed(acc), data);213 assert_err!(result, <CommonError<Test>>::NotSufficientFounds);214 });215}216217#[test]218fn create_fungible_collection_fails_with_large_decimal_numbers() {219 new_test_ext().execute_with(|| {220 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();221 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();222 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();223224 let data: CreateCollectionData<u64> = CreateCollectionData {225 name: col_name1.try_into().unwrap(),226 description: col_desc1.try_into().unwrap(),227 token_prefix: token_prefix1.try_into().unwrap(),228 mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),229 ..Default::default()230 };231232 let origin1 = Origin::signed(1);233 assert_noop!(234 Unique::create_collection_ex(origin1, data),235 UniqueError::<Test>::CollectionDecimalPointLimitExceeded236 );237 });238}239240#[test]241fn create_nft_item() {242 new_test_ext().execute_with(|| {243 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));244245 let data = default_nft_data();246 create_test_item(collection_id, &data.clone().into());247248 assert_eq!(249 get_token_properties(collection_id, TokenId(1)).as_slice(),250 data.properties.as_slice(),251 );252 });253}254255// Use cases tests region256// #region257#[test]258fn create_nft_multiple_items() {259 new_test_ext().execute_with(|| {260 create_test_collection(&CollectionMode::NFT, CollectionId(1));261262 let origin1 = Origin::signed(1);263264 let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];265266 assert_ok!(Unique::create_multiple_items(267 origin1,268 CollectionId(1),269 account(1),270 items_data271 .clone()272 .into_iter()273 .map(|d| { d.into() })274 .collect()275 ));276 for (index, data) in items_data.into_iter().enumerate() {277 assert_eq!(278 get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),279 data.properties.as_slice()280 );281 }282 });283}284285#[test]286fn create_refungible_item() {287 new_test_ext().execute_with(|| {288 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));289290 let data = default_re_fungible_data();291 create_test_item(collection_id, &data.clone().into());292 let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));293 let balance =294 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));295 assert_eq!(item.const_data, data.const_data.into_inner());296 assert_eq!(balance, 1023);297 });298}299300#[test]301fn create_multiple_refungible_items() {302 new_test_ext().execute_with(|| {303 create_test_collection(&CollectionMode::ReFungible, CollectionId(1));304305 let origin1 = Origin::signed(1);306307 let items_data = vec![308 default_re_fungible_data(),309 default_re_fungible_data(),310 default_re_fungible_data(),311 ];312313 assert_ok!(Unique::create_multiple_items(314 origin1,315 CollectionId(1),316 account(1),317 items_data318 .clone()319 .into_iter()320 .map(|d| { d.into() })321 .collect()322 ));323 for (index, data) in items_data.into_iter().enumerate() {324 let item = <pallet_refungible::TokenData<Test>>::get((325 CollectionId(1),326 TokenId((index + 1) as u32),327 ));328 let balance =329 <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));330 assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());331 assert_eq!(balance, 1023);332 }333 });334}335336#[test]337fn create_fungible_item() {338 new_test_ext().execute_with(|| {339 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));340341 let data = default_fungible_data();342 create_test_item(collection_id, &data.into());343344 assert_eq!(345 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),346 5347 );348 });349}350351//#[test]352// fn create_multiple_fungible_items() {353// new_test_ext().execute_with(|| {354// default_limits();355356// create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));357358// let origin1 = Origin::signed(1);359360// let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];361362// assert_ok!(Unique::create_multiple_items(363// origin1.clone(),364// 1,365// 1,366// items_data.clone().into_iter().map(|d| { d.into() }).collect()367// ));368369// for (index, _) in items_data.iter().enumerate() {370// assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);371// }372// assert_eq!(Unique::balance_count(1, 1), 3000);373// assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);374// });375// }376377#[test]378fn transfer_fungible_item() {379 new_test_ext().execute_with(|| {380 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));381382 let origin1 = Origin::signed(1);383 let origin2 = Origin::signed(2);384385 let data = default_fungible_data();386 create_test_item(collection_id, &data.into());387388 assert_eq!(389 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),390 5391 );392393 // change owner scenario394 assert_ok!(Unique::transfer(395 origin1,396 account(2),397 CollectionId(1),398 TokenId(0),399 5400 ));401 assert_eq!(402 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),403 0404 );405406 // split item scenario407 assert_ok!(Unique::transfer(408 origin2.clone(),409 account(3),410 CollectionId(1),411 TokenId(0),412 3413 ));414415 // split item and new owner has account scenario416 assert_ok!(Unique::transfer(417 origin2,418 account(3),419 CollectionId(1),420 TokenId(0),421 1422 ));423 assert_eq!(424 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),425 1426 );427 assert_eq!(428 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),429 4430 );431 });432}433434#[test]435fn transfer_refungible_item() {436 new_test_ext().execute_with(|| {437 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));438439 // Create RFT 1 in 1023 pieces for account 1440 let data = default_re_fungible_data();441 create_test_item(collection_id, &data.clone().into());442 let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));443 assert_eq!(item.const_data, data.const_data.into_inner());444 assert_eq!(445 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),446 1447 );448 assert_eq!(449 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),450 1023451 );452 assert_eq!(453 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),454 true455 );456457 // Account 1 transfers all 1023 pieces of RFT 1 to account 2458 let origin1 = Origin::signed(1);459 let origin2 = Origin::signed(2);460 assert_ok!(Unique::transfer(461 origin1,462 account(2),463 CollectionId(1),464 TokenId(1),465 1023466 ));467 assert_eq!(468 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),469 1023470 );471 assert_eq!(472 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),473 0474 );475 assert_eq!(476 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),477 1478 );479 assert_eq!(480 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),481 false482 );483 assert_eq!(484 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),485 true486 );487488 // Account 2 transfers 500 pieces of RFT 1 to account 3489 assert_ok!(Unique::transfer(490 origin2.clone(),491 account(3),492 CollectionId(1),493 TokenId(1),494 500495 ));496 assert_eq!(497 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),498 523499 );500 assert_eq!(501 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),502 500503 );504 assert_eq!(505 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),506 1507 );508 assert_eq!(509 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),510 1511 );512 assert_eq!(513 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),514 true515 );516 assert_eq!(517 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),518 true519 );520521 // Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance522 assert_ok!(Unique::transfer(523 origin2,524 account(3),525 CollectionId(1),526 TokenId(1),527 200528 ));529 assert_eq!(530 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),531 323532 );533 assert_eq!(534 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),535 700536 );537 assert_eq!(538 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),539 1540 );541 assert_eq!(542 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),543 1544 );545 assert_eq!(546 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),547 true548 );549 assert_eq!(550 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),551 true552 );553 });554}555556#[test]557fn transfer_nft_item() {558 new_test_ext().execute_with(|| {559 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));560561 let data = default_nft_data();562 create_test_item(collection_id, &data.into());563 assert_eq!(564 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),565 1566 );567 assert_eq!(568 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),569 true570 );571572 let origin1 = Origin::signed(1);573 // default scenario574 assert_ok!(Unique::transfer(575 origin1,576 account(2),577 CollectionId(1),578 TokenId(1),579 1580 ));581 assert_eq!(582 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),583 0584 );585 assert_eq!(586 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),587 1588 );589 assert_eq!(590 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),591 false592 );593 assert_eq!(594 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),595 true596 );597 });598}599600#[test]601fn transfer_nft_item_wrong_value() {602 new_test_ext().execute_with(|| {603 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));604605 let data = default_nft_data();606 create_test_item(collection_id, &data.into());607 assert_eq!(608 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),609 1610 );611 assert_eq!(612 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),613 true614 );615616 let origin1 = Origin::signed(1);617618 assert_noop!(619 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)620 .map_err(|e| e.error),621 <pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount622 );623 });624}625626#[test]627fn transfer_nft_item_zero_value() {628 new_test_ext().execute_with(|| {629 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));630631 let data = default_nft_data();632 create_test_item(collection_id, &data.into());633 assert_eq!(634 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),635 1636 );637 assert_eq!(638 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),639 true640 );641642 let origin1 = Origin::signed(1);643644 // Transferring 0 amount works on NFT...645 assert_ok!(Unique::transfer(646 origin1,647 account(2),648 CollectionId(1),649 TokenId(1),650 0651 ));652 // ... and results in no transfer653 assert_eq!(654 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),655 1656 );657 assert_eq!(658 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),659 true660 );661 });662}663664#[test]665fn nft_approve_and_transfer_from() {666 new_test_ext().execute_with(|| {667 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));668669 let data = default_nft_data();670 create_test_item(collection_id, &data.into());671672 let origin1 = Origin::signed(1);673 let origin2 = Origin::signed(2);674675 assert_eq!(676 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),677 1678 );679 assert_eq!(680 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),681 true682 );683684 // neg transfer_from685 assert_noop!(686 Unique::transfer_from(687 origin2.clone(),688 account(1),689 account(2),690 CollectionId(1),691 TokenId(1),692 1693 )694 .map_err(|e| e.error),695 CommonError::<Test>::ApprovedValueTooLow696 );697698 // do approve699 assert_ok!(Unique::approve(700 origin1,701 account(2),702 CollectionId(1),703 TokenId(1),704 1705 ));706 assert_eq!(707 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),708 account(2)709 );710711 assert_ok!(Unique::transfer_from(712 origin2,713 account(1),714 account(3),715 CollectionId(1),716 TokenId(1),717 1718 ));719 assert!(720 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()721 );722 });723}724725#[test]726fn nft_approve_and_transfer_from_allow_list() {727 new_test_ext().execute_with(|| {728 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));729730 let origin1 = Origin::signed(1);731 let origin2 = Origin::signed(2);732733 // Create NFT 1 for account 1734 let data = default_nft_data();735 create_test_item(collection_id, &data.clone().into());736 assert_eq!(737 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),738 1739 );740 assert_eq!(741 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),742 true743 );744745 // Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list746 assert_ok!(Unique::set_collection_permissions(747 origin1.clone(),748 CollectionId(1),749 CollectionPermissions {750 mint_mode: Some(true),751 access: Some(AccessMode::AllowList),752 nesting: None,753 }754 ));755 assert_ok!(Unique::add_to_allow_list(756 origin1.clone(),757 CollectionId(1),758 account(1)759 ));760 assert_ok!(Unique::add_to_allow_list(761 origin1.clone(),762 CollectionId(1),763 account(2)764 ));765 assert_ok!(Unique::add_to_allow_list(766 origin1.clone(),767 CollectionId(1),768 account(3)769 ));770771 // Account 1 approves account 2 for NFT 1772 assert_ok!(Unique::approve(773 origin1.clone(),774 account(2),775 CollectionId(1),776 TokenId(1),777 1778 ));779 assert_eq!(780 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),781 account(2)782 );783784 // Account 2 transfers NFT 1 from account 1 to account 3785 assert_ok!(Unique::transfer_from(786 origin2,787 account(1),788 account(3),789 CollectionId(1),790 TokenId(1),791 1792 ));793 assert!(794 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()795 );796 });797}798799#[test]800fn refungible_approve_and_transfer_from() {801 new_test_ext().execute_with(|| {802 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));803804 let origin1 = Origin::signed(1);805 let origin2 = Origin::signed(2);806807 // Create RFT 1 in 1023 pieces for account 1808 let data = default_re_fungible_data();809 create_test_item(collection_id, &data.into());810811 assert_eq!(812 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),813 1814 );815 assert_eq!(816 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),817 1023818 );819 assert_eq!(820 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),821 true822 );823824 // Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list825 assert_ok!(Unique::set_collection_permissions(826 origin1.clone(),827 CollectionId(1),828 CollectionPermissions {829 mint_mode: Some(true),830 access: Some(AccessMode::AllowList),831 nesting: None,832 }833 ));834 assert_ok!(Unique::add_to_allow_list(835 origin1.clone(),836 CollectionId(1),837 account(1)838 ));839 assert_ok!(Unique::add_to_allow_list(840 origin1.clone(),841 CollectionId(1),842 account(2)843 ));844 assert_ok!(Unique::add_to_allow_list(845 origin1.clone(),846 CollectionId(1),847 account(3)848 ));849850 // Account 1 approves account 2 for 1023 pieces of RFT 1851 assert_ok!(Unique::approve(852 origin1,853 account(2),854 CollectionId(1),855 TokenId(1),856 1023857 ));858 assert_eq!(859 <pallet_refungible::Allowance<Test>>::get((860 CollectionId(1),861 TokenId(1),862 account(1),863 account(2)864 )),865 1023866 );867868 // Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3869 assert_ok!(Unique::transfer_from(870 origin2,871 account(1),872 account(3),873 CollectionId(1),874 TokenId(1),875 100876 ));877 assert_eq!(878 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),879 1880 );881 assert_eq!(882 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),883 1884 );885 assert_eq!(886 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),887 923888 );889 assert_eq!(890 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),891 100892 );893 assert_eq!(894 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),895 true896 );897 assert_eq!(898 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),899 true900 );901 assert_eq!(902 <pallet_refungible::Allowance<Test>>::get((903 CollectionId(1),904 TokenId(1),905 account(1),906 account(2)907 )),908 923909 );910 });911}912913#[test]914fn fungible_approve_and_transfer_from() {915 new_test_ext().execute_with(|| {916 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));917918 let data = default_fungible_data();919 create_test_item(collection_id, &data.into());920921 let origin1 = Origin::signed(1);922 let origin2 = Origin::signed(2);923924 assert_ok!(Unique::set_collection_permissions(925 origin1.clone(),926 CollectionId(1),927 CollectionPermissions {928 mint_mode: Some(true),929 access: Some(AccessMode::AllowList),930 nesting: None,931 }932 ));933 assert_ok!(Unique::add_to_allow_list(934 origin1.clone(),935 CollectionId(1),936 account(1)937 ));938 assert_ok!(Unique::add_to_allow_list(939 origin1.clone(),940 CollectionId(1),941 account(2)942 ));943 assert_ok!(Unique::add_to_allow_list(944 origin1.clone(),945 CollectionId(1),946 account(3)947 ));948949 // do approve950 assert_ok!(Unique::approve(951 origin1.clone(),952 account(2),953 CollectionId(1),954 TokenId(0),955 5956 ));957 assert_eq!(958 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),959 5960 );961 assert_ok!(Unique::approve(962 origin1,963 account(3),964 CollectionId(1),965 TokenId(0),966 5967 ));968 assert_eq!(969 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),970 5971 );972 assert_eq!(973 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),974 5975 );976977 assert_ok!(Unique::transfer_from(978 origin2.clone(),979 account(1),980 account(3),981 CollectionId(1),982 TokenId(0),983 4984 ));985986 assert_eq!(987 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),988 1989 );990991 assert_noop!(992 Unique::transfer_from(993 origin2,994 account(1),995 account(3),996 CollectionId(1),997 TokenId(0),998 4999 )1000 .map_err(|e| e.error),1001 CommonError::<Test>::ApprovedValueTooLow1002 );1003 });1004}10051006#[test]1007fn change_collection_owner() {1008 new_test_ext().execute_with(|| {1009 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10101011 let origin1 = Origin::signed(1);1012 assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1013 assert_eq!(1014 <pallet_common::CollectionById<Test>>::get(collection_id)1015 .unwrap()1016 .owner,1017 21018 );1019 });1020}10211022#[test]1023fn destroy_collection() {1024 new_test_ext().execute_with(|| {1025 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10261027 let origin1 = Origin::signed(1);1028 assert_ok!(Unique::destroy_collection(origin1, collection_id));1029 });1030}10311032#[test]1033fn burn_nft_item() {1034 new_test_ext().execute_with(|| {1035 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10361037 let origin1 = Origin::signed(1);10381039 let data = default_nft_data();1040 create_test_item(collection_id, &data.into());10411042 // check balance (collection with id = 1, user id = 1)1043 assert_eq!(1044 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1045 11046 );10471048 // burn item1049 assert_ok!(Unique::burn_item(1050 origin1.clone(),1051 collection_id,1052 TokenId(1),1053 11054 ));1055 assert_eq!(1056 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1057 01058 );1059 });1060}10611062#[test]1063fn burn_same_nft_item_twice() {1064 new_test_ext().execute_with(|| {1065 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10661067 let origin1 = Origin::signed(1);10681069 let data = default_nft_data();1070 create_test_item(collection_id, &data.into());10711072 // check balance (collection with id = 1, user id = 1)1073 assert_eq!(1074 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1075 11076 );10771078 // burn item1079 assert_ok!(Unique::burn_item(1080 origin1.clone(),1081 collection_id,1082 TokenId(1),1083 11084 ));10851086 // burn item again1087 assert_noop!(1088 Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1089 CommonError::<Test>::TokenNotFound1090 );10911092 assert_eq!(1093 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1094 01095 );1096 });1097}10981099#[test]1100fn burn_fungible_item() {1101 new_test_ext().execute_with(|| {1102 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11031104 let origin1 = Origin::signed(1);1105 assert_ok!(Unique::add_collection_admin(1106 origin1.clone(),1107 collection_id,1108 account(2)1109 ));11101111 let data = default_fungible_data();1112 create_test_item(collection_id, &data.into());11131114 // check balance (collection with id = 1, user id = 1)1115 assert_eq!(1116 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1117 51118 );11191120 // burn item1121 assert_ok!(Unique::burn_item(1122 origin1.clone(),1123 CollectionId(1),1124 TokenId(0),1125 51126 ));1127 assert_noop!(1128 Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1129 CommonError::<Test>::TokenValueTooLow1130 );11311132 assert_eq!(1133 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1134 01135 );1136 });1137}11381139#[test]1140fn burn_fungible_item_with_token_id() {1141 new_test_ext().execute_with(|| {1142 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11431144 let origin1 = Origin::signed(1);1145 assert_ok!(Unique::add_collection_admin(1146 origin1.clone(),1147 collection_id,1148 account(2)1149 ));11501151 let data = default_fungible_data();1152 create_test_item(collection_id, &data.into());11531154 // check balance (collection with id = 1, user id = 1)1155 assert_eq!(1156 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1157 51158 );11591160 // Try to burn item using Token ID1161 assert_noop!(1162 Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1163 <pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1164 );1165 });1166}1167#[test]1168fn burn_refungible_item() {1169 new_test_ext().execute_with(|| {1170 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1171 let origin1 = Origin::signed(1);11721173 assert_ok!(Unique::set_collection_permissions(1174 origin1.clone(),1175 collection_id,1176 CollectionPermissions {1177 mint_mode: Some(true),1178 access: Some(AccessMode::AllowList),1179 nesting: None,1180 }1181 ));1182 assert_ok!(Unique::add_to_allow_list(1183 origin1.clone(),1184 collection_id,1185 account(1)1186 ));11871188 assert_ok!(Unique::add_collection_admin(1189 origin1.clone(),1190 collection_id,1191 account(2)1192 ));11931194 let data = default_re_fungible_data();1195 create_test_item(collection_id, &data.into());11961197 // check balance (collection with id = 1, user id = 2)1198 assert_eq!(1199 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1200 11201 );1202 assert_eq!(1203 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1204 10231205 );12061207 // burn item1208 assert_ok!(Unique::burn_item(1209 origin1.clone(),1210 collection_id,1211 TokenId(1),1212 10231213 ));1214 assert_noop!(1215 Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1216 CommonError::<Test>::TokenValueTooLow1217 );12181219 assert_eq!(1220 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1221 01222 );1223 });1224}12251226#[test]1227fn add_collection_admin() {1228 new_test_ext().execute_with(|| {1229 let collection1_id =1230 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1231 let origin1 = Origin::signed(1);12321233 // Add collection admins1234 assert_ok!(Unique::add_collection_admin(1235 origin1.clone(),1236 collection1_id,1237 account(2)1238 ));1239 assert_ok!(Unique::add_collection_admin(1240 origin1,1241 collection1_id,1242 account(3)1243 ));12441245 // Owner is not an admin by default1246 assert_eq!(1247 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1248 false1249 );1250 assert!(<pallet_common::IsAdmin<Test>>::get((1251 CollectionId(1),1252 account(2)1253 )));1254 assert!(<pallet_common::IsAdmin<Test>>::get((1255 CollectionId(1),1256 account(3)1257 )));1258 });1259}12601261#[test]1262fn remove_collection_admin() {1263 new_test_ext().execute_with(|| {1264 let collection1_id =1265 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1266 let origin1 = Origin::signed(1);12671268 // Add collection admins 2 and 31269 assert_ok!(Unique::add_collection_admin(1270 origin1.clone(),1271 collection1_id,1272 account(2)1273 ));1274 assert_ok!(Unique::add_collection_admin(1275 origin1.clone(),1276 collection1_id,1277 account(3)1278 ));12791280 assert!(<pallet_common::IsAdmin<Test>>::get((1281 CollectionId(1),1282 account(2)1283 )));1284 assert!(<pallet_common::IsAdmin<Test>>::get((1285 CollectionId(1),1286 account(3)1287 )));12881289 // remove admin 31290 assert_ok!(Unique::remove_collection_admin(1291 origin1,1292 CollectionId(1),1293 account(3)1294 ));12951296 // 2 is still admin, 3 is not an admin anymore1297 assert!(<pallet_common::IsAdmin<Test>>::get((1298 CollectionId(1),1299 account(2)1300 )));1301 assert_eq!(1302 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1303 false1304 );1305 });1306}13071308#[test]1309fn balance_of() {1310 new_test_ext().execute_with(|| {1311 let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1312 let fungible_collection_id =1313 create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1314 let re_fungible_collection_id =1315 create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13161317 // check balance before1318 assert_eq!(1319 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1320 01321 );1322 assert_eq!(1323 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1324 01325 );1326 assert_eq!(1327 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1328 01329 );13301331 let nft_data = default_nft_data();1332 create_test_item(nft_collection_id, &nft_data.into());13331334 let fungible_data = default_fungible_data();1335 create_test_item(fungible_collection_id, &fungible_data.into());13361337 let re_fungible_data = default_re_fungible_data();1338 create_test_item(re_fungible_collection_id, &re_fungible_data.into());13391340 // check balance (collection with id = 1, user id = 1)1341 assert_eq!(1342 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1343 11344 );1345 assert_eq!(1346 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1347 51348 );1349 assert_eq!(1350 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1351 11352 );13531354 assert_eq!(1355 <pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1356 true1357 );1358 assert_eq!(1359 <pallet_refungible::Owned<Test>>::get((1360 re_fungible_collection_id,1361 account(1),1362 TokenId(1)1363 )),1364 true1365 );1366 });1367}13681369#[test]1370fn approve() {1371 new_test_ext().execute_with(|| {1372 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13731374 let data = default_nft_data();1375 create_test_item(collection_id, &data.into());13761377 let origin1 = Origin::signed(1);13781379 // approve1380 assert_ok!(Unique::approve(1381 origin1,1382 account(2),1383 CollectionId(1),1384 TokenId(1),1385 11386 ));1387 assert_eq!(1388 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1389 account(2)1390 );1391 });1392}13931394#[test]1395fn transfer_from() {1396 new_test_ext().execute_with(|| {1397 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1398 let origin1 = Origin::signed(1);1399 let origin2 = Origin::signed(2);14001401 let data = default_nft_data();1402 create_test_item(collection_id, &data.into());14031404 // approve1405 assert_ok!(Unique::approve(1406 origin1.clone(),1407 account(2),1408 CollectionId(1),1409 TokenId(1),1410 11411 ));1412 assert_eq!(1413 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1414 account(2)1415 );14161417 assert_ok!(Unique::set_collection_permissions(1418 origin1.clone(),1419 CollectionId(1),1420 CollectionPermissions {1421 mint_mode: Some(true),1422 access: Some(AccessMode::AllowList),1423 nesting: None,1424 }1425 ));1426 assert_ok!(Unique::add_to_allow_list(1427 origin1.clone(),1428 CollectionId(1),1429 account(1)1430 ));1431 assert_ok!(Unique::add_to_allow_list(1432 origin1.clone(),1433 CollectionId(1),1434 account(2)1435 ));1436 assert_ok!(Unique::add_to_allow_list(1437 origin1,1438 CollectionId(1),1439 account(3)1440 ));14411442 assert_ok!(Unique::transfer_from(1443 origin2,1444 account(1),1445 account(2),1446 CollectionId(1),1447 TokenId(1),1448 11449 ));14501451 // after transfer1452 assert_eq!(1453 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1454 01455 );1456 assert_eq!(1457 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1458 11459 );1460 });1461}14621463// #endregion14641465// Coverage tests region1466// #region14671468#[test]1469fn owner_can_add_address_to_allow_list() {1470 new_test_ext().execute_with(|| {1471 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14721473 let origin1 = Origin::signed(1);1474 assert_ok!(Unique::add_to_allow_list(1475 origin1,1476 collection_id,1477 account(2)1478 ));1479 assert!(<pallet_common::Allowlist<Test>>::get((1480 collection_id,1481 account(2)1482 )));1483 });1484}14851486#[test]1487fn admin_can_add_address_to_allow_list() {1488 new_test_ext().execute_with(|| {1489 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1490 let origin1 = Origin::signed(1);1491 let origin2 = Origin::signed(2);14921493 assert_ok!(Unique::add_collection_admin(1494 origin1,1495 collection_id,1496 account(2)1497 ));1498 assert_ok!(Unique::add_to_allow_list(1499 origin2,1500 collection_id,1501 account(3)1502 ));1503 assert!(<pallet_common::Allowlist<Test>>::get((1504 collection_id,1505 account(3)1506 )));1507 });1508}15091510#[test]1511fn nonprivileged_user_cannot_add_address_to_allow_list() {1512 new_test_ext().execute_with(|| {1513 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15141515 let origin2 = Origin::signed(2);1516 assert_noop!(1517 Unique::add_to_allow_list(origin2, collection_id, account(3)),1518 CommonError::<Test>::NoPermission1519 );1520 });1521}15221523#[test]1524fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1525 new_test_ext().execute_with(|| {1526 let origin1 = Origin::signed(1);15271528 assert_noop!(1529 Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1530 CommonError::<Test>::CollectionNotFound1531 );1532 });1533}15341535#[test]1536fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1537 new_test_ext().execute_with(|| {1538 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15391540 let origin1 = Origin::signed(1);1541 assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1542 assert_noop!(1543 Unique::add_to_allow_list(origin1, collection_id, account(2)),1544 CommonError::<Test>::CollectionNotFound1545 );1546 });1547}15481549// If address is already added to allow list, nothing happens1550#[test]1551fn address_is_already_added_to_allow_list() {1552 new_test_ext().execute_with(|| {1553 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1554 let origin1 = Origin::signed(1);15551556 assert_ok!(Unique::add_to_allow_list(1557 origin1.clone(),1558 collection_id,1559 account(2)1560 ));1561 assert_ok!(Unique::add_to_allow_list(1562 origin1,1563 collection_id,1564 account(2)1565 ));1566 assert!(<pallet_common::Allowlist<Test>>::get((1567 collection_id,1568 account(2)1569 )));1570 });1571}15721573#[test]1574fn owner_can_remove_address_from_allow_list() {1575 new_test_ext().execute_with(|| {1576 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15771578 let origin1 = Origin::signed(1);1579 assert_ok!(Unique::add_to_allow_list(1580 origin1.clone(),1581 collection_id,1582 account(2)1583 ));1584 assert_ok!(Unique::remove_from_allow_list(1585 origin1,1586 collection_id,1587 account(2)1588 ));1589 assert_eq!(1590 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1591 false1592 );1593 });1594}15951596#[test]1597fn admin_can_remove_address_from_allow_list() {1598 new_test_ext().execute_with(|| {1599 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1600 let origin1 = Origin::signed(1);1601 let origin2 = Origin::signed(2);16021603 // Owner adds admin1604 assert_ok!(Unique::add_collection_admin(1605 origin1.clone(),1606 collection_id,1607 account(2)1608 ));16091610 // Owner adds address 3 to allow list1611 assert_ok!(Unique::add_to_allow_list(1612 origin1,1613 collection_id,1614 account(3)1615 ));16161617 // Admin removes address 3 from allow list1618 assert_ok!(Unique::remove_from_allow_list(1619 origin2,1620 collection_id,1621 account(3)1622 ));1623 assert_eq!(1624 <pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1625 false1626 );1627 });1628}16291630#[test]1631fn nonprivileged_user_cannot_remove_address_from_allow_list() {1632 new_test_ext().execute_with(|| {1633 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1634 let origin1 = Origin::signed(1);1635 let origin2 = Origin::signed(2);16361637 assert_ok!(Unique::add_to_allow_list(1638 origin1,1639 collection_id,1640 account(2)1641 ));1642 assert_noop!(1643 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1644 CommonError::<Test>::NoPermission1645 );1646 assert!(<pallet_common::Allowlist<Test>>::get((1647 collection_id,1648 account(2)1649 )));1650 });1651}16521653#[test]1654fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1655 new_test_ext().execute_with(|| {1656 let origin1 = Origin::signed(1);16571658 assert_noop!(1659 Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1660 CommonError::<Test>::CollectionNotFound1661 );1662 });1663}16641665#[test]1666fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1667 new_test_ext().execute_with(|| {1668 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1669 let origin1 = Origin::signed(1);1670 let origin2 = Origin::signed(2);16711672 // Add account 2 to allow list1673 assert_ok!(Unique::add_to_allow_list(1674 origin1.clone(),1675 collection_id,1676 account(2)1677 ));16781679 // Account 2 is in collection allow-list1680 assert!(<pallet_common::Allowlist<Test>>::get((1681 collection_id,1682 account(2)1683 )));16841685 // Destroy collection1686 assert_ok!(Unique::destroy_collection(origin1, collection_id));16871688 // Attempt to remove account 2 from collection allow-list => error1689 assert_noop!(1690 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1691 CommonError::<Test>::CollectionNotFound1692 );16931694 // Account 2 is not found in collection allow-list anyway1695 assert_eq!(1696 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1697 false1698 );1699 });1700}17011702// If address is already removed from allow list, nothing happens1703#[test]1704fn address_is_already_removed_from_allow_list() {1705 new_test_ext().execute_with(|| {1706 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1707 let origin1 = Origin::signed(1);17081709 assert_ok!(Unique::add_to_allow_list(1710 origin1.clone(),1711 collection_id,1712 account(2)1713 ));1714 assert_ok!(Unique::remove_from_allow_list(1715 origin1.clone(),1716 collection_id,1717 account(2)1718 ));1719 assert_eq!(1720 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1721 false1722 );1723 assert_ok!(Unique::remove_from_allow_list(1724 origin1,1725 collection_id,1726 account(2)1727 ));1728 assert_eq!(1729 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1730 false1731 );1732 });1733}17341735// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1736#[test]1737fn allow_list_test_1() {1738 new_test_ext().execute_with(|| {1739 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17401741 let origin1 = Origin::signed(1);17421743 let data = default_nft_data();1744 create_test_item(collection_id, &data.into());17451746 assert_ok!(Unique::set_collection_permissions(1747 origin1.clone(),1748 collection_id,1749 CollectionPermissions {1750 mint_mode: None,1751 access: Some(AccessMode::AllowList),1752 nesting: None,1753 }1754 ));1755 assert_ok!(Unique::add_to_allow_list(1756 origin1.clone(),1757 collection_id,1758 account(2)1759 ));17601761 assert_noop!(1762 Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1763 .map_err(|e| e.error),1764 CommonError::<Test>::AddressNotInAllowlist1765 );1766 });1767}17681769#[test]1770fn allow_list_test_2() {1771 new_test_ext().execute_with(|| {1772 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1773 let origin1 = Origin::signed(1);17741775 let data = default_nft_data();1776 create_test_item(collection_id, &data.into());17771778 assert_ok!(Unique::set_collection_permissions(1779 origin1.clone(),1780 collection_id,1781 CollectionPermissions {1782 mint_mode: None,1783 access: Some(AccessMode::AllowList),1784 nesting: None,1785 }1786 ));1787 assert_ok!(Unique::add_to_allow_list(1788 origin1.clone(),1789 collection_id,1790 account(1)1791 ));1792 assert_ok!(Unique::add_to_allow_list(1793 origin1.clone(),1794 collection_id,1795 account(2)1796 ));17971798 // do approve1799 assert_ok!(Unique::approve(1800 origin1.clone(),1801 account(1),1802 collection_id,1803 TokenId(1),1804 11805 ));1806 assert_eq!(1807 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1808 account(1)1809 );18101811 assert_ok!(Unique::remove_from_allow_list(1812 origin1.clone(),1813 collection_id,1814 account(1)1815 ));18161817 assert_noop!(1818 Unique::transfer_from(1819 origin1,1820 account(1),1821 account(3),1822 CollectionId(1),1823 TokenId(1),1824 11825 )1826 .map_err(|e| e.error),1827 CommonError::<Test>::AddressNotInAllowlist1828 );1829 });1830}18311832// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1833#[test]1834fn allow_list_test_3() {1835 new_test_ext().execute_with(|| {1836 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18371838 let origin1 = Origin::signed(1);18391840 let data = default_nft_data();1841 create_test_item(collection_id, &data.into());18421843 assert_ok!(Unique::set_collection_permissions(1844 origin1.clone(),1845 collection_id,1846 CollectionPermissions {1847 mint_mode: None,1848 access: Some(AccessMode::AllowList),1849 nesting: None,1850 }1851 ));1852 assert_ok!(Unique::add_to_allow_list(1853 origin1.clone(),1854 collection_id,1855 account(1)1856 ));18571858 assert_noop!(1859 Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1860 .map_err(|e| e.error),1861 CommonError::<Test>::AddressNotInAllowlist1862 );1863 });1864}18651866#[test]1867fn allow_list_test_4() {1868 new_test_ext().execute_with(|| {1869 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18701871 let origin1 = Origin::signed(1);18721873 let data = default_nft_data();1874 create_test_item(collection_id, &data.into());18751876 assert_ok!(Unique::set_collection_permissions(1877 origin1.clone(),1878 collection_id,1879 CollectionPermissions {1880 mint_mode: None,1881 access: Some(AccessMode::AllowList),1882 nesting: None,1883 }1884 ));1885 assert_ok!(Unique::add_to_allow_list(1886 origin1.clone(),1887 collection_id,1888 account(1)1889 ));1890 assert_ok!(Unique::add_to_allow_list(1891 origin1.clone(),1892 collection_id,1893 account(2)1894 ));18951896 // do approve1897 assert_ok!(Unique::approve(1898 origin1.clone(),1899 account(1),1900 collection_id,1901 TokenId(1),1902 11903 ));1904 assert_eq!(1905 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1906 account(1)1907 );19081909 assert_ok!(Unique::remove_from_allow_list(1910 origin1.clone(),1911 collection_id,1912 account(2)1913 ));19141915 assert_noop!(1916 Unique::transfer_from(1917 origin1,1918 account(1),1919 account(3),1920 collection_id,1921 TokenId(1),1922 11923 )1924 .map_err(|e| e.error),1925 CommonError::<Test>::AddressNotInAllowlist1926 );1927 });1928}19291930// 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)1931#[test]1932fn allow_list_test_5() {1933 new_test_ext().execute_with(|| {1934 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19351936 let origin1 = Origin::signed(1);19371938 let data = default_nft_data();1939 create_test_item(collection_id, &data.into());19401941 assert_ok!(Unique::set_collection_permissions(1942 origin1.clone(),1943 collection_id,1944 CollectionPermissions {1945 mint_mode: None,1946 access: Some(AccessMode::AllowList),1947 nesting: None,1948 }1949 ));1950 assert_noop!(1951 Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1952 CommonError::<Test>::AddressNotInAllowlist1953 );1954 });1955}19561957// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1958#[test]1959fn allow_list_test_6() {1960 new_test_ext().execute_with(|| {1961 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19621963 let origin1 = Origin::signed(1);19641965 let data = default_nft_data();1966 create_test_item(collection_id, &data.into());19671968 assert_ok!(Unique::set_collection_permissions(1969 origin1.clone(),1970 collection_id,1971 CollectionPermissions {1972 mint_mode: None,1973 access: Some(AccessMode::AllowList),1974 nesting: None,1975 }1976 ));19771978 // do approve1979 assert_noop!(1980 Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1981 .map_err(|e| e.error),1982 CommonError::<Test>::AddressNotInAllowlist1983 );1984 });1985}19861987// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1988// tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1989#[test]1990fn allow_list_test_7() {1991 new_test_ext().execute_with(|| {1992 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19931994 let data = default_nft_data();1995 create_test_item(collection_id, &data.into());19961997 let origin1 = Origin::signed(1);19981999 assert_ok!(Unique::set_collection_permissions(2000 origin1.clone(),2001 collection_id,2002 CollectionPermissions {2003 mint_mode: None,2004 access: Some(AccessMode::AllowList),2005 nesting: None,2006 }2007 ));2008 assert_ok!(Unique::add_to_allow_list(2009 origin1.clone(),2010 collection_id,2011 account(1)2012 ));2013 assert_ok!(Unique::add_to_allow_list(2014 origin1.clone(),2015 collection_id,2016 account(2)2017 ));20182019 assert_ok!(Unique::transfer(2020 origin1,2021 account(2),2022 CollectionId(1),2023 TokenId(1),2024 12025 ));2026 });2027}20282029#[test]2030fn allow_list_test_8() {2031 new_test_ext().execute_with(|| {2032 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20332034 // Create NFT for account 12035 let data = default_nft_data();2036 create_test_item(collection_id, &data.into());20372038 let origin1 = Origin::signed(1);20392040 // Toggle Allow List mode and add accounts 1 and 22041 assert_ok!(Unique::set_collection_permissions(2042 origin1.clone(),2043 collection_id,2044 CollectionPermissions {2045 mint_mode: None,2046 access: Some(AccessMode::AllowList),2047 nesting: None,2048 }2049 ));2050 assert_ok!(Unique::add_to_allow_list(2051 origin1.clone(),2052 collection_id,2053 account(1)2054 ));2055 assert_ok!(Unique::add_to_allow_list(2056 origin1.clone(),2057 collection_id,2058 account(2)2059 ));20602061 // Sself-approve account 1 for NFT 12062 assert_ok!(Unique::approve(2063 origin1.clone(),2064 account(1),2065 CollectionId(1),2066 TokenId(1),2067 12068 ));2069 assert_eq!(2070 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2071 account(1)2072 );20732074 // Transfer from 1 to 22075 assert_ok!(Unique::transfer_from(2076 origin1,2077 account(1),2078 account(2),2079 CollectionId(1),2080 TokenId(1),2081 12082 ));2083 });2084}20852086// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2087#[test]2088fn allow_list_test_9() {2089 new_test_ext().execute_with(|| {2090 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2091 let origin1 = Origin::signed(1);20922093 assert_ok!(Unique::set_collection_permissions(2094 origin1.clone(),2095 collection_id,2096 CollectionPermissions {2097 mint_mode: Some(false),2098 access: Some(AccessMode::AllowList),2099 nesting: None,2100 }2101 ));21022103 let data = default_nft_data();2104 create_test_item(collection_id, &data.into());2105 });2106}21072108// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2109#[test]2110fn allow_list_test_10() {2111 new_test_ext().execute_with(|| {2112 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21132114 let origin1 = Origin::signed(1);2115 let origin2 = Origin::signed(2);21162117 assert_ok!(Unique::set_collection_permissions(2118 origin1.clone(),2119 collection_id,2120 CollectionPermissions {2121 mint_mode: Some(false),2122 access: Some(AccessMode::AllowList),2123 nesting: None,2124 }2125 ));21262127 assert_ok!(Unique::add_collection_admin(2128 origin1,2129 collection_id,2130 account(2)2131 ));21322133 assert_ok!(Unique::create_item(2134 origin2,2135 collection_id,2136 account(2),2137 default_nft_data().into()2138 ));2139 });2140}21412142// 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.2143#[test]2144fn allow_list_test_11() {2145 new_test_ext().execute_with(|| {2146 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21472148 let origin1 = Origin::signed(1);2149 let origin2 = Origin::signed(2);21502151 assert_ok!(Unique::set_collection_permissions(2152 origin1.clone(),2153 collection_id,2154 CollectionPermissions {2155 mint_mode: Some(false),2156 access: Some(AccessMode::AllowList),2157 nesting: None,2158 }2159 ));2160 assert_ok!(Unique::add_to_allow_list(2161 origin1,2162 collection_id,2163 account(2)2164 ));21652166 assert_noop!(2167 Unique::create_item(2168 origin2,2169 CollectionId(1),2170 account(2),2171 default_nft_data().into()2172 )2173 .map_err(|e| e.error),2174 CommonError::<Test>::PublicMintingNotAllowed2175 );2176 });2177}21782179// 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.2180#[test]2181fn allow_list_test_12() {2182 new_test_ext().execute_with(|| {2183 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21842185 let origin1 = Origin::signed(1);2186 let origin2 = Origin::signed(2);21872188 assert_ok!(Unique::set_collection_permissions(2189 origin1.clone(),2190 collection_id,2191 CollectionPermissions {2192 mint_mode: Some(false),2193 access: Some(AccessMode::AllowList),2194 nesting: None,2195 }2196 ));21972198 assert_noop!(2199 Unique::create_item(2200 origin2,2201 CollectionId(1),2202 account(2),2203 default_nft_data().into()2204 )2205 .map_err(|e| e.error),2206 CommonError::<Test>::PublicMintingNotAllowed2207 );2208 });2209}22102211// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2212#[test]2213fn allow_list_test_13() {2214 new_test_ext().execute_with(|| {2215 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22162217 let origin1 = Origin::signed(1);22182219 assert_ok!(Unique::set_collection_permissions(2220 origin1.clone(),2221 collection_id,2222 CollectionPermissions {2223 mint_mode: Some(true),2224 access: Some(AccessMode::AllowList),2225 nesting: None,2226 }2227 ));22282229 let data = default_nft_data();2230 create_test_item(collection_id, &data.into());2231 });2232}22332234// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2235#[test]2236fn allow_list_test_14() {2237 new_test_ext().execute_with(|| {2238 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22392240 let origin1 = Origin::signed(1);2241 let origin2 = Origin::signed(2);22422243 assert_ok!(Unique::set_collection_permissions(2244 origin1.clone(),2245 collection_id,2246 CollectionPermissions {2247 mint_mode: Some(true),2248 access: Some(AccessMode::AllowList),2249 nesting: None,2250 }2251 ));22522253 assert_ok!(Unique::add_collection_admin(2254 origin1,2255 collection_id,2256 account(2)2257 ));22582259 assert_ok!(Unique::create_item(2260 origin2,2261 collection_id,2262 account(2),2263 default_nft_data().into()2264 ));2265 });2266}22672268// 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.2269#[test]2270fn allow_list_test_15() {2271 new_test_ext().execute_with(|| {2272 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22732274 let origin1 = Origin::signed(1);2275 let origin2 = Origin::signed(2);22762277 assert_ok!(Unique::set_collection_permissions(2278 origin1.clone(),2279 collection_id,2280 CollectionPermissions {2281 mint_mode: Some(true),2282 access: Some(AccessMode::AllowList),2283 nesting: None,2284 }2285 ));22862287 assert_noop!(2288 Unique::create_item(2289 origin2,2290 collection_id,2291 account(2),2292 default_nft_data().into()2293 )2294 .map_err(|e| e.error),2295 CommonError::<Test>::AddressNotInAllowlist2296 );2297 });2298}22992300// 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.2301#[test]2302fn allow_list_test_16() {2303 new_test_ext().execute_with(|| {2304 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23052306 let origin1 = Origin::signed(1);2307 let origin2 = Origin::signed(2);23082309 assert_ok!(Unique::set_collection_permissions(2310 origin1.clone(),2311 collection_id,2312 CollectionPermissions {2313 mint_mode: Some(true),2314 access: Some(AccessMode::AllowList),2315 nesting: None,2316 }2317 ));2318 assert_ok!(Unique::add_to_allow_list(2319 origin1,2320 collection_id,2321 account(2)2322 ));23232324 assert_ok!(Unique::create_item(2325 origin2,2326 collection_id,2327 account(2),2328 default_nft_data().into()2329 ));2330 });2331}23322333// Total number of collections. Positive test2334#[test]2335fn total_number_collections_bound() {2336 new_test_ext().execute_with(|| {2337 create_test_collection(&CollectionMode::NFT, CollectionId(1));2338 });2339}23402341#[test]2342fn create_max_collections() {2343 new_test_ext().execute_with(|| {2344 for i in 1..COLLECTION_NUMBER_LIMIT {2345 create_test_collection(&CollectionMode::NFT, CollectionId(i));2346 }2347 });2348}23492350// Total number of collections. Negative test2351#[test]2352fn total_number_collections_bound_neg() {2353 new_test_ext().execute_with(|| {2354 let origin1 = Origin::signed(1);23552356 for i in 1..=COLLECTION_NUMBER_LIMIT {2357 create_test_collection(&CollectionMode::NFT, CollectionId(i));2358 }23592360 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2361 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2362 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23632364 let data: CreateCollectionData<u64> = CreateCollectionData {2365 name: col_name1.try_into().unwrap(),2366 description: col_desc1.try_into().unwrap(),2367 token_prefix: token_prefix1.try_into().unwrap(),2368 mode: CollectionMode::NFT,2369 ..Default::default()2370 };23712372 // 11-th collection in chain. Expects error2373 assert_noop!(2374 Unique::create_collection_ex(origin1, data),2375 CommonError::<Test>::TotalCollectionsLimitExceeded2376 );2377 });2378}23792380// Owned tokens by a single address. Positive test2381#[test]2382fn owned_tokens_bound() {2383 new_test_ext().execute_with(|| {2384 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23852386 let data = default_nft_data();2387 create_test_item(collection_id, &data.clone().into());2388 create_test_item(collection_id, &data.into());2389 });2390}23912392// Owned tokens by a single address. Negotive test2393#[test]2394fn owned_tokens_bound_neg() {2395 new_test_ext().execute_with(|| {2396 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23972398 let origin1 = Origin::signed(1);23992400 for _ in 1..=MAX_TOKEN_OWNERSHIP {2401 let data = default_nft_data();2402 create_test_item(collection_id, &data.clone().into());2403 }24042405 let data = default_nft_data();2406 assert_noop!(2407 Unique::create_item(origin1, CollectionId(1), account(1), data.into())2408 .map_err(|e| e.error),2409 CommonError::<Test>::AccountTokenLimitExceeded2410 );2411 });2412}24132414// Number of collection admins. Positive test2415#[test]2416fn collection_admins_bound() {2417 new_test_ext().execute_with(|| {2418 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24192420 let origin1 = Origin::signed(1);24212422 assert_ok!(Unique::add_collection_admin(2423 origin1.clone(),2424 collection_id,2425 account(2)2426 ));2427 assert_ok!(Unique::add_collection_admin(2428 origin1,2429 collection_id,2430 account(3)2431 ));2432 });2433}24342435// Number of collection admins. Negotive test2436#[test]2437fn collection_admins_bound_neg() {2438 new_test_ext().execute_with(|| {2439 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24402441 let origin1 = Origin::signed(1);24422443 for i in 0..COLLECTION_ADMINS_LIMIT {2444 assert_ok!(Unique::add_collection_admin(2445 origin1.clone(),2446 collection_id,2447 account((2 + i).into())2448 ));2449 }2450 assert_noop!(2451 Unique::add_collection_admin(2452 origin1,2453 collection_id,2454 account((3 + COLLECTION_ADMINS_LIMIT).into())2455 ),2456 CommonError::<Test>::CollectionAdminCountExceeded2457 );2458 });2459}2460// #endregion24612462#[test]2463fn collection_transfer_flag_works() {2464 new_test_ext().execute_with(|| {2465 let origin1 = Origin::signed(1);24662467 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2468 assert_ok!(Unique::set_transfers_enabled_flag(2469 origin1,2470 collection_id,2471 true2472 ));24732474 let data = default_nft_data();2475 create_test_item(collection_id, &data.into());2476 assert_eq!(2477 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2478 12479 );2480 assert_eq!(2481 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2482 true2483 );24842485 let origin1 = Origin::signed(1);24862487 // default scenario2488 assert_ok!(Unique::transfer(2489 origin1,2490 account(2),2491 collection_id,2492 TokenId(1),2493 12494 ));2495 assert_eq!(2496 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2497 false2498 );2499 assert_eq!(2500 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2501 true2502 );2503 assert_eq!(2504 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2505 02506 );2507 assert_eq!(2508 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2509 12510 );2511 });2512}25132514#[test]2515fn collection_transfer_flag_works_neg() {2516 new_test_ext().execute_with(|| {2517 let origin1 = Origin::signed(1);25182519 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2520 assert_ok!(Unique::set_transfers_enabled_flag(2521 origin1,2522 collection_id,2523 false2524 ));25252526 let data = default_nft_data();2527 create_test_item(collection_id, &data.into());2528 assert_eq!(2529 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2530 12531 );2532 assert_eq!(2533 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2534 true2535 );25362537 let origin1 = Origin::signed(1);25382539 // default scenario2540 assert_noop!(2541 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2542 .map_err(|e| e.error),2543 CommonError::<Test>::TransferNotAllowed2544 );2545 assert_eq!(2546 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2547 12548 );2549 assert_eq!(2550 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2551 02552 );2553 assert_eq!(2554 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2555 true2556 );2557 assert_eq!(2558 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2559 false2560 );2561 });2562}25632564#[test]2565fn collection_sponsoring() {2566 new_test_ext().execute_with(|| {2567 // default_limits();2568 let user1 = 1_u64;2569 let user2 = 777_u64;2570 let origin1 = Origin::signed(user1);2571 let origin2 = Origin::signed(user2);2572 let account2 = account(user2);25732574 let collection_id =2575 create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2576 assert_ok!(Unique::set_collection_sponsor(2577 origin1.clone(),2578 collection_id,2579 user12580 ));2581 assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25822583 // Expect error while have no permissions2584 assert!(Unique::create_item(2585 origin2.clone(),2586 collection_id,2587 account2.clone(),2588 default_nft_data().into()2589 )2590 .is_err());25912592 assert_ok!(Unique::set_collection_permissions(2593 origin1.clone(),2594 collection_id,2595 CollectionPermissions {2596 mint_mode: Some(true),2597 access: Some(AccessMode::AllowList),2598 nesting: None,2599 }2600 ));2601 assert_ok!(Unique::add_to_allow_list(2602 origin1.clone(),2603 collection_id,2604 account2.clone()2605 ));26062607 assert_ok!(Unique::create_item(2608 origin2,2609 collection_id,2610 account2,2611 default_nft_data().into()2612 ));2613 });2614}