git.delta.rocks / unique-network / refs/commits / 0c40eab5740e

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, RuntimeOrigin, Unique, new_test_ext};19use up_data_structs::{20	COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData,21	CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, TokenId,22	MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionMode, AccessMode, CollectionPermissions,23	PropertyKeyPermission, PropertyPermission, Property, CollectionPropertiesVec,24	CollectionPropertiesPermissionsVec,25};26use frame_support::{assert_noop, assert_ok, assert_err};27use sp_std::convert::TryInto;28use pallet_evm::account::CrossAccountId;29use pallet_common::Error as CommonError;30use pallet_unique::Error as UniqueError;3132fn add_balance(user: u64, value: u64) {33	const DONOR_USER: u64 = 999;34	assert_ok!(<pallet_balances::Pallet<Test>>::set_balance(35		RuntimeOrigin::root(),36		DONOR_USER,37		value,38		039	));40	assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(41		RuntimeOrigin::root(),42		DONOR_USER,43		user,44		value45	));46}4748fn default_nft_data() -> CreateNftData {49	CreateNftData {50		properties: vec![Property {51			key: b"test-prop".to_vec().try_into().unwrap(),52			value: b"test-nft-prop".to_vec().try_into().unwrap(),53		}]54		.try_into()55		.unwrap(),56	}57}5859fn default_fungible_data() -> CreateFungibleData {60	CreateFungibleData { value: 5 }61}6263fn default_re_fungible_data() -> CreateReFungibleData {64	CreateReFungibleData {65		pieces: 1023,66		properties: vec![Property {67			key: b"test-prop".to_vec().try_into().unwrap(),68			value: b"test-nft-prop".to_vec().try_into().unwrap(),69		}]70		.try_into()71		.unwrap(),72	}73}7475fn create_test_collection_for_owner(76	mode: &CollectionMode,77	owner: u64,78	id: CollectionId,79) -> CollectionId {80	add_balance(owner, CollectionCreationPrice::get() as u64 + 1);8182	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();83	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();84	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();85	let token_property_permissions: CollectionPropertiesPermissionsVec =86		vec![PropertyKeyPermission {87			key: b"test-prop".to_vec().try_into().unwrap(),88			permission: PropertyPermission {89				mutable: true,90				collection_admin: false,91				token_owner: true,92			},93		}]94		.try_into()95		.unwrap();96	let properties: CollectionPropertiesVec = vec![Property {97		key: b"test-collection-prop".to_vec().try_into().unwrap(),98		value: b"test-collection-value".to_vec().try_into().unwrap(),99	}]100	.try_into()101	.unwrap();102103	let data: CreateCollectionData<u64> = CreateCollectionData {104		name: col_name1.try_into().unwrap(),105		description: col_desc1.try_into().unwrap(),106		token_prefix: token_prefix1.try_into().unwrap(),107		mode: mode.clone(),108		token_property_permissions: token_property_permissions.clone(),109		properties: properties.clone(),110		..Default::default()111	};112113	let origin1 = RuntimeOrigin::signed(owner);114	assert_ok!(Unique::create_collection_ex(origin1, data));115116	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();117	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();118	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();119	assert_eq!(120		<pallet_common::CollectionById<Test>>::get(id)121			.unwrap()122			.owner,123		owner124	);125	assert_eq!(126		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,127		saved_col_name128	);129	assert_eq!(130		<pallet_common::CollectionById<Test>>::get(id).unwrap().mode,131		*mode132	);133	assert_eq!(134		<pallet_common::CollectionById<Test>>::get(id)135			.unwrap()136			.description,137		saved_description138	);139	assert_eq!(140		<pallet_common::CollectionById<Test>>::get(id)141			.unwrap()142			.token_prefix,143		saved_prefix144	);145	assert_eq!(146		get_collection_property_permissions(id).as_slice(),147		token_property_permissions.as_slice()148	);149	assert_eq!(150		get_collection_properties(id).as_slice(),151		properties.as_slice()152	);153	id154}155156fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {157	<pallet_common::Pallet<Test>>::property_permissions(collection_id)158		.into_iter()159		.map(|(key, permission)| PropertyKeyPermission { key, permission })160		.collect()161}162163fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {164	<pallet_common::Pallet<Test>>::collection_properties(collection_id)165		.into_iter()166		.map(|(key, value)| Property { key, value })167		.collect()168}169170fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {171	<pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))172		.into_iter()173		.map(|(key, value)| Property { key, value })174		.collect()175}176177fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {178	create_test_collection_for_owner(&mode, 1, id)179}180181fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {182	let origin1 = RuntimeOrigin::signed(1);183	assert_ok!(Unique::create_item(184		origin1,185		collection_id,186		account(1),187		data.clone()188	));189}190191fn account(sub: u64) -> TestCrossAccountId {192	TestCrossAccountId::from_sub(sub)193}194195// Use cases tests region196// #region197198#[test]199fn check_not_sufficient_founds() {200	new_test_ext().execute_with(|| {201		let acc: u64 = 1;202		<pallet_balances::Pallet<Test>>::set_balance(RuntimeOrigin::root(), acc, 0, 0).unwrap();203204		let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();205		let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();206		let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();207208		let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =209			CreateCollectionData {210				name: name.try_into().unwrap(),211				description: description.try_into().unwrap(),212				token_prefix: token_prefix.try_into().unwrap(),213				mode: CollectionMode::NFT,214				..Default::default()215			};216217		let result = Unique::create_collection_ex(RuntimeOrigin::signed(acc), data);218		assert_err!(result, <CommonError<Test>>::NotSufficientFounds);219	});220}221222#[test]223fn create_fungible_collection_fails_with_large_decimal_numbers() {224	new_test_ext().execute_with(|| {225		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();226		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();227		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();228229		let data: CreateCollectionData<u64> = CreateCollectionData {230			name: col_name1.try_into().unwrap(),231			description: col_desc1.try_into().unwrap(),232			token_prefix: token_prefix1.try_into().unwrap(),233			mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),234			..Default::default()235		};236237		let origin1 = RuntimeOrigin::signed(1);238		assert_noop!(239			Unique::create_collection_ex(origin1, data),240			UniqueError::<Test>::CollectionDecimalPointLimitExceeded241		);242	});243}244245#[test]246fn create_nft_item() {247	new_test_ext().execute_with(|| {248		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));249250		let data = default_nft_data();251		create_test_item(collection_id, &data.clone().into());252253		assert_eq!(254			get_token_properties(collection_id, TokenId(1)).as_slice(),255			data.properties.as_slice(),256		);257	});258}259260// Use cases tests region261// #region262#[test]263fn create_nft_multiple_items() {264	new_test_ext().execute_with(|| {265		create_test_collection(&CollectionMode::NFT, CollectionId(1));266267		let origin1 = RuntimeOrigin::signed(1);268269		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];270271		assert_ok!(Unique::create_multiple_items(272			origin1,273			CollectionId(1),274			account(1),275			items_data276				.clone()277				.into_iter()278				.map(|d| { d.into() })279				.collect()280		));281		for (index, data) in items_data.into_iter().enumerate() {282			assert_eq!(283				get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),284				data.properties.as_slice()285			);286		}287	});288}289290#[test]291fn create_refungible_item() {292	new_test_ext().execute_with(|| {293		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));294295		let data = default_re_fungible_data();296		create_test_item(collection_id, &data.clone().into());297		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));298		let balance =299			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));300		assert_eq!(balance, 1023);301	});302}303304#[test]305fn create_multiple_refungible_items() {306	new_test_ext().execute_with(|| {307		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));308309		let origin1 = RuntimeOrigin::signed(1);310311		let items_data = vec![312			default_re_fungible_data(),313			default_re_fungible_data(),314			default_re_fungible_data(),315		];316317		assert_ok!(Unique::create_multiple_items(318			origin1,319			CollectionId(1),320			account(1),321			items_data322				.clone()323				.into_iter()324				.map(|d| { d.into() })325				.collect()326		));327		for (index, data) in items_data.into_iter().enumerate() {328			let item = <pallet_refungible::TokenData<Test>>::get((329				CollectionId(1),330				TokenId((index + 1) as u32),331			));332			let balance =333				<pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));334			assert_eq!(balance, 1023);335		}336	});337}338339#[test]340fn create_fungible_item() {341	new_test_ext().execute_with(|| {342		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));343344		let data = default_fungible_data();345		create_test_item(collection_id, &data.into());346347		assert_eq!(348			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),349			5350		);351	});352}353354//#[test]355// fn create_multiple_fungible_items() {356//     new_test_ext().execute_with(|| {357//         default_limits();358359//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));360361//         let origin1 = RuntimeOrigin::signed(1);362363//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];364365//         assert_ok!(Unique::create_multiple_items(366//             origin1.clone(),367//             1,368//             1,369//             items_data.clone().into_iter().map(|d| { d.into() }).collect()370//         ));371372//         for (index, _) in items_data.iter().enumerate() {373//             assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);374//         }375//         assert_eq!(Unique::balance_count(1, 1), 3000);376//         assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);377//     });378// }379380#[test]381fn transfer_fungible_item() {382	new_test_ext().execute_with(|| {383		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));384385		let origin1 = RuntimeOrigin::signed(1);386		let origin2 = RuntimeOrigin::signed(2);387388		let data = default_fungible_data();389		create_test_item(collection_id, &data.into());390391		assert_eq!(392			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),393			5394		);395396		// change owner scenario397		assert_ok!(Unique::transfer(398			origin1,399			account(2),400			CollectionId(1),401			TokenId(0),402			5403		));404		assert_eq!(405			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),406			0407		);408409		// split item scenario410		assert_ok!(Unique::transfer(411			origin2.clone(),412			account(3),413			CollectionId(1),414			TokenId(0),415			3416		));417418		// split item and new owner has account scenario419		assert_ok!(Unique::transfer(420			origin2,421			account(3),422			CollectionId(1),423			TokenId(0),424			1425		));426		assert_eq!(427			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),428			1429		);430		assert_eq!(431			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),432			4433		);434	});435}436437#[test]438fn transfer_refungible_item() {439	new_test_ext().execute_with(|| {440		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));441442		// Create RFT 1 in 1023 pieces for account 1443		let data = default_re_fungible_data();444		create_test_item(collection_id, &data.clone().into());445		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));446		assert_eq!(447			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),448			1449		);450		assert_eq!(451			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),452			1023453		);454		assert_eq!(455			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),456			true457		);458459		// Account 1 transfers all 1023 pieces of RFT 1 to account 2460		let origin1 = RuntimeOrigin::signed(1);461		let origin2 = RuntimeOrigin::signed(2);462		assert_ok!(Unique::transfer(463			origin1,464			account(2),465			CollectionId(1),466			TokenId(1),467			1023468		));469		assert_eq!(470			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),471			1023472		);473		assert_eq!(474			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),475			0476		);477		assert_eq!(478			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),479			1480		);481		assert_eq!(482			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),483			false484		);485		assert_eq!(486			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),487			true488		);489490		// Account 2 transfers 500 pieces of RFT 1 to account 3491		assert_ok!(Unique::transfer(492			origin2.clone(),493			account(3),494			CollectionId(1),495			TokenId(1),496			500497		));498		assert_eq!(499			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),500			523501		);502		assert_eq!(503			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),504			500505		);506		assert_eq!(507			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),508			1509		);510		assert_eq!(511			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),512			1513		);514		assert_eq!(515			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),516			true517		);518		assert_eq!(519			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),520			true521		);522523		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance524		assert_ok!(Unique::transfer(525			origin2,526			account(3),527			CollectionId(1),528			TokenId(1),529			200530		));531		assert_eq!(532			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),533			323534		);535		assert_eq!(536			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),537			700538		);539		assert_eq!(540			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),541			1542		);543		assert_eq!(544			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),545			1546		);547		assert_eq!(548			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),549			true550		);551		assert_eq!(552			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),553			true554		);555	});556}557558#[test]559fn transfer_nft_item() {560	new_test_ext().execute_with(|| {561		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));562563		let data = default_nft_data();564		create_test_item(collection_id, &data.into());565		assert_eq!(566			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),567			1568		);569		assert_eq!(570			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),571			true572		);573574		let origin1 = RuntimeOrigin::signed(1);575		// default scenario576		assert_ok!(Unique::transfer(577			origin1,578			account(2),579			CollectionId(1),580			TokenId(1),581			1582		));583		assert_eq!(584			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),585			0586		);587		assert_eq!(588			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),589			1590		);591		assert_eq!(592			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),593			false594		);595		assert_eq!(596			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),597			true598		);599	});600}601602#[test]603fn transfer_nft_item_wrong_value() {604	new_test_ext().execute_with(|| {605		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));606607		let data = default_nft_data();608		create_test_item(collection_id, &data.into());609		assert_eq!(610			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),611			1612		);613		assert_eq!(614			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),615			true616		);617618		let origin1 = RuntimeOrigin::signed(1);619620		assert_noop!(621			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)622				.map_err(|e| e.error),623			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount624		);625	});626}627628#[test]629fn nft_approve_and_transfer_from() {630	new_test_ext().execute_with(|| {631		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));632633		let data = default_nft_data();634		create_test_item(collection_id, &data.into());635636		let origin1 = RuntimeOrigin::signed(1);637		let origin2 = RuntimeOrigin::signed(2);638639		assert_eq!(640			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),641			1642		);643		assert_eq!(644			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),645			true646		);647648		// neg transfer_from649		assert_noop!(650			Unique::transfer_from(651				origin2.clone(),652				account(1),653				account(2),654				CollectionId(1),655				TokenId(1),656				1657			)658			.map_err(|e| e.error),659			CommonError::<Test>::ApprovedValueTooLow660		);661662		// do approve663		assert_ok!(Unique::approve(664			origin1,665			account(2),666			CollectionId(1),667			TokenId(1),668			1669		));670		assert_eq!(671			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),672			account(2)673		);674675		assert_ok!(Unique::transfer_from(676			origin2,677			account(1),678			account(3),679			CollectionId(1),680			TokenId(1),681			1682		));683		assert!(684			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()685		);686	});687}688689#[test]690fn nft_approve_and_transfer_from_allow_list() {691	new_test_ext().execute_with(|| {692		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));693694		let origin1 = RuntimeOrigin::signed(1);695		let origin2 = RuntimeOrigin::signed(2);696697		// Create NFT 1 for account 1698		let data = default_nft_data();699		create_test_item(collection_id, &data.clone().into());700		assert_eq!(701			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),702			1703		);704		assert_eq!(705			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),706			true707		);708709		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list710		assert_ok!(Unique::set_collection_permissions(711			origin1.clone(),712			CollectionId(1),713			CollectionPermissions {714				mint_mode: Some(true),715				access: Some(AccessMode::AllowList),716				nesting: None,717			}718		));719		assert_ok!(Unique::add_to_allow_list(720			origin1.clone(),721			CollectionId(1),722			account(1)723		));724		assert_ok!(Unique::add_to_allow_list(725			origin1.clone(),726			CollectionId(1),727			account(2)728		));729		assert_ok!(Unique::add_to_allow_list(730			origin1.clone(),731			CollectionId(1),732			account(3)733		));734735		// Account 1 approves account 2 for NFT 1736		assert_ok!(Unique::approve(737			origin1.clone(),738			account(2),739			CollectionId(1),740			TokenId(1),741			1742		));743		assert_eq!(744			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),745			account(2)746		);747748		// Account 2 transfers NFT 1 from account 1 to account 3749		assert_ok!(Unique::transfer_from(750			origin2,751			account(1),752			account(3),753			CollectionId(1),754			TokenId(1),755			1756		));757		assert!(758			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()759		);760	});761}762763#[test]764fn refungible_approve_and_transfer_from() {765	new_test_ext().execute_with(|| {766		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));767768		let origin1 = RuntimeOrigin::signed(1);769		let origin2 = RuntimeOrigin::signed(2);770771		// Create RFT 1 in 1023 pieces for account 1772		let data = default_re_fungible_data();773		create_test_item(collection_id, &data.into());774775		assert_eq!(776			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),777			1778		);779		assert_eq!(780			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),781			1023782		);783		assert_eq!(784			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),785			true786		);787788		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list789		assert_ok!(Unique::set_collection_permissions(790			origin1.clone(),791			CollectionId(1),792			CollectionPermissions {793				mint_mode: Some(true),794				access: Some(AccessMode::AllowList),795				nesting: None,796			}797		));798		assert_ok!(Unique::add_to_allow_list(799			origin1.clone(),800			CollectionId(1),801			account(1)802		));803		assert_ok!(Unique::add_to_allow_list(804			origin1.clone(),805			CollectionId(1),806			account(2)807		));808		assert_ok!(Unique::add_to_allow_list(809			origin1.clone(),810			CollectionId(1),811			account(3)812		));813814		// Account 1 approves account 2 for 1023 pieces of RFT 1815		assert_ok!(Unique::approve(816			origin1,817			account(2),818			CollectionId(1),819			TokenId(1),820			1023821		));822		assert_eq!(823			<pallet_refungible::Allowance<Test>>::get((824				CollectionId(1),825				TokenId(1),826				account(1),827				account(2)828			)),829			1023830		);831832		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3833		assert_ok!(Unique::transfer_from(834			origin2,835			account(1),836			account(3),837			CollectionId(1),838			TokenId(1),839			100840		));841		assert_eq!(842			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),843			1844		);845		assert_eq!(846			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),847			1848		);849		assert_eq!(850			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),851			923852		);853		assert_eq!(854			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),855			100856		);857		assert_eq!(858			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),859			true860		);861		assert_eq!(862			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),863			true864		);865		assert_eq!(866			<pallet_refungible::Allowance<Test>>::get((867				CollectionId(1),868				TokenId(1),869				account(1),870				account(2)871			)),872			923873		);874	});875}876877#[test]878fn fungible_approve_and_transfer_from() {879	new_test_ext().execute_with(|| {880		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));881882		let data = default_fungible_data();883		create_test_item(collection_id, &data.into());884885		let origin1 = RuntimeOrigin::signed(1);886		let origin2 = RuntimeOrigin::signed(2);887888		assert_ok!(Unique::set_collection_permissions(889			origin1.clone(),890			CollectionId(1),891			CollectionPermissions {892				mint_mode: Some(true),893				access: Some(AccessMode::AllowList),894				nesting: None,895			}896		));897		assert_ok!(Unique::add_to_allow_list(898			origin1.clone(),899			CollectionId(1),900			account(1)901		));902		assert_ok!(Unique::add_to_allow_list(903			origin1.clone(),904			CollectionId(1),905			account(2)906		));907		assert_ok!(Unique::add_to_allow_list(908			origin1.clone(),909			CollectionId(1),910			account(3)911		));912913		// do approve914		assert_ok!(Unique::approve(915			origin1.clone(),916			account(2),917			CollectionId(1),918			TokenId(0),919			5920		));921		assert_eq!(922			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),923			5924		);925		assert_ok!(Unique::approve(926			origin1,927			account(3),928			CollectionId(1),929			TokenId(0),930			5931		));932		assert_eq!(933			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),934			5935		);936		assert_eq!(937			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),938			5939		);940941		assert_ok!(Unique::transfer_from(942			origin2.clone(),943			account(1),944			account(3),945			CollectionId(1),946			TokenId(0),947			4948		));949950		assert_eq!(951			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),952			1953		);954955		assert_noop!(956			Unique::transfer_from(957				origin2,958				account(1),959				account(3),960				CollectionId(1),961				TokenId(0),962				4963			)964			.map_err(|e| e.error),965			CommonError::<Test>::ApprovedValueTooLow966		);967	});968}969970#[test]971fn change_collection_owner() {972	new_test_ext().execute_with(|| {973		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));974975		let origin1 = RuntimeOrigin::signed(1);976		assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));977		assert_eq!(978			<pallet_common::CollectionById<Test>>::get(collection_id)979				.unwrap()980				.owner,981			2982		);983	});984}985986#[test]987fn destroy_collection() {988	new_test_ext().execute_with(|| {989		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));990991		let origin1 = RuntimeOrigin::signed(1);992		assert_ok!(Unique::destroy_collection(origin1, collection_id));993	});994}995996#[test]997fn burn_nft_item() {998	new_test_ext().execute_with(|| {999		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10001001		let origin1 = RuntimeOrigin::signed(1);10021003		let data = default_nft_data();1004		create_test_item(collection_id, &data.into());10051006		// check balance (collection with id = 1, user id = 1)1007		assert_eq!(1008			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1009			11010		);10111012		// burn item1013		assert_ok!(Unique::burn_item(1014			origin1.clone(),1015			collection_id,1016			TokenId(1),1017			11018		));1019		assert_eq!(1020			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1021			01022		);1023	});1024}10251026#[test]1027fn burn_same_nft_item_twice() {1028	new_test_ext().execute_with(|| {1029		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10301031		let origin1 = RuntimeOrigin::signed(1);10321033		let data = default_nft_data();1034		create_test_item(collection_id, &data.into());10351036		// check balance (collection with id = 1, user id = 1)1037		assert_eq!(1038			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1039			11040		);10411042		// burn item1043		assert_ok!(Unique::burn_item(1044			origin1.clone(),1045			collection_id,1046			TokenId(1),1047			11048		));10491050		// burn item again1051		assert_noop!(1052			Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1053			CommonError::<Test>::TokenNotFound1054		);10551056		assert_eq!(1057			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1058			01059		);1060	});1061}10621063#[test]1064fn burn_fungible_item() {1065	new_test_ext().execute_with(|| {1066		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));10671068		let origin1 = RuntimeOrigin::signed(1);1069		assert_ok!(Unique::add_collection_admin(1070			origin1.clone(),1071			collection_id,1072			account(2)1073		));10741075		let data = default_fungible_data();1076		create_test_item(collection_id, &data.into());10771078		// check balance (collection with id = 1, user id = 1)1079		assert_eq!(1080			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1081			51082		);10831084		// burn item1085		assert_ok!(Unique::burn_item(1086			origin1.clone(),1087			CollectionId(1),1088			TokenId(0),1089			51090		));1091		assert_noop!(1092			Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1093			CommonError::<Test>::TokenValueTooLow1094		);10951096		assert_eq!(1097			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1098			01099		);1100	});1101}11021103#[test]1104fn burn_fungible_item_with_token_id() {1105	new_test_ext().execute_with(|| {1106		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11071108		let origin1 = RuntimeOrigin::signed(1);1109		assert_ok!(Unique::add_collection_admin(1110			origin1.clone(),1111			collection_id,1112			account(2)1113		));11141115		let data = default_fungible_data();1116		create_test_item(collection_id, &data.into());11171118		// check balance (collection with id = 1, user id = 1)1119		assert_eq!(1120			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1121			51122		);11231124		// Try to burn item using Token ID1125		assert_noop!(1126			Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1127			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1128		);1129	});1130}1131#[test]1132fn burn_refungible_item() {1133	new_test_ext().execute_with(|| {1134		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1135		let origin1 = RuntimeOrigin::signed(1);11361137		assert_ok!(Unique::set_collection_permissions(1138			origin1.clone(),1139			collection_id,1140			CollectionPermissions {1141				mint_mode: Some(true),1142				access: Some(AccessMode::AllowList),1143				nesting: None,1144			}1145		));1146		assert_ok!(Unique::add_to_allow_list(1147			origin1.clone(),1148			collection_id,1149			account(1)1150		));11511152		assert_ok!(Unique::add_collection_admin(1153			origin1.clone(),1154			collection_id,1155			account(2)1156		));11571158		let data = default_re_fungible_data();1159		create_test_item(collection_id, &data.into());11601161		// check balance (collection with id = 1, user id = 2)1162		assert_eq!(1163			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1164			11165		);1166		assert_eq!(1167			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1168			10231169		);11701171		// burn item1172		assert_ok!(Unique::burn_item(1173			origin1.clone(),1174			collection_id,1175			TokenId(1),1176			10231177		));1178		assert_noop!(1179			Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1180			CommonError::<Test>::TokenValueTooLow1181		);11821183		assert_eq!(1184			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1185			01186		);1187	});1188}11891190#[test]1191fn add_collection_admin() {1192	new_test_ext().execute_with(|| {1193		let collection1_id =1194			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1195		let origin1 = RuntimeOrigin::signed(1);11961197		// Add collection admins1198		assert_ok!(Unique::add_collection_admin(1199			origin1.clone(),1200			collection1_id,1201			account(2)1202		));1203		assert_ok!(Unique::add_collection_admin(1204			origin1,1205			collection1_id,1206			account(3)1207		));12081209		// Owner is not an admin by default1210		assert_eq!(1211			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1212			false1213		);1214		assert!(<pallet_common::IsAdmin<Test>>::get((1215			CollectionId(1),1216			account(2)1217		)));1218		assert!(<pallet_common::IsAdmin<Test>>::get((1219			CollectionId(1),1220			account(3)1221		)));1222	});1223}12241225#[test]1226fn remove_collection_admin() {1227	new_test_ext().execute_with(|| {1228		let collection1_id =1229			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1230		let origin1 = RuntimeOrigin::signed(1);12311232		// Add collection admins 2 and 31233		assert_ok!(Unique::add_collection_admin(1234			origin1.clone(),1235			collection1_id,1236			account(2)1237		));1238		assert_ok!(Unique::add_collection_admin(1239			origin1.clone(),1240			collection1_id,1241			account(3)1242		));12431244		assert!(<pallet_common::IsAdmin<Test>>::get((1245			CollectionId(1),1246			account(2)1247		)));1248		assert!(<pallet_common::IsAdmin<Test>>::get((1249			CollectionId(1),1250			account(3)1251		)));12521253		// remove admin 31254		assert_ok!(Unique::remove_collection_admin(1255			origin1,1256			CollectionId(1),1257			account(3)1258		));12591260		// 2 is still admin, 3 is not an admin anymore1261		assert!(<pallet_common::IsAdmin<Test>>::get((1262			CollectionId(1),1263			account(2)1264		)));1265		assert_eq!(1266			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1267			false1268		);1269	});1270}12711272#[test]1273fn balance_of() {1274	new_test_ext().execute_with(|| {1275		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1276		let fungible_collection_id =1277			create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1278		let re_fungible_collection_id =1279			create_test_collection(&CollectionMode::ReFungible, CollectionId(3));12801281		// check balance before1282		assert_eq!(1283			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1284			01285		);1286		assert_eq!(1287			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1288			01289		);1290		assert_eq!(1291			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1292			01293		);12941295		let nft_data = default_nft_data();1296		create_test_item(nft_collection_id, &nft_data.into());12971298		let fungible_data = default_fungible_data();1299		create_test_item(fungible_collection_id, &fungible_data.into());13001301		let re_fungible_data = default_re_fungible_data();1302		create_test_item(re_fungible_collection_id, &re_fungible_data.into());13031304		// check balance (collection with id = 1, user id = 1)1305		assert_eq!(1306			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1307			11308		);1309		assert_eq!(1310			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1311			51312		);1313		assert_eq!(1314			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1315			11316		);13171318		assert_eq!(1319			<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1320			true1321		);1322		assert_eq!(1323			<pallet_refungible::Owned<Test>>::get((1324				re_fungible_collection_id,1325				account(1),1326				TokenId(1)1327			)),1328			true1329		);1330	});1331}13321333#[test]1334fn approve() {1335	new_test_ext().execute_with(|| {1336		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13371338		let data = default_nft_data();1339		create_test_item(collection_id, &data.into());13401341		let origin1 = RuntimeOrigin::signed(1);13421343		// approve1344		assert_ok!(Unique::approve(1345			origin1,1346			account(2),1347			CollectionId(1),1348			TokenId(1),1349			11350		));1351		assert_eq!(1352			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1353			account(2)1354		);1355	});1356}13571358#[test]1359fn transfer_from() {1360	new_test_ext().execute_with(|| {1361		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1362		let origin1 = RuntimeOrigin::signed(1);1363		let origin2 = RuntimeOrigin::signed(2);13641365		let data = default_nft_data();1366		create_test_item(collection_id, &data.into());13671368		// approve1369		assert_ok!(Unique::approve(1370			origin1.clone(),1371			account(2),1372			CollectionId(1),1373			TokenId(1),1374			11375		));1376		assert_eq!(1377			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1378			account(2)1379		);13801381		assert_ok!(Unique::set_collection_permissions(1382			origin1.clone(),1383			CollectionId(1),1384			CollectionPermissions {1385				mint_mode: Some(true),1386				access: Some(AccessMode::AllowList),1387				nesting: None,1388			}1389		));1390		assert_ok!(Unique::add_to_allow_list(1391			origin1.clone(),1392			CollectionId(1),1393			account(1)1394		));1395		assert_ok!(Unique::add_to_allow_list(1396			origin1.clone(),1397			CollectionId(1),1398			account(2)1399		));1400		assert_ok!(Unique::add_to_allow_list(1401			origin1,1402			CollectionId(1),1403			account(3)1404		));14051406		assert_ok!(Unique::transfer_from(1407			origin2,1408			account(1),1409			account(2),1410			CollectionId(1),1411			TokenId(1),1412			11413		));14141415		// after transfer1416		assert_eq!(1417			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1418			01419		);1420		assert_eq!(1421			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1422			11423		);1424	});1425}14261427// #endregion14281429// Coverage tests region1430// #region14311432#[test]1433fn owner_can_add_address_to_allow_list() {1434	new_test_ext().execute_with(|| {1435		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14361437		let origin1 = RuntimeOrigin::signed(1);1438		assert_ok!(Unique::add_to_allow_list(1439			origin1,1440			collection_id,1441			account(2)1442		));1443		assert!(<pallet_common::Allowlist<Test>>::get((1444			collection_id,1445			account(2)1446		)));1447	});1448}14491450#[test]1451fn admin_can_add_address_to_allow_list() {1452	new_test_ext().execute_with(|| {1453		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1454		let origin1 = RuntimeOrigin::signed(1);1455		let origin2 = RuntimeOrigin::signed(2);14561457		assert_ok!(Unique::add_collection_admin(1458			origin1,1459			collection_id,1460			account(2)1461		));1462		assert_ok!(Unique::add_to_allow_list(1463			origin2,1464			collection_id,1465			account(3)1466		));1467		assert!(<pallet_common::Allowlist<Test>>::get((1468			collection_id,1469			account(3)1470		)));1471	});1472}14731474#[test]1475fn nonprivileged_user_cannot_add_address_to_allow_list() {1476	new_test_ext().execute_with(|| {1477		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14781479		let origin2 = RuntimeOrigin::signed(2);1480		assert_noop!(1481			Unique::add_to_allow_list(origin2, collection_id, account(3)),1482			CommonError::<Test>::NoPermission1483		);1484	});1485}14861487#[test]1488fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1489	new_test_ext().execute_with(|| {1490		let origin1 = RuntimeOrigin::signed(1);14911492		assert_noop!(1493			Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1494			CommonError::<Test>::CollectionNotFound1495		);1496	});1497}14981499#[test]1500fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1501	new_test_ext().execute_with(|| {1502		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15031504		let origin1 = RuntimeOrigin::signed(1);1505		assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1506		assert_noop!(1507			Unique::add_to_allow_list(origin1, collection_id, account(2)),1508			CommonError::<Test>::CollectionNotFound1509		);1510	});1511}15121513// If address is already added to allow list, nothing happens1514#[test]1515fn address_is_already_added_to_allow_list() {1516	new_test_ext().execute_with(|| {1517		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1518		let origin1 = RuntimeOrigin::signed(1);15191520		assert_ok!(Unique::add_to_allow_list(1521			origin1.clone(),1522			collection_id,1523			account(2)1524		));1525		assert_ok!(Unique::add_to_allow_list(1526			origin1,1527			collection_id,1528			account(2)1529		));1530		assert!(<pallet_common::Allowlist<Test>>::get((1531			collection_id,1532			account(2)1533		)));1534	});1535}15361537#[test]1538fn owner_can_remove_address_from_allow_list() {1539	new_test_ext().execute_with(|| {1540		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15411542		let origin1 = RuntimeOrigin::signed(1);1543		assert_ok!(Unique::add_to_allow_list(1544			origin1.clone(),1545			collection_id,1546			account(2)1547		));1548		assert_ok!(Unique::remove_from_allow_list(1549			origin1,1550			collection_id,1551			account(2)1552		));1553		assert_eq!(1554			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1555			false1556		);1557	});1558}15591560#[test]1561fn admin_can_remove_address_from_allow_list() {1562	new_test_ext().execute_with(|| {1563		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1564		let origin1 = RuntimeOrigin::signed(1);1565		let origin2 = RuntimeOrigin::signed(2);15661567		// Owner adds admin1568		assert_ok!(Unique::add_collection_admin(1569			origin1.clone(),1570			collection_id,1571			account(2)1572		));15731574		// Owner adds address 3 to allow list1575		assert_ok!(Unique::add_to_allow_list(1576			origin1,1577			collection_id,1578			account(3)1579		));15801581		// Admin removes address 3 from allow list1582		assert_ok!(Unique::remove_from_allow_list(1583			origin2,1584			collection_id,1585			account(3)1586		));1587		assert_eq!(1588			<pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1589			false1590		);1591	});1592}15931594#[test]1595fn nonprivileged_user_cannot_remove_address_from_allow_list() {1596	new_test_ext().execute_with(|| {1597		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1598		let origin1 = RuntimeOrigin::signed(1);1599		let origin2 = RuntimeOrigin::signed(2);16001601		assert_ok!(Unique::add_to_allow_list(1602			origin1,1603			collection_id,1604			account(2)1605		));1606		assert_noop!(1607			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1608			CommonError::<Test>::NoPermission1609		);1610		assert!(<pallet_common::Allowlist<Test>>::get((1611			collection_id,1612			account(2)1613		)));1614	});1615}16161617#[test]1618fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1619	new_test_ext().execute_with(|| {1620		let origin1 = RuntimeOrigin::signed(1);16211622		assert_noop!(1623			Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1624			CommonError::<Test>::CollectionNotFound1625		);1626	});1627}16281629#[test]1630fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1631	new_test_ext().execute_with(|| {1632		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1633		let origin1 = RuntimeOrigin::signed(1);1634		let origin2 = RuntimeOrigin::signed(2);16351636		// Add account 2 to allow list1637		assert_ok!(Unique::add_to_allow_list(1638			origin1.clone(),1639			collection_id,1640			account(2)1641		));16421643		// Account 2 is in collection allow-list1644		assert!(<pallet_common::Allowlist<Test>>::get((1645			collection_id,1646			account(2)1647		)));16481649		// Destroy collection1650		assert_ok!(Unique::destroy_collection(origin1, collection_id));16511652		// Attempt to remove account 2 from collection allow-list => error1653		assert_noop!(1654			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1655			CommonError::<Test>::CollectionNotFound1656		);16571658		// Account 2 is not found in collection allow-list anyway1659		assert_eq!(1660			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1661			false1662		);1663	});1664}16651666// If address is already removed from allow list, nothing happens1667#[test]1668fn address_is_already_removed_from_allow_list() {1669	new_test_ext().execute_with(|| {1670		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1671		let origin1 = RuntimeOrigin::signed(1);16721673		assert_ok!(Unique::add_to_allow_list(1674			origin1.clone(),1675			collection_id,1676			account(2)1677		));1678		assert_ok!(Unique::remove_from_allow_list(1679			origin1.clone(),1680			collection_id,1681			account(2)1682		));1683		assert_eq!(1684			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1685			false1686		);1687		assert_ok!(Unique::remove_from_allow_list(1688			origin1,1689			collection_id,1690			account(2)1691		));1692		assert_eq!(1693			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1694			false1695		);1696	});1697}16981699// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1700#[test]1701fn allow_list_test_1() {1702	new_test_ext().execute_with(|| {1703		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17041705		let origin1 = RuntimeOrigin::signed(1);17061707		let data = default_nft_data();1708		create_test_item(collection_id, &data.into());17091710		assert_ok!(Unique::set_collection_permissions(1711			origin1.clone(),1712			collection_id,1713			CollectionPermissions {1714				mint_mode: None,1715				access: Some(AccessMode::AllowList),1716				nesting: None,1717			}1718		));1719		assert_ok!(Unique::add_to_allow_list(1720			origin1.clone(),1721			collection_id,1722			account(2)1723		));17241725		assert_noop!(1726			Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1727				.map_err(|e| e.error),1728			CommonError::<Test>::AddressNotInAllowlist1729		);1730	});1731}17321733#[test]1734fn allow_list_test_2() {1735	new_test_ext().execute_with(|| {1736		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1737		let origin1 = RuntimeOrigin::signed(1);17381739		let data = default_nft_data();1740		create_test_item(collection_id, &data.into());17411742		assert_ok!(Unique::set_collection_permissions(1743			origin1.clone(),1744			collection_id,1745			CollectionPermissions {1746				mint_mode: None,1747				access: Some(AccessMode::AllowList),1748				nesting: None,1749			}1750		));1751		assert_ok!(Unique::add_to_allow_list(1752			origin1.clone(),1753			collection_id,1754			account(1)1755		));1756		assert_ok!(Unique::add_to_allow_list(1757			origin1.clone(),1758			collection_id,1759			account(2)1760		));17611762		// do approve1763		assert_ok!(Unique::approve(1764			origin1.clone(),1765			account(1),1766			collection_id,1767			TokenId(1),1768			11769		));1770		assert_eq!(1771			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1772			account(1)1773		);17741775		assert_ok!(Unique::remove_from_allow_list(1776			origin1.clone(),1777			collection_id,1778			account(1)1779		));17801781		assert_noop!(1782			Unique::transfer_from(1783				origin1,1784				account(1),1785				account(3),1786				CollectionId(1),1787				TokenId(1),1788				11789			)1790			.map_err(|e| e.error),1791			CommonError::<Test>::AddressNotInAllowlist1792		);1793	});1794}17951796// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1797#[test]1798fn allow_list_test_3() {1799	new_test_ext().execute_with(|| {1800		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18011802		let origin1 = RuntimeOrigin::signed(1);18031804		let data = default_nft_data();1805		create_test_item(collection_id, &data.into());18061807		assert_ok!(Unique::set_collection_permissions(1808			origin1.clone(),1809			collection_id,1810			CollectionPermissions {1811				mint_mode: None,1812				access: Some(AccessMode::AllowList),1813				nesting: None,1814			}1815		));1816		assert_ok!(Unique::add_to_allow_list(1817			origin1.clone(),1818			collection_id,1819			account(1)1820		));18211822		assert_noop!(1823			Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1824				.map_err(|e| e.error),1825			CommonError::<Test>::AddressNotInAllowlist1826		);1827	});1828}18291830#[test]1831fn allow_list_test_4() {1832	new_test_ext().execute_with(|| {1833		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18341835		let origin1 = RuntimeOrigin::signed(1);18361837		let data = default_nft_data();1838		create_test_item(collection_id, &data.into());18391840		assert_ok!(Unique::set_collection_permissions(1841			origin1.clone(),1842			collection_id,1843			CollectionPermissions {1844				mint_mode: None,1845				access: Some(AccessMode::AllowList),1846				nesting: None,1847			}1848		));1849		assert_ok!(Unique::add_to_allow_list(1850			origin1.clone(),1851			collection_id,1852			account(1)1853		));1854		assert_ok!(Unique::add_to_allow_list(1855			origin1.clone(),1856			collection_id,1857			account(2)1858		));18591860		// do approve1861		assert_ok!(Unique::approve(1862			origin1.clone(),1863			account(1),1864			collection_id,1865			TokenId(1),1866			11867		));1868		assert_eq!(1869			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1870			account(1)1871		);18721873		assert_ok!(Unique::remove_from_allow_list(1874			origin1.clone(),1875			collection_id,1876			account(2)1877		));18781879		assert_noop!(1880			Unique::transfer_from(1881				origin1,1882				account(1),1883				account(3),1884				collection_id,1885				TokenId(1),1886				11887			)1888			.map_err(|e| e.error),1889			CommonError::<Test>::AddressNotInAllowlist1890		);1891	});1892}18931894// If Public Access mode is set to AllowList, tokens can’t be destroyed by a non-allowlisted address (even if it owned them before enabling AllowList mode)1895#[test]1896fn allow_list_test_5() {1897	new_test_ext().execute_with(|| {1898		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18991900		let origin1 = RuntimeOrigin::signed(1);19011902		let data = default_nft_data();1903		create_test_item(collection_id, &data.into());19041905		assert_ok!(Unique::set_collection_permissions(1906			origin1.clone(),1907			collection_id,1908			CollectionPermissions {1909				mint_mode: None,1910				access: Some(AccessMode::AllowList),1911				nesting: None,1912			}1913		));1914		assert_noop!(1915			Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1916			CommonError::<Test>::AddressNotInAllowlist1917		);1918	});1919}19201921// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1922#[test]1923fn allow_list_test_6() {1924	new_test_ext().execute_with(|| {1925		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19261927		let origin1 = RuntimeOrigin::signed(1);19281929		let data = default_nft_data();1930		create_test_item(collection_id, &data.into());19311932		assert_ok!(Unique::set_collection_permissions(1933			origin1.clone(),1934			collection_id,1935			CollectionPermissions {1936				mint_mode: None,1937				access: Some(AccessMode::AllowList),1938				nesting: None,1939			}1940		));19411942		// do approve1943		assert_noop!(1944			Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1945				.map_err(|e| e.error),1946			CommonError::<Test>::AddressNotInAllowlist1947		);1948	});1949}19501951// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1952//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1953#[test]1954fn allow_list_test_7() {1955	new_test_ext().execute_with(|| {1956		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19571958		let data = default_nft_data();1959		create_test_item(collection_id, &data.into());19601961		let origin1 = RuntimeOrigin::signed(1);19621963		assert_ok!(Unique::set_collection_permissions(1964			origin1.clone(),1965			collection_id,1966			CollectionPermissions {1967				mint_mode: None,1968				access: Some(AccessMode::AllowList),1969				nesting: None,1970			}1971		));1972		assert_ok!(Unique::add_to_allow_list(1973			origin1.clone(),1974			collection_id,1975			account(1)1976		));1977		assert_ok!(Unique::add_to_allow_list(1978			origin1.clone(),1979			collection_id,1980			account(2)1981		));19821983		assert_ok!(Unique::transfer(1984			origin1,1985			account(2),1986			CollectionId(1),1987			TokenId(1),1988			11989		));1990	});1991}19921993#[test]1994fn allow_list_test_8() {1995	new_test_ext().execute_with(|| {1996		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19971998		// Create NFT for account 11999		let data = default_nft_data();2000		create_test_item(collection_id, &data.into());20012002		let origin1 = RuntimeOrigin::signed(1);20032004		// Toggle Allow List mode and add accounts 1 and 22005		assert_ok!(Unique::set_collection_permissions(2006			origin1.clone(),2007			collection_id,2008			CollectionPermissions {2009				mint_mode: None,2010				access: Some(AccessMode::AllowList),2011				nesting: None,2012			}2013		));2014		assert_ok!(Unique::add_to_allow_list(2015			origin1.clone(),2016			collection_id,2017			account(1)2018		));2019		assert_ok!(Unique::add_to_allow_list(2020			origin1.clone(),2021			collection_id,2022			account(2)2023		));20242025		// Sself-approve account 1 for NFT 12026		assert_ok!(Unique::approve(2027			origin1.clone(),2028			account(1),2029			CollectionId(1),2030			TokenId(1),2031			12032		));2033		assert_eq!(2034			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2035			account(1)2036		);20372038		// Transfer from 1 to 22039		assert_ok!(Unique::transfer_from(2040			origin1,2041			account(1),2042			account(2),2043			CollectionId(1),2044			TokenId(1),2045			12046		));2047	});2048}20492050// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2051#[test]2052fn allow_list_test_9() {2053	new_test_ext().execute_with(|| {2054		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2055		let origin1 = RuntimeOrigin::signed(1);20562057		assert_ok!(Unique::set_collection_permissions(2058			origin1.clone(),2059			collection_id,2060			CollectionPermissions {2061				mint_mode: Some(false),2062				access: Some(AccessMode::AllowList),2063				nesting: None,2064			}2065		));20662067		let data = default_nft_data();2068		create_test_item(collection_id, &data.into());2069	});2070}20712072// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2073#[test]2074fn allow_list_test_10() {2075	new_test_ext().execute_with(|| {2076		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20772078		let origin1 = RuntimeOrigin::signed(1);2079		let origin2 = RuntimeOrigin::signed(2);20802081		assert_ok!(Unique::set_collection_permissions(2082			origin1.clone(),2083			collection_id,2084			CollectionPermissions {2085				mint_mode: Some(false),2086				access: Some(AccessMode::AllowList),2087				nesting: None,2088			}2089		));20902091		assert_ok!(Unique::add_collection_admin(2092			origin1,2093			collection_id,2094			account(2)2095		));20962097		assert_ok!(Unique::create_item(2098			origin2,2099			collection_id,2100			account(2),2101			default_nft_data().into()2102		));2103	});2104}21052106// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and allow listed address.2107#[test]2108fn allow_list_test_11() {2109	new_test_ext().execute_with(|| {2110		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21112112		let origin1 = RuntimeOrigin::signed(1);2113		let origin2 = RuntimeOrigin::signed(2);21142115		assert_ok!(Unique::set_collection_permissions(2116			origin1.clone(),2117			collection_id,2118			CollectionPermissions {2119				mint_mode: Some(false),2120				access: Some(AccessMode::AllowList),2121				nesting: None,2122			}2123		));2124		assert_ok!(Unique::add_to_allow_list(2125			origin1,2126			collection_id,2127			account(2)2128		));21292130		assert_noop!(2131			Unique::create_item(2132				origin2,2133				CollectionId(1),2134				account(2),2135				default_nft_data().into()2136			)2137			.map_err(|e| e.error),2138			CommonError::<Test>::PublicMintingNotAllowed2139		);2140	});2141}21422143// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-allow listed address.2144#[test]2145fn allow_list_test_12() {2146	new_test_ext().execute_with(|| {2147		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21482149		let origin1 = RuntimeOrigin::signed(1);2150		let origin2 = RuntimeOrigin::signed(2);21512152		assert_ok!(Unique::set_collection_permissions(2153			origin1.clone(),2154			collection_id,2155			CollectionPermissions {2156				mint_mode: Some(false),2157				access: Some(AccessMode::AllowList),2158				nesting: None,2159			}2160		));21612162		assert_noop!(2163			Unique::create_item(2164				origin2,2165				CollectionId(1),2166				account(2),2167				default_nft_data().into()2168			)2169			.map_err(|e| e.error),2170			CommonError::<Test>::PublicMintingNotAllowed2171		);2172	});2173}21742175// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2176#[test]2177fn allow_list_test_13() {2178	new_test_ext().execute_with(|| {2179		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21802181		let origin1 = RuntimeOrigin::signed(1);21822183		assert_ok!(Unique::set_collection_permissions(2184			origin1.clone(),2185			collection_id,2186			CollectionPermissions {2187				mint_mode: Some(true),2188				access: Some(AccessMode::AllowList),2189				nesting: None,2190			}2191		));21922193		let data = default_nft_data();2194		create_test_item(collection_id, &data.into());2195	});2196}21972198// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2199#[test]2200fn allow_list_test_14() {2201	new_test_ext().execute_with(|| {2202		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22032204		let origin1 = RuntimeOrigin::signed(1);2205		let origin2 = RuntimeOrigin::signed(2);22062207		assert_ok!(Unique::set_collection_permissions(2208			origin1.clone(),2209			collection_id,2210			CollectionPermissions {2211				mint_mode: Some(true),2212				access: Some(AccessMode::AllowList),2213				nesting: None,2214			}2215		));22162217		assert_ok!(Unique::add_collection_admin(2218			origin1,2219			collection_id,2220			account(2)2221		));22222223		assert_ok!(Unique::create_item(2224			origin2,2225			collection_id,2226			account(2),2227			default_nft_data().into()2228		));2229	});2230}22312232// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-allow listed address.2233#[test]2234fn allow_list_test_15() {2235	new_test_ext().execute_with(|| {2236		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22372238		let origin1 = RuntimeOrigin::signed(1);2239		let origin2 = RuntimeOrigin::signed(2);22402241		assert_ok!(Unique::set_collection_permissions(2242			origin1.clone(),2243			collection_id,2244			CollectionPermissions {2245				mint_mode: Some(true),2246				access: Some(AccessMode::AllowList),2247				nesting: None,2248			}2249		));22502251		assert_noop!(2252			Unique::create_item(2253				origin2,2254				collection_id,2255				account(2),2256				default_nft_data().into()2257			)2258			.map_err(|e| e.error),2259			CommonError::<Test>::AddressNotInAllowlist2260		);2261	});2262}22632264// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by non-privileged and allow listed address.2265#[test]2266fn allow_list_test_16() {2267	new_test_ext().execute_with(|| {2268		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22692270		let origin1 = RuntimeOrigin::signed(1);2271		let origin2 = RuntimeOrigin::signed(2);22722273		assert_ok!(Unique::set_collection_permissions(2274			origin1.clone(),2275			collection_id,2276			CollectionPermissions {2277				mint_mode: Some(true),2278				access: Some(AccessMode::AllowList),2279				nesting: None,2280			}2281		));2282		assert_ok!(Unique::add_to_allow_list(2283			origin1,2284			collection_id,2285			account(2)2286		));22872288		assert_ok!(Unique::create_item(2289			origin2,2290			collection_id,2291			account(2),2292			default_nft_data().into()2293		));2294	});2295}22962297// Total number of collections. Positive test2298#[test]2299fn total_number_collections_bound() {2300	new_test_ext().execute_with(|| {2301		create_test_collection(&CollectionMode::NFT, CollectionId(1));2302	});2303}23042305#[test]2306fn create_max_collections() {2307	new_test_ext().execute_with(|| {2308		for i in 1..COLLECTION_NUMBER_LIMIT {2309			create_test_collection(&CollectionMode::NFT, CollectionId(i));2310		}2311	});2312}23132314// Total number of collections. Negative test2315#[test]2316fn total_number_collections_bound_neg() {2317	new_test_ext().execute_with(|| {2318		let origin1 = RuntimeOrigin::signed(1);23192320		for i in 1..=COLLECTION_NUMBER_LIMIT {2321			create_test_collection(&CollectionMode::NFT, CollectionId(i));2322		}23232324		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2325		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2326		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23272328		let data: CreateCollectionData<u64> = CreateCollectionData {2329			name: col_name1.try_into().unwrap(),2330			description: col_desc1.try_into().unwrap(),2331			token_prefix: token_prefix1.try_into().unwrap(),2332			mode: CollectionMode::NFT,2333			..Default::default()2334		};23352336		// 11-th collection in chain. Expects error2337		assert_noop!(2338			Unique::create_collection_ex(origin1, data),2339			CommonError::<Test>::TotalCollectionsLimitExceeded2340		);2341	});2342}23432344// Owned tokens by a single address. Positive test2345#[test]2346fn owned_tokens_bound() {2347	new_test_ext().execute_with(|| {2348		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23492350		let data = default_nft_data();2351		create_test_item(collection_id, &data.clone().into());2352		create_test_item(collection_id, &data.into());2353	});2354}23552356// Owned tokens by a single address. Negotive test2357#[test]2358fn owned_tokens_bound_neg() {2359	new_test_ext().execute_with(|| {2360		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23612362		let origin1 = RuntimeOrigin::signed(1);23632364		for _ in 1..=MAX_TOKEN_OWNERSHIP {2365			let data = default_nft_data();2366			create_test_item(collection_id, &data.clone().into());2367		}23682369		let data = default_nft_data();2370		assert_noop!(2371			Unique::create_item(origin1, CollectionId(1), account(1), data.into())2372				.map_err(|e| e.error),2373			CommonError::<Test>::AccountTokenLimitExceeded2374		);2375	});2376}23772378// Number of collection admins. Positive test2379#[test]2380fn collection_admins_bound() {2381	new_test_ext().execute_with(|| {2382		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23832384		let origin1 = RuntimeOrigin::signed(1);23852386		assert_ok!(Unique::add_collection_admin(2387			origin1.clone(),2388			collection_id,2389			account(2)2390		));2391		assert_ok!(Unique::add_collection_admin(2392			origin1,2393			collection_id,2394			account(3)2395		));2396	});2397}23982399// Number of collection admins. Negotive test2400#[test]2401fn collection_admins_bound_neg() {2402	new_test_ext().execute_with(|| {2403		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24042405		let origin1 = RuntimeOrigin::signed(1);24062407		for i in 0..COLLECTION_ADMINS_LIMIT {2408			assert_ok!(Unique::add_collection_admin(2409				origin1.clone(),2410				collection_id,2411				account((2 + i).into())2412			));2413		}2414		assert_noop!(2415			Unique::add_collection_admin(2416				origin1,2417				collection_id,2418				account((3 + COLLECTION_ADMINS_LIMIT).into())2419			),2420			CommonError::<Test>::CollectionAdminCountExceeded2421		);2422	});2423}2424// #endregion24252426#[test]2427fn collection_transfer_flag_works() {2428	new_test_ext().execute_with(|| {2429		let origin1 = RuntimeOrigin::signed(1);24302431		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2432		assert_ok!(Unique::set_transfers_enabled_flag(2433			origin1,2434			collection_id,2435			true2436		));24372438		let data = default_nft_data();2439		create_test_item(collection_id, &data.into());2440		assert_eq!(2441			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2442			12443		);2444		assert_eq!(2445			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2446			true2447		);24482449		let origin1 = RuntimeOrigin::signed(1);24502451		// default scenario2452		assert_ok!(Unique::transfer(2453			origin1,2454			account(2),2455			collection_id,2456			TokenId(1),2457			12458		));2459		assert_eq!(2460			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2461			false2462		);2463		assert_eq!(2464			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2465			true2466		);2467		assert_eq!(2468			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2469			02470		);2471		assert_eq!(2472			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2473			12474		);2475	});2476}24772478#[test]2479fn collection_transfer_flag_works_neg() {2480	new_test_ext().execute_with(|| {2481		let origin1 = RuntimeOrigin::signed(1);24822483		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2484		assert_ok!(Unique::set_transfers_enabled_flag(2485			origin1,2486			collection_id,2487			false2488		));24892490		let data = default_nft_data();2491		create_test_item(collection_id, &data.into());2492		assert_eq!(2493			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2494			12495		);2496		assert_eq!(2497			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2498			true2499		);25002501		let origin1 = RuntimeOrigin::signed(1);25022503		// default scenario2504		assert_noop!(2505			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2506				.map_err(|e| e.error),2507			CommonError::<Test>::TransferNotAllowed2508		);2509		assert_eq!(2510			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2511			12512		);2513		assert_eq!(2514			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2515			02516		);2517		assert_eq!(2518			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2519			true2520		);2521		assert_eq!(2522			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2523			false2524		);2525	});2526}25272528#[test]2529fn collection_sponsoring() {2530	new_test_ext().execute_with(|| {2531		// default_limits();2532		let user1 = 1_u64;2533		let user2 = 777_u64;2534		let origin1 = RuntimeOrigin::signed(user1);2535		let origin2 = RuntimeOrigin::signed(user2);2536		let account2 = account(user2);25372538		let collection_id =2539			create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2540		assert_ok!(Unique::set_collection_sponsor(2541			origin1.clone(),2542			collection_id,2543			user12544		));2545		assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25462547		// Expect error while have no permissions2548		assert!(Unique::create_item(2549			origin2.clone(),2550			collection_id,2551			account2.clone(),2552			default_nft_data().into()2553		)2554		.is_err());25552556		assert_ok!(Unique::set_collection_permissions(2557			origin1.clone(),2558			collection_id,2559			CollectionPermissions {2560				mint_mode: Some(true),2561				access: Some(AccessMode::AllowList),2562				nesting: None,2563			}2564		));2565		assert_ok!(Unique::add_to_allow_list(2566			origin1.clone(),2567			collection_id,2568			account2.clone()2569		));25702571		assert_ok!(Unique::create_item(2572			origin2,2573			collection_id,2574			account2,2575			default_nft_data().into()2576		));2577	});2578}