git.delta.rocks / unique-network / refs/commits / 4819755773f4

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 frame_support::{assert_err, assert_noop, assert_ok};19use pallet_common::Error as CommonError;20use pallet_evm::account::CrossAccountId;21use pallet_unique::Error as UniqueError;22use sp_std::convert::TryInto;23use up_data_structs::{24	AccessMode, CollectionId, CollectionMode, CollectionPermissions,25	CollectionPropertiesPermissionsVec, CollectionPropertiesVec, CreateCollectionData,26	CreateFungibleData, CreateItemData, CreateNftData, CreateReFungibleData, Property,27	PropertyKeyPermission, PropertyPermission, TokenId, COLLECTION_ADMINS_LIMIT,28	COLLECTION_NUMBER_LIMIT, MAX_DECIMAL_POINTS, MAX_TOKEN_OWNERSHIP,29};3031use crate::{32	new_test_ext, CollectionCreationPrice, RuntimeOrigin, Test, TestCrossAccountId, Unique,33};3435fn add_balance(user: u64, value: u64) {36	const DONOR_USER: u64 = 999;37	assert_ok!(<pallet_balances::Pallet<Test>>::force_set_balance(38		RuntimeOrigin::root(),39		DONOR_USER,40		value,41	));42	assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(43		RuntimeOrigin::root(),44		DONOR_USER,45		user,46		value47	));48}4950fn default_nft_data() -> CreateNftData {51	CreateNftData {52		properties: vec![Property {53			key: b"test-prop".to_vec().try_into().unwrap(),54			value: b"test-nft-prop".to_vec().try_into().unwrap(),55		}]56		.try_into()57		.unwrap(),58	}59}6061fn default_fungible_data() -> CreateFungibleData {62	CreateFungibleData { value: 5 }63}6465fn default_re_fungible_data() -> CreateReFungibleData {66	CreateReFungibleData {67		pieces: 1023,68		properties: vec![Property {69			key: b"test-prop".to_vec().try_into().unwrap(),70			value: b"test-nft-prop".to_vec().try_into().unwrap(),71		}]72		.try_into()73		.unwrap(),74	}75}7677fn create_test_collection_for_owner(78	mode: &CollectionMode,79	owner: u64,80	id: CollectionId,81) -> CollectionId {82	add_balance(owner, CollectionCreationPrice::get() as u64 + 1);8384	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();85	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();86	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();87	let token_property_permissions: CollectionPropertiesPermissionsVec =88		vec![PropertyKeyPermission {89			key: b"test-prop".to_vec().try_into().unwrap(),90			permission: PropertyPermission {91				mutable: true,92				collection_admin: false,93				token_owner: true,94			},95		}]96		.try_into()97		.unwrap();98	let properties: CollectionPropertiesVec = vec![Property {99		key: b"test-collection-prop".to_vec().try_into().unwrap(),100		value: b"test-collection-value".to_vec().try_into().unwrap(),101	}]102	.try_into()103	.unwrap();104105	let data = CreateCollectionData {106		name: col_name1.try_into().unwrap(),107		description: col_desc1.try_into().unwrap(),108		token_prefix: token_prefix1.try_into().unwrap(),109		mode: mode.clone(),110		token_property_permissions: token_property_permissions.clone(),111		properties: properties.clone(),112		..Default::default()113	};114115	let origin1 = RuntimeOrigin::signed(owner);116	assert_ok!(Unique::create_collection_ex(origin1, data));117118	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();119	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();120	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();121	assert_eq!(122		<pallet_common::CollectionById<Test>>::get(id)123			.unwrap()124			.owner,125		owner126	);127	assert_eq!(128		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,129		saved_col_name130	);131	assert_eq!(132		<pallet_common::CollectionById<Test>>::get(id).unwrap().mode,133		*mode134	);135	assert_eq!(136		<pallet_common::CollectionById<Test>>::get(id)137			.unwrap()138			.description,139		saved_description140	);141	assert_eq!(142		<pallet_common::CollectionById<Test>>::get(id)143			.unwrap()144			.token_prefix,145		saved_prefix146	);147	assert_eq!(148		get_collection_property_permissions(id).as_slice(),149		token_property_permissions.as_slice()150	);151	assert_eq!(152		get_collection_properties(id).as_slice(),153		properties.as_slice()154	);155	id156}157158fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {159	<pallet_common::Pallet<Test>>::property_permissions(collection_id)160		.into_iter()161		.map(|(key, permission)| PropertyKeyPermission { key, permission })162		.collect()163}164165fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {166	<pallet_common::Pallet<Test>>::collection_properties(collection_id)167		.into_iter()168		.map(|(key, value)| Property { key, value })169		.collect()170}171172fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {173	<pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))174		.unwrap_or_default()175		.into_iter()176		.map(|(key, value)| Property { key, value })177		.collect()178}179180fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {181	create_test_collection_for_owner(&mode, 1, id)182}183184fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {185	let origin1 = RuntimeOrigin::signed(1);186	assert_ok!(Unique::create_item(187		origin1,188		collection_id,189		account(1),190		data.clone()191	));192}193194fn account(sub: u64) -> TestCrossAccountId {195	TestCrossAccountId::from_sub(sub)196}197198// Use cases tests region199// #region200201#[test]202fn check_not_sufficient_founds() {203	new_test_ext().execute_with(|| {204		let acc: u64 = 1;205		<pallet_balances::Pallet<Test>>::force_set_balance(RuntimeOrigin::root(), acc, 0).unwrap();206207		let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();208		let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();209		let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();210211		let data = CreateCollectionData {212			name: name.try_into().unwrap(),213			description: description.try_into().unwrap(),214			token_prefix: token_prefix.try_into().unwrap(),215			mode: CollectionMode::NFT,216			..Default::default()217		};218219		let result = Unique::create_collection_ex(RuntimeOrigin::signed(acc), data);220		assert_err!(result, <CommonError<Test>>::NotSufficientFounds);221	});222}223224#[test]225fn create_fungible_collection_fails_with_large_decimal_numbers() {226	new_test_ext().execute_with(|| {227		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();228		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();229		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();230231		let data = CreateCollectionData {232			name: col_name1.try_into().unwrap(),233			description: col_desc1.try_into().unwrap(),234			token_prefix: token_prefix1.try_into().unwrap(),235			mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),236			..Default::default()237		};238239		let origin1 = RuntimeOrigin::signed(1);240		assert_noop!(241			Unique::create_collection_ex(origin1, data),242			UniqueError::<Test>::CollectionDecimalPointLimitExceeded243		);244	});245}246247#[test]248fn create_nft_item() {249	new_test_ext().execute_with(|| {250		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));251252		let data = default_nft_data();253		create_test_item(collection_id, &data.clone().into());254255		assert_eq!(256			get_token_properties(collection_id, TokenId(1)).as_slice(),257			data.properties.as_slice(),258		);259	});260}261262// Use cases tests region263// #region264#[test]265fn create_nft_multiple_items() {266	new_test_ext().execute_with(|| {267		create_test_collection(&CollectionMode::NFT, CollectionId(1));268269		let origin1 = RuntimeOrigin::signed(1);270271		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];272273		assert_ok!(Unique::create_multiple_items(274			origin1,275			CollectionId(1),276			account(1),277			items_data278				.clone()279				.into_iter()280				.map(|d| { d.into() })281				.collect()282		));283		for (index, data) in items_data.into_iter().enumerate() {284			assert_eq!(285				get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),286				data.properties.as_slice()287			);288		}289	});290}291292#[test]293fn create_refungible_item() {294	new_test_ext().execute_with(|| {295		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));296297		let data = default_re_fungible_data();298		create_test_item(collection_id, &data.clone().into());299		let balance =300			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));301		assert_eq!(balance, 1023);302	});303}304305#[test]306fn create_multiple_refungible_items() {307	new_test_ext().execute_with(|| {308		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));309310		let origin1 = RuntimeOrigin::signed(1);311312		let items_data = vec![313			default_re_fungible_data(),314			default_re_fungible_data(),315			default_re_fungible_data(),316		];317318		assert_ok!(Unique::create_multiple_items(319			origin1,320			CollectionId(1),321			account(1),322			items_data323				.clone()324				.into_iter()325				.map(|d| { d.into() })326				.collect()327		));328		for (index, _data) in items_data.into_iter().enumerate() {329			let balance = <pallet_refungible::Balance<Test>>::get((330				CollectionId(1),331				TokenId((index + 1) as u32),332				account(1),333			));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		assert_eq!(446			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),447			1448		);449		assert_eq!(450			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),451			1023452		);453		assert_eq!(454			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),455			true456		);457458		// Account 1 transfers all 1023 pieces of RFT 1 to account 2459		let origin1 = RuntimeOrigin::signed(1);460		let origin2 = RuntimeOrigin::signed(2);461		assert_ok!(Unique::transfer(462			origin1,463			account(2),464			CollectionId(1),465			TokenId(1),466			1023467		));468		assert_eq!(469			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),470			1023471		);472		assert_eq!(473			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),474			0475		);476		assert_eq!(477			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),478			1479		);480		assert_eq!(481			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),482			false483		);484		assert_eq!(485			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),486			true487		);488489		// Account 2 transfers 500 pieces of RFT 1 to account 3490		assert_ok!(Unique::transfer(491			origin2.clone(),492			account(3),493			CollectionId(1),494			TokenId(1),495			500496		));497		assert_eq!(498			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),499			523500		);501		assert_eq!(502			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),503			500504		);505		assert_eq!(506			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),507			1508		);509		assert_eq!(510			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),511			1512		);513		assert_eq!(514			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),515			true516		);517		assert_eq!(518			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),519			true520		);521522		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance523		assert_ok!(Unique::transfer(524			origin2,525			account(3),526			CollectionId(1),527			TokenId(1),528			200529		));530		assert_eq!(531			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),532			323533		);534		assert_eq!(535			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),536			700537		);538		assert_eq!(539			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),540			1541		);542		assert_eq!(543			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),544			1545		);546		assert_eq!(547			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),548			true549		);550		assert_eq!(551			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),552			true553		);554	});555}556557#[test]558fn transfer_nft_item() {559	new_test_ext().execute_with(|| {560		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));561562		let data = default_nft_data();563		create_test_item(collection_id, &data.into());564		assert_eq!(565			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),566			1567		);568		assert_eq!(569			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),570			true571		);572573		let origin1 = RuntimeOrigin::signed(1);574		// default scenario575		assert_ok!(Unique::transfer(576			origin1,577			account(2),578			CollectionId(1),579			TokenId(1),580			1581		));582		assert_eq!(583			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),584			0585		);586		assert_eq!(587			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),588			1589		);590		assert_eq!(591			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),592			false593		);594		assert_eq!(595			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),596			true597		);598	});599}600601#[test]602fn transfer_nft_item_wrong_value() {603	new_test_ext().execute_with(|| {604		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));605606		let data = default_nft_data();607		create_test_item(collection_id, &data.into());608		assert_eq!(609			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),610			1611		);612		assert_eq!(613			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),614			true615		);616617		let origin1 = RuntimeOrigin::signed(1);618619		assert_noop!(620			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)621				.map_err(|e| e.error),622			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount623		);624	});625}626627#[test]628fn transfer_nft_item_zero_value() {629	new_test_ext().execute_with(|| {630		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));631632		let data = default_nft_data();633		create_test_item(collection_id, &data.into());634		assert_eq!(635			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),636			1637		);638		assert_eq!(639			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),640			true641		);642643		let origin1 = RuntimeOrigin::signed(1);644645		// Transferring 0 amount works on NFT...646		assert_ok!(Unique::transfer(647			origin1,648			account(2),649			CollectionId(1),650			TokenId(1),651			0652		));653		// ... and results in no transfer654		assert_eq!(655			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),656			1657		);658		assert_eq!(659			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),660			true661		);662	});663}664665#[test]666fn nft_approve_and_transfer_from() {667	new_test_ext().execute_with(|| {668		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));669670		let data = default_nft_data();671		create_test_item(collection_id, &data.into());672673		let origin1 = RuntimeOrigin::signed(1);674		let origin2 = RuntimeOrigin::signed(2);675676		assert_eq!(677			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),678			1679		);680		assert_eq!(681			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),682			true683		);684685		// neg transfer_from686		assert_noop!(687			Unique::transfer_from(688				origin2.clone(),689				account(1),690				account(2),691				CollectionId(1),692				TokenId(1),693				1694			)695			.map_err(|e| e.error),696			CommonError::<Test>::ApprovedValueTooLow697		);698699		// do approve700		assert_ok!(Unique::approve(701			origin1,702			account(2),703			CollectionId(1),704			TokenId(1),705			1706		));707		assert_eq!(708			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),709			account(2)710		);711712		assert_ok!(Unique::transfer_from(713			origin2,714			account(1),715			account(3),716			CollectionId(1),717			TokenId(1),718			1719		));720		assert!(721			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()722		);723	});724}725726#[test]727fn nft_approve_and_transfer_from_allow_list() {728	new_test_ext().execute_with(|| {729		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));730731		let origin1 = RuntimeOrigin::signed(1);732		let origin2 = RuntimeOrigin::signed(2);733734		// Create NFT 1 for account 1735		let data = default_nft_data();736		create_test_item(collection_id, &data.clone().into());737		assert_eq!(738			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),739			1740		);741		assert_eq!(742			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),743			true744		);745746		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list747		assert_ok!(Unique::set_collection_permissions(748			origin1.clone(),749			CollectionId(1),750			CollectionPermissions {751				mint_mode: Some(true),752				access: Some(AccessMode::AllowList),753				nesting: None,754			}755		));756		assert_ok!(Unique::add_to_allow_list(757			origin1.clone(),758			CollectionId(1),759			account(1)760		));761		assert_ok!(Unique::add_to_allow_list(762			origin1.clone(),763			CollectionId(1),764			account(2)765		));766		assert_ok!(Unique::add_to_allow_list(767			origin1.clone(),768			CollectionId(1),769			account(3)770		));771772		// Account 1 approves account 2 for NFT 1773		assert_ok!(Unique::approve(774			origin1.clone(),775			account(2),776			CollectionId(1),777			TokenId(1),778			1779		));780		assert_eq!(781			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),782			account(2)783		);784785		// Account 2 transfers NFT 1 from account 1 to account 3786		assert_ok!(Unique::transfer_from(787			origin2,788			account(1),789			account(3),790			CollectionId(1),791			TokenId(1),792			1793		));794		assert!(795			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()796		);797	});798}799800#[test]801fn refungible_approve_and_transfer_from() {802	new_test_ext().execute_with(|| {803		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));804805		let origin1 = RuntimeOrigin::signed(1);806		let origin2 = RuntimeOrigin::signed(2);807808		// Create RFT 1 in 1023 pieces for account 1809		let data = default_re_fungible_data();810		create_test_item(collection_id, &data.into());811812		assert_eq!(813			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),814			1815		);816		assert_eq!(817			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),818			1023819		);820		assert_eq!(821			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),822			true823		);824825		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list826		assert_ok!(Unique::set_collection_permissions(827			origin1.clone(),828			CollectionId(1),829			CollectionPermissions {830				mint_mode: Some(true),831				access: Some(AccessMode::AllowList),832				nesting: None,833			}834		));835		assert_ok!(Unique::add_to_allow_list(836			origin1.clone(),837			CollectionId(1),838			account(1)839		));840		assert_ok!(Unique::add_to_allow_list(841			origin1.clone(),842			CollectionId(1),843			account(2)844		));845		assert_ok!(Unique::add_to_allow_list(846			origin1.clone(),847			CollectionId(1),848			account(3)849		));850851		// Account 1 approves account 2 for 1023 pieces of RFT 1852		assert_ok!(Unique::approve(853			origin1,854			account(2),855			CollectionId(1),856			TokenId(1),857			1023858		));859		assert_eq!(860			<pallet_refungible::Allowance<Test>>::get((861				CollectionId(1),862				TokenId(1),863				account(1),864				account(2)865			)),866			1023867		);868869		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3870		assert_ok!(Unique::transfer_from(871			origin2,872			account(1),873			account(3),874			CollectionId(1),875			TokenId(1),876			100877		));878		assert_eq!(879			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),880			1881		);882		assert_eq!(883			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),884			1885		);886		assert_eq!(887			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),888			923889		);890		assert_eq!(891			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),892			100893		);894		assert_eq!(895			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),896			true897		);898		assert_eq!(899			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),900			true901		);902		assert_eq!(903			<pallet_refungible::Allowance<Test>>::get((904				CollectionId(1),905				TokenId(1),906				account(1),907				account(2)908			)),909			923910		);911	});912}913914#[test]915fn fungible_approve_and_transfer_from() {916	new_test_ext().execute_with(|| {917		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));918919		let data = default_fungible_data();920		create_test_item(collection_id, &data.into());921922		let origin1 = RuntimeOrigin::signed(1);923		let origin2 = RuntimeOrigin::signed(2);924925		assert_ok!(Unique::set_collection_permissions(926			origin1.clone(),927			CollectionId(1),928			CollectionPermissions {929				mint_mode: Some(true),930				access: Some(AccessMode::AllowList),931				nesting: None,932			}933		));934		assert_ok!(Unique::add_to_allow_list(935			origin1.clone(),936			CollectionId(1),937			account(1)938		));939		assert_ok!(Unique::add_to_allow_list(940			origin1.clone(),941			CollectionId(1),942			account(2)943		));944		assert_ok!(Unique::add_to_allow_list(945			origin1.clone(),946			CollectionId(1),947			account(3)948		));949950		// do approve951		assert_ok!(Unique::approve(952			origin1.clone(),953			account(2),954			CollectionId(1),955			TokenId(0),956			5957		));958		assert_eq!(959			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),960			5961		);962		assert_ok!(Unique::approve(963			origin1,964			account(3),965			CollectionId(1),966			TokenId(0),967			5968		));969		assert_eq!(970			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),971			5972		);973		assert_eq!(974			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),975			5976		);977978		assert_ok!(Unique::transfer_from(979			origin2.clone(),980			account(1),981			account(3),982			CollectionId(1),983			TokenId(0),984			4985		));986987		assert_eq!(988			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),989			1990		);991992		assert_noop!(993			Unique::transfer_from(994				origin2,995				account(1),996				account(3),997				CollectionId(1),998				TokenId(0),999				41000			)1001			.map_err(|e| e.error),1002			CommonError::<Test>::ApprovedValueTooLow1003		);1004	});1005}10061007#[test]1008fn change_collection_owner() {1009	new_test_ext().execute_with(|| {1010		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10111012		let origin1 = RuntimeOrigin::signed(1);1013		assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1014		assert_eq!(1015			<pallet_common::CollectionById<Test>>::get(collection_id)1016				.unwrap()1017				.owner,1018			21019		);1020	});1021}10221023#[test]1024fn destroy_collection() {1025	new_test_ext().execute_with(|| {1026		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10271028		let origin1 = RuntimeOrigin::signed(1);1029		assert_ok!(Unique::destroy_collection(origin1, collection_id));1030	});1031}10321033#[test]1034fn burn_nft_item() {1035	new_test_ext().execute_with(|| {1036		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10371038		let origin1 = RuntimeOrigin::signed(1);10391040		let data = default_nft_data();1041		create_test_item(collection_id, &data.into());10421043		// check balance (collection with id = 1, user id = 1)1044		assert_eq!(1045			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1046			11047		);10481049		// burn item1050		assert_ok!(Unique::burn_item(1051			origin1.clone(),1052			collection_id,1053			TokenId(1),1054			11055		));1056		assert_eq!(1057			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1058			01059		);1060	});1061}10621063#[test]1064fn burn_same_nft_item_twice() {1065	new_test_ext().execute_with(|| {1066		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10671068		let origin1 = RuntimeOrigin::signed(1);10691070		let data = default_nft_data();1071		create_test_item(collection_id, &data.into());10721073		// check balance (collection with id = 1, user id = 1)1074		assert_eq!(1075			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1076			11077		);10781079		// burn item1080		assert_ok!(Unique::burn_item(1081			origin1.clone(),1082			collection_id,1083			TokenId(1),1084			11085		));10861087		// burn item again1088		assert_noop!(1089			Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1090			CommonError::<Test>::TokenNotFound1091		);10921093		assert_eq!(1094			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1095			01096		);1097	});1098}10991100#[test]1101fn burn_fungible_item() {1102	new_test_ext().execute_with(|| {1103		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11041105		let origin1 = RuntimeOrigin::signed(1);1106		assert_ok!(Unique::add_collection_admin(1107			origin1.clone(),1108			collection_id,1109			account(2)1110		));11111112		let data = default_fungible_data();1113		create_test_item(collection_id, &data.into());11141115		// check balance (collection with id = 1, user id = 1)1116		assert_eq!(1117			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1118			51119		);11201121		// burn item1122		assert_ok!(Unique::burn_item(1123			origin1.clone(),1124			CollectionId(1),1125			TokenId(0),1126			51127		));1128		assert_noop!(1129			Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1130			CommonError::<Test>::TokenValueTooLow1131		);11321133		assert_eq!(1134			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1135			01136		);1137	});1138}11391140#[test]1141fn burn_fungible_item_with_token_id() {1142	new_test_ext().execute_with(|| {1143		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11441145		let origin1 = RuntimeOrigin::signed(1);1146		assert_ok!(Unique::add_collection_admin(1147			origin1.clone(),1148			collection_id,1149			account(2)1150		));11511152		let data = default_fungible_data();1153		create_test_item(collection_id, &data.into());11541155		// check balance (collection with id = 1, user id = 1)1156		assert_eq!(1157			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1158			51159		);11601161		// Try to burn item using Token ID1162		assert_noop!(1163			Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1164			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1165		);1166	});1167}1168#[test]1169fn burn_refungible_item() {1170	new_test_ext().execute_with(|| {1171		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1172		let origin1 = RuntimeOrigin::signed(1);11731174		assert_ok!(Unique::set_collection_permissions(1175			origin1.clone(),1176			collection_id,1177			CollectionPermissions {1178				mint_mode: Some(true),1179				access: Some(AccessMode::AllowList),1180				nesting: None,1181			}1182		));1183		assert_ok!(Unique::add_to_allow_list(1184			origin1.clone(),1185			collection_id,1186			account(1)1187		));11881189		assert_ok!(Unique::add_collection_admin(1190			origin1.clone(),1191			collection_id,1192			account(2)1193		));11941195		let data = default_re_fungible_data();1196		create_test_item(collection_id, &data.into());11971198		// check balance (collection with id = 1, user id = 2)1199		assert_eq!(1200			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1201			11202		);1203		assert_eq!(1204			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1205			10231206		);12071208		// burn item1209		assert_ok!(Unique::burn_item(1210			origin1.clone(),1211			collection_id,1212			TokenId(1),1213			10231214		));1215		assert_noop!(1216			Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1217			CommonError::<Test>::TokenValueTooLow1218		);12191220		assert_eq!(1221			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1222			01223		);1224	});1225}12261227#[test]1228fn add_collection_admin() {1229	new_test_ext().execute_with(|| {1230		let collection1_id =1231			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1232		let origin1 = RuntimeOrigin::signed(1);12331234		// Add collection admins1235		assert_ok!(Unique::add_collection_admin(1236			origin1.clone(),1237			collection1_id,1238			account(2)1239		));1240		assert_ok!(Unique::add_collection_admin(1241			origin1,1242			collection1_id,1243			account(3)1244		));12451246		// Owner is not an admin by default1247		assert_eq!(1248			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1249			false1250		);1251		assert!(<pallet_common::IsAdmin<Test>>::get((1252			CollectionId(1),1253			account(2)1254		)));1255		assert!(<pallet_common::IsAdmin<Test>>::get((1256			CollectionId(1),1257			account(3)1258		)));1259	});1260}12611262#[test]1263fn remove_collection_admin() {1264	new_test_ext().execute_with(|| {1265		let collection1_id =1266			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1267		let origin1 = RuntimeOrigin::signed(1);12681269		// Add collection admins 2 and 31270		assert_ok!(Unique::add_collection_admin(1271			origin1.clone(),1272			collection1_id,1273			account(2)1274		));1275		assert_ok!(Unique::add_collection_admin(1276			origin1.clone(),1277			collection1_id,1278			account(3)1279		));12801281		assert!(<pallet_common::IsAdmin<Test>>::get((1282			CollectionId(1),1283			account(2)1284		)));1285		assert!(<pallet_common::IsAdmin<Test>>::get((1286			CollectionId(1),1287			account(3)1288		)));12891290		// remove admin 31291		assert_ok!(Unique::remove_collection_admin(1292			origin1,1293			CollectionId(1),1294			account(3)1295		));12961297		// 2 is still admin, 3 is not an admin anymore1298		assert!(<pallet_common::IsAdmin<Test>>::get((1299			CollectionId(1),1300			account(2)1301		)));1302		assert_eq!(1303			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1304			false1305		);1306	});1307}13081309#[test]1310fn balance_of() {1311	new_test_ext().execute_with(|| {1312		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1313		let fungible_collection_id =1314			create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1315		let re_fungible_collection_id =1316			create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13171318		// check balance before1319		assert_eq!(1320			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1321			01322		);1323		assert_eq!(1324			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1325			01326		);1327		assert_eq!(1328			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1329			01330		);13311332		let nft_data = default_nft_data();1333		create_test_item(nft_collection_id, &nft_data.into());13341335		let fungible_data = default_fungible_data();1336		create_test_item(fungible_collection_id, &fungible_data.into());13371338		let re_fungible_data = default_re_fungible_data();1339		create_test_item(re_fungible_collection_id, &re_fungible_data.into());13401341		// check balance (collection with id = 1, user id = 1)1342		assert_eq!(1343			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1344			11345		);1346		assert_eq!(1347			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1348			51349		);1350		assert_eq!(1351			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1352			11353		);13541355		assert_eq!(1356			<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1357			true1358		);1359		assert_eq!(1360			<pallet_refungible::Owned<Test>>::get((1361				re_fungible_collection_id,1362				account(1),1363				TokenId(1)1364			)),1365			true1366		);1367	});1368}13691370#[test]1371fn approve() {1372	new_test_ext().execute_with(|| {1373		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13741375		let data = default_nft_data();1376		create_test_item(collection_id, &data.into());13771378		let origin1 = RuntimeOrigin::signed(1);13791380		// approve1381		assert_ok!(Unique::approve(1382			origin1,1383			account(2),1384			CollectionId(1),1385			TokenId(1),1386			11387		));1388		assert_eq!(1389			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1390			account(2)1391		);1392	});1393}13941395#[test]1396fn transfer_from() {1397	new_test_ext().execute_with(|| {1398		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1399		let origin1 = RuntimeOrigin::signed(1);1400		let origin2 = RuntimeOrigin::signed(2);14011402		let data = default_nft_data();1403		create_test_item(collection_id, &data.into());14041405		// approve1406		assert_ok!(Unique::approve(1407			origin1.clone(),1408			account(2),1409			CollectionId(1),1410			TokenId(1),1411			11412		));1413		assert_eq!(1414			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1415			account(2)1416		);14171418		assert_ok!(Unique::set_collection_permissions(1419			origin1.clone(),1420			CollectionId(1),1421			CollectionPermissions {1422				mint_mode: Some(true),1423				access: Some(AccessMode::AllowList),1424				nesting: None,1425			}1426		));1427		assert_ok!(Unique::add_to_allow_list(1428			origin1.clone(),1429			CollectionId(1),1430			account(1)1431		));1432		assert_ok!(Unique::add_to_allow_list(1433			origin1.clone(),1434			CollectionId(1),1435			account(2)1436		));1437		assert_ok!(Unique::add_to_allow_list(1438			origin1,1439			CollectionId(1),1440			account(3)1441		));14421443		assert_ok!(Unique::transfer_from(1444			origin2,1445			account(1),1446			account(2),1447			CollectionId(1),1448			TokenId(1),1449			11450		));14511452		// after transfer1453		assert_eq!(1454			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1455			01456		);1457		assert_eq!(1458			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1459			11460		);1461	});1462}14631464// #endregion14651466// Coverage tests region1467// #region14681469#[test]1470fn owner_can_add_address_to_allow_list() {1471	new_test_ext().execute_with(|| {1472		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14731474		let origin1 = RuntimeOrigin::signed(1);1475		assert_ok!(Unique::add_to_allow_list(1476			origin1,1477			collection_id,1478			account(2)1479		));1480		assert!(<pallet_common::Allowlist<Test>>::get((1481			collection_id,1482			account(2)1483		)));1484	});1485}14861487#[test]1488fn admin_can_add_address_to_allow_list() {1489	new_test_ext().execute_with(|| {1490		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1491		let origin1 = RuntimeOrigin::signed(1);1492		let origin2 = RuntimeOrigin::signed(2);14931494		assert_ok!(Unique::add_collection_admin(1495			origin1,1496			collection_id,1497			account(2)1498		));1499		assert_ok!(Unique::add_to_allow_list(1500			origin2,1501			collection_id,1502			account(3)1503		));1504		assert!(<pallet_common::Allowlist<Test>>::get((1505			collection_id,1506			account(3)1507		)));1508	});1509}15101511#[test]1512fn nonprivileged_user_cannot_add_address_to_allow_list() {1513	new_test_ext().execute_with(|| {1514		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15151516		let origin2 = RuntimeOrigin::signed(2);1517		assert_noop!(1518			Unique::add_to_allow_list(origin2, collection_id, account(3)),1519			CommonError::<Test>::NoPermission1520		);1521	});1522}15231524#[test]1525fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1526	new_test_ext().execute_with(|| {1527		let origin1 = RuntimeOrigin::signed(1);15281529		assert_noop!(1530			Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1531			CommonError::<Test>::CollectionNotFound1532		);1533	});1534}15351536#[test]1537fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1538	new_test_ext().execute_with(|| {1539		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15401541		let origin1 = RuntimeOrigin::signed(1);1542		assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1543		assert_noop!(1544			Unique::add_to_allow_list(origin1, collection_id, account(2)),1545			CommonError::<Test>::CollectionNotFound1546		);1547	});1548}15491550// If address is already added to allow list, nothing happens1551#[test]1552fn address_is_already_added_to_allow_list() {1553	new_test_ext().execute_with(|| {1554		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1555		let origin1 = RuntimeOrigin::signed(1);15561557		assert_ok!(Unique::add_to_allow_list(1558			origin1.clone(),1559			collection_id,1560			account(2)1561		));1562		assert_ok!(Unique::add_to_allow_list(1563			origin1,1564			collection_id,1565			account(2)1566		));1567		assert!(<pallet_common::Allowlist<Test>>::get((1568			collection_id,1569			account(2)1570		)));1571	});1572}15731574#[test]1575fn owner_can_remove_address_from_allow_list() {1576	new_test_ext().execute_with(|| {1577		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15781579		let origin1 = RuntimeOrigin::signed(1);1580		assert_ok!(Unique::add_to_allow_list(1581			origin1.clone(),1582			collection_id,1583			account(2)1584		));1585		assert_ok!(Unique::remove_from_allow_list(1586			origin1,1587			collection_id,1588			account(2)1589		));1590		assert_eq!(1591			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1592			false1593		);1594	});1595}15961597#[test]1598fn admin_can_remove_address_from_allow_list() {1599	new_test_ext().execute_with(|| {1600		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1601		let origin1 = RuntimeOrigin::signed(1);1602		let origin2 = RuntimeOrigin::signed(2);16031604		// Owner adds admin1605		assert_ok!(Unique::add_collection_admin(1606			origin1.clone(),1607			collection_id,1608			account(2)1609		));16101611		// Owner adds address 3 to allow list1612		assert_ok!(Unique::add_to_allow_list(1613			origin1,1614			collection_id,1615			account(3)1616		));16171618		// Admin removes address 3 from allow list1619		assert_ok!(Unique::remove_from_allow_list(1620			origin2,1621			collection_id,1622			account(3)1623		));1624		assert_eq!(1625			<pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1626			false1627		);1628	});1629}16301631#[test]1632fn nonprivileged_user_cannot_remove_address_from_allow_list() {1633	new_test_ext().execute_with(|| {1634		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1635		let origin1 = RuntimeOrigin::signed(1);1636		let origin2 = RuntimeOrigin::signed(2);16371638		assert_ok!(Unique::add_to_allow_list(1639			origin1,1640			collection_id,1641			account(2)1642		));1643		assert_noop!(1644			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1645			CommonError::<Test>::NoPermission1646		);1647		assert!(<pallet_common::Allowlist<Test>>::get((1648			collection_id,1649			account(2)1650		)));1651	});1652}16531654#[test]1655fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1656	new_test_ext().execute_with(|| {1657		let origin1 = RuntimeOrigin::signed(1);16581659		assert_noop!(1660			Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1661			CommonError::<Test>::CollectionNotFound1662		);1663	});1664}16651666#[test]1667fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1668	new_test_ext().execute_with(|| {1669		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1670		let origin1 = RuntimeOrigin::signed(1);1671		let origin2 = RuntimeOrigin::signed(2);16721673		// Add account 2 to allow list1674		assert_ok!(Unique::add_to_allow_list(1675			origin1.clone(),1676			collection_id,1677			account(2)1678		));16791680		// Account 2 is in collection allow-list1681		assert!(<pallet_common::Allowlist<Test>>::get((1682			collection_id,1683			account(2)1684		)));16851686		// Destroy collection1687		assert_ok!(Unique::destroy_collection(origin1, collection_id));16881689		// Attempt to remove account 2 from collection allow-list => error1690		assert_noop!(1691			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1692			CommonError::<Test>::CollectionNotFound1693		);16941695		// Account 2 is not found in collection allow-list anyway1696		assert_eq!(1697			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1698			false1699		);1700	});1701}17021703// If address is already removed from allow list, nothing happens1704#[test]1705fn address_is_already_removed_from_allow_list() {1706	new_test_ext().execute_with(|| {1707		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1708		let origin1 = RuntimeOrigin::signed(1);17091710		assert_ok!(Unique::add_to_allow_list(1711			origin1.clone(),1712			collection_id,1713			account(2)1714		));1715		assert_ok!(Unique::remove_from_allow_list(1716			origin1.clone(),1717			collection_id,1718			account(2)1719		));1720		assert_eq!(1721			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1722			false1723		);1724		assert_ok!(Unique::remove_from_allow_list(1725			origin1,1726			collection_id,1727			account(2)1728		));1729		assert_eq!(1730			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1731			false1732		);1733	});1734}17351736// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1737#[test]1738fn allow_list_test_1() {1739	new_test_ext().execute_with(|| {1740		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17411742		let origin1 = RuntimeOrigin::signed(1);1743		assert_ok!(Unique::add_collection_admin(1744			origin1.clone(),1745			collection_id,1746			account(1)1747		));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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::signed(1);2121		let origin2 = RuntimeOrigin::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 = RuntimeOrigin::signed(1);2155		let origin2 = RuntimeOrigin::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 = RuntimeOrigin::signed(1);2192		let origin2 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::signed(1);2247		let origin2 = RuntimeOrigin::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 = RuntimeOrigin::signed(1);2281		let origin2 = RuntimeOrigin::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 = RuntimeOrigin::signed(1);2313		let origin2 = RuntimeOrigin::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 = RuntimeOrigin::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 {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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::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 = RuntimeOrigin::signed(user1);2577		let origin2 = RuntimeOrigin::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}26212622mod check_token_permissions {2623	use pallet_common::LazyValue;26242625	use super::*;26262627	fn test<FTE: FnOnce() -> bool>(2628		i: usize,2629		test_case: &pallet_common::tests::TestCase,2630		check_token_existence: &mut LazyValue<bool, FTE>,2631	) {2632		let collection_admin = test_case.collection_admin;2633		let mut is_collection_admin = LazyValue::new(|| test_case.is_collection_admin);2634		let token_owner = test_case.token_owner;2635		let mut is_token_owner = LazyValue::new(|| Ok(test_case.is_token_owner));2636		let is_no_permission = test_case.no_permission;26372638		let result = pallet_common::tests::check_token_permissions::<Test, _, _, FTE>(2639			collection_admin,2640			token_owner,2641			&mut is_collection_admin,2642			&mut is_token_owner,2643			check_token_existence,2644		);26452646		if is_no_permission {2647			assert!(2648				result.is_err(),2649				"{i}: {test_case:?}, token_exist: {}",2650				check_token_existence.value()2651			);2652			assert_err!(result, pallet_common::Error::<Test>::NoPermission,);2653		} else if check_token_existence.has_value() && !check_token_existence.value() {2654			assert!(2655				result.is_err(),2656				"{i}: {test_case:?}, token_exist: {}",2657				check_token_existence.value()2658			);2659			assert_err!(result, pallet_common::Error::<Test>::TokenNotFound,);2660		}2661	}26622663	#[test]2664	fn no_permission_only() {2665		new_test_ext().execute_with(|| {2666			let mut check_token_existence = LazyValue::new(|| true);2667			for (i, row) in pallet_common::tests::TABLE.iter().enumerate() {2668				test(i, row, &mut check_token_existence);2669			}2670		});2671	}26722673	#[test]2674	fn no_permission_and_token_not_found() {2675		new_test_ext().execute_with(|| {2676			for (i, row) in pallet_common::tests::TABLE.iter().enumerate() {2677				// This is inside the loop to keep track of whether the lambda was called2678				let mut check_token_existence = LazyValue::new(|| false);2679				test(i, row, &mut check_token_existence);2680			}2681		});2682	}2683}