git.delta.rocks / unique-network / refs/commits / bb6d71bbdc4d

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		properties: vec![Property {68			key: b"test-prop".to_vec().try_into().unwrap(),69			value: b"test-nft-prop".to_vec().try_into().unwrap(),70		}]71		.try_into()72		.unwrap(),73	}74}7576fn create_test_collection_for_owner(77	mode: &CollectionMode,78	owner: u64,79	id: CollectionId,80) -> CollectionId {81	add_balance(owner, CollectionCreationPrice::get() as u64 + 1);8283	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();84	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();85	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();86	let token_property_permissions: CollectionPropertiesPermissionsVec =87		vec![PropertyKeyPermission {88			key: b"test-prop".to_vec().try_into().unwrap(),89			permission: PropertyPermission {90				mutable: true,91				collection_admin: false,92				token_owner: true,93			},94		}]95		.try_into()96		.unwrap();97	let properties: CollectionPropertiesVec = vec![Property {98		key: b"test-collection-prop".to_vec().try_into().unwrap(),99		value: b"test-collection-value".to_vec().try_into().unwrap(),100	}]101	.try_into()102	.unwrap();103104	let data: CreateCollectionData<u64> = CreateCollectionData {105		name: col_name1.try_into().unwrap(),106		description: col_desc1.try_into().unwrap(),107		token_prefix: token_prefix1.try_into().unwrap(),108		mode: mode.clone(),109		token_property_permissions: token_property_permissions.clone(),110		properties: properties.clone(),111		..Default::default()112	};113114	let origin1 = Origin::signed(owner);115	assert_ok!(Unique::create_collection_ex(origin1, data));116117	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();118	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();119	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();120	assert_eq!(121		<pallet_common::CollectionById<Test>>::get(id)122			.unwrap()123			.owner,124		owner125	);126	assert_eq!(127		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,128		saved_col_name129	);130	assert_eq!(131		<pallet_common::CollectionById<Test>>::get(id).unwrap().mode,132		*mode133	);134	assert_eq!(135		<pallet_common::CollectionById<Test>>::get(id)136			.unwrap()137			.description,138		saved_description139	);140	assert_eq!(141		<pallet_common::CollectionById<Test>>::get(id)142			.unwrap()143			.token_prefix,144		saved_prefix145	);146	assert_eq!(147		get_collection_property_permissions(id).as_slice(),148		token_property_permissions.as_slice()149	);150	assert_eq!(151		get_collection_properties(id).as_slice(),152		properties.as_slice()153	);154	id155}156157fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {158	<pallet_common::Pallet<Test>>::property_permissions(collection_id)159		.into_iter()160		.map(|(key, permission)| PropertyKeyPermission { key, permission })161		.collect()162}163164fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {165	<pallet_common::Pallet<Test>>::collection_properties(collection_id)166		.into_iter()167		.map(|(key, value)| Property { key, value })168		.collect()169}170171fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {172	<pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))173		.into_iter()174		.map(|(key, value)| Property { key, value })175		.collect()176}177178fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {179	create_test_collection_for_owner(&mode, 1, id)180}181182fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {183	let origin1 = Origin::signed(1);184	assert_ok!(Unique::create_item(185		origin1,186		collection_id,187		account(1),188		data.clone()189	));190}191192fn account(sub: u64) -> TestCrossAccountId {193	TestCrossAccountId::from_sub(sub)194}195196// Use cases tests region197// #region198199#[test]200fn check_not_sufficient_founds() {201	new_test_ext().execute_with(|| {202		let acc: u64 = 1;203		<pallet_balances::Pallet<Test>>::set_balance(Origin::root(), acc, 0, 0).unwrap();204205		let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();206		let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();207		let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();208209		let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =210			CreateCollectionData {211				name: name.try_into().unwrap(),212				description: description.try_into().unwrap(),213				token_prefix: token_prefix.try_into().unwrap(),214				mode: CollectionMode::NFT,215				..Default::default()216			};217218		let result = Unique::create_collection_ex(Origin::signed(acc), data);219		assert_err!(result, <CommonError<Test>>::NotSufficientFounds);220	});221}222223#[test]224fn create_fungible_collection_fails_with_large_decimal_numbers() {225	new_test_ext().execute_with(|| {226		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();227		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();228		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();229230		let data: CreateCollectionData<u64> = CreateCollectionData {231			name: col_name1.try_into().unwrap(),232			description: col_desc1.try_into().unwrap(),233			token_prefix: token_prefix1.try_into().unwrap(),234			mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),235			..Default::default()236		};237238		let origin1 = Origin::signed(1);239		assert_noop!(240			Unique::create_collection_ex(origin1, data),241			UniqueError::<Test>::CollectionDecimalPointLimitExceeded242		);243	});244}245246#[test]247fn create_nft_item() {248	new_test_ext().execute_with(|| {249		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));250251		let data = default_nft_data();252		create_test_item(collection_id, &data.clone().into());253254		assert_eq!(255			get_token_properties(collection_id, TokenId(1)).as_slice(),256			data.properties.as_slice(),257		);258	});259}260261// Use cases tests region262// #region263#[test]264fn create_nft_multiple_items() {265	new_test_ext().execute_with(|| {266		create_test_collection(&CollectionMode::NFT, CollectionId(1));267268		let origin1 = Origin::signed(1);269270		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];271272		assert_ok!(Unique::create_multiple_items(273			origin1,274			CollectionId(1),275			account(1),276			items_data277				.clone()278				.into_iter()279				.map(|d| { d.into() })280				.collect()281		));282		for (index, data) in items_data.into_iter().enumerate() {283			assert_eq!(284				get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),285				data.properties.as_slice()286			);287		}288	});289}290291#[test]292fn create_refungible_item() {293	new_test_ext().execute_with(|| {294		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));295296		let data = default_re_fungible_data();297		create_test_item(collection_id, &data.clone().into());298		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));299		let balance =300			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));301		assert_eq!(item.const_data, data.const_data.into_inner());302		assert_eq!(balance, 1023);303	});304}305306#[test]307fn create_multiple_refungible_items() {308	new_test_ext().execute_with(|| {309		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));310311		let origin1 = Origin::signed(1);312313		let items_data = vec![314			default_re_fungible_data(),315			default_re_fungible_data(),316			default_re_fungible_data(),317		];318319		assert_ok!(Unique::create_multiple_items(320			origin1,321			CollectionId(1),322			account(1),323			items_data324				.clone()325				.into_iter()326				.map(|d| { d.into() })327				.collect()328		));329		for (index, data) in items_data.into_iter().enumerate() {330			let item = <pallet_refungible::TokenData<Test>>::get((331				CollectionId(1),332				TokenId((index + 1) as u32),333			));334			let balance =335				<pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));336			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());337			assert_eq!(balance, 1023);338		}339	});340}341342#[test]343fn create_fungible_item() {344	new_test_ext().execute_with(|| {345		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));346347		let data = default_fungible_data();348		create_test_item(collection_id, &data.into());349350		assert_eq!(351			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),352			5353		);354	});355}356357//#[test]358// fn create_multiple_fungible_items() {359//     new_test_ext().execute_with(|| {360//         default_limits();361362//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));363364//         let origin1 = Origin::signed(1);365366//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];367368//         assert_ok!(Unique::create_multiple_items(369//             origin1.clone(),370//             1,371//             1,372//             items_data.clone().into_iter().map(|d| { d.into() }).collect()373//         ));374375//         for (index, _) in items_data.iter().enumerate() {376//             assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);377//         }378//         assert_eq!(Unique::balance_count(1, 1), 3000);379//         assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);380//     });381// }382383#[test]384fn transfer_fungible_item() {385	new_test_ext().execute_with(|| {386		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));387388		let origin1 = Origin::signed(1);389		let origin2 = Origin::signed(2);390391		let data = default_fungible_data();392		create_test_item(collection_id, &data.into());393394		assert_eq!(395			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),396			5397		);398399		// change owner scenario400		assert_ok!(Unique::transfer(401			origin1,402			account(2),403			CollectionId(1),404			TokenId(0),405			5406		));407		assert_eq!(408			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),409			0410		);411412		// split item scenario413		assert_ok!(Unique::transfer(414			origin2.clone(),415			account(3),416			CollectionId(1),417			TokenId(0),418			3419		));420421		// split item and new owner has account scenario422		assert_ok!(Unique::transfer(423			origin2,424			account(3),425			CollectionId(1),426			TokenId(0),427			1428		));429		assert_eq!(430			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),431			1432		);433		assert_eq!(434			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),435			4436		);437	});438}439440#[test]441fn transfer_refungible_item() {442	new_test_ext().execute_with(|| {443		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));444445		// Create RFT 1 in 1023 pieces for account 1446		let data = default_re_fungible_data();447		create_test_item(collection_id, &data.clone().into());448		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));449		assert_eq!(item.const_data, data.const_data.into_inner());450		assert_eq!(451			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),452			1453		);454		assert_eq!(455			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),456			1023457		);458		assert_eq!(459			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),460			true461		);462463		// Account 1 transfers all 1023 pieces of RFT 1 to account 2464		let origin1 = Origin::signed(1);465		let origin2 = Origin::signed(2);466		assert_ok!(Unique::transfer(467			origin1,468			account(2),469			CollectionId(1),470			TokenId(1),471			1023472		));473		assert_eq!(474			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),475			1023476		);477		assert_eq!(478			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),479			0480		);481		assert_eq!(482			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),483			1484		);485		assert_eq!(486			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),487			false488		);489		assert_eq!(490			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),491			true492		);493494		// Account 2 transfers 500 pieces of RFT 1 to account 3495		assert_ok!(Unique::transfer(496			origin2.clone(),497			account(3),498			CollectionId(1),499			TokenId(1),500			500501		));502		assert_eq!(503			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),504			523505		);506		assert_eq!(507			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),508			500509		);510		assert_eq!(511			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),512			1513		);514		assert_eq!(515			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),516			1517		);518		assert_eq!(519			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),520			true521		);522		assert_eq!(523			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),524			true525		);526527		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance528		assert_ok!(Unique::transfer(529			origin2,530			account(3),531			CollectionId(1),532			TokenId(1),533			200534		));535		assert_eq!(536			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),537			323538		);539		assert_eq!(540			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),541			700542		);543		assert_eq!(544			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),545			1546		);547		assert_eq!(548			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),549			1550		);551		assert_eq!(552			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),553			true554		);555		assert_eq!(556			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),557			true558		);559	});560}561562#[test]563fn transfer_nft_item() {564	new_test_ext().execute_with(|| {565		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));566567		let data = default_nft_data();568		create_test_item(collection_id, &data.into());569		assert_eq!(570			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),571			1572		);573		assert_eq!(574			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),575			true576		);577578		let origin1 = Origin::signed(1);579		// default scenario580		assert_ok!(Unique::transfer(581			origin1,582			account(2),583			CollectionId(1),584			TokenId(1),585			1586		));587		assert_eq!(588			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),589			0590		);591		assert_eq!(592			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),593			1594		);595		assert_eq!(596			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),597			false598		);599		assert_eq!(600			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),601			true602		);603	});604}605606#[test]607fn transfer_nft_item_wrong_value() {608	new_test_ext().execute_with(|| {609		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));610611		let data = default_nft_data();612		create_test_item(collection_id, &data.into());613		assert_eq!(614			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),615			1616		);617		assert_eq!(618			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),619			true620		);621622		let origin1 = Origin::signed(1);623624		assert_noop!(625			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)626				.map_err(|e| e.error),627			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount628		);629	});630}631632#[test]633fn transfer_nft_item_zero_value() {634	new_test_ext().execute_with(|| {635		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));636637		let data = default_nft_data();638		create_test_item(collection_id, &data.into());639		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		let origin1 = Origin::signed(1);649650		// Transferring 0 amount works on NFT...651		assert_ok!(Unique::transfer(652			origin1,653			account(2),654			CollectionId(1),655			TokenId(1),656			0657		));658		// ... and results in no transfer659		assert_eq!(660			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),661			1662		);663		assert_eq!(664			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),665			true666		);667	});668}669670#[test]671fn nft_approve_and_transfer_from() {672	new_test_ext().execute_with(|| {673		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));674675		let data = default_nft_data();676		create_test_item(collection_id, &data.into());677678		let origin1 = Origin::signed(1);679		let origin2 = Origin::signed(2);680681		assert_eq!(682			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),683			1684		);685		assert_eq!(686			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),687			true688		);689690		// neg transfer_from691		assert_noop!(692			Unique::transfer_from(693				origin2.clone(),694				account(1),695				account(2),696				CollectionId(1),697				TokenId(1),698				1699			)700			.map_err(|e| e.error),701			CommonError::<Test>::ApprovedValueTooLow702		);703704		// do approve705		assert_ok!(Unique::approve(706			origin1,707			account(2),708			CollectionId(1),709			TokenId(1),710			1711		));712		assert_eq!(713			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),714			account(2)715		);716717		assert_ok!(Unique::transfer_from(718			origin2,719			account(1),720			account(3),721			CollectionId(1),722			TokenId(1),723			1724		));725		assert!(726			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()727		);728	});729}730731#[test]732fn nft_approve_and_transfer_from_allow_list() {733	new_test_ext().execute_with(|| {734		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));735736		let origin1 = Origin::signed(1);737		let origin2 = Origin::signed(2);738739		// Create NFT 1 for account 1740		let data = default_nft_data();741		create_test_item(collection_id, &data.clone().into());742		assert_eq!(743			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),744			1745		);746		assert_eq!(747			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),748			true749		);750751		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list752		assert_ok!(Unique::set_collection_permissions(753			origin1.clone(),754			CollectionId(1),755			CollectionPermissions {756				mint_mode: Some(true),757				access: Some(AccessMode::AllowList),758				nesting: None,759			}760		));761		assert_ok!(Unique::add_to_allow_list(762			origin1.clone(),763			CollectionId(1),764			account(1)765		));766		assert_ok!(Unique::add_to_allow_list(767			origin1.clone(),768			CollectionId(1),769			account(2)770		));771		assert_ok!(Unique::add_to_allow_list(772			origin1.clone(),773			CollectionId(1),774			account(3)775		));776777		// Account 1 approves account 2 for NFT 1778		assert_ok!(Unique::approve(779			origin1.clone(),780			account(2),781			CollectionId(1),782			TokenId(1),783			1784		));785		assert_eq!(786			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),787			account(2)788		);789790		// Account 2 transfers NFT 1 from account 1 to account 3791		assert_ok!(Unique::transfer_from(792			origin2,793			account(1),794			account(3),795			CollectionId(1),796			TokenId(1),797			1798		));799		assert!(800			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()801		);802	});803}804805#[test]806fn refungible_approve_and_transfer_from() {807	new_test_ext().execute_with(|| {808		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));809810		let origin1 = Origin::signed(1);811		let origin2 = Origin::signed(2);812813		// Create RFT 1 in 1023 pieces for account 1814		let data = default_re_fungible_data();815		create_test_item(collection_id, &data.into());816817		assert_eq!(818			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),819			1820		);821		assert_eq!(822			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),823			1023824		);825		assert_eq!(826			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),827			true828		);829830		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list831		assert_ok!(Unique::set_collection_permissions(832			origin1.clone(),833			CollectionId(1),834			CollectionPermissions {835				mint_mode: Some(true),836				access: Some(AccessMode::AllowList),837				nesting: None,838			}839		));840		assert_ok!(Unique::add_to_allow_list(841			origin1.clone(),842			CollectionId(1),843			account(1)844		));845		assert_ok!(Unique::add_to_allow_list(846			origin1.clone(),847			CollectionId(1),848			account(2)849		));850		assert_ok!(Unique::add_to_allow_list(851			origin1.clone(),852			CollectionId(1),853			account(3)854		));855856		// Account 1 approves account 2 for 1023 pieces of RFT 1857		assert_ok!(Unique::approve(858			origin1,859			account(2),860			CollectionId(1),861			TokenId(1),862			1023863		));864		assert_eq!(865			<pallet_refungible::Allowance<Test>>::get((866				CollectionId(1),867				TokenId(1),868				account(1),869				account(2)870			)),871			1023872		);873874		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3875		assert_ok!(Unique::transfer_from(876			origin2,877			account(1),878			account(3),879			CollectionId(1),880			TokenId(1),881			100882		));883		assert_eq!(884			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),885			1886		);887		assert_eq!(888			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),889			1890		);891		assert_eq!(892			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),893			923894		);895		assert_eq!(896			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),897			100898		);899		assert_eq!(900			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),901			true902		);903		assert_eq!(904			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),905			true906		);907		assert_eq!(908			<pallet_refungible::Allowance<Test>>::get((909				CollectionId(1),910				TokenId(1),911				account(1),912				account(2)913			)),914			923915		);916	});917}918919#[test]920fn fungible_approve_and_transfer_from() {921	new_test_ext().execute_with(|| {922		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));923924		let data = default_fungible_data();925		create_test_item(collection_id, &data.into());926927		let origin1 = Origin::signed(1);928		let origin2 = Origin::signed(2);929930		assert_ok!(Unique::set_collection_permissions(931			origin1.clone(),932			CollectionId(1),933			CollectionPermissions {934				mint_mode: Some(true),935				access: Some(AccessMode::AllowList),936				nesting: None,937			}938		));939		assert_ok!(Unique::add_to_allow_list(940			origin1.clone(),941			CollectionId(1),942			account(1)943		));944		assert_ok!(Unique::add_to_allow_list(945			origin1.clone(),946			CollectionId(1),947			account(2)948		));949		assert_ok!(Unique::add_to_allow_list(950			origin1.clone(),951			CollectionId(1),952			account(3)953		));954955		// do approve956		assert_ok!(Unique::approve(957			origin1.clone(),958			account(2),959			CollectionId(1),960			TokenId(0),961			5962		));963		assert_eq!(964			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),965			5966		);967		assert_ok!(Unique::approve(968			origin1,969			account(3),970			CollectionId(1),971			TokenId(0),972			5973		));974		assert_eq!(975			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),976			5977		);978		assert_eq!(979			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),980			5981		);982983		assert_ok!(Unique::transfer_from(984			origin2.clone(),985			account(1),986			account(3),987			CollectionId(1),988			TokenId(0),989			4990		));991992		assert_eq!(993			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),994			1995		);996997		assert_noop!(998			Unique::transfer_from(999				origin2,1000				account(1),1001				account(3),1002				CollectionId(1),1003				TokenId(0),1004				41005			)1006			.map_err(|e| e.error),1007			CommonError::<Test>::ApprovedValueTooLow1008		);1009	});1010}10111012#[test]1013fn change_collection_owner() {1014	new_test_ext().execute_with(|| {1015		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10161017		let origin1 = Origin::signed(1);1018		assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1019		assert_eq!(1020			<pallet_common::CollectionById<Test>>::get(collection_id)1021				.unwrap()1022				.owner,1023			21024		);1025	});1026}10271028#[test]1029fn destroy_collection() {1030	new_test_ext().execute_with(|| {1031		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10321033		let origin1 = Origin::signed(1);1034		assert_ok!(Unique::destroy_collection(origin1, collection_id));1035	});1036}10371038#[test]1039fn burn_nft_item() {1040	new_test_ext().execute_with(|| {1041		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10421043		let origin1 = Origin::signed(1);10441045		let data = default_nft_data();1046		create_test_item(collection_id, &data.into());10471048		// check balance (collection with id = 1, user id = 1)1049		assert_eq!(1050			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1051			11052		);10531054		// burn item1055		assert_ok!(Unique::burn_item(1056			origin1.clone(),1057			collection_id,1058			TokenId(1),1059			11060		));1061		assert_eq!(1062			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1063			01064		);1065	});1066}10671068#[test]1069fn burn_same_nft_item_twice() {1070	new_test_ext().execute_with(|| {1071		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10721073		let origin1 = Origin::signed(1);10741075		let data = default_nft_data();1076		create_test_item(collection_id, &data.into());10771078		// check balance (collection with id = 1, user id = 1)1079		assert_eq!(1080			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1081			11082		);10831084		// burn item1085		assert_ok!(Unique::burn_item(1086			origin1.clone(),1087			collection_id,1088			TokenId(1),1089			11090		));10911092		// burn item again1093		assert_noop!(1094			Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1095			CommonError::<Test>::TokenNotFound1096		);10971098		assert_eq!(1099			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1100			01101		);1102	});1103}11041105#[test]1106fn burn_fungible_item() {1107	new_test_ext().execute_with(|| {1108		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11091110		let origin1 = Origin::signed(1);1111		assert_ok!(Unique::add_collection_admin(1112			origin1.clone(),1113			collection_id,1114			account(2)1115		));11161117		let data = default_fungible_data();1118		create_test_item(collection_id, &data.into());11191120		// check balance (collection with id = 1, user id = 1)1121		assert_eq!(1122			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1123			51124		);11251126		// burn item1127		assert_ok!(Unique::burn_item(1128			origin1.clone(),1129			CollectionId(1),1130			TokenId(0),1131			51132		));1133		assert_noop!(1134			Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1135			CommonError::<Test>::TokenValueTooLow1136		);11371138		assert_eq!(1139			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1140			01141		);1142	});1143}11441145#[test]1146fn burn_fungible_item_with_token_id() {1147	new_test_ext().execute_with(|| {1148		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11491150		let origin1 = Origin::signed(1);1151		assert_ok!(Unique::add_collection_admin(1152			origin1.clone(),1153			collection_id,1154			account(2)1155		));11561157		let data = default_fungible_data();1158		create_test_item(collection_id, &data.into());11591160		// check balance (collection with id = 1, user id = 1)1161		assert_eq!(1162			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1163			51164		);11651166		// Try to burn item using Token ID1167		assert_noop!(1168			Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1169			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1170		);1171	});1172}1173#[test]1174fn burn_refungible_item() {1175	new_test_ext().execute_with(|| {1176		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1177		let origin1 = Origin::signed(1);11781179		assert_ok!(Unique::set_collection_permissions(1180			origin1.clone(),1181			collection_id,1182			CollectionPermissions {1183				mint_mode: Some(true),1184				access: Some(AccessMode::AllowList),1185				nesting: None,1186			}1187		));1188		assert_ok!(Unique::add_to_allow_list(1189			origin1.clone(),1190			collection_id,1191			account(1)1192		));11931194		assert_ok!(Unique::add_collection_admin(1195			origin1.clone(),1196			collection_id,1197			account(2)1198		));11991200		let data = default_re_fungible_data();1201		create_test_item(collection_id, &data.into());12021203		// check balance (collection with id = 1, user id = 2)1204		assert_eq!(1205			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1206			11207		);1208		assert_eq!(1209			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1210			10231211		);12121213		// burn item1214		assert_ok!(Unique::burn_item(1215			origin1.clone(),1216			collection_id,1217			TokenId(1),1218			10231219		));1220		assert_noop!(1221			Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1222			CommonError::<Test>::TokenValueTooLow1223		);12241225		assert_eq!(1226			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1227			01228		);1229	});1230}12311232#[test]1233fn add_collection_admin() {1234	new_test_ext().execute_with(|| {1235		let collection1_id =1236			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1237		let origin1 = Origin::signed(1);12381239		// Add collection admins1240		assert_ok!(Unique::add_collection_admin(1241			origin1.clone(),1242			collection1_id,1243			account(2)1244		));1245		assert_ok!(Unique::add_collection_admin(1246			origin1,1247			collection1_id,1248			account(3)1249		));12501251		// Owner is not an admin by default1252		assert_eq!(1253			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1254			false1255		);1256		assert!(<pallet_common::IsAdmin<Test>>::get((1257			CollectionId(1),1258			account(2)1259		)));1260		assert!(<pallet_common::IsAdmin<Test>>::get((1261			CollectionId(1),1262			account(3)1263		)));1264	});1265}12661267#[test]1268fn remove_collection_admin() {1269	new_test_ext().execute_with(|| {1270		let collection1_id =1271			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1272		let origin1 = Origin::signed(1);12731274		// Add collection admins 2 and 31275		assert_ok!(Unique::add_collection_admin(1276			origin1.clone(),1277			collection1_id,1278			account(2)1279		));1280		assert_ok!(Unique::add_collection_admin(1281			origin1.clone(),1282			collection1_id,1283			account(3)1284		));12851286		assert!(<pallet_common::IsAdmin<Test>>::get((1287			CollectionId(1),1288			account(2)1289		)));1290		assert!(<pallet_common::IsAdmin<Test>>::get((1291			CollectionId(1),1292			account(3)1293		)));12941295		// remove admin 31296		assert_ok!(Unique::remove_collection_admin(1297			origin1,1298			CollectionId(1),1299			account(3)1300		));13011302		// 2 is still admin, 3 is not an admin anymore1303		assert!(<pallet_common::IsAdmin<Test>>::get((1304			CollectionId(1),1305			account(2)1306		)));1307		assert_eq!(1308			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1309			false1310		);1311	});1312}13131314#[test]1315fn balance_of() {1316	new_test_ext().execute_with(|| {1317		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1318		let fungible_collection_id =1319			create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1320		let re_fungible_collection_id =1321			create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13221323		// check balance before1324		assert_eq!(1325			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1326			01327		);1328		assert_eq!(1329			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1330			01331		);1332		assert_eq!(1333			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1334			01335		);13361337		let nft_data = default_nft_data();1338		create_test_item(nft_collection_id, &nft_data.into());13391340		let fungible_data = default_fungible_data();1341		create_test_item(fungible_collection_id, &fungible_data.into());13421343		let re_fungible_data = default_re_fungible_data();1344		create_test_item(re_fungible_collection_id, &re_fungible_data.into());13451346		// check balance (collection with id = 1, user id = 1)1347		assert_eq!(1348			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1349			11350		);1351		assert_eq!(1352			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1353			51354		);1355		assert_eq!(1356			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1357			11358		);13591360		assert_eq!(1361			<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1362			true1363		);1364		assert_eq!(1365			<pallet_refungible::Owned<Test>>::get((1366				re_fungible_collection_id,1367				account(1),1368				TokenId(1)1369			)),1370			true1371		);1372	});1373}13741375#[test]1376fn approve() {1377	new_test_ext().execute_with(|| {1378		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13791380		let data = default_nft_data();1381		create_test_item(collection_id, &data.into());13821383		let origin1 = Origin::signed(1);13841385		// approve1386		assert_ok!(Unique::approve(1387			origin1,1388			account(2),1389			CollectionId(1),1390			TokenId(1),1391			11392		));1393		assert_eq!(1394			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1395			account(2)1396		);1397	});1398}13991400#[test]1401fn transfer_from() {1402	new_test_ext().execute_with(|| {1403		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1404		let origin1 = Origin::signed(1);1405		let origin2 = Origin::signed(2);14061407		let data = default_nft_data();1408		create_test_item(collection_id, &data.into());14091410		// approve1411		assert_ok!(Unique::approve(1412			origin1.clone(),1413			account(2),1414			CollectionId(1),1415			TokenId(1),1416			11417		));1418		assert_eq!(1419			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1420			account(2)1421		);14221423		assert_ok!(Unique::set_collection_permissions(1424			origin1.clone(),1425			CollectionId(1),1426			CollectionPermissions {1427				mint_mode: Some(true),1428				access: Some(AccessMode::AllowList),1429				nesting: None,1430			}1431		));1432		assert_ok!(Unique::add_to_allow_list(1433			origin1.clone(),1434			CollectionId(1),1435			account(1)1436		));1437		assert_ok!(Unique::add_to_allow_list(1438			origin1.clone(),1439			CollectionId(1),1440			account(2)1441		));1442		assert_ok!(Unique::add_to_allow_list(1443			origin1,1444			CollectionId(1),1445			account(3)1446		));14471448		assert_ok!(Unique::transfer_from(1449			origin2,1450			account(1),1451			account(2),1452			CollectionId(1),1453			TokenId(1),1454			11455		));14561457		// after transfer1458		assert_eq!(1459			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1460			01461		);1462		assert_eq!(1463			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1464			11465		);1466	});1467}14681469// #endregion14701471// Coverage tests region1472// #region14731474#[test]1475fn owner_can_add_address_to_allow_list() {1476	new_test_ext().execute_with(|| {1477		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14781479		let origin1 = Origin::signed(1);1480		assert_ok!(Unique::add_to_allow_list(1481			origin1,1482			collection_id,1483			account(2)1484		));1485		assert!(<pallet_common::Allowlist<Test>>::get((1486			collection_id,1487			account(2)1488		)));1489	});1490}14911492#[test]1493fn admin_can_add_address_to_allow_list() {1494	new_test_ext().execute_with(|| {1495		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1496		let origin1 = Origin::signed(1);1497		let origin2 = Origin::signed(2);14981499		assert_ok!(Unique::add_collection_admin(1500			origin1,1501			collection_id,1502			account(2)1503		));1504		assert_ok!(Unique::add_to_allow_list(1505			origin2,1506			collection_id,1507			account(3)1508		));1509		assert!(<pallet_common::Allowlist<Test>>::get((1510			collection_id,1511			account(3)1512		)));1513	});1514}15151516#[test]1517fn nonprivileged_user_cannot_add_address_to_allow_list() {1518	new_test_ext().execute_with(|| {1519		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15201521		let origin2 = Origin::signed(2);1522		assert_noop!(1523			Unique::add_to_allow_list(origin2, collection_id, account(3)),1524			CommonError::<Test>::NoPermission1525		);1526	});1527}15281529#[test]1530fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1531	new_test_ext().execute_with(|| {1532		let origin1 = Origin::signed(1);15331534		assert_noop!(1535			Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1536			CommonError::<Test>::CollectionNotFound1537		);1538	});1539}15401541#[test]1542fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1543	new_test_ext().execute_with(|| {1544		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15451546		let origin1 = Origin::signed(1);1547		assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1548		assert_noop!(1549			Unique::add_to_allow_list(origin1, collection_id, account(2)),1550			CommonError::<Test>::CollectionNotFound1551		);1552	});1553}15541555// If address is already added to allow list, nothing happens1556#[test]1557fn address_is_already_added_to_allow_list() {1558	new_test_ext().execute_with(|| {1559		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1560		let origin1 = Origin::signed(1);15611562		assert_ok!(Unique::add_to_allow_list(1563			origin1.clone(),1564			collection_id,1565			account(2)1566		));1567		assert_ok!(Unique::add_to_allow_list(1568			origin1,1569			collection_id,1570			account(2)1571		));1572		assert!(<pallet_common::Allowlist<Test>>::get((1573			collection_id,1574			account(2)1575		)));1576	});1577}15781579#[test]1580fn owner_can_remove_address_from_allow_list() {1581	new_test_ext().execute_with(|| {1582		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15831584		let origin1 = Origin::signed(1);1585		assert_ok!(Unique::add_to_allow_list(1586			origin1.clone(),1587			collection_id,1588			account(2)1589		));1590		assert_ok!(Unique::remove_from_allow_list(1591			origin1,1592			collection_id,1593			account(2)1594		));1595		assert_eq!(1596			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1597			false1598		);1599	});1600}16011602#[test]1603fn admin_can_remove_address_from_allow_list() {1604	new_test_ext().execute_with(|| {1605		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1606		let origin1 = Origin::signed(1);1607		let origin2 = Origin::signed(2);16081609		// Owner adds admin1610		assert_ok!(Unique::add_collection_admin(1611			origin1.clone(),1612			collection_id,1613			account(2)1614		));16151616		// Owner adds address 3 to allow list1617		assert_ok!(Unique::add_to_allow_list(1618			origin1,1619			collection_id,1620			account(3)1621		));16221623		// Admin removes address 3 from allow list1624		assert_ok!(Unique::remove_from_allow_list(1625			origin2,1626			collection_id,1627			account(3)1628		));1629		assert_eq!(1630			<pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1631			false1632		);1633	});1634}16351636#[test]1637fn nonprivileged_user_cannot_remove_address_from_allow_list() {1638	new_test_ext().execute_with(|| {1639		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1640		let origin1 = Origin::signed(1);1641		let origin2 = Origin::signed(2);16421643		assert_ok!(Unique::add_to_allow_list(1644			origin1,1645			collection_id,1646			account(2)1647		));1648		assert_noop!(1649			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1650			CommonError::<Test>::NoPermission1651		);1652		assert!(<pallet_common::Allowlist<Test>>::get((1653			collection_id,1654			account(2)1655		)));1656	});1657}16581659#[test]1660fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1661	new_test_ext().execute_with(|| {1662		let origin1 = Origin::signed(1);16631664		assert_noop!(1665			Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1666			CommonError::<Test>::CollectionNotFound1667		);1668	});1669}16701671#[test]1672fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1673	new_test_ext().execute_with(|| {1674		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1675		let origin1 = Origin::signed(1);1676		let origin2 = Origin::signed(2);16771678		// Add account 2 to allow list1679		assert_ok!(Unique::add_to_allow_list(1680			origin1.clone(),1681			collection_id,1682			account(2)1683		));16841685		// Account 2 is in collection allow-list1686		assert!(<pallet_common::Allowlist<Test>>::get((1687			collection_id,1688			account(2)1689		)));16901691		// Destroy collection1692		assert_ok!(Unique::destroy_collection(origin1, collection_id));16931694		// Attempt to remove account 2 from collection allow-list => error1695		assert_noop!(1696			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1697			CommonError::<Test>::CollectionNotFound1698		);16991700		// Account 2 is not found in collection allow-list anyway1701		assert_eq!(1702			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1703			false1704		);1705	});1706}17071708// If address is already removed from allow list, nothing happens1709#[test]1710fn address_is_already_removed_from_allow_list() {1711	new_test_ext().execute_with(|| {1712		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1713		let origin1 = Origin::signed(1);17141715		assert_ok!(Unique::add_to_allow_list(1716			origin1.clone(),1717			collection_id,1718			account(2)1719		));1720		assert_ok!(Unique::remove_from_allow_list(1721			origin1.clone(),1722			collection_id,1723			account(2)1724		));1725		assert_eq!(1726			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1727			false1728		);1729		assert_ok!(Unique::remove_from_allow_list(1730			origin1,1731			collection_id,1732			account(2)1733		));1734		assert_eq!(1735			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1736			false1737		);1738	});1739}17401741// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1742#[test]1743fn allow_list_test_1() {1744	new_test_ext().execute_with(|| {1745		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17461747		let origin1 = Origin::signed(1);17481749		let data = default_nft_data();1750		create_test_item(collection_id, &data.into());17511752		assert_ok!(Unique::set_collection_permissions(1753			origin1.clone(),1754			collection_id,1755			CollectionPermissions {1756				mint_mode: None,1757				access: Some(AccessMode::AllowList),1758				nesting: None,1759			}1760		));1761		assert_ok!(Unique::add_to_allow_list(1762			origin1.clone(),1763			collection_id,1764			account(2)1765		));17661767		assert_noop!(1768			Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1769				.map_err(|e| e.error),1770			CommonError::<Test>::AddressNotInAllowlist1771		);1772	});1773}17741775#[test]1776fn allow_list_test_2() {1777	new_test_ext().execute_with(|| {1778		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1779		let origin1 = Origin::signed(1);17801781		let data = default_nft_data();1782		create_test_item(collection_id, &data.into());17831784		assert_ok!(Unique::set_collection_permissions(1785			origin1.clone(),1786			collection_id,1787			CollectionPermissions {1788				mint_mode: None,1789				access: Some(AccessMode::AllowList),1790				nesting: None,1791			}1792		));1793		assert_ok!(Unique::add_to_allow_list(1794			origin1.clone(),1795			collection_id,1796			account(1)1797		));1798		assert_ok!(Unique::add_to_allow_list(1799			origin1.clone(),1800			collection_id,1801			account(2)1802		));18031804		// do approve1805		assert_ok!(Unique::approve(1806			origin1.clone(),1807			account(1),1808			collection_id,1809			TokenId(1),1810			11811		));1812		assert_eq!(1813			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1814			account(1)1815		);18161817		assert_ok!(Unique::remove_from_allow_list(1818			origin1.clone(),1819			collection_id,1820			account(1)1821		));18221823		assert_noop!(1824			Unique::transfer_from(1825				origin1,1826				account(1),1827				account(3),1828				CollectionId(1),1829				TokenId(1),1830				11831			)1832			.map_err(|e| e.error),1833			CommonError::<Test>::AddressNotInAllowlist1834		);1835	});1836}18371838// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1839#[test]1840fn allow_list_test_3() {1841	new_test_ext().execute_with(|| {1842		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18431844		let origin1 = Origin::signed(1);18451846		let data = default_nft_data();1847		create_test_item(collection_id, &data.into());18481849		assert_ok!(Unique::set_collection_permissions(1850			origin1.clone(),1851			collection_id,1852			CollectionPermissions {1853				mint_mode: None,1854				access: Some(AccessMode::AllowList),1855				nesting: None,1856			}1857		));1858		assert_ok!(Unique::add_to_allow_list(1859			origin1.clone(),1860			collection_id,1861			account(1)1862		));18631864		assert_noop!(1865			Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1866				.map_err(|e| e.error),1867			CommonError::<Test>::AddressNotInAllowlist1868		);1869	});1870}18711872#[test]1873fn allow_list_test_4() {1874	new_test_ext().execute_with(|| {1875		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18761877		let origin1 = Origin::signed(1);18781879		let data = default_nft_data();1880		create_test_item(collection_id, &data.into());18811882		assert_ok!(Unique::set_collection_permissions(1883			origin1.clone(),1884			collection_id,1885			CollectionPermissions {1886				mint_mode: None,1887				access: Some(AccessMode::AllowList),1888				nesting: None,1889			}1890		));1891		assert_ok!(Unique::add_to_allow_list(1892			origin1.clone(),1893			collection_id,1894			account(1)1895		));1896		assert_ok!(Unique::add_to_allow_list(1897			origin1.clone(),1898			collection_id,1899			account(2)1900		));19011902		// do approve1903		assert_ok!(Unique::approve(1904			origin1.clone(),1905			account(1),1906			collection_id,1907			TokenId(1),1908			11909		));1910		assert_eq!(1911			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1912			account(1)1913		);19141915		assert_ok!(Unique::remove_from_allow_list(1916			origin1.clone(),1917			collection_id,1918			account(2)1919		));19201921		assert_noop!(1922			Unique::transfer_from(1923				origin1,1924				account(1),1925				account(3),1926				collection_id,1927				TokenId(1),1928				11929			)1930			.map_err(|e| e.error),1931			CommonError::<Test>::AddressNotInAllowlist1932		);1933	});1934}19351936// 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)1937#[test]1938fn allow_list_test_5() {1939	new_test_ext().execute_with(|| {1940		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19411942		let origin1 = Origin::signed(1);19431944		let data = default_nft_data();1945		create_test_item(collection_id, &data.into());19461947		assert_ok!(Unique::set_collection_permissions(1948			origin1.clone(),1949			collection_id,1950			CollectionPermissions {1951				mint_mode: None,1952				access: Some(AccessMode::AllowList),1953				nesting: None,1954			}1955		));1956		assert_noop!(1957			Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1958			CommonError::<Test>::AddressNotInAllowlist1959		);1960	});1961}19621963// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1964#[test]1965fn allow_list_test_6() {1966	new_test_ext().execute_with(|| {1967		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19681969		let origin1 = Origin::signed(1);19701971		let data = default_nft_data();1972		create_test_item(collection_id, &data.into());19731974		assert_ok!(Unique::set_collection_permissions(1975			origin1.clone(),1976			collection_id,1977			CollectionPermissions {1978				mint_mode: None,1979				access: Some(AccessMode::AllowList),1980				nesting: None,1981			}1982		));19831984		// do approve1985		assert_noop!(1986			Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1987				.map_err(|e| e.error),1988			CommonError::<Test>::AddressNotInAllowlist1989		);1990	});1991}19921993// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1994//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1995#[test]1996fn allow_list_test_7() {1997	new_test_ext().execute_with(|| {1998		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19992000		let data = default_nft_data();2001		create_test_item(collection_id, &data.into());20022003		let origin1 = Origin::signed(1);20042005		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		assert_ok!(Unique::transfer(2026			origin1,2027			account(2),2028			CollectionId(1),2029			TokenId(1),2030			12031		));2032	});2033}20342035#[test]2036fn allow_list_test_8() {2037	new_test_ext().execute_with(|| {2038		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20392040		// Create NFT for account 12041		let data = default_nft_data();2042		create_test_item(collection_id, &data.into());20432044		let origin1 = Origin::signed(1);20452046		// Toggle Allow List mode and add accounts 1 and 22047		assert_ok!(Unique::set_collection_permissions(2048			origin1.clone(),2049			collection_id,2050			CollectionPermissions {2051				mint_mode: None,2052				access: Some(AccessMode::AllowList),2053				nesting: None,2054			}2055		));2056		assert_ok!(Unique::add_to_allow_list(2057			origin1.clone(),2058			collection_id,2059			account(1)2060		));2061		assert_ok!(Unique::add_to_allow_list(2062			origin1.clone(),2063			collection_id,2064			account(2)2065		));20662067		// Sself-approve account 1 for NFT 12068		assert_ok!(Unique::approve(2069			origin1.clone(),2070			account(1),2071			CollectionId(1),2072			TokenId(1),2073			12074		));2075		assert_eq!(2076			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2077			account(1)2078		);20792080		// Transfer from 1 to 22081		assert_ok!(Unique::transfer_from(2082			origin1,2083			account(1),2084			account(2),2085			CollectionId(1),2086			TokenId(1),2087			12088		));2089	});2090}20912092// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2093#[test]2094fn allow_list_test_9() {2095	new_test_ext().execute_with(|| {2096		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2097		let origin1 = Origin::signed(1);20982099		assert_ok!(Unique::set_collection_permissions(2100			origin1.clone(),2101			collection_id,2102			CollectionPermissions {2103				mint_mode: Some(false),2104				access: Some(AccessMode::AllowList),2105				nesting: None,2106			}2107		));21082109		let data = default_nft_data();2110		create_test_item(collection_id, &data.into());2111	});2112}21132114// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2115#[test]2116fn allow_list_test_10() {2117	new_test_ext().execute_with(|| {2118		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21192120		let origin1 = Origin::signed(1);2121		let origin2 = Origin::signed(2);21222123		assert_ok!(Unique::set_collection_permissions(2124			origin1.clone(),2125			collection_id,2126			CollectionPermissions {2127				mint_mode: Some(false),2128				access: Some(AccessMode::AllowList),2129				nesting: None,2130			}2131		));21322133		assert_ok!(Unique::add_collection_admin(2134			origin1,2135			collection_id,2136			account(2)2137		));21382139		assert_ok!(Unique::create_item(2140			origin2,2141			collection_id,2142			account(2),2143			default_nft_data().into()2144		));2145	});2146}21472148// 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.2149#[test]2150fn allow_list_test_11() {2151	new_test_ext().execute_with(|| {2152		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21532154		let origin1 = Origin::signed(1);2155		let origin2 = Origin::signed(2);21562157		assert_ok!(Unique::set_collection_permissions(2158			origin1.clone(),2159			collection_id,2160			CollectionPermissions {2161				mint_mode: Some(false),2162				access: Some(AccessMode::AllowList),2163				nesting: None,2164			}2165		));2166		assert_ok!(Unique::add_to_allow_list(2167			origin1,2168			collection_id,2169			account(2)2170		));21712172		assert_noop!(2173			Unique::create_item(2174				origin2,2175				CollectionId(1),2176				account(2),2177				default_nft_data().into()2178			)2179			.map_err(|e| e.error),2180			CommonError::<Test>::PublicMintingNotAllowed2181		);2182	});2183}21842185// 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.2186#[test]2187fn allow_list_test_12() {2188	new_test_ext().execute_with(|| {2189		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21902191		let origin1 = Origin::signed(1);2192		let origin2 = Origin::signed(2);21932194		assert_ok!(Unique::set_collection_permissions(2195			origin1.clone(),2196			collection_id,2197			CollectionPermissions {2198				mint_mode: Some(false),2199				access: Some(AccessMode::AllowList),2200				nesting: None,2201			}2202		));22032204		assert_noop!(2205			Unique::create_item(2206				origin2,2207				CollectionId(1),2208				account(2),2209				default_nft_data().into()2210			)2211			.map_err(|e| e.error),2212			CommonError::<Test>::PublicMintingNotAllowed2213		);2214	});2215}22162217// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2218#[test]2219fn allow_list_test_13() {2220	new_test_ext().execute_with(|| {2221		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22222223		let origin1 = Origin::signed(1);22242225		assert_ok!(Unique::set_collection_permissions(2226			origin1.clone(),2227			collection_id,2228			CollectionPermissions {2229				mint_mode: Some(true),2230				access: Some(AccessMode::AllowList),2231				nesting: None,2232			}2233		));22342235		let data = default_nft_data();2236		create_test_item(collection_id, &data.into());2237	});2238}22392240// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2241#[test]2242fn allow_list_test_14() {2243	new_test_ext().execute_with(|| {2244		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22452246		let origin1 = Origin::signed(1);2247		let origin2 = Origin::signed(2);22482249		assert_ok!(Unique::set_collection_permissions(2250			origin1.clone(),2251			collection_id,2252			CollectionPermissions {2253				mint_mode: Some(true),2254				access: Some(AccessMode::AllowList),2255				nesting: None,2256			}2257		));22582259		assert_ok!(Unique::add_collection_admin(2260			origin1,2261			collection_id,2262			account(2)2263		));22642265		assert_ok!(Unique::create_item(2266			origin2,2267			collection_id,2268			account(2),2269			default_nft_data().into()2270		));2271	});2272}22732274// 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.2275#[test]2276fn allow_list_test_15() {2277	new_test_ext().execute_with(|| {2278		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22792280		let origin1 = Origin::signed(1);2281		let origin2 = Origin::signed(2);22822283		assert_ok!(Unique::set_collection_permissions(2284			origin1.clone(),2285			collection_id,2286			CollectionPermissions {2287				mint_mode: Some(true),2288				access: Some(AccessMode::AllowList),2289				nesting: None,2290			}2291		));22922293		assert_noop!(2294			Unique::create_item(2295				origin2,2296				collection_id,2297				account(2),2298				default_nft_data().into()2299			)2300			.map_err(|e| e.error),2301			CommonError::<Test>::AddressNotInAllowlist2302		);2303	});2304}23052306// 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.2307#[test]2308fn allow_list_test_16() {2309	new_test_ext().execute_with(|| {2310		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23112312		let origin1 = Origin::signed(1);2313		let origin2 = Origin::signed(2);23142315		assert_ok!(Unique::set_collection_permissions(2316			origin1.clone(),2317			collection_id,2318			CollectionPermissions {2319				mint_mode: Some(true),2320				access: Some(AccessMode::AllowList),2321				nesting: None,2322			}2323		));2324		assert_ok!(Unique::add_to_allow_list(2325			origin1,2326			collection_id,2327			account(2)2328		));23292330		assert_ok!(Unique::create_item(2331			origin2,2332			collection_id,2333			account(2),2334			default_nft_data().into()2335		));2336	});2337}23382339// Total number of collections. Positive test2340#[test]2341fn total_number_collections_bound() {2342	new_test_ext().execute_with(|| {2343		create_test_collection(&CollectionMode::NFT, CollectionId(1));2344	});2345}23462347#[test]2348fn create_max_collections() {2349	new_test_ext().execute_with(|| {2350		for i in 1..COLLECTION_NUMBER_LIMIT {2351			create_test_collection(&CollectionMode::NFT, CollectionId(i));2352		}2353	});2354}23552356// Total number of collections. Negative test2357#[test]2358fn total_number_collections_bound_neg() {2359	new_test_ext().execute_with(|| {2360		let origin1 = Origin::signed(1);23612362		for i in 1..=COLLECTION_NUMBER_LIMIT {2363			create_test_collection(&CollectionMode::NFT, CollectionId(i));2364		}23652366		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2367		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2368		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23692370		let data: CreateCollectionData<u64> = CreateCollectionData {2371			name: col_name1.try_into().unwrap(),2372			description: col_desc1.try_into().unwrap(),2373			token_prefix: token_prefix1.try_into().unwrap(),2374			mode: CollectionMode::NFT,2375			..Default::default()2376		};23772378		// 11-th collection in chain. Expects error2379		assert_noop!(2380			Unique::create_collection_ex(origin1, data),2381			CommonError::<Test>::TotalCollectionsLimitExceeded2382		);2383	});2384}23852386// Owned tokens by a single address. Positive test2387#[test]2388fn owned_tokens_bound() {2389	new_test_ext().execute_with(|| {2390		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23912392		let data = default_nft_data();2393		create_test_item(collection_id, &data.clone().into());2394		create_test_item(collection_id, &data.into());2395	});2396}23972398// Owned tokens by a single address. Negotive test2399#[test]2400fn owned_tokens_bound_neg() {2401	new_test_ext().execute_with(|| {2402		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24032404		let origin1 = Origin::signed(1);24052406		for _ in 1..=MAX_TOKEN_OWNERSHIP {2407			let data = default_nft_data();2408			create_test_item(collection_id, &data.clone().into());2409		}24102411		let data = default_nft_data();2412		assert_noop!(2413			Unique::create_item(origin1, CollectionId(1), account(1), data.into())2414				.map_err(|e| e.error),2415			CommonError::<Test>::AccountTokenLimitExceeded2416		);2417	});2418}24192420// Number of collection admins. Positive test2421#[test]2422fn collection_admins_bound() {2423	new_test_ext().execute_with(|| {2424		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24252426		let origin1 = Origin::signed(1);24272428		assert_ok!(Unique::add_collection_admin(2429			origin1.clone(),2430			collection_id,2431			account(2)2432		));2433		assert_ok!(Unique::add_collection_admin(2434			origin1,2435			collection_id,2436			account(3)2437		));2438	});2439}24402441// Number of collection admins. Negotive test2442#[test]2443fn collection_admins_bound_neg() {2444	new_test_ext().execute_with(|| {2445		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24462447		let origin1 = Origin::signed(1);24482449		for i in 0..COLLECTION_ADMINS_LIMIT {2450			assert_ok!(Unique::add_collection_admin(2451				origin1.clone(),2452				collection_id,2453				account((2 + i).into())2454			));2455		}2456		assert_noop!(2457			Unique::add_collection_admin(2458				origin1,2459				collection_id,2460				account((3 + COLLECTION_ADMINS_LIMIT).into())2461			),2462			CommonError::<Test>::CollectionAdminCountExceeded2463		);2464	});2465}2466// #endregion24672468#[test]2469fn collection_transfer_flag_works() {2470	new_test_ext().execute_with(|| {2471		let origin1 = Origin::signed(1);24722473		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2474		assert_ok!(Unique::set_transfers_enabled_flag(2475			origin1,2476			collection_id,2477			true2478		));24792480		let data = default_nft_data();2481		create_test_item(collection_id, &data.into());2482		assert_eq!(2483			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2484			12485		);2486		assert_eq!(2487			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2488			true2489		);24902491		let origin1 = Origin::signed(1);24922493		// default scenario2494		assert_ok!(Unique::transfer(2495			origin1,2496			account(2),2497			collection_id,2498			TokenId(1),2499			12500		));2501		assert_eq!(2502			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2503			false2504		);2505		assert_eq!(2506			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2507			true2508		);2509		assert_eq!(2510			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2511			02512		);2513		assert_eq!(2514			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2515			12516		);2517	});2518}25192520#[test]2521fn collection_transfer_flag_works_neg() {2522	new_test_ext().execute_with(|| {2523		let origin1 = Origin::signed(1);25242525		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2526		assert_ok!(Unique::set_transfers_enabled_flag(2527			origin1,2528			collection_id,2529			false2530		));25312532		let data = default_nft_data();2533		create_test_item(collection_id, &data.into());2534		assert_eq!(2535			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2536			12537		);2538		assert_eq!(2539			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2540			true2541		);25422543		let origin1 = Origin::signed(1);25442545		// default scenario2546		assert_noop!(2547			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2548				.map_err(|e| e.error),2549			CommonError::<Test>::TransferNotAllowed2550		);2551		assert_eq!(2552			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2553			12554		);2555		assert_eq!(2556			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2557			02558		);2559		assert_eq!(2560			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2561			true2562		);2563		assert_eq!(2564			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2565			false2566		);2567	});2568}25692570#[test]2571fn collection_sponsoring() {2572	new_test_ext().execute_with(|| {2573		// default_limits();2574		let user1 = 1_u64;2575		let user2 = 777_u64;2576		let origin1 = Origin::signed(user1);2577		let origin2 = Origin::signed(user2);2578		let account2 = account(user2);25792580		let collection_id =2581			create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2582		assert_ok!(Unique::set_collection_sponsor(2583			origin1.clone(),2584			collection_id,2585			user12586		));2587		assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25882589		// Expect error while have no permissions2590		assert!(Unique::create_item(2591			origin2.clone(),2592			collection_id,2593			account2.clone(),2594			default_nft_data().into()2595		)2596		.is_err());25972598		assert_ok!(Unique::set_collection_permissions(2599			origin1.clone(),2600			collection_id,2601			CollectionPermissions {2602				mint_mode: Some(true),2603				access: Some(AccessMode::AllowList),2604				nesting: None,2605			}2606		));2607		assert_ok!(Unique::add_to_allow_list(2608			origin1.clone(),2609			collection_id,2610			account2.clone()2611		));26122613		assert_ok!(Unique::create_item(2614			origin2,2615			collection_id,2616			account2,2617			default_nft_data().into()2618		));2619	});2620}