difftreelog
chore cargo fmt
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 balance =298 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));299 assert_eq!(balance, 1023);300 });301}302303#[test]304fn create_multiple_refungible_items() {305 new_test_ext().execute_with(|| {306 create_test_collection(&CollectionMode::ReFungible, CollectionId(1));307308 let origin1 = RuntimeOrigin::signed(1);309310 let items_data = vec![311 default_re_fungible_data(),312 default_re_fungible_data(),313 default_re_fungible_data(),314 ];315316 assert_ok!(Unique::create_multiple_items(317 origin1,318 CollectionId(1),319 account(1),320 items_data321 .clone()322 .into_iter()323 .map(|d| { d.into() })324 .collect()325 ));326 for (index, data) in items_data.into_iter().enumerate() {327 let balance =328 <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId((index + 1) as u32), account(1)));329 assert_eq!(balance, 1023);330 }331 });332}333334#[test]335fn create_fungible_item() {336 new_test_ext().execute_with(|| {337 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));338339 let data = default_fungible_data();340 create_test_item(collection_id, &data.into());341342 assert_eq!(343 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),344 5345 );346 });347}348349//#[test]350// fn create_multiple_fungible_items() {351// new_test_ext().execute_with(|| {352// default_limits();353354// create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));355356// let origin1 = RuntimeOrigin::signed(1);357358// let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];359360// assert_ok!(Unique::create_multiple_items(361// origin1.clone(),362// 1,363// 1,364// items_data.clone().into_iter().map(|d| { d.into() }).collect()365// ));366367// for (index, _) in items_data.iter().enumerate() {368// assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);369// }370// assert_eq!(Unique::balance_count(1, 1), 3000);371// assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);372// });373// }374375#[test]376fn transfer_fungible_item() {377 new_test_ext().execute_with(|| {378 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));379380 let origin1 = RuntimeOrigin::signed(1);381 let origin2 = RuntimeOrigin::signed(2);382383 let data = default_fungible_data();384 create_test_item(collection_id, &data.into());385386 assert_eq!(387 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),388 5389 );390391 // change owner scenario392 assert_ok!(Unique::transfer(393 origin1,394 account(2),395 CollectionId(1),396 TokenId(0),397 5398 ));399 assert_eq!(400 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),401 0402 );403404 // split item scenario405 assert_ok!(Unique::transfer(406 origin2.clone(),407 account(3),408 CollectionId(1),409 TokenId(0),410 3411 ));412413 // split item and new owner has account scenario414 assert_ok!(Unique::transfer(415 origin2,416 account(3),417 CollectionId(1),418 TokenId(0),419 1420 ));421 assert_eq!(422 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),423 1424 );425 assert_eq!(426 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),427 4428 );429 });430}431432#[test]433fn transfer_refungible_item() {434 new_test_ext().execute_with(|| {435 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));436437 // Create RFT 1 in 1023 pieces for account 1438 let data = default_re_fungible_data();439 create_test_item(collection_id, &data.clone().into());440 assert_eq!(441 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),442 1443 );444 assert_eq!(445 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),446 1023447 );448 assert_eq!(449 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),450 true451 );452453 // Account 1 transfers all 1023 pieces of RFT 1 to account 2454 let origin1 = RuntimeOrigin::signed(1);455 let origin2 = RuntimeOrigin::signed(2);456 assert_ok!(Unique::transfer(457 origin1,458 account(2),459 CollectionId(1),460 TokenId(1),461 1023462 ));463 assert_eq!(464 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),465 1023466 );467 assert_eq!(468 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),469 0470 );471 assert_eq!(472 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),473 1474 );475 assert_eq!(476 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),477 false478 );479 assert_eq!(480 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),481 true482 );483484 // Account 2 transfers 500 pieces of RFT 1 to account 3485 assert_ok!(Unique::transfer(486 origin2.clone(),487 account(3),488 CollectionId(1),489 TokenId(1),490 500491 ));492 assert_eq!(493 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),494 523495 );496 assert_eq!(497 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),498 500499 );500 assert_eq!(501 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),502 1503 );504 assert_eq!(505 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),506 1507 );508 assert_eq!(509 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),510 true511 );512 assert_eq!(513 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),514 true515 );516517 // Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance518 assert_ok!(Unique::transfer(519 origin2,520 account(3),521 CollectionId(1),522 TokenId(1),523 200524 ));525 assert_eq!(526 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),527 323528 );529 assert_eq!(530 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),531 700532 );533 assert_eq!(534 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),535 1536 );537 assert_eq!(538 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),539 1540 );541 assert_eq!(542 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),543 true544 );545 assert_eq!(546 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),547 true548 );549 });550}551552#[test]553fn transfer_nft_item() {554 new_test_ext().execute_with(|| {555 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));556557 let data = default_nft_data();558 create_test_item(collection_id, &data.into());559 assert_eq!(560 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),561 1562 );563 assert_eq!(564 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),565 true566 );567568 let origin1 = RuntimeOrigin::signed(1);569 // default scenario570 assert_ok!(Unique::transfer(571 origin1,572 account(2),573 CollectionId(1),574 TokenId(1),575 1576 ));577 assert_eq!(578 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),579 0580 );581 assert_eq!(582 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),583 1584 );585 assert_eq!(586 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),587 false588 );589 assert_eq!(590 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),591 true592 );593 });594}595596#[test]597fn transfer_nft_item_wrong_value() {598 new_test_ext().execute_with(|| {599 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));600601 let data = default_nft_data();602 create_test_item(collection_id, &data.into());603 assert_eq!(604 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),605 1606 );607 assert_eq!(608 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),609 true610 );611612 let origin1 = RuntimeOrigin::signed(1);613614 assert_noop!(615 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)616 .map_err(|e| e.error),617 <pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount618 );619 });620}621622#[test]623fn transfer_nft_item_zero_value() {624 new_test_ext().execute_with(|| {625 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));626627 let data = default_nft_data();628 create_test_item(collection_id, &data.into());629 assert_eq!(630 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),631 1632 );633 assert_eq!(634 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),635 true636 );637638 let origin1 = RuntimeOrigin::signed(1);639640 // Transferring 0 amount works on NFT...641 assert_ok!(Unique::transfer(642 origin1,643 account(2),644 CollectionId(1),645 TokenId(1),646 0647 ));648 // ... and results in no transfer649 assert_eq!(650 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),651 1652 );653 assert_eq!(654 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),655 true656 );657 });658}659660#[test]661fn nft_approve_and_transfer_from() {662 new_test_ext().execute_with(|| {663 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));664665 let data = default_nft_data();666 create_test_item(collection_id, &data.into());667668 let origin1 = RuntimeOrigin::signed(1);669 let origin2 = RuntimeOrigin::signed(2);670671 assert_eq!(672 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),673 1674 );675 assert_eq!(676 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),677 true678 );679680 // neg transfer_from681 assert_noop!(682 Unique::transfer_from(683 origin2.clone(),684 account(1),685 account(2),686 CollectionId(1),687 TokenId(1),688 1689 )690 .map_err(|e| e.error),691 CommonError::<Test>::ApprovedValueTooLow692 );693694 // do approve695 assert_ok!(Unique::approve(696 origin1,697 account(2),698 CollectionId(1),699 TokenId(1),700 1701 ));702 assert_eq!(703 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),704 account(2)705 );706707 assert_ok!(Unique::transfer_from(708 origin2,709 account(1),710 account(3),711 CollectionId(1),712 TokenId(1),713 1714 ));715 assert!(716 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()717 );718 });719}720721#[test]722fn nft_approve_and_transfer_from_allow_list() {723 new_test_ext().execute_with(|| {724 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));725726 let origin1 = RuntimeOrigin::signed(1);727 let origin2 = RuntimeOrigin::signed(2);728729 // Create NFT 1 for account 1730 let data = default_nft_data();731 create_test_item(collection_id, &data.clone().into());732 assert_eq!(733 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),734 1735 );736 assert_eq!(737 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),738 true739 );740741 // Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list742 assert_ok!(Unique::set_collection_permissions(743 origin1.clone(),744 CollectionId(1),745 CollectionPermissions {746 mint_mode: Some(true),747 access: Some(AccessMode::AllowList),748 nesting: None,749 }750 ));751 assert_ok!(Unique::add_to_allow_list(752 origin1.clone(),753 CollectionId(1),754 account(1)755 ));756 assert_ok!(Unique::add_to_allow_list(757 origin1.clone(),758 CollectionId(1),759 account(2)760 ));761 assert_ok!(Unique::add_to_allow_list(762 origin1.clone(),763 CollectionId(1),764 account(3)765 ));766767 // Account 1 approves account 2 for NFT 1768 assert_ok!(Unique::approve(769 origin1.clone(),770 account(2),771 CollectionId(1),772 TokenId(1),773 1774 ));775 assert_eq!(776 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),777 account(2)778 );779780 // Account 2 transfers NFT 1 from account 1 to account 3781 assert_ok!(Unique::transfer_from(782 origin2,783 account(1),784 account(3),785 CollectionId(1),786 TokenId(1),787 1788 ));789 assert!(790 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()791 );792 });793}794795#[test]796fn refungible_approve_and_transfer_from() {797 new_test_ext().execute_with(|| {798 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));799800 let origin1 = RuntimeOrigin::signed(1);801 let origin2 = RuntimeOrigin::signed(2);802803 // Create RFT 1 in 1023 pieces for account 1804 let data = default_re_fungible_data();805 create_test_item(collection_id, &data.into());806807 assert_eq!(808 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),809 1810 );811 assert_eq!(812 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),813 1023814 );815 assert_eq!(816 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),817 true818 );819820 // Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list821 assert_ok!(Unique::set_collection_permissions(822 origin1.clone(),823 CollectionId(1),824 CollectionPermissions {825 mint_mode: Some(true),826 access: Some(AccessMode::AllowList),827 nesting: None,828 }829 ));830 assert_ok!(Unique::add_to_allow_list(831 origin1.clone(),832 CollectionId(1),833 account(1)834 ));835 assert_ok!(Unique::add_to_allow_list(836 origin1.clone(),837 CollectionId(1),838 account(2)839 ));840 assert_ok!(Unique::add_to_allow_list(841 origin1.clone(),842 CollectionId(1),843 account(3)844 ));845846 // Account 1 approves account 2 for 1023 pieces of RFT 1847 assert_ok!(Unique::approve(848 origin1,849 account(2),850 CollectionId(1),851 TokenId(1),852 1023853 ));854 assert_eq!(855 <pallet_refungible::Allowance<Test>>::get((856 CollectionId(1),857 TokenId(1),858 account(1),859 account(2)860 )),861 1023862 );863864 // Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3865 assert_ok!(Unique::transfer_from(866 origin2,867 account(1),868 account(3),869 CollectionId(1),870 TokenId(1),871 100872 ));873 assert_eq!(874 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),875 1876 );877 assert_eq!(878 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),879 1880 );881 assert_eq!(882 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),883 923884 );885 assert_eq!(886 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),887 100888 );889 assert_eq!(890 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),891 true892 );893 assert_eq!(894 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),895 true896 );897 assert_eq!(898 <pallet_refungible::Allowance<Test>>::get((899 CollectionId(1),900 TokenId(1),901 account(1),902 account(2)903 )),904 923905 );906 });907}908909#[test]910fn fungible_approve_and_transfer_from() {911 new_test_ext().execute_with(|| {912 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));913914 let data = default_fungible_data();915 create_test_item(collection_id, &data.into());916917 let origin1 = RuntimeOrigin::signed(1);918 let origin2 = RuntimeOrigin::signed(2);919920 assert_ok!(Unique::set_collection_permissions(921 origin1.clone(),922 CollectionId(1),923 CollectionPermissions {924 mint_mode: Some(true),925 access: Some(AccessMode::AllowList),926 nesting: None,927 }928 ));929 assert_ok!(Unique::add_to_allow_list(930 origin1.clone(),931 CollectionId(1),932 account(1)933 ));934 assert_ok!(Unique::add_to_allow_list(935 origin1.clone(),936 CollectionId(1),937 account(2)938 ));939 assert_ok!(Unique::add_to_allow_list(940 origin1.clone(),941 CollectionId(1),942 account(3)943 ));944945 // do approve946 assert_ok!(Unique::approve(947 origin1.clone(),948 account(2),949 CollectionId(1),950 TokenId(0),951 5952 ));953 assert_eq!(954 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),955 5956 );957 assert_ok!(Unique::approve(958 origin1,959 account(3),960 CollectionId(1),961 TokenId(0),962 5963 ));964 assert_eq!(965 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),966 5967 );968 assert_eq!(969 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),970 5971 );972973 assert_ok!(Unique::transfer_from(974 origin2.clone(),975 account(1),976 account(3),977 CollectionId(1),978 TokenId(0),979 4980 ));981982 assert_eq!(983 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),984 1985 );986987 assert_noop!(988 Unique::transfer_from(989 origin2,990 account(1),991 account(3),992 CollectionId(1),993 TokenId(0),994 4995 )996 .map_err(|e| e.error),997 CommonError::<Test>::ApprovedValueTooLow998 );999 });1000}10011002#[test]1003fn change_collection_owner() {1004 new_test_ext().execute_with(|| {1005 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10061007 let origin1 = RuntimeOrigin::signed(1);1008 assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1009 assert_eq!(1010 <pallet_common::CollectionById<Test>>::get(collection_id)1011 .unwrap()1012 .owner,1013 21014 );1015 });1016}10171018#[test]1019fn destroy_collection() {1020 new_test_ext().execute_with(|| {1021 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10221023 let origin1 = RuntimeOrigin::signed(1);1024 assert_ok!(Unique::destroy_collection(origin1, collection_id));1025 });1026}10271028#[test]1029fn burn_nft_item() {1030 new_test_ext().execute_with(|| {1031 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10321033 let origin1 = RuntimeOrigin::signed(1);10341035 let data = default_nft_data();1036 create_test_item(collection_id, &data.into());10371038 // check balance (collection with id = 1, user id = 1)1039 assert_eq!(1040 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1041 11042 );10431044 // burn item1045 assert_ok!(Unique::burn_item(1046 origin1.clone(),1047 collection_id,1048 TokenId(1),1049 11050 ));1051 assert_eq!(1052 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1053 01054 );1055 });1056}10571058#[test]1059fn burn_same_nft_item_twice() {1060 new_test_ext().execute_with(|| {1061 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10621063 let origin1 = RuntimeOrigin::signed(1);10641065 let data = default_nft_data();1066 create_test_item(collection_id, &data.into());10671068 // check balance (collection with id = 1, user id = 1)1069 assert_eq!(1070 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1071 11072 );10731074 // burn item1075 assert_ok!(Unique::burn_item(1076 origin1.clone(),1077 collection_id,1078 TokenId(1),1079 11080 ));10811082 // burn item again1083 assert_noop!(1084 Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1085 CommonError::<Test>::TokenNotFound1086 );10871088 assert_eq!(1089 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1090 01091 );1092 });1093}10941095#[test]1096fn burn_fungible_item() {1097 new_test_ext().execute_with(|| {1098 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));10991100 let origin1 = RuntimeOrigin::signed(1);1101 assert_ok!(Unique::add_collection_admin(1102 origin1.clone(),1103 collection_id,1104 account(2)1105 ));11061107 let data = default_fungible_data();1108 create_test_item(collection_id, &data.into());11091110 // check balance (collection with id = 1, user id = 1)1111 assert_eq!(1112 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1113 51114 );11151116 // burn item1117 assert_ok!(Unique::burn_item(1118 origin1.clone(),1119 CollectionId(1),1120 TokenId(0),1121 51122 ));1123 assert_noop!(1124 Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1125 CommonError::<Test>::TokenValueTooLow1126 );11271128 assert_eq!(1129 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1130 01131 );1132 });1133}11341135#[test]1136fn burn_fungible_item_with_token_id() {1137 new_test_ext().execute_with(|| {1138 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11391140 let origin1 = RuntimeOrigin::signed(1);1141 assert_ok!(Unique::add_collection_admin(1142 origin1.clone(),1143 collection_id,1144 account(2)1145 ));11461147 let data = default_fungible_data();1148 create_test_item(collection_id, &data.into());11491150 // check balance (collection with id = 1, user id = 1)1151 assert_eq!(1152 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1153 51154 );11551156 // Try to burn item using Token ID1157 assert_noop!(1158 Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1159 <pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1160 );1161 });1162}1163#[test]1164fn burn_refungible_item() {1165 new_test_ext().execute_with(|| {1166 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1167 let origin1 = RuntimeOrigin::signed(1);11681169 assert_ok!(Unique::set_collection_permissions(1170 origin1.clone(),1171 collection_id,1172 CollectionPermissions {1173 mint_mode: Some(true),1174 access: Some(AccessMode::AllowList),1175 nesting: None,1176 }1177 ));1178 assert_ok!(Unique::add_to_allow_list(1179 origin1.clone(),1180 collection_id,1181 account(1)1182 ));11831184 assert_ok!(Unique::add_collection_admin(1185 origin1.clone(),1186 collection_id,1187 account(2)1188 ));11891190 let data = default_re_fungible_data();1191 create_test_item(collection_id, &data.into());11921193 // check balance (collection with id = 1, user id = 2)1194 assert_eq!(1195 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1196 11197 );1198 assert_eq!(1199 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1200 10231201 );12021203 // burn item1204 assert_ok!(Unique::burn_item(1205 origin1.clone(),1206 collection_id,1207 TokenId(1),1208 10231209 ));1210 assert_noop!(1211 Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1212 CommonError::<Test>::TokenValueTooLow1213 );12141215 assert_eq!(1216 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1217 01218 );1219 });1220}12211222#[test]1223fn add_collection_admin() {1224 new_test_ext().execute_with(|| {1225 let collection1_id =1226 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1227 let origin1 = RuntimeOrigin::signed(1);12281229 // Add collection admins1230 assert_ok!(Unique::add_collection_admin(1231 origin1.clone(),1232 collection1_id,1233 account(2)1234 ));1235 assert_ok!(Unique::add_collection_admin(1236 origin1,1237 collection1_id,1238 account(3)1239 ));12401241 // Owner is not an admin by default1242 assert_eq!(1243 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1244 false1245 );1246 assert!(<pallet_common::IsAdmin<Test>>::get((1247 CollectionId(1),1248 account(2)1249 )));1250 assert!(<pallet_common::IsAdmin<Test>>::get((1251 CollectionId(1),1252 account(3)1253 )));1254 });1255}12561257#[test]1258fn remove_collection_admin() {1259 new_test_ext().execute_with(|| {1260 let collection1_id =1261 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1262 let origin1 = RuntimeOrigin::signed(1);12631264 // Add collection admins 2 and 31265 assert_ok!(Unique::add_collection_admin(1266 origin1.clone(),1267 collection1_id,1268 account(2)1269 ));1270 assert_ok!(Unique::add_collection_admin(1271 origin1.clone(),1272 collection1_id,1273 account(3)1274 ));12751276 assert!(<pallet_common::IsAdmin<Test>>::get((1277 CollectionId(1),1278 account(2)1279 )));1280 assert!(<pallet_common::IsAdmin<Test>>::get((1281 CollectionId(1),1282 account(3)1283 )));12841285 // remove admin 31286 assert_ok!(Unique::remove_collection_admin(1287 origin1,1288 CollectionId(1),1289 account(3)1290 ));12911292 // 2 is still admin, 3 is not an admin anymore1293 assert!(<pallet_common::IsAdmin<Test>>::get((1294 CollectionId(1),1295 account(2)1296 )));1297 assert_eq!(1298 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1299 false1300 );1301 });1302}13031304#[test]1305fn balance_of() {1306 new_test_ext().execute_with(|| {1307 let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1308 let fungible_collection_id =1309 create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1310 let re_fungible_collection_id =1311 create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13121313 // check balance before1314 assert_eq!(1315 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1316 01317 );1318 assert_eq!(1319 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1320 01321 );1322 assert_eq!(1323 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1324 01325 );13261327 let nft_data = default_nft_data();1328 create_test_item(nft_collection_id, &nft_data.into());13291330 let fungible_data = default_fungible_data();1331 create_test_item(fungible_collection_id, &fungible_data.into());13321333 let re_fungible_data = default_re_fungible_data();1334 create_test_item(re_fungible_collection_id, &re_fungible_data.into());13351336 // check balance (collection with id = 1, user id = 1)1337 assert_eq!(1338 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1339 11340 );1341 assert_eq!(1342 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1343 51344 );1345 assert_eq!(1346 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1347 11348 );13491350 assert_eq!(1351 <pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1352 true1353 );1354 assert_eq!(1355 <pallet_refungible::Owned<Test>>::get((1356 re_fungible_collection_id,1357 account(1),1358 TokenId(1)1359 )),1360 true1361 );1362 });1363}13641365#[test]1366fn approve() {1367 new_test_ext().execute_with(|| {1368 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13691370 let data = default_nft_data();1371 create_test_item(collection_id, &data.into());13721373 let origin1 = RuntimeOrigin::signed(1);13741375 // approve1376 assert_ok!(Unique::approve(1377 origin1,1378 account(2),1379 CollectionId(1),1380 TokenId(1),1381 11382 ));1383 assert_eq!(1384 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1385 account(2)1386 );1387 });1388}13891390#[test]1391fn transfer_from() {1392 new_test_ext().execute_with(|| {1393 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1394 let origin1 = RuntimeOrigin::signed(1);1395 let origin2 = RuntimeOrigin::signed(2);13961397 let data = default_nft_data();1398 create_test_item(collection_id, &data.into());13991400 // approve1401 assert_ok!(Unique::approve(1402 origin1.clone(),1403 account(2),1404 CollectionId(1),1405 TokenId(1),1406 11407 ));1408 assert_eq!(1409 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1410 account(2)1411 );14121413 assert_ok!(Unique::set_collection_permissions(1414 origin1.clone(),1415 CollectionId(1),1416 CollectionPermissions {1417 mint_mode: Some(true),1418 access: Some(AccessMode::AllowList),1419 nesting: None,1420 }1421 ));1422 assert_ok!(Unique::add_to_allow_list(1423 origin1.clone(),1424 CollectionId(1),1425 account(1)1426 ));1427 assert_ok!(Unique::add_to_allow_list(1428 origin1.clone(),1429 CollectionId(1),1430 account(2)1431 ));1432 assert_ok!(Unique::add_to_allow_list(1433 origin1,1434 CollectionId(1),1435 account(3)1436 ));14371438 assert_ok!(Unique::transfer_from(1439 origin2,1440 account(1),1441 account(2),1442 CollectionId(1),1443 TokenId(1),1444 11445 ));14461447 // after transfer1448 assert_eq!(1449 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1450 01451 );1452 assert_eq!(1453 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1454 11455 );1456 });1457}14581459// #endregion14601461// Coverage tests region1462// #region14631464#[test]1465fn owner_can_add_address_to_allow_list() {1466 new_test_ext().execute_with(|| {1467 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14681469 let origin1 = RuntimeOrigin::signed(1);1470 assert_ok!(Unique::add_to_allow_list(1471 origin1,1472 collection_id,1473 account(2)1474 ));1475 assert!(<pallet_common::Allowlist<Test>>::get((1476 collection_id,1477 account(2)1478 )));1479 });1480}14811482#[test]1483fn admin_can_add_address_to_allow_list() {1484 new_test_ext().execute_with(|| {1485 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1486 let origin1 = RuntimeOrigin::signed(1);1487 let origin2 = RuntimeOrigin::signed(2);14881489 assert_ok!(Unique::add_collection_admin(1490 origin1,1491 collection_id,1492 account(2)1493 ));1494 assert_ok!(Unique::add_to_allow_list(1495 origin2,1496 collection_id,1497 account(3)1498 ));1499 assert!(<pallet_common::Allowlist<Test>>::get((1500 collection_id,1501 account(3)1502 )));1503 });1504}15051506#[test]1507fn nonprivileged_user_cannot_add_address_to_allow_list() {1508 new_test_ext().execute_with(|| {1509 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15101511 let origin2 = RuntimeOrigin::signed(2);1512 assert_noop!(1513 Unique::add_to_allow_list(origin2, collection_id, account(3)),1514 CommonError::<Test>::NoPermission1515 );1516 });1517}15181519#[test]1520fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1521 new_test_ext().execute_with(|| {1522 let origin1 = RuntimeOrigin::signed(1);15231524 assert_noop!(1525 Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1526 CommonError::<Test>::CollectionNotFound1527 );1528 });1529}15301531#[test]1532fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1533 new_test_ext().execute_with(|| {1534 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15351536 let origin1 = RuntimeOrigin::signed(1);1537 assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1538 assert_noop!(1539 Unique::add_to_allow_list(origin1, collection_id, account(2)),1540 CommonError::<Test>::CollectionNotFound1541 );1542 });1543}15441545// If address is already added to allow list, nothing happens1546#[test]1547fn address_is_already_added_to_allow_list() {1548 new_test_ext().execute_with(|| {1549 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1550 let origin1 = RuntimeOrigin::signed(1);15511552 assert_ok!(Unique::add_to_allow_list(1553 origin1.clone(),1554 collection_id,1555 account(2)1556 ));1557 assert_ok!(Unique::add_to_allow_list(1558 origin1,1559 collection_id,1560 account(2)1561 ));1562 assert!(<pallet_common::Allowlist<Test>>::get((1563 collection_id,1564 account(2)1565 )));1566 });1567}15681569#[test]1570fn owner_can_remove_address_from_allow_list() {1571 new_test_ext().execute_with(|| {1572 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15731574 let origin1 = RuntimeOrigin::signed(1);1575 assert_ok!(Unique::add_to_allow_list(1576 origin1.clone(),1577 collection_id,1578 account(2)1579 ));1580 assert_ok!(Unique::remove_from_allow_list(1581 origin1,1582 collection_id,1583 account(2)1584 ));1585 assert_eq!(1586 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1587 false1588 );1589 });1590}15911592#[test]1593fn admin_can_remove_address_from_allow_list() {1594 new_test_ext().execute_with(|| {1595 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1596 let origin1 = RuntimeOrigin::signed(1);1597 let origin2 = RuntimeOrigin::signed(2);15981599 // Owner adds admin1600 assert_ok!(Unique::add_collection_admin(1601 origin1.clone(),1602 collection_id,1603 account(2)1604 ));16051606 // Owner adds address 3 to allow list1607 assert_ok!(Unique::add_to_allow_list(1608 origin1,1609 collection_id,1610 account(3)1611 ));16121613 // Admin removes address 3 from allow list1614 assert_ok!(Unique::remove_from_allow_list(1615 origin2,1616 collection_id,1617 account(3)1618 ));1619 assert_eq!(1620 <pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1621 false1622 );1623 });1624}16251626#[test]1627fn nonprivileged_user_cannot_remove_address_from_allow_list() {1628 new_test_ext().execute_with(|| {1629 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1630 let origin1 = RuntimeOrigin::signed(1);1631 let origin2 = RuntimeOrigin::signed(2);16321633 assert_ok!(Unique::add_to_allow_list(1634 origin1,1635 collection_id,1636 account(2)1637 ));1638 assert_noop!(1639 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1640 CommonError::<Test>::NoPermission1641 );1642 assert!(<pallet_common::Allowlist<Test>>::get((1643 collection_id,1644 account(2)1645 )));1646 });1647}16481649#[test]1650fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1651 new_test_ext().execute_with(|| {1652 let origin1 = RuntimeOrigin::signed(1);16531654 assert_noop!(1655 Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1656 CommonError::<Test>::CollectionNotFound1657 );1658 });1659}16601661#[test]1662fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1663 new_test_ext().execute_with(|| {1664 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1665 let origin1 = RuntimeOrigin::signed(1);1666 let origin2 = RuntimeOrigin::signed(2);16671668 // Add account 2 to allow list1669 assert_ok!(Unique::add_to_allow_list(1670 origin1.clone(),1671 collection_id,1672 account(2)1673 ));16741675 // Account 2 is in collection allow-list1676 assert!(<pallet_common::Allowlist<Test>>::get((1677 collection_id,1678 account(2)1679 )));16801681 // Destroy collection1682 assert_ok!(Unique::destroy_collection(origin1, collection_id));16831684 // Attempt to remove account 2 from collection allow-list => error1685 assert_noop!(1686 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1687 CommonError::<Test>::CollectionNotFound1688 );16891690 // Account 2 is not found in collection allow-list anyway1691 assert_eq!(1692 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1693 false1694 );1695 });1696}16971698// If address is already removed from allow list, nothing happens1699#[test]1700fn address_is_already_removed_from_allow_list() {1701 new_test_ext().execute_with(|| {1702 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1703 let origin1 = RuntimeOrigin::signed(1);17041705 assert_ok!(Unique::add_to_allow_list(1706 origin1.clone(),1707 collection_id,1708 account(2)1709 ));1710 assert_ok!(Unique::remove_from_allow_list(1711 origin1.clone(),1712 collection_id,1713 account(2)1714 ));1715 assert_eq!(1716 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1717 false1718 );1719 assert_ok!(Unique::remove_from_allow_list(1720 origin1,1721 collection_id,1722 account(2)1723 ));1724 assert_eq!(1725 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1726 false1727 );1728 });1729}17301731// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1732#[test]1733fn allow_list_test_1() {1734 new_test_ext().execute_with(|| {1735 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17361737 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(2)1755 ));17561757 assert_noop!(1758 Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1759 .map_err(|e| e.error),1760 CommonError::<Test>::AddressNotInAllowlist1761 );1762 });1763}17641765#[test]1766fn allow_list_test_2() {1767 new_test_ext().execute_with(|| {1768 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1769 let origin1 = RuntimeOrigin::signed(1);17701771 let data = default_nft_data();1772 create_test_item(collection_id, &data.into());17731774 assert_ok!(Unique::set_collection_permissions(1775 origin1.clone(),1776 collection_id,1777 CollectionPermissions {1778 mint_mode: None,1779 access: Some(AccessMode::AllowList),1780 nesting: None,1781 }1782 ));1783 assert_ok!(Unique::add_to_allow_list(1784 origin1.clone(),1785 collection_id,1786 account(1)1787 ));1788 assert_ok!(Unique::add_to_allow_list(1789 origin1.clone(),1790 collection_id,1791 account(2)1792 ));17931794 // do approve1795 assert_ok!(Unique::approve(1796 origin1.clone(),1797 account(1),1798 collection_id,1799 TokenId(1),1800 11801 ));1802 assert_eq!(1803 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1804 account(1)1805 );18061807 assert_ok!(Unique::remove_from_allow_list(1808 origin1.clone(),1809 collection_id,1810 account(1)1811 ));18121813 assert_noop!(1814 Unique::transfer_from(1815 origin1,1816 account(1),1817 account(3),1818 CollectionId(1),1819 TokenId(1),1820 11821 )1822 .map_err(|e| e.error),1823 CommonError::<Test>::AddressNotInAllowlist1824 );1825 });1826}18271828// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1829#[test]1830fn allow_list_test_3() {1831 new_test_ext().execute_with(|| {1832 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18331834 let origin1 = RuntimeOrigin::signed(1);18351836 let data = default_nft_data();1837 create_test_item(collection_id, &data.into());18381839 assert_ok!(Unique::set_collection_permissions(1840 origin1.clone(),1841 collection_id,1842 CollectionPermissions {1843 mint_mode: None,1844 access: Some(AccessMode::AllowList),1845 nesting: None,1846 }1847 ));1848 assert_ok!(Unique::add_to_allow_list(1849 origin1.clone(),1850 collection_id,1851 account(1)1852 ));18531854 assert_noop!(1855 Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1856 .map_err(|e| e.error),1857 CommonError::<Test>::AddressNotInAllowlist1858 );1859 });1860}18611862#[test]1863fn allow_list_test_4() {1864 new_test_ext().execute_with(|| {1865 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18661867 let origin1 = RuntimeOrigin::signed(1);18681869 let data = default_nft_data();1870 create_test_item(collection_id, &data.into());18711872 assert_ok!(Unique::set_collection_permissions(1873 origin1.clone(),1874 collection_id,1875 CollectionPermissions {1876 mint_mode: None,1877 access: Some(AccessMode::AllowList),1878 nesting: None,1879 }1880 ));1881 assert_ok!(Unique::add_to_allow_list(1882 origin1.clone(),1883 collection_id,1884 account(1)1885 ));1886 assert_ok!(Unique::add_to_allow_list(1887 origin1.clone(),1888 collection_id,1889 account(2)1890 ));18911892 // do approve1893 assert_ok!(Unique::approve(1894 origin1.clone(),1895 account(1),1896 collection_id,1897 TokenId(1),1898 11899 ));1900 assert_eq!(1901 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1902 account(1)1903 );19041905 assert_ok!(Unique::remove_from_allow_list(1906 origin1.clone(),1907 collection_id,1908 account(2)1909 ));19101911 assert_noop!(1912 Unique::transfer_from(1913 origin1,1914 account(1),1915 account(3),1916 collection_id,1917 TokenId(1),1918 11919 )1920 .map_err(|e| e.error),1921 CommonError::<Test>::AddressNotInAllowlist1922 );1923 });1924}19251926// 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)1927#[test]1928fn allow_list_test_5() {1929 new_test_ext().execute_with(|| {1930 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19311932 let origin1 = RuntimeOrigin::signed(1);19331934 let data = default_nft_data();1935 create_test_item(collection_id, &data.into());19361937 assert_ok!(Unique::set_collection_permissions(1938 origin1.clone(),1939 collection_id,1940 CollectionPermissions {1941 mint_mode: None,1942 access: Some(AccessMode::AllowList),1943 nesting: None,1944 }1945 ));1946 assert_noop!(1947 Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1948 CommonError::<Test>::AddressNotInAllowlist1949 );1950 });1951}19521953// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1954#[test]1955fn allow_list_test_6() {1956 new_test_ext().execute_with(|| {1957 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19581959 let origin1 = RuntimeOrigin::signed(1);19601961 let data = default_nft_data();1962 create_test_item(collection_id, &data.into());19631964 assert_ok!(Unique::set_collection_permissions(1965 origin1.clone(),1966 collection_id,1967 CollectionPermissions {1968 mint_mode: None,1969 access: Some(AccessMode::AllowList),1970 nesting: None,1971 }1972 ));19731974 // do approve1975 assert_noop!(1976 Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1977 .map_err(|e| e.error),1978 CommonError::<Test>::AddressNotInAllowlist1979 );1980 });1981}19821983// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1984// tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1985#[test]1986fn allow_list_test_7() {1987 new_test_ext().execute_with(|| {1988 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19891990 let data = default_nft_data();1991 create_test_item(collection_id, &data.into());19921993 let origin1 = RuntimeOrigin::signed(1);19941995 assert_ok!(Unique::set_collection_permissions(1996 origin1.clone(),1997 collection_id,1998 CollectionPermissions {1999 mint_mode: None,2000 access: Some(AccessMode::AllowList),2001 nesting: None,2002 }2003 ));2004 assert_ok!(Unique::add_to_allow_list(2005 origin1.clone(),2006 collection_id,2007 account(1)2008 ));2009 assert_ok!(Unique::add_to_allow_list(2010 origin1.clone(),2011 collection_id,2012 account(2)2013 ));20142015 assert_ok!(Unique::transfer(2016 origin1,2017 account(2),2018 CollectionId(1),2019 TokenId(1),2020 12021 ));2022 });2023}20242025#[test]2026fn allow_list_test_8() {2027 new_test_ext().execute_with(|| {2028 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20292030 // Create NFT for account 12031 let data = default_nft_data();2032 create_test_item(collection_id, &data.into());20332034 let origin1 = RuntimeOrigin::signed(1);20352036 // Toggle Allow List mode and add accounts 1 and 22037 assert_ok!(Unique::set_collection_permissions(2038 origin1.clone(),2039 collection_id,2040 CollectionPermissions {2041 mint_mode: None,2042 access: Some(AccessMode::AllowList),2043 nesting: None,2044 }2045 ));2046 assert_ok!(Unique::add_to_allow_list(2047 origin1.clone(),2048 collection_id,2049 account(1)2050 ));2051 assert_ok!(Unique::add_to_allow_list(2052 origin1.clone(),2053 collection_id,2054 account(2)2055 ));20562057 // Sself-approve account 1 for NFT 12058 assert_ok!(Unique::approve(2059 origin1.clone(),2060 account(1),2061 CollectionId(1),2062 TokenId(1),2063 12064 ));2065 assert_eq!(2066 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2067 account(1)2068 );20692070 // Transfer from 1 to 22071 assert_ok!(Unique::transfer_from(2072 origin1,2073 account(1),2074 account(2),2075 CollectionId(1),2076 TokenId(1),2077 12078 ));2079 });2080}20812082// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2083#[test]2084fn allow_list_test_9() {2085 new_test_ext().execute_with(|| {2086 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2087 let origin1 = RuntimeOrigin::signed(1);20882089 assert_ok!(Unique::set_collection_permissions(2090 origin1.clone(),2091 collection_id,2092 CollectionPermissions {2093 mint_mode: Some(false),2094 access: Some(AccessMode::AllowList),2095 nesting: None,2096 }2097 ));20982099 let data = default_nft_data();2100 create_test_item(collection_id, &data.into());2101 });2102}21032104// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2105#[test]2106fn allow_list_test_10() {2107 new_test_ext().execute_with(|| {2108 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21092110 let origin1 = RuntimeOrigin::signed(1);2111 let origin2 = RuntimeOrigin::signed(2);21122113 assert_ok!(Unique::set_collection_permissions(2114 origin1.clone(),2115 collection_id,2116 CollectionPermissions {2117 mint_mode: Some(false),2118 access: Some(AccessMode::AllowList),2119 nesting: None,2120 }2121 ));21222123 assert_ok!(Unique::add_collection_admin(2124 origin1,2125 collection_id,2126 account(2)2127 ));21282129 assert_ok!(Unique::create_item(2130 origin2,2131 collection_id,2132 account(2),2133 default_nft_data().into()2134 ));2135 });2136}21372138// 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.2139#[test]2140fn allow_list_test_11() {2141 new_test_ext().execute_with(|| {2142 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21432144 let origin1 = RuntimeOrigin::signed(1);2145 let origin2 = RuntimeOrigin::signed(2);21462147 assert_ok!(Unique::set_collection_permissions(2148 origin1.clone(),2149 collection_id,2150 CollectionPermissions {2151 mint_mode: Some(false),2152 access: Some(AccessMode::AllowList),2153 nesting: None,2154 }2155 ));2156 assert_ok!(Unique::add_to_allow_list(2157 origin1,2158 collection_id,2159 account(2)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 false, tokens cannot be created by non-privileged and non-allow listed address.2176#[test]2177fn allow_list_test_12() {2178 new_test_ext().execute_with(|| {2179 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21802181 let origin1 = RuntimeOrigin::signed(1);2182 let origin2 = RuntimeOrigin::signed(2);21832184 assert_ok!(Unique::set_collection_permissions(2185 origin1.clone(),2186 collection_id,2187 CollectionPermissions {2188 mint_mode: Some(false),2189 access: Some(AccessMode::AllowList),2190 nesting: None,2191 }2192 ));21932194 assert_noop!(2195 Unique::create_item(2196 origin2,2197 CollectionId(1),2198 account(2),2199 default_nft_data().into()2200 )2201 .map_err(|e| e.error),2202 CommonError::<Test>::PublicMintingNotAllowed2203 );2204 });2205}22062207// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2208#[test]2209fn allow_list_test_13() {2210 new_test_ext().execute_with(|| {2211 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22122213 let origin1 = RuntimeOrigin::signed(1);22142215 assert_ok!(Unique::set_collection_permissions(2216 origin1.clone(),2217 collection_id,2218 CollectionPermissions {2219 mint_mode: Some(true),2220 access: Some(AccessMode::AllowList),2221 nesting: None,2222 }2223 ));22242225 let data = default_nft_data();2226 create_test_item(collection_id, &data.into());2227 });2228}22292230// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2231#[test]2232fn allow_list_test_14() {2233 new_test_ext().execute_with(|| {2234 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22352236 let origin1 = RuntimeOrigin::signed(1);2237 let origin2 = RuntimeOrigin::signed(2);22382239 assert_ok!(Unique::set_collection_permissions(2240 origin1.clone(),2241 collection_id,2242 CollectionPermissions {2243 mint_mode: Some(true),2244 access: Some(AccessMode::AllowList),2245 nesting: None,2246 }2247 ));22482249 assert_ok!(Unique::add_collection_admin(2250 origin1,2251 collection_id,2252 account(2)2253 ));22542255 assert_ok!(Unique::create_item(2256 origin2,2257 collection_id,2258 account(2),2259 default_nft_data().into()2260 ));2261 });2262}22632264// 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.2265#[test]2266fn allow_list_test_15() {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 ));22822283 assert_noop!(2284 Unique::create_item(2285 origin2,2286 collection_id,2287 account(2),2288 default_nft_data().into()2289 )2290 .map_err(|e| e.error),2291 CommonError::<Test>::AddressNotInAllowlist2292 );2293 });2294}22952296// 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.2297#[test]2298fn allow_list_test_16() {2299 new_test_ext().execute_with(|| {2300 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23012302 let origin1 = RuntimeOrigin::signed(1);2303 let origin2 = RuntimeOrigin::signed(2);23042305 assert_ok!(Unique::set_collection_permissions(2306 origin1.clone(),2307 collection_id,2308 CollectionPermissions {2309 mint_mode: Some(true),2310 access: Some(AccessMode::AllowList),2311 nesting: None,2312 }2313 ));2314 assert_ok!(Unique::add_to_allow_list(2315 origin1,2316 collection_id,2317 account(2)2318 ));23192320 assert_ok!(Unique::create_item(2321 origin2,2322 collection_id,2323 account(2),2324 default_nft_data().into()2325 ));2326 });2327}23282329// Total number of collections. Positive test2330#[test]2331fn total_number_collections_bound() {2332 new_test_ext().execute_with(|| {2333 create_test_collection(&CollectionMode::NFT, CollectionId(1));2334 });2335}23362337#[test]2338fn create_max_collections() {2339 new_test_ext().execute_with(|| {2340 for i in 1..COLLECTION_NUMBER_LIMIT {2341 create_test_collection(&CollectionMode::NFT, CollectionId(i));2342 }2343 });2344}23452346// Total number of collections. Negative test2347#[test]2348fn total_number_collections_bound_neg() {2349 new_test_ext().execute_with(|| {2350 let origin1 = RuntimeOrigin::signed(1);23512352 for i in 1..=COLLECTION_NUMBER_LIMIT {2353 create_test_collection(&CollectionMode::NFT, CollectionId(i));2354 }23552356 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2357 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2358 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23592360 let data: CreateCollectionData<u64> = CreateCollectionData {2361 name: col_name1.try_into().unwrap(),2362 description: col_desc1.try_into().unwrap(),2363 token_prefix: token_prefix1.try_into().unwrap(),2364 mode: CollectionMode::NFT,2365 ..Default::default()2366 };23672368 // 11-th collection in chain. Expects error2369 assert_noop!(2370 Unique::create_collection_ex(origin1, data),2371 CommonError::<Test>::TotalCollectionsLimitExceeded2372 );2373 });2374}23752376// Owned tokens by a single address. Positive test2377#[test]2378fn owned_tokens_bound() {2379 new_test_ext().execute_with(|| {2380 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23812382 let data = default_nft_data();2383 create_test_item(collection_id, &data.clone().into());2384 create_test_item(collection_id, &data.into());2385 });2386}23872388// Owned tokens by a single address. Negotive test2389#[test]2390fn owned_tokens_bound_neg() {2391 new_test_ext().execute_with(|| {2392 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23932394 let origin1 = RuntimeOrigin::signed(1);23952396 for _ in 1..=MAX_TOKEN_OWNERSHIP {2397 let data = default_nft_data();2398 create_test_item(collection_id, &data.clone().into());2399 }24002401 let data = default_nft_data();2402 assert_noop!(2403 Unique::create_item(origin1, CollectionId(1), account(1), data.into())2404 .map_err(|e| e.error),2405 CommonError::<Test>::AccountTokenLimitExceeded2406 );2407 });2408}24092410// Number of collection admins. Positive test2411#[test]2412fn collection_admins_bound() {2413 new_test_ext().execute_with(|| {2414 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24152416 let origin1 = RuntimeOrigin::signed(1);24172418 assert_ok!(Unique::add_collection_admin(2419 origin1.clone(),2420 collection_id,2421 account(2)2422 ));2423 assert_ok!(Unique::add_collection_admin(2424 origin1,2425 collection_id,2426 account(3)2427 ));2428 });2429}24302431// Number of collection admins. Negotive test2432#[test]2433fn collection_admins_bound_neg() {2434 new_test_ext().execute_with(|| {2435 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24362437 let origin1 = RuntimeOrigin::signed(1);24382439 for i in 0..COLLECTION_ADMINS_LIMIT {2440 assert_ok!(Unique::add_collection_admin(2441 origin1.clone(),2442 collection_id,2443 account((2 + i).into())2444 ));2445 }2446 assert_noop!(2447 Unique::add_collection_admin(2448 origin1,2449 collection_id,2450 account((3 + COLLECTION_ADMINS_LIMIT).into())2451 ),2452 CommonError::<Test>::CollectionAdminCountExceeded2453 );2454 });2455}2456// #endregion24572458#[test]2459fn collection_transfer_flag_works() {2460 new_test_ext().execute_with(|| {2461 let origin1 = RuntimeOrigin::signed(1);24622463 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2464 assert_ok!(Unique::set_transfers_enabled_flag(2465 origin1,2466 collection_id,2467 true2468 ));24692470 let data = default_nft_data();2471 create_test_item(collection_id, &data.into());2472 assert_eq!(2473 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2474 12475 );2476 assert_eq!(2477 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2478 true2479 );24802481 let origin1 = RuntimeOrigin::signed(1);24822483 // default scenario2484 assert_ok!(Unique::transfer(2485 origin1,2486 account(2),2487 collection_id,2488 TokenId(1),2489 12490 ));2491 assert_eq!(2492 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2493 false2494 );2495 assert_eq!(2496 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2497 true2498 );2499 assert_eq!(2500 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2501 02502 );2503 assert_eq!(2504 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2505 12506 );2507 });2508}25092510#[test]2511fn collection_transfer_flag_works_neg() {2512 new_test_ext().execute_with(|| {2513 let origin1 = RuntimeOrigin::signed(1);25142515 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2516 assert_ok!(Unique::set_transfers_enabled_flag(2517 origin1,2518 collection_id,2519 false2520 ));25212522 let data = default_nft_data();2523 create_test_item(collection_id, &data.into());2524 assert_eq!(2525 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2526 12527 );2528 assert_eq!(2529 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2530 true2531 );25322533 let origin1 = RuntimeOrigin::signed(1);25342535 // default scenario2536 assert_noop!(2537 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2538 .map_err(|e| e.error),2539 CommonError::<Test>::TransferNotAllowed2540 );2541 assert_eq!(2542 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2543 12544 );2545 assert_eq!(2546 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2547 02548 );2549 assert_eq!(2550 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2551 true2552 );2553 assert_eq!(2554 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2555 false2556 );2557 });2558}25592560#[test]2561fn collection_sponsoring() {2562 new_test_ext().execute_with(|| {2563 // default_limits();2564 let user1 = 1_u64;2565 let user2 = 777_u64;2566 let origin1 = RuntimeOrigin::signed(user1);2567 let origin2 = RuntimeOrigin::signed(user2);2568 let account2 = account(user2);25692570 let collection_id =2571 create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2572 assert_ok!(Unique::set_collection_sponsor(2573 origin1.clone(),2574 collection_id,2575 user12576 ));2577 assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25782579 // Expect error while have no permissions2580 assert!(Unique::create_item(2581 origin2.clone(),2582 collection_id,2583 account2.clone(),2584 default_nft_data().into()2585 )2586 .is_err());25872588 assert_ok!(Unique::set_collection_permissions(2589 origin1.clone(),2590 collection_id,2591 CollectionPermissions {2592 mint_mode: Some(true),2593 access: Some(AccessMode::AllowList),2594 nesting: None,2595 }2596 ));2597 assert_ok!(Unique::add_to_allow_list(2598 origin1.clone(),2599 collection_id,2600 account2.clone()2601 ));26022603 assert_ok!(Unique::create_item(2604 origin2,2605 collection_id,2606 account2,2607 default_nft_data().into()2608 ));2609 });2610}