difftreelog
fix(tests) fix default_nft_data
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,22 TokenId, MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionField, SchemaVersion,23 CollectionMode, AccessMode,24};25use frame_support::{assert_noop, assert_ok, assert_err};26use sp_std::convert::TryInto;27use pallet_evm::account::CrossAccountId;28use pallet_common::Error as CommonError;29use pallet_unique::Error as UniqueError;3031fn add_balance(user: u64, value: u64) {32 const DONOR_USER: u64 = 999;33 assert_ok!(<pallet_balances::Pallet<Test>>::set_balance(34 Origin::root(),35 DONOR_USER,36 value,37 038 ));39 assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(40 Origin::root(),41 DONOR_USER,42 user,43 value44 ));45}4647fn default_nft_data() -> CreateNftData {48 CreateNftData {49 const_data: vec![1, 2, 3].try_into().unwrap(),50 }51}5253fn default_fungible_data() -> CreateFungibleData {54 CreateFungibleData { value: 5 }55}5657fn default_re_fungible_data() -> CreateReFungibleData {58 CreateReFungibleData {59 const_data: vec![1, 2, 3].try_into().unwrap(),60 pieces: 1023,61 }62}6364fn create_test_collection_for_owner(65 mode: &CollectionMode,66 owner: u64,67 id: CollectionId,68) -> CollectionId {69 add_balance(owner, CollectionCreationPrice::get() as u64 + 1);7071 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();72 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();73 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();7475 let data: CreateCollectionData<u64> = CreateCollectionData {76 name: col_name1.try_into().unwrap(),77 description: col_desc1.try_into().unwrap(),78 token_prefix: token_prefix1.try_into().unwrap(),79 mode: mode.clone(),80 ..Default::default()81 };8283 let origin1 = Origin::signed(owner);84 assert_ok!(Unique::create_collection_ex(origin1, data));8586 let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();87 let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();88 let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();89 assert_eq!(90 <pallet_common::CollectionById<Test>>::get(id)91 .unwrap()92 .owner,93 owner94 );95 assert_eq!(96 <pallet_common::CollectionById<Test>>::get(id).unwrap().name,97 saved_col_name98 );99 assert_eq!(100 <pallet_common::CollectionById<Test>>::get(id).unwrap().mode,101 *mode102 );103 assert_eq!(104 <pallet_common::CollectionById<Test>>::get(id)105 .unwrap()106 .description,107 saved_description108 );109 assert_eq!(110 <pallet_common::CollectionById<Test>>::get(id)111 .unwrap()112 .token_prefix,113 saved_prefix114 );115 id116}117118fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {119 create_test_collection_for_owner(&mode, 1, id)120}121122fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {123 let origin1 = Origin::signed(1);124 assert_ok!(Unique::create_item(125 origin1,126 collection_id,127 account(1),128 data.clone()129 ));130}131132fn account(sub: u64) -> TestCrossAccountId {133 TestCrossAccountId::from_sub(sub)134}135136// Use cases tests region137// #region138139#[test]140fn set_version_schema() {141 new_test_ext().execute_with(|| {142 let origin1 = Origin::signed(1);143 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));144145 assert_ok!(Unique::set_schema_version(146 origin1,147 collection_id,148 SchemaVersion::Unique149 ));150 assert_eq!(151 <pallet_common::CollectionById<Test>>::get(collection_id)152 .unwrap()153 .schema_version,154 SchemaVersion::Unique155 );156 });157}158159#[test]160fn check_not_sufficient_founds() {161 new_test_ext().execute_with(|| {162 let acc: u64 = 1;163 <pallet_balances::Pallet<Test>>::set_balance(Origin::root(), acc, 0, 0).unwrap();164165 let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();166 let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();167 let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();168169 let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =170 CreateCollectionData {171 name: name.try_into().unwrap(),172 description: description.try_into().unwrap(),173 token_prefix: token_prefix.try_into().unwrap(),174 mode: CollectionMode::NFT,175 ..Default::default()176 };177178 let result = Unique::create_collection_ex(Origin::signed(acc), data);179 assert_err!(result, <CommonError<Test>>::NotSufficientFounds);180 });181}182183#[test]184fn create_fungible_collection_fails_with_large_decimal_numbers() {185 new_test_ext().execute_with(|| {186 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();187 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();188 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();189190 let data: CreateCollectionData<u64> = CreateCollectionData {191 name: col_name1.try_into().unwrap(),192 description: col_desc1.try_into().unwrap(),193 token_prefix: token_prefix1.try_into().unwrap(),194 mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),195 ..Default::default()196 };197198 let origin1 = Origin::signed(1);199 assert_noop!(200 Unique::create_collection_ex(origin1, data),201 UniqueError::<Test>::CollectionDecimalPointLimitExceeded202 );203 });204}205206#[test]207fn create_nft_item() {208 new_test_ext().execute_with(|| {209 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));210211 let data = default_nft_data();212 create_test_item(collection_id, &data.clone().into());213214 let item = <pallet_nonfungible::TokenData<Test>>::get((collection_id, 1)).unwrap();215 assert_eq!(item.const_data, data.const_data.into_inner());216 });217}218219// Use cases tests region220// #region221#[test]222fn create_nft_multiple_items() {223 new_test_ext().execute_with(|| {224 create_test_collection(&CollectionMode::NFT, CollectionId(1));225226 let origin1 = Origin::signed(1);227228 let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];229230 assert_ok!(Unique::create_multiple_items(231 origin1,232 CollectionId(1),233 account(1),234 items_data235 .clone()236 .into_iter()237 .map(|d| { d.into() })238 .collect()239 ));240 for (index, data) in items_data.into_iter().enumerate() {241 let item = <pallet_nonfungible::TokenData<Test>>::get((242 CollectionId(1),243 TokenId((index + 1) as u32),244 ))245 .unwrap();246 assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());247 }248 });249}250251#[test]252fn create_refungible_item() {253 new_test_ext().execute_with(|| {254 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));255256 let data = default_re_fungible_data();257 create_test_item(collection_id, &data.clone().into());258 let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));259 let balance =260 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));261 assert_eq!(item.const_data, data.const_data.into_inner());262 assert_eq!(balance, 1023);263 });264}265266#[test]267fn create_multiple_refungible_items() {268 new_test_ext().execute_with(|| {269 create_test_collection(&CollectionMode::ReFungible, CollectionId(1));270271 let origin1 = Origin::signed(1);272273 let items_data = vec![274 default_re_fungible_data(),275 default_re_fungible_data(),276 default_re_fungible_data(),277 ];278279 assert_ok!(Unique::create_multiple_items(280 origin1,281 CollectionId(1),282 account(1),283 items_data284 .clone()285 .into_iter()286 .map(|d| { d.into() })287 .collect()288 ));289 for (index, data) in items_data.into_iter().enumerate() {290 let item = <pallet_refungible::TokenData<Test>>::get((291 CollectionId(1),292 TokenId((index + 1) as u32),293 ));294 let balance =295 <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));296 assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());297 assert_eq!(balance, 1023);298 }299 });300}301302#[test]303fn create_fungible_item() {304 new_test_ext().execute_with(|| {305 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));306307 let data = default_fungible_data();308 create_test_item(collection_id, &data.into());309310 assert_eq!(311 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),312 5313 );314 });315}316317//#[test]318// fn create_multiple_fungible_items() {319// new_test_ext().execute_with(|| {320// default_limits();321322// create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));323324// let origin1 = Origin::signed(1);325326// let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];327328// assert_ok!(Unique::create_multiple_items(329// origin1.clone(),330// 1,331// 1,332// items_data.clone().into_iter().map(|d| { d.into() }).collect()333// ));334335// for (index, _) in items_data.iter().enumerate() {336// assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);337// }338// assert_eq!(Unique::balance_count(1, 1), 3000);339// assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);340// });341// }342343#[test]344fn transfer_fungible_item() {345 new_test_ext().execute_with(|| {346 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));347348 let origin1 = Origin::signed(1);349 let origin2 = Origin::signed(2);350351 let data = default_fungible_data();352 create_test_item(collection_id, &data.into());353354 assert_eq!(355 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),356 5357 );358359 // change owner scenario360 assert_ok!(Unique::transfer(361 origin1,362 account(2),363 CollectionId(1),364 TokenId(0),365 5366 ));367 assert_eq!(368 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),369 0370 );371372 // split item scenario373 assert_ok!(Unique::transfer(374 origin2.clone(),375 account(3),376 CollectionId(1),377 TokenId(0),378 3379 ));380381 // split item and new owner has account scenario382 assert_ok!(Unique::transfer(383 origin2,384 account(3),385 CollectionId(1),386 TokenId(0),387 1388 ));389 assert_eq!(390 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),391 1392 );393 assert_eq!(394 <pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),395 4396 );397 });398}399400#[test]401fn transfer_refungible_item() {402 new_test_ext().execute_with(|| {403 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));404405 // Create RFT 1 in 1023 pieces for account 1406 let data = default_re_fungible_data();407 create_test_item(collection_id, &data.clone().into());408 let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));409 assert_eq!(item.const_data, data.const_data.into_inner());410 assert_eq!(411 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),412 1413 );414 assert_eq!(415 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),416 1023417 );418 assert_eq!(419 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),420 true421 );422423 // Account 1 transfers all 1023 pieces of RFT 1 to account 2424 let origin1 = Origin::signed(1);425 let origin2 = Origin::signed(2);426 assert_ok!(Unique::transfer(427 origin1,428 account(2),429 CollectionId(1),430 TokenId(1),431 1023432 ));433 assert_eq!(434 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),435 1023436 );437 assert_eq!(438 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),439 0440 );441 assert_eq!(442 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),443 1444 );445 assert_eq!(446 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),447 false448 );449 assert_eq!(450 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),451 true452 );453454 // Account 2 transfers 500 pieces of RFT 1 to account 3455 assert_ok!(Unique::transfer(456 origin2.clone(),457 account(3),458 CollectionId(1),459 TokenId(1),460 500461 ));462 assert_eq!(463 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),464 523465 );466 assert_eq!(467 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),468 500469 );470 assert_eq!(471 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),472 1473 );474 assert_eq!(475 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),476 1477 );478 assert_eq!(479 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),480 true481 );482 assert_eq!(483 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),484 true485 );486487 // Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance488 assert_ok!(Unique::transfer(489 origin2,490 account(3),491 CollectionId(1),492 TokenId(1),493 200494 ));495 assert_eq!(496 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),497 323498 );499 assert_eq!(500 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),501 700502 );503 assert_eq!(504 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),505 1506 );507 assert_eq!(508 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),509 1510 );511 assert_eq!(512 <pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),513 true514 );515 assert_eq!(516 <pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),517 true518 );519 });520}521522#[test]523fn transfer_nft_item() {524 new_test_ext().execute_with(|| {525 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));526527 let data = default_nft_data();528 create_test_item(collection_id, &data.into());529 assert_eq!(530 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),531 1532 );533 assert_eq!(534 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),535 true536 );537538 let origin1 = Origin::signed(1);539 // default scenario540 assert_ok!(Unique::transfer(541 origin1,542 account(2),543 CollectionId(1),544 TokenId(1),545 1546 ));547 assert_eq!(548 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),549 0550 );551 assert_eq!(552 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),553 1554 );555 assert_eq!(556 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),557 false558 );559 assert_eq!(560 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),561 true562 );563 });564}565566#[test]567fn transfer_nft_item_wrong_value() {568 new_test_ext().execute_with(|| {569 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));570571 let data = default_nft_data();572 create_test_item(collection_id, &data.into());573 assert_eq!(574 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),575 1576 );577 assert_eq!(578 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),579 true580 );581582 let origin1 = Origin::signed(1);583584 assert_noop!(585 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)586 .map_err(|e| e.error),587 <pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount588 );589 });590}591592#[test]593fn transfer_nft_item_zero_value() {594 new_test_ext().execute_with(|| {595 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));596597 let data = default_nft_data();598 create_test_item(collection_id, &data.into());599 assert_eq!(600 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),601 1602 );603 assert_eq!(604 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),605 true606 );607608 let origin1 = Origin::signed(1);609610 // Transferring 0 amount works on NFT...611 assert_ok!(Unique::transfer(612 origin1,613 account(2),614 CollectionId(1),615 TokenId(1),616 0617 ));618 // ... and results in no transfer619 assert_eq!(620 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),621 1622 );623 assert_eq!(624 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),625 true626 );627 });628}629630#[test]631fn nft_approve_and_transfer_from() {632 new_test_ext().execute_with(|| {633 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));634635 let data = default_nft_data();636 create_test_item(collection_id, &data.into());637638 let origin1 = Origin::signed(1);639 let origin2 = Origin::signed(2);640641 assert_eq!(642 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),643 1644 );645 assert_eq!(646 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),647 true648 );649650 // neg transfer_from651 assert_noop!(652 Unique::transfer_from(653 origin2.clone(),654 account(1),655 account(2),656 CollectionId(1),657 TokenId(1),658 1659 )660 .map_err(|e| e.error),661 CommonError::<Test>::ApprovedValueTooLow662 );663664 // do approve665 assert_ok!(Unique::approve(666 origin1,667 account(2),668 CollectionId(1),669 TokenId(1),670 1671 ));672 assert_eq!(673 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),674 account(2)675 );676677 assert_ok!(Unique::transfer_from(678 origin2,679 account(1),680 account(3),681 CollectionId(1),682 TokenId(1),683 1684 ));685 assert!(686 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()687 );688 });689}690691#[test]692fn nft_approve_and_transfer_from_allow_list() {693 new_test_ext().execute_with(|| {694 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));695696 let origin1 = Origin::signed(1);697 let origin2 = Origin::signed(2);698699 // Create NFT 1 for account 1700 let data = default_nft_data();701 create_test_item(collection_id, &data.clone().into());702 assert_eq!(703 &<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1)))704 .unwrap()705 .const_data,706 &data.const_data.into_inner()707 );708 assert_eq!(709 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),710 1711 );712 assert_eq!(713 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),714 true715 );716717 // Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list718 assert_ok!(Unique::set_mint_permission(719 origin1.clone(),720 CollectionId(1),721 true722 ));723 assert_ok!(Unique::set_public_access_mode(724 origin1.clone(),725 CollectionId(1),726 AccessMode::AllowList727 ));728 assert_ok!(Unique::add_to_allow_list(729 origin1.clone(),730 CollectionId(1),731 account(1)732 ));733 assert_ok!(Unique::add_to_allow_list(734 origin1.clone(),735 CollectionId(1),736 account(2)737 ));738 assert_ok!(Unique::add_to_allow_list(739 origin1.clone(),740 CollectionId(1),741 account(3)742 ));743744 // Account 1 approves account 2 for NFT 1745 assert_ok!(Unique::approve(746 origin1.clone(),747 account(2),748 CollectionId(1),749 TokenId(1),750 1751 ));752 assert_eq!(753 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),754 account(2)755 );756757 // Account 2 transfers NFT 1 from account 1 to account 3758 assert_ok!(Unique::transfer_from(759 origin2,760 account(1),761 account(3),762 CollectionId(1),763 TokenId(1),764 1765 ));766 assert!(767 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()768 );769 });770}771772#[test]773fn refungible_approve_and_transfer_from() {774 new_test_ext().execute_with(|| {775 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));776777 let origin1 = Origin::signed(1);778 let origin2 = Origin::signed(2);779780 // Create RFT 1 in 1023 pieces for account 1781 let data = default_re_fungible_data();782 create_test_item(collection_id, &data.into());783784 assert_eq!(785 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),786 1787 );788 assert_eq!(789 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),790 1023791 );792 assert_eq!(793 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),794 true795 );796797 // Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list798 assert_ok!(Unique::set_mint_permission(799 origin1.clone(),800 CollectionId(1),801 true802 ));803 assert_ok!(Unique::set_public_access_mode(804 origin1.clone(),805 CollectionId(1),806 AccessMode::AllowList807 ));808 assert_ok!(Unique::add_to_allow_list(809 origin1.clone(),810 CollectionId(1),811 account(1)812 ));813 assert_ok!(Unique::add_to_allow_list(814 origin1.clone(),815 CollectionId(1),816 account(2)817 ));818 assert_ok!(Unique::add_to_allow_list(819 origin1.clone(),820 CollectionId(1),821 account(3)822 ));823824 // Account 1 approves account 2 for 1023 pieces of RFT 1825 assert_ok!(Unique::approve(826 origin1,827 account(2),828 CollectionId(1),829 TokenId(1),830 1023831 ));832 assert_eq!(833 <pallet_refungible::Allowance<Test>>::get((834 CollectionId(1),835 TokenId(1),836 account(1),837 account(2)838 )),839 1023840 );841842 // Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3843 assert_ok!(Unique::transfer_from(844 origin2,845 account(1),846 account(3),847 CollectionId(1),848 TokenId(1),849 100850 ));851 assert_eq!(852 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),853 1854 );855 assert_eq!(856 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),857 1858 );859 assert_eq!(860 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),861 923862 );863 assert_eq!(864 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),865 100866 );867 assert_eq!(868 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),869 true870 );871 assert_eq!(872 <pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),873 true874 );875 assert_eq!(876 <pallet_refungible::Allowance<Test>>::get((877 CollectionId(1),878 TokenId(1),879 account(1),880 account(2)881 )),882 923883 );884 });885}886887#[test]888fn fungible_approve_and_transfer_from() {889 new_test_ext().execute_with(|| {890 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));891892 let data = default_fungible_data();893 create_test_item(collection_id, &data.into());894895 let origin1 = Origin::signed(1);896 let origin2 = Origin::signed(2);897898 assert_ok!(Unique::set_mint_permission(899 origin1.clone(),900 CollectionId(1),901 true902 ));903 assert_ok!(Unique::set_public_access_mode(904 origin1.clone(),905 CollectionId(1),906 AccessMode::AllowList907 ));908 assert_ok!(Unique::add_to_allow_list(909 origin1.clone(),910 CollectionId(1),911 account(1)912 ));913 assert_ok!(Unique::add_to_allow_list(914 origin1.clone(),915 CollectionId(1),916 account(2)917 ));918 assert_ok!(Unique::add_to_allow_list(919 origin1.clone(),920 CollectionId(1),921 account(3)922 ));923924 // do approve925 assert_ok!(Unique::approve(926 origin1.clone(),927 account(2),928 CollectionId(1),929 TokenId(0),930 5931 ));932 assert_eq!(933 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),934 5935 );936 assert_ok!(Unique::approve(937 origin1,938 account(3),939 CollectionId(1),940 TokenId(0),941 5942 ));943 assert_eq!(944 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),945 5946 );947 assert_eq!(948 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),949 5950 );951952 assert_ok!(Unique::transfer_from(953 origin2.clone(),954 account(1),955 account(3),956 CollectionId(1),957 TokenId(0),958 4959 ));960961 assert_eq!(962 <pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),963 1964 );965966 assert_noop!(967 Unique::transfer_from(968 origin2,969 account(1),970 account(3),971 CollectionId(1),972 TokenId(0),973 4974 )975 .map_err(|e| e.error),976 CommonError::<Test>::ApprovedValueTooLow977 );978 });979}980981#[test]982fn change_collection_owner() {983 new_test_ext().execute_with(|| {984 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));985986 let origin1 = Origin::signed(1);987 assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));988 assert_eq!(989 <pallet_common::CollectionById<Test>>::get(collection_id)990 .unwrap()991 .owner,992 2993 );994 });995}996997#[test]998fn destroy_collection() {999 new_test_ext().execute_with(|| {1000 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10011002 let origin1 = Origin::signed(1);1003 assert_ok!(Unique::destroy_collection(origin1, collection_id));1004 });1005}10061007#[test]1008fn burn_nft_item() {1009 new_test_ext().execute_with(|| {1010 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10111012 let origin1 = Origin::signed(1);10131014 let data = default_nft_data();1015 create_test_item(collection_id, &data.into());10161017 // check balance (collection with id = 1, user id = 1)1018 assert_eq!(1019 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1020 11021 );10221023 // burn item1024 assert_ok!(Unique::burn_item(1025 origin1.clone(),1026 collection_id,1027 TokenId(1),1028 11029 ));1030 assert_eq!(1031 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1032 01033 );1034 });1035}10361037#[test]1038fn burn_same_nft_item_twice() {1039 new_test_ext().execute_with(|| {1040 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10411042 let origin1 = Origin::signed(1);10431044 let data = default_nft_data();1045 create_test_item(collection_id, &data.into());10461047 // check balance (collection with id = 1, user id = 1)1048 assert_eq!(1049 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1050 11051 );10521053 // burn item1054 assert_ok!(Unique::burn_item(1055 origin1.clone(),1056 collection_id,1057 TokenId(1),1058 11059 ));10601061 // burn item again1062 assert_noop!(1063 Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1064 CommonError::<Test>::TokenNotFound1065 );10661067 assert_eq!(1068 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1069 01070 );1071 });1072}10731074#[test]1075fn burn_fungible_item() {1076 new_test_ext().execute_with(|| {1077 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));10781079 let origin1 = Origin::signed(1);1080 assert_ok!(Unique::add_collection_admin(1081 origin1.clone(),1082 collection_id,1083 account(2)1084 ));10851086 let data = default_fungible_data();1087 create_test_item(collection_id, &data.into());10881089 // check balance (collection with id = 1, user id = 1)1090 assert_eq!(1091 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1092 51093 );10941095 // burn item1096 assert_ok!(Unique::burn_item(1097 origin1.clone(),1098 CollectionId(1),1099 TokenId(0),1100 51101 ));1102 assert_noop!(1103 Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1104 CommonError::<Test>::TokenValueTooLow1105 );11061107 assert_eq!(1108 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1109 01110 );1111 });1112}11131114#[test]1115fn burn_fungible_item_with_token_id() {1116 new_test_ext().execute_with(|| {1117 let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11181119 let origin1 = Origin::signed(1);1120 assert_ok!(Unique::add_collection_admin(1121 origin1.clone(),1122 collection_id,1123 account(2)1124 ));11251126 let data = default_fungible_data();1127 create_test_item(collection_id, &data.into());11281129 // check balance (collection with id = 1, user id = 1)1130 assert_eq!(1131 <pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1132 51133 );11341135 // Try to burn item using Token ID1136 assert_noop!(1137 Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1138 <pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1139 );1140 });1141}1142#[test]1143fn burn_refungible_item() {1144 new_test_ext().execute_with(|| {1145 let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1146 let origin1 = Origin::signed(1);11471148 assert_ok!(Unique::set_mint_permission(1149 origin1.clone(),1150 collection_id,1151 true1152 ));1153 assert_ok!(Unique::set_public_access_mode(1154 origin1.clone(),1155 collection_id,1156 AccessMode::AllowList1157 ));1158 assert_ok!(Unique::add_to_allow_list(1159 origin1.clone(),1160 collection_id,1161 account(1)1162 ));11631164 assert_ok!(Unique::add_collection_admin(1165 origin1.clone(),1166 collection_id,1167 account(2)1168 ));11691170 let data = default_re_fungible_data();1171 create_test_item(collection_id, &data.into());11721173 // check balance (collection with id = 1, user id = 2)1174 assert_eq!(1175 <pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1176 11177 );1178 assert_eq!(1179 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1180 10231181 );11821183 // burn item1184 assert_ok!(Unique::burn_item(1185 origin1.clone(),1186 collection_id,1187 TokenId(1),1188 10231189 ));1190 assert_noop!(1191 Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1192 CommonError::<Test>::TokenValueTooLow1193 );11941195 assert_eq!(1196 <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1197 01198 );1199 });1200}12011202#[test]1203fn add_collection_admin() {1204 new_test_ext().execute_with(|| {1205 let collection1_id =1206 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1207 let origin1 = Origin::signed(1);12081209 // Add collection admins1210 assert_ok!(Unique::add_collection_admin(1211 origin1.clone(),1212 collection1_id,1213 account(2)1214 ));1215 assert_ok!(Unique::add_collection_admin(1216 origin1,1217 collection1_id,1218 account(3)1219 ));12201221 // Owner is not an admin by default1222 assert_eq!(1223 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1224 false1225 );1226 assert!(<pallet_common::IsAdmin<Test>>::get((1227 CollectionId(1),1228 account(2)1229 )));1230 assert!(<pallet_common::IsAdmin<Test>>::get((1231 CollectionId(1),1232 account(3)1233 )));1234 });1235}12361237#[test]1238fn remove_collection_admin() {1239 new_test_ext().execute_with(|| {1240 let collection1_id =1241 create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1242 let origin1 = Origin::signed(1);1243 let origin2 = Origin::signed(2);12441245 // Add collection admins 2 and 31246 assert_ok!(Unique::add_collection_admin(1247 origin1.clone(),1248 collection1_id,1249 account(2)1250 ));1251 assert_ok!(Unique::add_collection_admin(1252 origin1,1253 collection1_id,1254 account(3)1255 ));12561257 assert!(<pallet_common::IsAdmin<Test>>::get((1258 CollectionId(1),1259 account(2)1260 )));1261 assert!(<pallet_common::IsAdmin<Test>>::get((1262 CollectionId(1),1263 account(3)1264 )));12651266 // remove admin 31267 assert_ok!(Unique::remove_collection_admin(1268 origin2,1269 CollectionId(1),1270 account(3)1271 ));12721273 // 2 is still admin, 3 is not an admin anymore1274 assert!(<pallet_common::IsAdmin<Test>>::get((1275 CollectionId(1),1276 account(2)1277 )));1278 assert_eq!(1279 <pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1280 false1281 );1282 });1283}12841285#[test]1286fn balance_of() {1287 new_test_ext().execute_with(|| {1288 let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1289 let fungible_collection_id =1290 create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1291 let re_fungible_collection_id =1292 create_test_collection(&CollectionMode::ReFungible, CollectionId(3));12931294 // check balance before1295 assert_eq!(1296 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1297 01298 );1299 assert_eq!(1300 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1301 01302 );1303 assert_eq!(1304 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1305 01306 );13071308 let nft_data = default_nft_data();1309 create_test_item(nft_collection_id, &nft_data.into());13101311 let fungible_data = default_fungible_data();1312 create_test_item(fungible_collection_id, &fungible_data.into());13131314 let re_fungible_data = default_re_fungible_data();1315 create_test_item(re_fungible_collection_id, &re_fungible_data.into());13161317 // check balance (collection with id = 1, user id = 1)1318 assert_eq!(1319 <pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1320 11321 );1322 assert_eq!(1323 <pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1324 51325 );1326 assert_eq!(1327 <pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1328 11329 );13301331 assert_eq!(1332 <pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1333 true1334 );1335 assert_eq!(1336 <pallet_refungible::Owned<Test>>::get((1337 re_fungible_collection_id,1338 account(1),1339 TokenId(1)1340 )),1341 true1342 );1343 });1344}13451346#[test]1347fn approve() {1348 new_test_ext().execute_with(|| {1349 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13501351 let data = default_nft_data();1352 create_test_item(collection_id, &data.into());13531354 let origin1 = Origin::signed(1);13551356 // approve1357 assert_ok!(Unique::approve(1358 origin1,1359 account(2),1360 CollectionId(1),1361 TokenId(1),1362 11363 ));1364 assert_eq!(1365 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1366 account(2)1367 );1368 });1369}13701371#[test]1372fn transfer_from() {1373 new_test_ext().execute_with(|| {1374 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1375 let origin1 = Origin::signed(1);1376 let origin2 = Origin::signed(2);13771378 let data = default_nft_data();1379 create_test_item(collection_id, &data.into());13801381 // approve1382 assert_ok!(Unique::approve(1383 origin1.clone(),1384 account(2),1385 CollectionId(1),1386 TokenId(1),1387 11388 ));1389 assert_eq!(1390 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1391 account(2)1392 );13931394 assert_ok!(Unique::set_mint_permission(1395 origin1.clone(),1396 CollectionId(1),1397 true1398 ));1399 assert_ok!(Unique::set_public_access_mode(1400 origin1.clone(),1401 CollectionId(1),1402 AccessMode::AllowList1403 ));1404 assert_ok!(Unique::add_to_allow_list(1405 origin1.clone(),1406 CollectionId(1),1407 account(1)1408 ));1409 assert_ok!(Unique::add_to_allow_list(1410 origin1.clone(),1411 CollectionId(1),1412 account(2)1413 ));1414 assert_ok!(Unique::add_to_allow_list(1415 origin1,1416 CollectionId(1),1417 account(3)1418 ));14191420 assert_ok!(Unique::transfer_from(1421 origin2,1422 account(1),1423 account(2),1424 CollectionId(1),1425 TokenId(1),1426 11427 ));14281429 // after transfer1430 assert_eq!(1431 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1432 01433 );1434 assert_eq!(1435 <pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1436 11437 );1438 });1439}14401441// #endregion14421443// Coverage tests region1444// #region14451446#[test]1447fn owner_can_add_address_to_allow_list() {1448 new_test_ext().execute_with(|| {1449 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14501451 let origin1 = Origin::signed(1);1452 assert_ok!(Unique::add_to_allow_list(1453 origin1,1454 collection_id,1455 account(2)1456 ));1457 assert!(<pallet_common::Allowlist<Test>>::get((1458 collection_id,1459 account(2)1460 )));1461 });1462}14631464#[test]1465fn admin_can_add_address_to_allow_list() {1466 new_test_ext().execute_with(|| {1467 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1468 let origin1 = Origin::signed(1);1469 let origin2 = Origin::signed(2);14701471 assert_ok!(Unique::add_collection_admin(1472 origin1,1473 collection_id,1474 account(2)1475 ));1476 assert_ok!(Unique::add_to_allow_list(1477 origin2,1478 collection_id,1479 account(3)1480 ));1481 assert!(<pallet_common::Allowlist<Test>>::get((1482 collection_id,1483 account(3)1484 )));1485 });1486}14871488#[test]1489fn nonprivileged_user_cannot_add_address_to_allow_list() {1490 new_test_ext().execute_with(|| {1491 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14921493 let origin2 = Origin::signed(2);1494 assert_noop!(1495 Unique::add_to_allow_list(origin2, collection_id, account(3)),1496 CommonError::<Test>::NoPermission1497 );1498 });1499}15001501#[test]1502fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1503 new_test_ext().execute_with(|| {1504 let origin1 = Origin::signed(1);15051506 assert_noop!(1507 Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1508 CommonError::<Test>::CollectionNotFound1509 );1510 });1511}15121513#[test]1514fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1515 new_test_ext().execute_with(|| {1516 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15171518 let origin1 = Origin::signed(1);1519 assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1520 assert_noop!(1521 Unique::add_to_allow_list(origin1, collection_id, account(2)),1522 CommonError::<Test>::CollectionNotFound1523 );1524 });1525}15261527// If address is already added to allow list, nothing happens1528#[test]1529fn address_is_already_added_to_allow_list() {1530 new_test_ext().execute_with(|| {1531 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1532 let origin1 = Origin::signed(1);15331534 assert_ok!(Unique::add_to_allow_list(1535 origin1.clone(),1536 collection_id,1537 account(2)1538 ));1539 assert_ok!(Unique::add_to_allow_list(1540 origin1,1541 collection_id,1542 account(2)1543 ));1544 assert!(<pallet_common::Allowlist<Test>>::get((1545 collection_id,1546 account(2)1547 )));1548 });1549}15501551#[test]1552fn owner_can_remove_address_from_allow_list() {1553 new_test_ext().execute_with(|| {1554 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15551556 let origin1 = Origin::signed(1);1557 assert_ok!(Unique::add_to_allow_list(1558 origin1.clone(),1559 collection_id,1560 account(2)1561 ));1562 assert_ok!(Unique::remove_from_allow_list(1563 origin1,1564 collection_id,1565 account(2)1566 ));1567 assert_eq!(1568 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1569 false1570 );1571 });1572}15731574#[test]1575fn admin_can_remove_address_from_allow_list() {1576 new_test_ext().execute_with(|| {1577 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1578 let origin1 = Origin::signed(1);1579 let origin2 = Origin::signed(2);15801581 // Owner adds admin1582 assert_ok!(Unique::add_collection_admin(1583 origin1.clone(),1584 collection_id,1585 account(2)1586 ));15871588 // Owner adds address 3 to allow list1589 assert_ok!(Unique::add_to_allow_list(1590 origin1,1591 collection_id,1592 account(3)1593 ));15941595 // Admin removes address 3 from allow list1596 assert_ok!(Unique::remove_from_allow_list(1597 origin2,1598 collection_id,1599 account(3)1600 ));1601 assert_eq!(1602 <pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1603 false1604 );1605 });1606}16071608#[test]1609fn nonprivileged_user_cannot_remove_address_from_allow_list() {1610 new_test_ext().execute_with(|| {1611 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1612 let origin1 = Origin::signed(1);1613 let origin2 = Origin::signed(2);16141615 assert_ok!(Unique::add_to_allow_list(1616 origin1,1617 collection_id,1618 account(2)1619 ));1620 assert_noop!(1621 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1622 CommonError::<Test>::NoPermission1623 );1624 assert!(<pallet_common::Allowlist<Test>>::get((1625 collection_id,1626 account(2)1627 )));1628 });1629}16301631#[test]1632fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1633 new_test_ext().execute_with(|| {1634 let origin1 = Origin::signed(1);16351636 assert_noop!(1637 Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1638 CommonError::<Test>::CollectionNotFound1639 );1640 });1641}16421643#[test]1644fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1645 new_test_ext().execute_with(|| {1646 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1647 let origin1 = Origin::signed(1);1648 let origin2 = Origin::signed(2);16491650 // Add account 2 to allow list1651 assert_ok!(Unique::add_to_allow_list(1652 origin1.clone(),1653 collection_id,1654 account(2)1655 ));16561657 // Account 2 is in collection allow-list1658 assert!(<pallet_common::Allowlist<Test>>::get((1659 collection_id,1660 account(2)1661 )));16621663 // Destroy collection1664 assert_ok!(Unique::destroy_collection(origin1, collection_id));16651666 // Attempt to remove account 2 from collection allow-list => error1667 assert_noop!(1668 Unique::remove_from_allow_list(origin2, collection_id, account(2)),1669 CommonError::<Test>::CollectionNotFound1670 );16711672 // Account 2 is not found in collection allow-list anyway1673 assert_eq!(1674 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1675 false1676 );1677 });1678}16791680// If address is already removed from allow list, nothing happens1681#[test]1682fn address_is_already_removed_from_allow_list() {1683 new_test_ext().execute_with(|| {1684 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1685 let origin1 = Origin::signed(1);16861687 assert_ok!(Unique::add_to_allow_list(1688 origin1.clone(),1689 collection_id,1690 account(2)1691 ));1692 assert_ok!(Unique::remove_from_allow_list(1693 origin1.clone(),1694 collection_id,1695 account(2)1696 ));1697 assert_eq!(1698 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1699 false1700 );1701 assert_ok!(Unique::remove_from_allow_list(1702 origin1,1703 collection_id,1704 account(2)1705 ));1706 assert_eq!(1707 <pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1708 false1709 );1710 });1711}17121713// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1714#[test]1715fn allow_list_test_1() {1716 new_test_ext().execute_with(|| {1717 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17181719 let origin1 = Origin::signed(1);17201721 let data = default_nft_data();1722 create_test_item(collection_id, &data.into());17231724 assert_ok!(Unique::set_public_access_mode(1725 origin1.clone(),1726 collection_id,1727 AccessMode::AllowList1728 ));1729 assert_ok!(Unique::add_to_allow_list(1730 origin1.clone(),1731 collection_id,1732 account(2)1733 ));17341735 assert_noop!(1736 Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1737 .map_err(|e| e.error),1738 CommonError::<Test>::AddressNotInAllowlist1739 );1740 });1741}17421743#[test]1744fn allow_list_test_2() {1745 new_test_ext().execute_with(|| {1746 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1747 let origin1 = Origin::signed(1);17481749 let data = default_nft_data();1750 create_test_item(collection_id, &data.into());17511752 assert_ok!(Unique::set_public_access_mode(1753 origin1.clone(),1754 collection_id,1755 AccessMode::AllowList1756 ));1757 assert_ok!(Unique::add_to_allow_list(1758 origin1.clone(),1759 collection_id,1760 account(1)1761 ));1762 assert_ok!(Unique::add_to_allow_list(1763 origin1.clone(),1764 collection_id,1765 account(2)1766 ));17671768 // do approve1769 assert_ok!(Unique::approve(1770 origin1.clone(),1771 account(1),1772 collection_id,1773 TokenId(1),1774 11775 ));1776 assert_eq!(1777 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1778 account(1)1779 );17801781 assert_ok!(Unique::remove_from_allow_list(1782 origin1.clone(),1783 collection_id,1784 account(1)1785 ));17861787 assert_noop!(1788 Unique::transfer_from(1789 origin1,1790 account(1),1791 account(3),1792 CollectionId(1),1793 TokenId(1),1794 11795 )1796 .map_err(|e| e.error),1797 CommonError::<Test>::AddressNotInAllowlist1798 );1799 });1800}18011802// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1803#[test]1804fn allow_list_test_3() {1805 new_test_ext().execute_with(|| {1806 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18071808 let origin1 = Origin::signed(1);18091810 let data = default_nft_data();1811 create_test_item(collection_id, &data.into());18121813 assert_ok!(Unique::set_public_access_mode(1814 origin1.clone(),1815 collection_id,1816 AccessMode::AllowList1817 ));1818 assert_ok!(Unique::add_to_allow_list(1819 origin1.clone(),1820 collection_id,1821 account(1)1822 ));18231824 assert_noop!(1825 Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1826 .map_err(|e| e.error),1827 CommonError::<Test>::AddressNotInAllowlist1828 );1829 });1830}18311832#[test]1833fn allow_list_test_4() {1834 new_test_ext().execute_with(|| {1835 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18361837 let origin1 = Origin::signed(1);18381839 let data = default_nft_data();1840 create_test_item(collection_id, &data.into());18411842 assert_ok!(Unique::set_public_access_mode(1843 origin1.clone(),1844 collection_id,1845 AccessMode::AllowList1846 ));1847 assert_ok!(Unique::add_to_allow_list(1848 origin1.clone(),1849 collection_id,1850 account(1)1851 ));1852 assert_ok!(Unique::add_to_allow_list(1853 origin1.clone(),1854 collection_id,1855 account(2)1856 ));18571858 // do approve1859 assert_ok!(Unique::approve(1860 origin1.clone(),1861 account(1),1862 collection_id,1863 TokenId(1),1864 11865 ));1866 assert_eq!(1867 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1868 account(1)1869 );18701871 assert_ok!(Unique::remove_from_allow_list(1872 origin1.clone(),1873 collection_id,1874 account(2)1875 ));18761877 assert_noop!(1878 Unique::transfer_from(1879 origin1,1880 account(1),1881 account(3),1882 collection_id,1883 TokenId(1),1884 11885 )1886 .map_err(|e| e.error),1887 CommonError::<Test>::AddressNotInAllowlist1888 );1889 });1890}18911892// 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)1893#[test]1894fn allow_list_test_5() {1895 new_test_ext().execute_with(|| {1896 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18971898 let origin1 = Origin::signed(1);18991900 let data = default_nft_data();1901 create_test_item(collection_id, &data.into());19021903 assert_ok!(Unique::set_public_access_mode(1904 origin1.clone(),1905 collection_id,1906 AccessMode::AllowList1907 ));1908 assert_noop!(1909 Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1910 CommonError::<Test>::AddressNotInAllowlist1911 );1912 });1913}19141915// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1916#[test]1917fn allow_list_test_6() {1918 new_test_ext().execute_with(|| {1919 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19201921 let origin1 = Origin::signed(1);19221923 let data = default_nft_data();1924 create_test_item(collection_id, &data.into());19251926 assert_ok!(Unique::set_public_access_mode(1927 origin1.clone(),1928 collection_id,1929 AccessMode::AllowList1930 ));19311932 // do approve1933 assert_noop!(1934 Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1935 .map_err(|e| e.error),1936 CommonError::<Test>::AddressNotInAllowlist1937 );1938 });1939}19401941// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1942// tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1943#[test]1944fn allow_list_test_7() {1945 new_test_ext().execute_with(|| {1946 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19471948 let data = default_nft_data();1949 create_test_item(collection_id, &data.into());19501951 let origin1 = Origin::signed(1);19521953 assert_ok!(Unique::set_public_access_mode(1954 origin1.clone(),1955 collection_id,1956 AccessMode::AllowList1957 ));1958 assert_ok!(Unique::add_to_allow_list(1959 origin1.clone(),1960 collection_id,1961 account(1)1962 ));1963 assert_ok!(Unique::add_to_allow_list(1964 origin1.clone(),1965 collection_id,1966 account(2)1967 ));19681969 assert_ok!(Unique::transfer(1970 origin1,1971 account(2),1972 CollectionId(1),1973 TokenId(1),1974 11975 ));1976 });1977}19781979#[test]1980fn allow_list_test_8() {1981 new_test_ext().execute_with(|| {1982 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19831984 // Create NFT for account 11985 let data = default_nft_data();1986 create_test_item(collection_id, &data.into());19871988 let origin1 = Origin::signed(1);19891990 // Toggle Allow List mode and add accounts 1 and 21991 assert_ok!(Unique::set_public_access_mode(1992 origin1.clone(),1993 collection_id,1994 AccessMode::AllowList1995 ));1996 assert_ok!(Unique::add_to_allow_list(1997 origin1.clone(),1998 collection_id,1999 account(1)2000 ));2001 assert_ok!(Unique::add_to_allow_list(2002 origin1.clone(),2003 collection_id,2004 account(2)2005 ));20062007 // Sself-approve account 1 for NFT 12008 assert_ok!(Unique::approve(2009 origin1.clone(),2010 account(1),2011 CollectionId(1),2012 TokenId(1),2013 12014 ));2015 assert_eq!(2016 <pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2017 account(1)2018 );20192020 // Transfer from 1 to 22021 assert_ok!(Unique::transfer_from(2022 origin1,2023 account(1),2024 account(2),2025 CollectionId(1),2026 TokenId(1),2027 12028 ));2029 });2030}20312032// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2033#[test]2034fn allow_list_test_9() {2035 new_test_ext().execute_with(|| {2036 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2037 let origin1 = Origin::signed(1);20382039 assert_ok!(Unique::set_public_access_mode(2040 origin1.clone(),2041 collection_id,2042 AccessMode::AllowList2043 ));2044 assert_ok!(Unique::set_mint_permission(origin1, collection_id, false));20452046 let data = default_nft_data();2047 create_test_item(collection_id, &data.into());2048 });2049}20502051// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2052#[test]2053fn allow_list_test_10() {2054 new_test_ext().execute_with(|| {2055 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20562057 let origin1 = Origin::signed(1);2058 let origin2 = Origin::signed(2);20592060 assert_ok!(Unique::set_public_access_mode(2061 origin1.clone(),2062 collection_id,2063 AccessMode::AllowList2064 ));2065 assert_ok!(Unique::set_mint_permission(2066 origin1.clone(),2067 collection_id,2068 false2069 ));20702071 assert_ok!(Unique::add_collection_admin(2072 origin1,2073 collection_id,2074 account(2)2075 ));20762077 assert_ok!(Unique::create_item(2078 origin2,2079 collection_id,2080 account(2),2081 default_nft_data().into()2082 ));2083 });2084}20852086// 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.2087#[test]2088fn allow_list_test_11() {2089 new_test_ext().execute_with(|| {2090 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20912092 let origin1 = Origin::signed(1);2093 let origin2 = Origin::signed(2);20942095 assert_ok!(Unique::set_public_access_mode(2096 origin1.clone(),2097 collection_id,2098 AccessMode::AllowList2099 ));2100 assert_ok!(Unique::set_mint_permission(2101 origin1.clone(),2102 collection_id,2103 false2104 ));2105 assert_ok!(Unique::add_to_allow_list(2106 origin1,2107 collection_id,2108 account(2)2109 ));21102111 assert_noop!(2112 Unique::create_item(2113 origin2,2114 CollectionId(1),2115 account(2),2116 default_nft_data().into()2117 )2118 .map_err(|e| e.error),2119 CommonError::<Test>::PublicMintingNotAllowed2120 );2121 });2122}21232124// 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.2125#[test]2126fn allow_list_test_12() {2127 new_test_ext().execute_with(|| {2128 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21292130 let origin1 = Origin::signed(1);2131 let origin2 = Origin::signed(2);21322133 assert_ok!(Unique::set_public_access_mode(2134 origin1.clone(),2135 collection_id,2136 AccessMode::AllowList2137 ));2138 assert_ok!(Unique::set_mint_permission(origin1, collection_id, false));21392140 assert_noop!(2141 Unique::create_item(2142 origin2,2143 CollectionId(1),2144 account(2),2145 default_nft_data().into()2146 )2147 .map_err(|e| e.error),2148 CommonError::<Test>::PublicMintingNotAllowed2149 );2150 });2151}21522153// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2154#[test]2155fn allow_list_test_13() {2156 new_test_ext().execute_with(|| {2157 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21582159 let origin1 = Origin::signed(1);21602161 assert_ok!(Unique::set_public_access_mode(2162 origin1.clone(),2163 collection_id,2164 AccessMode::AllowList2165 ));2166 assert_ok!(Unique::set_mint_permission(origin1, collection_id, true));21672168 let data = default_nft_data();2169 create_test_item(collection_id, &data.into());2170 });2171}21722173// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2174#[test]2175fn allow_list_test_14() {2176 new_test_ext().execute_with(|| {2177 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21782179 let origin1 = Origin::signed(1);2180 let origin2 = Origin::signed(2);21812182 assert_ok!(Unique::set_public_access_mode(2183 origin1.clone(),2184 collection_id,2185 AccessMode::AllowList2186 ));2187 assert_ok!(Unique::set_mint_permission(2188 origin1.clone(),2189 collection_id,2190 true2191 ));21922193 assert_ok!(Unique::add_collection_admin(2194 origin1,2195 collection_id,2196 account(2)2197 ));21982199 assert_ok!(Unique::create_item(2200 origin2,2201 collection_id,2202 account(2),2203 default_nft_data().into()2204 ));2205 });2206}22072208// 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.2209#[test]2210fn allow_list_test_15() {2211 new_test_ext().execute_with(|| {2212 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22132214 let origin1 = Origin::signed(1);2215 let origin2 = Origin::signed(2);22162217 assert_ok!(Unique::set_public_access_mode(2218 origin1.clone(),2219 collection_id,2220 AccessMode::AllowList2221 ));2222 assert_ok!(Unique::set_mint_permission(origin1, collection_id, true));22232224 assert_noop!(2225 Unique::create_item(2226 origin2,2227 collection_id,2228 account(2),2229 default_nft_data().into()2230 )2231 .map_err(|e| e.error),2232 CommonError::<Test>::AddressNotInAllowlist2233 );2234 });2235}22362237// 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.2238#[test]2239fn allow_list_test_16() {2240 new_test_ext().execute_with(|| {2241 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22422243 let origin1 = Origin::signed(1);2244 let origin2 = Origin::signed(2);22452246 assert_ok!(Unique::set_public_access_mode(2247 origin1.clone(),2248 collection_id,2249 AccessMode::AllowList2250 ));2251 assert_ok!(Unique::set_mint_permission(2252 origin1.clone(),2253 collection_id,2254 true2255 ));2256 assert_ok!(Unique::add_to_allow_list(2257 origin1,2258 collection_id,2259 account(2)2260 ));22612262 assert_ok!(Unique::create_item(2263 origin2,2264 collection_id,2265 account(2),2266 default_nft_data().into()2267 ));2268 });2269}22702271// Total number of collections. Positive test2272#[test]2273fn total_number_collections_bound() {2274 new_test_ext().execute_with(|| {2275 create_test_collection(&CollectionMode::NFT, CollectionId(1));2276 });2277}22782279#[test]2280fn create_max_collections() {2281 new_test_ext().execute_with(|| {2282 for i in 1..COLLECTION_NUMBER_LIMIT {2283 create_test_collection(&CollectionMode::NFT, CollectionId(i));2284 }2285 });2286}22872288// Total number of collections. Negative test2289#[test]2290fn total_number_collections_bound_neg() {2291 new_test_ext().execute_with(|| {2292 let origin1 = Origin::signed(1);22932294 for i in 1..=COLLECTION_NUMBER_LIMIT {2295 create_test_collection(&CollectionMode::NFT, CollectionId(i));2296 }22972298 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2299 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2300 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23012302 let data: CreateCollectionData<u64> = CreateCollectionData {2303 name: col_name1.try_into().unwrap(),2304 description: col_desc1.try_into().unwrap(),2305 token_prefix: token_prefix1.try_into().unwrap(),2306 mode: CollectionMode::NFT,2307 ..Default::default()2308 };23092310 // 11-th collection in chain. Expects error2311 assert_noop!(2312 Unique::create_collection_ex(origin1, data),2313 CommonError::<Test>::TotalCollectionsLimitExceeded2314 );2315 });2316}23172318// Owned tokens by a single address. Positive test2319#[test]2320fn owned_tokens_bound() {2321 new_test_ext().execute_with(|| {2322 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23232324 let data = default_nft_data();2325 create_test_item(collection_id, &data.clone().into());2326 create_test_item(collection_id, &data.into());2327 });2328}23292330// Owned tokens by a single address. Negotive test2331#[test]2332fn owned_tokens_bound_neg() {2333 new_test_ext().execute_with(|| {2334 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23352336 let origin1 = Origin::signed(1);23372338 for _ in 1..=MAX_TOKEN_OWNERSHIP {2339 let data = default_nft_data();2340 create_test_item(collection_id, &data.clone().into());2341 }23422343 let data = default_nft_data();2344 assert_noop!(2345 Unique::create_item(origin1, CollectionId(1), account(1), data.into())2346 .map_err(|e| e.error),2347 CommonError::<Test>::AccountTokenLimitExceeded2348 );2349 });2350}23512352// Number of collection admins. Positive test2353#[test]2354fn collection_admins_bound() {2355 new_test_ext().execute_with(|| {2356 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23572358 let origin1 = Origin::signed(1);23592360 assert_ok!(Unique::add_collection_admin(2361 origin1.clone(),2362 collection_id,2363 account(2)2364 ));2365 assert_ok!(Unique::add_collection_admin(2366 origin1,2367 collection_id,2368 account(3)2369 ));2370 });2371}23722373// Number of collection admins. Negotive test2374#[test]2375fn collection_admins_bound_neg() {2376 new_test_ext().execute_with(|| {2377 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23782379 let origin1 = Origin::signed(1);23802381 for i in 0..COLLECTION_ADMINS_LIMIT {2382 assert_ok!(Unique::add_collection_admin(2383 origin1.clone(),2384 collection_id,2385 account((2 + i).into())2386 ));2387 }2388 assert_noop!(2389 Unique::add_collection_admin(2390 origin1,2391 collection_id,2392 account((3 + COLLECTION_ADMINS_LIMIT).into())2393 ),2394 CommonError::<Test>::CollectionAdminCountExceeded2395 );2396 });2397}2398// #endregion23992400#[test]2401fn set_const_on_chain_schema() {2402 new_test_ext().execute_with(|| {2403 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24042405 let origin1 = Origin::signed(1);2406 assert_ok!(Unique::set_const_on_chain_schema(2407 origin1,2408 collection_id,2409 b"test const on chain schema".to_vec().try_into().unwrap()2410 ));24112412 assert_eq!(2413 <pallet_common::CollectionData<Test>>::get((2414 collection_id,2415 CollectionField::ConstOnChainSchema2416 )),2417 b"test const on chain schema".to_vec()2418 );2419 });2420}24212422#[test]2423fn collection_transfer_flag_works() {2424 new_test_ext().execute_with(|| {2425 let origin1 = Origin::signed(1);24262427 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2428 assert_ok!(Unique::set_transfers_enabled_flag(2429 origin1,2430 collection_id,2431 true2432 ));24332434 let data = default_nft_data();2435 create_test_item(collection_id, &data.into());2436 assert_eq!(2437 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2438 12439 );2440 assert_eq!(2441 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2442 true2443 );24442445 let origin1 = Origin::signed(1);24462447 // default scenario2448 assert_ok!(Unique::transfer(2449 origin1,2450 account(2),2451 collection_id,2452 TokenId(1),2453 12454 ));2455 assert_eq!(2456 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2457 false2458 );2459 assert_eq!(2460 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2461 true2462 );2463 assert_eq!(2464 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2465 02466 );2467 assert_eq!(2468 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2469 12470 );2471 });2472}24732474#[test]2475fn collection_transfer_flag_works_neg() {2476 new_test_ext().execute_with(|| {2477 let origin1 = Origin::signed(1);24782479 let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2480 assert_ok!(Unique::set_transfers_enabled_flag(2481 origin1,2482 collection_id,2483 false2484 ));24852486 let data = default_nft_data();2487 create_test_item(collection_id, &data.into());2488 assert_eq!(2489 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2490 12491 );2492 assert_eq!(2493 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2494 true2495 );24962497 let origin1 = Origin::signed(1);24982499 // default scenario2500 assert_noop!(2501 Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2502 .map_err(|e| e.error),2503 CommonError::<Test>::TransferNotAllowed2504 );2505 assert_eq!(2506 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2507 12508 );2509 assert_eq!(2510 <pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2511 02512 );2513 assert_eq!(2514 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2515 true2516 );2517 assert_eq!(2518 <pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2519 false2520 );2521 });2522}25232524#[test]2525fn collection_sponsoring() {2526 new_test_ext().execute_with(|| {2527 // default_limits();2528 let user1 = 1_u64;2529 let user2 = 777_u64;2530 let origin1 = Origin::signed(user1);2531 let origin2 = Origin::signed(user2);2532 let account2 = account(user2);25332534 let collection_id =2535 create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2536 assert_ok!(Unique::set_collection_sponsor(2537 origin1.clone(),2538 collection_id,2539 user12540 ));2541 assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25422543 // Expect error while have no permissions2544 assert!(Unique::create_item(2545 origin2.clone(),2546 collection_id,2547 account2.clone(),2548 default_nft_data().into()2549 )2550 .is_err());25512552 assert_ok!(Unique::set_public_access_mode(2553 origin1.clone(),2554 collection_id,2555 AccessMode::AllowList2556 ));2557 assert_ok!(Unique::add_to_allow_list(2558 origin1.clone(),2559 collection_id,2560 account2.clone()2561 ));2562 assert_ok!(Unique::set_mint_permission(2563 origin1.clone(),2564 collection_id,2565 true2566 ));25672568 assert_ok!(Unique::create_item(2569 origin2,2570 collection_id,2571 account2,2572 default_nft_data().into()2573 ));2574 });2575}