git.delta.rocks / unique-network / refs/commits / 055cc66f716b

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