git.delta.rocks / unique-network / refs/commits / 3fb3c00ba4fd

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Tests to be written here18use crate::{Test, TestCrossAccountId, CollectionCreationPrice, RuntimeOrigin, Unique, new_test_ext};19use up_data_structs::{20	COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData,21	CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, TokenId,22	MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionMode, AccessMode, CollectionPermissions,23	PropertyKeyPermission, PropertyPermission, Property, CollectionPropertiesVec,24	CollectionPropertiesPermissionsVec,25};26use frame_support::{assert_noop, assert_ok, assert_err};27use sp_std::convert::TryInto;28use pallet_evm::account::CrossAccountId;29use pallet_common::Error as CommonError;30use pallet_unique::Error as UniqueError;3132fn add_balance(user: u64, value: u64) {33	const DONOR_USER: u64 = 999;34	assert_ok!(<pallet_balances::Pallet<Test>>::set_balance(35		RuntimeOrigin::root(),36		DONOR_USER,37		value,38		039	));40	assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(41		RuntimeOrigin::root(),42		DONOR_USER,43		user,44		value45	));46}4748fn default_nft_data() -> CreateNftData {49	CreateNftData {50		properties: vec![Property {51			key: b"test-prop".to_vec().try_into().unwrap(),52			value: b"test-nft-prop".to_vec().try_into().unwrap(),53		}]54		.try_into()55		.unwrap(),56	}57}5859fn default_fungible_data() -> CreateFungibleData {60	CreateFungibleData { value: 5 }61}6263fn default_re_fungible_data() -> CreateReFungibleData {64	CreateReFungibleData {65		pieces: 1023,66		properties: vec![Property {67			key: b"test-prop".to_vec().try_into().unwrap(),68			value: b"test-nft-prop".to_vec().try_into().unwrap(),69		}]70		.try_into()71		.unwrap(),72	}73}7475fn create_test_collection_for_owner(76	mode: &CollectionMode,77	owner: u64,78	id: CollectionId,79) -> CollectionId {80	add_balance(owner, CollectionCreationPrice::get() as u64 + 1);8182	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();83	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();84	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();85	let token_property_permissions: CollectionPropertiesPermissionsVec =86		vec![PropertyKeyPermission {87			key: b"test-prop".to_vec().try_into().unwrap(),88			permission: PropertyPermission {89				mutable: true,90				collection_admin: false,91				token_owner: true,92			},93		}]94		.try_into()95		.unwrap();96	let properties: CollectionPropertiesVec = vec![Property {97		key: b"test-collection-prop".to_vec().try_into().unwrap(),98		value: b"test-collection-value".to_vec().try_into().unwrap(),99	}]100	.try_into()101	.unwrap();102103	let data: CreateCollectionData<u64> = CreateCollectionData {104		name: col_name1.try_into().unwrap(),105		description: col_desc1.try_into().unwrap(),106		token_prefix: token_prefix1.try_into().unwrap(),107		mode: mode.clone(),108		token_property_permissions: token_property_permissions.clone(),109		properties: properties.clone(),110		..Default::default()111	};112113	let origin1 = RuntimeOrigin::signed(owner);114	assert_ok!(Unique::create_collection_ex(origin1, data));115116	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();117	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();118	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();119	assert_eq!(120		<pallet_common::CollectionById<Test>>::get(id)121			.unwrap()122			.owner,123		owner124	);125	assert_eq!(126		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,127		saved_col_name128	);129	assert_eq!(130		<pallet_common::CollectionById<Test>>::get(id).unwrap().mode,131		*mode132	);133	assert_eq!(134		<pallet_common::CollectionById<Test>>::get(id)135			.unwrap()136			.description,137		saved_description138	);139	assert_eq!(140		<pallet_common::CollectionById<Test>>::get(id)141			.unwrap()142			.token_prefix,143		saved_prefix144	);145	assert_eq!(146		get_collection_property_permissions(id).as_slice(),147		token_property_permissions.as_slice()148	);149	assert_eq!(150		get_collection_properties(id).as_slice(),151		properties.as_slice()152	);153	id154}155156fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {157	<pallet_common::Pallet<Test>>::property_permissions(collection_id)158		.into_iter()159		.map(|(key, permission)| PropertyKeyPermission { key, permission })160		.collect()161}162163fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {164	<pallet_common::Pallet<Test>>::collection_properties(collection_id)165		.into_iter()166		.map(|(key, value)| Property { key, value })167		.collect()168}169170fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {171	<pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))172		.into_iter()173		.map(|(key, value)| Property { key, value })174		.collect()175}176177fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {178	create_test_collection_for_owner(&mode, 1, id)179}180181fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {182	let origin1 = RuntimeOrigin::signed(1);183	assert_ok!(Unique::create_item(184		origin1,185		collection_id,186		account(1),187		data.clone()188	));189}190191fn account(sub: u64) -> TestCrossAccountId {192	TestCrossAccountId::from_sub(sub)193}194195// Use cases tests region196// #region197198#[test]199fn check_not_sufficient_founds() {200	new_test_ext().execute_with(|| {201		let acc: u64 = 1;202		<pallet_balances::Pallet<Test>>::set_balance(RuntimeOrigin::root(), acc, 0, 0).unwrap();203204		let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();205		let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();206		let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();207208		let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =209			CreateCollectionData {210				name: name.try_into().unwrap(),211				description: description.try_into().unwrap(),212				token_prefix: token_prefix.try_into().unwrap(),213				mode: CollectionMode::NFT,214				..Default::default()215			};216217		let result = Unique::create_collection_ex(RuntimeOrigin::signed(acc), data);218		assert_err!(result, <CommonError<Test>>::NotSufficientFounds);219	});220}221222#[test]223fn create_fungible_collection_fails_with_large_decimal_numbers() {224	new_test_ext().execute_with(|| {225		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();226		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();227		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();228229		let data: CreateCollectionData<u64> = CreateCollectionData {230			name: col_name1.try_into().unwrap(),231			description: col_desc1.try_into().unwrap(),232			token_prefix: token_prefix1.try_into().unwrap(),233			mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),234			..Default::default()235		};236237		let origin1 = RuntimeOrigin::signed(1);238		assert_noop!(239			Unique::create_collection_ex(origin1, data),240			UniqueError::<Test>::CollectionDecimalPointLimitExceeded241		);242	});243}244245#[test]246fn create_nft_item() {247	new_test_ext().execute_with(|| {248		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));249250		let data = default_nft_data();251		create_test_item(collection_id, &data.clone().into());252253		assert_eq!(254			get_token_properties(collection_id, TokenId(1)).as_slice(),255			data.properties.as_slice(),256		);257	});258}259260// Use cases tests region261// #region262#[test]263fn create_nft_multiple_items() {264	new_test_ext().execute_with(|| {265		create_test_collection(&CollectionMode::NFT, CollectionId(1));266267		let origin1 = RuntimeOrigin::signed(1);268269		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];270271		assert_ok!(Unique::create_multiple_items(272			origin1,273			CollectionId(1),274			account(1),275			items_data276				.clone()277				.into_iter()278				.map(|d| { d.into() })279				.collect()280		));281		for (index, data) in items_data.into_iter().enumerate() {282			assert_eq!(283				get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),284				data.properties.as_slice()285			);286		}287	});288}289290#[test]291fn create_refungible_item() {292	new_test_ext().execute_with(|| {293		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));294295		let data = default_re_fungible_data();296		create_test_item(collection_id, &data.clone().into());297		let balance =298			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));299		assert_eq!(balance, 1023);300	});301}302303#[test]304fn create_multiple_refungible_items() {305	new_test_ext().execute_with(|| {306		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));307308		let origin1 = RuntimeOrigin::signed(1);309310		let items_data = vec![311			default_re_fungible_data(),312			default_re_fungible_data(),313			default_re_fungible_data(),314		];315316		assert_ok!(Unique::create_multiple_items(317			origin1,318			CollectionId(1),319			account(1),320			items_data321				.clone()322				.into_iter()323				.map(|d| { d.into() })324				.collect()325		));326		for (index, data) in items_data.into_iter().enumerate() {327			let balance =328				<pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId((index + 1) as u32), account(1)));329			assert_eq!(balance, 1023);330		}331	});332}333334#[test]335fn create_fungible_item() {336	new_test_ext().execute_with(|| {337		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));338339		let data = default_fungible_data();340		create_test_item(collection_id, &data.into());341342		assert_eq!(343			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),344			5345		);346	});347}348349//#[test]350// fn create_multiple_fungible_items() {351//     new_test_ext().execute_with(|| {352//         default_limits();353354//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));355356//         let origin1 = RuntimeOrigin::signed(1);357358//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];359360//         assert_ok!(Unique::create_multiple_items(361//             origin1.clone(),362//             1,363//             1,364//             items_data.clone().into_iter().map(|d| { d.into() }).collect()365//         ));366367//         for (index, _) in items_data.iter().enumerate() {368//             assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);369//         }370//         assert_eq!(Unique::balance_count(1, 1), 3000);371//         assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);372//     });373// }374375#[test]376fn transfer_fungible_item() {377	new_test_ext().execute_with(|| {378		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));379380		let origin1 = RuntimeOrigin::signed(1);381		let origin2 = RuntimeOrigin::signed(2);382383		let data = default_fungible_data();384		create_test_item(collection_id, &data.into());385386		assert_eq!(387			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),388			5389		);390391		// change owner scenario392		assert_ok!(Unique::transfer(393			origin1,394			account(2),395			CollectionId(1),396			TokenId(0),397			5398		));399		assert_eq!(400			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),401			0402		);403404		// split item scenario405		assert_ok!(Unique::transfer(406			origin2.clone(),407			account(3),408			CollectionId(1),409			TokenId(0),410			3411		));412413		// split item and new owner has account scenario414		assert_ok!(Unique::transfer(415			origin2,416			account(3),417			CollectionId(1),418			TokenId(0),419			1420		));421		assert_eq!(422			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),423			1424		);425		assert_eq!(426			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),427			4428		);429	});430}431432#[test]433fn transfer_refungible_item() {434	new_test_ext().execute_with(|| {435		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));436437		// Create RFT 1 in 1023 pieces for account 1438		let data = default_re_fungible_data();439		create_test_item(collection_id, &data.clone().into());440		assert_eq!(441			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),442			1443		);444		assert_eq!(445			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),446			1023447		);448		assert_eq!(449			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),450			true451		);452453		// Account 1 transfers all 1023 pieces of RFT 1 to account 2454		let origin1 = RuntimeOrigin::signed(1);455		let origin2 = RuntimeOrigin::signed(2);456		assert_ok!(Unique::transfer(457			origin1,458			account(2),459			CollectionId(1),460			TokenId(1),461			1023462		));463		assert_eq!(464			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),465			1023466		);467		assert_eq!(468			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),469			0470		);471		assert_eq!(472			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),473			1474		);475		assert_eq!(476			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),477			false478		);479		assert_eq!(480			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),481			true482		);483484		// Account 2 transfers 500 pieces of RFT 1 to account 3485		assert_ok!(Unique::transfer(486			origin2.clone(),487			account(3),488			CollectionId(1),489			TokenId(1),490			500491		));492		assert_eq!(493			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),494			523495		);496		assert_eq!(497			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),498			500499		);500		assert_eq!(501			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),502			1503		);504		assert_eq!(505			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),506			1507		);508		assert_eq!(509			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),510			true511		);512		assert_eq!(513			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),514			true515		);516517		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance518		assert_ok!(Unique::transfer(519			origin2,520			account(3),521			CollectionId(1),522			TokenId(1),523			200524		));525		assert_eq!(526			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),527			323528		);529		assert_eq!(530			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),531			700532		);533		assert_eq!(534			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),535			1536		);537		assert_eq!(538			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),539			1540		);541		assert_eq!(542			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),543			true544		);545		assert_eq!(546			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),547			true548		);549	});550}551552#[test]553fn transfer_nft_item() {554	new_test_ext().execute_with(|| {555		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));556557		let data = default_nft_data();558		create_test_item(collection_id, &data.into());559		assert_eq!(560			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),561			1562		);563		assert_eq!(564			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),565			true566		);567568		let origin1 = RuntimeOrigin::signed(1);569		// default scenario570		assert_ok!(Unique::transfer(571			origin1,572			account(2),573			CollectionId(1),574			TokenId(1),575			1576		));577		assert_eq!(578			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),579			0580		);581		assert_eq!(582			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),583			1584		);585		assert_eq!(586			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),587			false588		);589		assert_eq!(590			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),591			true592		);593	});594}595596#[test]597fn transfer_nft_item_wrong_value() {598	new_test_ext().execute_with(|| {599		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));600601		let data = default_nft_data();602		create_test_item(collection_id, &data.into());603		assert_eq!(604			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),605			1606		);607		assert_eq!(608			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),609			true610		);611612		let origin1 = RuntimeOrigin::signed(1);613614		assert_noop!(615			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)616				.map_err(|e| e.error),617			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount618		);619	});620}621622#[test]623fn transfer_nft_item_zero_value() {624	new_test_ext().execute_with(|| {625		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));626627		let data = default_nft_data();628		create_test_item(collection_id, &data.into());629		assert_eq!(630			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),631			1632		);633		assert_eq!(634			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),635			true636		);637638		let origin1 = RuntimeOrigin::signed(1);639640		// Transferring 0 amount works on NFT...641		assert_ok!(Unique::transfer(642			origin1,643			account(2),644			CollectionId(1),645			TokenId(1),646			0647		));648		// ... and results in no transfer649		assert_eq!(650			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),651			1652		);653		assert_eq!(654			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),655			true656		);657	});658}659660#[test]661fn nft_approve_and_transfer_from() {662	new_test_ext().execute_with(|| {663		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));664665		let data = default_nft_data();666		create_test_item(collection_id, &data.into());667668		let origin1 = RuntimeOrigin::signed(1);669		let origin2 = RuntimeOrigin::signed(2);670671		assert_eq!(672			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),673			1674		);675		assert_eq!(676			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),677			true678		);679680		// neg transfer_from681		assert_noop!(682			Unique::transfer_from(683				origin2.clone(),684				account(1),685				account(2),686				CollectionId(1),687				TokenId(1),688				1689			)690			.map_err(|e| e.error),691			CommonError::<Test>::ApprovedValueTooLow692		);693694		// do approve695		assert_ok!(Unique::approve(696			origin1,697			account(2),698			CollectionId(1),699			TokenId(1),700			1701		));702		assert_eq!(703			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),704			account(2)705		);706707		assert_ok!(Unique::transfer_from(708			origin2,709			account(1),710			account(3),711			CollectionId(1),712			TokenId(1),713			1714		));715		assert!(716			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()717		);718	});719}720721#[test]722fn nft_approve_and_transfer_from_allow_list() {723	new_test_ext().execute_with(|| {724		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));725726		let origin1 = RuntimeOrigin::signed(1);727		let origin2 = RuntimeOrigin::signed(2);728729		// Create NFT 1 for account 1730		let data = default_nft_data();731		create_test_item(collection_id, &data.clone().into());732		assert_eq!(733			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),734			1735		);736		assert_eq!(737			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),738			true739		);740741		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list742		assert_ok!(Unique::set_collection_permissions(743			origin1.clone(),744			CollectionId(1),745			CollectionPermissions {746				mint_mode: Some(true),747				access: Some(AccessMode::AllowList),748				nesting: None,749			}750		));751		assert_ok!(Unique::add_to_allow_list(752			origin1.clone(),753			CollectionId(1),754			account(1)755		));756		assert_ok!(Unique::add_to_allow_list(757			origin1.clone(),758			CollectionId(1),759			account(2)760		));761		assert_ok!(Unique::add_to_allow_list(762			origin1.clone(),763			CollectionId(1),764			account(3)765		));766767		// Account 1 approves account 2 for NFT 1768		assert_ok!(Unique::approve(769			origin1.clone(),770			account(2),771			CollectionId(1),772			TokenId(1),773			1774		));775		assert_eq!(776			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),777			account(2)778		);779780		// Account 2 transfers NFT 1 from account 1 to account 3781		assert_ok!(Unique::transfer_from(782			origin2,783			account(1),784			account(3),785			CollectionId(1),786			TokenId(1),787			1788		));789		assert!(790			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()791		);792	});793}794795#[test]796fn refungible_approve_and_transfer_from() {797	new_test_ext().execute_with(|| {798		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));799800		let origin1 = RuntimeOrigin::signed(1);801		let origin2 = RuntimeOrigin::signed(2);802803		// Create RFT 1 in 1023 pieces for account 1804		let data = default_re_fungible_data();805		create_test_item(collection_id, &data.into());806807		assert_eq!(808			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),809			1810		);811		assert_eq!(812			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),813			1023814		);815		assert_eq!(816			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),817			true818		);819820		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list821		assert_ok!(Unique::set_collection_permissions(822			origin1.clone(),823			CollectionId(1),824			CollectionPermissions {825				mint_mode: Some(true),826				access: Some(AccessMode::AllowList),827				nesting: None,828			}829		));830		assert_ok!(Unique::add_to_allow_list(831			origin1.clone(),832			CollectionId(1),833			account(1)834		));835		assert_ok!(Unique::add_to_allow_list(836			origin1.clone(),837			CollectionId(1),838			account(2)839		));840		assert_ok!(Unique::add_to_allow_list(841			origin1.clone(),842			CollectionId(1),843			account(3)844		));845846		// Account 1 approves account 2 for 1023 pieces of RFT 1847		assert_ok!(Unique::approve(848			origin1,849			account(2),850			CollectionId(1),851			TokenId(1),852			1023853		));854		assert_eq!(855			<pallet_refungible::Allowance<Test>>::get((856				CollectionId(1),857				TokenId(1),858				account(1),859				account(2)860			)),861			1023862		);863864		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3865		assert_ok!(Unique::transfer_from(866			origin2,867			account(1),868			account(3),869			CollectionId(1),870			TokenId(1),871			100872		));873		assert_eq!(874			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),875			1876		);877		assert_eq!(878			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),879			1880		);881		assert_eq!(882			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),883			923884		);885		assert_eq!(886			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),887			100888		);889		assert_eq!(890			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),891			true892		);893		assert_eq!(894			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),895			true896		);897		assert_eq!(898			<pallet_refungible::Allowance<Test>>::get((899				CollectionId(1),900				TokenId(1),901				account(1),902				account(2)903			)),904			923905		);906	});907}908909#[test]910fn fungible_approve_and_transfer_from() {911	new_test_ext().execute_with(|| {912		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));913914		let data = default_fungible_data();915		create_test_item(collection_id, &data.into());916917		let origin1 = RuntimeOrigin::signed(1);918		let origin2 = RuntimeOrigin::signed(2);919920		assert_ok!(Unique::set_collection_permissions(921			origin1.clone(),922			CollectionId(1),923			CollectionPermissions {924				mint_mode: Some(true),925				access: Some(AccessMode::AllowList),926				nesting: None,927			}928		));929		assert_ok!(Unique::add_to_allow_list(930			origin1.clone(),931			CollectionId(1),932			account(1)933		));934		assert_ok!(Unique::add_to_allow_list(935			origin1.clone(),936			CollectionId(1),937			account(2)938		));939		assert_ok!(Unique::add_to_allow_list(940			origin1.clone(),941			CollectionId(1),942			account(3)943		));944945		// do approve946		assert_ok!(Unique::approve(947			origin1.clone(),948			account(2),949			CollectionId(1),950			TokenId(0),951			5952		));953		assert_eq!(954			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),955			5956		);957		assert_ok!(Unique::approve(958			origin1,959			account(3),960			CollectionId(1),961			TokenId(0),962			5963		));964		assert_eq!(965			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),966			5967		);968		assert_eq!(969			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),970			5971		);972973		assert_ok!(Unique::transfer_from(974			origin2.clone(),975			account(1),976			account(3),977			CollectionId(1),978			TokenId(0),979			4980		));981982		assert_eq!(983			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),984			1985		);986987		assert_noop!(988			Unique::transfer_from(989				origin2,990				account(1),991				account(3),992				CollectionId(1),993				TokenId(0),994				4995			)996			.map_err(|e| e.error),997			CommonError::<Test>::ApprovedValueTooLow998		);999	});1000}10011002#[test]1003fn change_collection_owner() {1004	new_test_ext().execute_with(|| {1005		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10061007		let origin1 = RuntimeOrigin::signed(1);1008		assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1009		assert_eq!(1010			<pallet_common::CollectionById<Test>>::get(collection_id)1011				.unwrap()1012				.owner,1013			21014		);1015	});1016}10171018#[test]1019fn destroy_collection() {1020	new_test_ext().execute_with(|| {1021		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10221023		let origin1 = RuntimeOrigin::signed(1);1024		assert_ok!(Unique::destroy_collection(origin1, collection_id));1025	});1026}10271028#[test]1029fn burn_nft_item() {1030	new_test_ext().execute_with(|| {1031		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10321033		let origin1 = RuntimeOrigin::signed(1);10341035		let data = default_nft_data();1036		create_test_item(collection_id, &data.into());10371038		// check balance (collection with id = 1, user id = 1)1039		assert_eq!(1040			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1041			11042		);10431044		// burn item1045		assert_ok!(Unique::burn_item(1046			origin1.clone(),1047			collection_id,1048			TokenId(1),1049			11050		));1051		assert_eq!(1052			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1053			01054		);1055	});1056}10571058#[test]1059fn burn_same_nft_item_twice() {1060	new_test_ext().execute_with(|| {1061		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10621063		let origin1 = RuntimeOrigin::signed(1);10641065		let data = default_nft_data();1066		create_test_item(collection_id, &data.into());10671068		// check balance (collection with id = 1, user id = 1)1069		assert_eq!(1070			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1071			11072		);10731074		// burn item1075		assert_ok!(Unique::burn_item(1076			origin1.clone(),1077			collection_id,1078			TokenId(1),1079			11080		));10811082		// burn item again1083		assert_noop!(1084			Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1085			CommonError::<Test>::TokenNotFound1086		);10871088		assert_eq!(1089			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1090			01091		);1092	});1093}10941095#[test]1096fn burn_fungible_item() {1097	new_test_ext().execute_with(|| {1098		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));10991100		let origin1 = RuntimeOrigin::signed(1);1101		assert_ok!(Unique::add_collection_admin(1102			origin1.clone(),1103			collection_id,1104			account(2)1105		));11061107		let data = default_fungible_data();1108		create_test_item(collection_id, &data.into());11091110		// check balance (collection with id = 1, user id = 1)1111		assert_eq!(1112			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1113			51114		);11151116		// burn item1117		assert_ok!(Unique::burn_item(1118			origin1.clone(),1119			CollectionId(1),1120			TokenId(0),1121			51122		));1123		assert_noop!(1124			Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1125			CommonError::<Test>::TokenValueTooLow1126		);11271128		assert_eq!(1129			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1130			01131		);1132	});1133}11341135#[test]1136fn burn_fungible_item_with_token_id() {1137	new_test_ext().execute_with(|| {1138		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11391140		let origin1 = RuntimeOrigin::signed(1);1141		assert_ok!(Unique::add_collection_admin(1142			origin1.clone(),1143			collection_id,1144			account(2)1145		));11461147		let data = default_fungible_data();1148		create_test_item(collection_id, &data.into());11491150		// check balance (collection with id = 1, user id = 1)1151		assert_eq!(1152			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1153			51154		);11551156		// Try to burn item using Token ID1157		assert_noop!(1158			Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1159			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1160		);1161	});1162}1163#[test]1164fn burn_refungible_item() {1165	new_test_ext().execute_with(|| {1166		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1167		let origin1 = RuntimeOrigin::signed(1);11681169		assert_ok!(Unique::set_collection_permissions(1170			origin1.clone(),1171			collection_id,1172			CollectionPermissions {1173				mint_mode: Some(true),1174				access: Some(AccessMode::AllowList),1175				nesting: None,1176			}1177		));1178		assert_ok!(Unique::add_to_allow_list(1179			origin1.clone(),1180			collection_id,1181			account(1)1182		));11831184		assert_ok!(Unique::add_collection_admin(1185			origin1.clone(),1186			collection_id,1187			account(2)1188		));11891190		let data = default_re_fungible_data();1191		create_test_item(collection_id, &data.into());11921193		// check balance (collection with id = 1, user id = 2)1194		assert_eq!(1195			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1196			11197		);1198		assert_eq!(1199			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1200			10231201		);12021203		// burn item1204		assert_ok!(Unique::burn_item(1205			origin1.clone(),1206			collection_id,1207			TokenId(1),1208			10231209		));1210		assert_noop!(1211			Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1212			CommonError::<Test>::TokenValueTooLow1213		);12141215		assert_eq!(1216			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1217			01218		);1219	});1220}12211222#[test]1223fn add_collection_admin() {1224	new_test_ext().execute_with(|| {1225		let collection1_id =1226			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1227		let origin1 = RuntimeOrigin::signed(1);12281229		// Add collection admins1230		assert_ok!(Unique::add_collection_admin(1231			origin1.clone(),1232			collection1_id,1233			account(2)1234		));1235		assert_ok!(Unique::add_collection_admin(1236			origin1,1237			collection1_id,1238			account(3)1239		));12401241		// Owner is not an admin by default1242		assert_eq!(1243			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1244			false1245		);1246		assert!(<pallet_common::IsAdmin<Test>>::get((1247			CollectionId(1),1248			account(2)1249		)));1250		assert!(<pallet_common::IsAdmin<Test>>::get((1251			CollectionId(1),1252			account(3)1253		)));1254	});1255}12561257#[test]1258fn remove_collection_admin() {1259	new_test_ext().execute_with(|| {1260		let collection1_id =1261			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1262		let origin1 = RuntimeOrigin::signed(1);12631264		// Add collection admins 2 and 31265		assert_ok!(Unique::add_collection_admin(1266			origin1.clone(),1267			collection1_id,1268			account(2)1269		));1270		assert_ok!(Unique::add_collection_admin(1271			origin1.clone(),1272			collection1_id,1273			account(3)1274		));12751276		assert!(<pallet_common::IsAdmin<Test>>::get((1277			CollectionId(1),1278			account(2)1279		)));1280		assert!(<pallet_common::IsAdmin<Test>>::get((1281			CollectionId(1),1282			account(3)1283		)));12841285		// remove admin 31286		assert_ok!(Unique::remove_collection_admin(1287			origin1,1288			CollectionId(1),1289			account(3)1290		));12911292		// 2 is still admin, 3 is not an admin anymore1293		assert!(<pallet_common::IsAdmin<Test>>::get((1294			CollectionId(1),1295			account(2)1296		)));1297		assert_eq!(1298			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1299			false1300		);1301	});1302}13031304#[test]1305fn balance_of() {1306	new_test_ext().execute_with(|| {1307		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1308		let fungible_collection_id =1309			create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1310		let re_fungible_collection_id =1311			create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13121313		// check balance before1314		assert_eq!(1315			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1316			01317		);1318		assert_eq!(1319			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1320			01321		);1322		assert_eq!(1323			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1324			01325		);13261327		let nft_data = default_nft_data();1328		create_test_item(nft_collection_id, &nft_data.into());13291330		let fungible_data = default_fungible_data();1331		create_test_item(fungible_collection_id, &fungible_data.into());13321333		let re_fungible_data = default_re_fungible_data();1334		create_test_item(re_fungible_collection_id, &re_fungible_data.into());13351336		// check balance (collection with id = 1, user id = 1)1337		assert_eq!(1338			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1339			11340		);1341		assert_eq!(1342			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1343			51344		);1345		assert_eq!(1346			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1347			11348		);13491350		assert_eq!(1351			<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1352			true1353		);1354		assert_eq!(1355			<pallet_refungible::Owned<Test>>::get((1356				re_fungible_collection_id,1357				account(1),1358				TokenId(1)1359			)),1360			true1361		);1362	});1363}13641365#[test]1366fn approve() {1367	new_test_ext().execute_with(|| {1368		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13691370		let data = default_nft_data();1371		create_test_item(collection_id, &data.into());13721373		let origin1 = RuntimeOrigin::signed(1);13741375		// approve1376		assert_ok!(Unique::approve(1377			origin1,1378			account(2),1379			CollectionId(1),1380			TokenId(1),1381			11382		));1383		assert_eq!(1384			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1385			account(2)1386		);1387	});1388}13891390#[test]1391fn transfer_from() {1392	new_test_ext().execute_with(|| {1393		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1394		let origin1 = RuntimeOrigin::signed(1);1395		let origin2 = RuntimeOrigin::signed(2);13961397		let data = default_nft_data();1398		create_test_item(collection_id, &data.into());13991400		// approve1401		assert_ok!(Unique::approve(1402			origin1.clone(),1403			account(2),1404			CollectionId(1),1405			TokenId(1),1406			11407		));1408		assert_eq!(1409			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1410			account(2)1411		);14121413		assert_ok!(Unique::set_collection_permissions(1414			origin1.clone(),1415			CollectionId(1),1416			CollectionPermissions {1417				mint_mode: Some(true),1418				access: Some(AccessMode::AllowList),1419				nesting: None,1420			}1421		));1422		assert_ok!(Unique::add_to_allow_list(1423			origin1.clone(),1424			CollectionId(1),1425			account(1)1426		));1427		assert_ok!(Unique::add_to_allow_list(1428			origin1.clone(),1429			CollectionId(1),1430			account(2)1431		));1432		assert_ok!(Unique::add_to_allow_list(1433			origin1,1434			CollectionId(1),1435			account(3)1436		));14371438		assert_ok!(Unique::transfer_from(1439			origin2,1440			account(1),1441			account(2),1442			CollectionId(1),1443			TokenId(1),1444			11445		));14461447		// after transfer1448		assert_eq!(1449			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1450			01451		);1452		assert_eq!(1453			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1454			11455		);1456	});1457}14581459// #endregion14601461// Coverage tests region1462// #region14631464#[test]1465fn owner_can_add_address_to_allow_list() {1466	new_test_ext().execute_with(|| {1467		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14681469		let origin1 = RuntimeOrigin::signed(1);1470		assert_ok!(Unique::add_to_allow_list(1471			origin1,1472			collection_id,1473			account(2)1474		));1475		assert!(<pallet_common::Allowlist<Test>>::get((1476			collection_id,1477			account(2)1478		)));1479	});1480}14811482#[test]1483fn admin_can_add_address_to_allow_list() {1484	new_test_ext().execute_with(|| {1485		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1486		let origin1 = RuntimeOrigin::signed(1);1487		let origin2 = RuntimeOrigin::signed(2);14881489		assert_ok!(Unique::add_collection_admin(1490			origin1,1491			collection_id,1492			account(2)1493		));1494		assert_ok!(Unique::add_to_allow_list(1495			origin2,1496			collection_id,1497			account(3)1498		));1499		assert!(<pallet_common::Allowlist<Test>>::get((1500			collection_id,1501			account(3)1502		)));1503	});1504}15051506#[test]1507fn nonprivileged_user_cannot_add_address_to_allow_list() {1508	new_test_ext().execute_with(|| {1509		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15101511		let origin2 = RuntimeOrigin::signed(2);1512		assert_noop!(1513			Unique::add_to_allow_list(origin2, collection_id, account(3)),1514			CommonError::<Test>::NoPermission1515		);1516	});1517}15181519#[test]1520fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1521	new_test_ext().execute_with(|| {1522		let origin1 = RuntimeOrigin::signed(1);15231524		assert_noop!(1525			Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1526			CommonError::<Test>::CollectionNotFound1527		);1528	});1529}15301531#[test]1532fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1533	new_test_ext().execute_with(|| {1534		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15351536		let origin1 = RuntimeOrigin::signed(1);1537		assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1538		assert_noop!(1539			Unique::add_to_allow_list(origin1, collection_id, account(2)),1540			CommonError::<Test>::CollectionNotFound1541		);1542	});1543}15441545// If address is already added to allow list, nothing happens1546#[test]1547fn address_is_already_added_to_allow_list() {1548	new_test_ext().execute_with(|| {1549		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1550		let origin1 = RuntimeOrigin::signed(1);15511552		assert_ok!(Unique::add_to_allow_list(1553			origin1.clone(),1554			collection_id,1555			account(2)1556		));1557		assert_ok!(Unique::add_to_allow_list(1558			origin1,1559			collection_id,1560			account(2)1561		));1562		assert!(<pallet_common::Allowlist<Test>>::get((1563			collection_id,1564			account(2)1565		)));1566	});1567}15681569#[test]1570fn owner_can_remove_address_from_allow_list() {1571	new_test_ext().execute_with(|| {1572		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15731574		let origin1 = RuntimeOrigin::signed(1);1575		assert_ok!(Unique::add_to_allow_list(1576			origin1.clone(),1577			collection_id,1578			account(2)1579		));1580		assert_ok!(Unique::remove_from_allow_list(1581			origin1,1582			collection_id,1583			account(2)1584		));1585		assert_eq!(1586			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1587			false1588		);1589	});1590}15911592#[test]1593fn admin_can_remove_address_from_allow_list() {1594	new_test_ext().execute_with(|| {1595		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1596		let origin1 = RuntimeOrigin::signed(1);1597		let origin2 = RuntimeOrigin::signed(2);15981599		// Owner adds admin1600		assert_ok!(Unique::add_collection_admin(1601			origin1.clone(),1602			collection_id,1603			account(2)1604		));16051606		// Owner adds address 3 to allow list1607		assert_ok!(Unique::add_to_allow_list(1608			origin1,1609			collection_id,1610			account(3)1611		));16121613		// Admin removes address 3 from allow list1614		assert_ok!(Unique::remove_from_allow_list(1615			origin2,1616			collection_id,1617			account(3)1618		));1619		assert_eq!(1620			<pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1621			false1622		);1623	});1624}16251626#[test]1627fn nonprivileged_user_cannot_remove_address_from_allow_list() {1628	new_test_ext().execute_with(|| {1629		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1630		let origin1 = RuntimeOrigin::signed(1);1631		let origin2 = RuntimeOrigin::signed(2);16321633		assert_ok!(Unique::add_to_allow_list(1634			origin1,1635			collection_id,1636			account(2)1637		));1638		assert_noop!(1639			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1640			CommonError::<Test>::NoPermission1641		);1642		assert!(<pallet_common::Allowlist<Test>>::get((1643			collection_id,1644			account(2)1645		)));1646	});1647}16481649#[test]1650fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1651	new_test_ext().execute_with(|| {1652		let origin1 = RuntimeOrigin::signed(1);16531654		assert_noop!(1655			Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1656			CommonError::<Test>::CollectionNotFound1657		);1658	});1659}16601661#[test]1662fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1663	new_test_ext().execute_with(|| {1664		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1665		let origin1 = RuntimeOrigin::signed(1);1666		let origin2 = RuntimeOrigin::signed(2);16671668		// Add account 2 to allow list1669		assert_ok!(Unique::add_to_allow_list(1670			origin1.clone(),1671			collection_id,1672			account(2)1673		));16741675		// Account 2 is in collection allow-list1676		assert!(<pallet_common::Allowlist<Test>>::get((1677			collection_id,1678			account(2)1679		)));16801681		// Destroy collection1682		assert_ok!(Unique::destroy_collection(origin1, collection_id));16831684		// Attempt to remove account 2 from collection allow-list => error1685		assert_noop!(1686			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1687			CommonError::<Test>::CollectionNotFound1688		);16891690		// Account 2 is not found in collection allow-list anyway1691		assert_eq!(1692			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1693			false1694		);1695	});1696}16971698// If address is already removed from allow list, nothing happens1699#[test]1700fn address_is_already_removed_from_allow_list() {1701	new_test_ext().execute_with(|| {1702		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1703		let origin1 = RuntimeOrigin::signed(1);17041705		assert_ok!(Unique::add_to_allow_list(1706			origin1.clone(),1707			collection_id,1708			account(2)1709		));1710		assert_ok!(Unique::remove_from_allow_list(1711			origin1.clone(),1712			collection_id,1713			account(2)1714		));1715		assert_eq!(1716			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1717			false1718		);1719		assert_ok!(Unique::remove_from_allow_list(1720			origin1,1721			collection_id,1722			account(2)1723		));1724		assert_eq!(1725			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1726			false1727		);1728	});1729}17301731// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1732#[test]1733fn allow_list_test_1() {1734	new_test_ext().execute_with(|| {1735		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17361737		let origin1 = RuntimeOrigin::signed(1);17381739		let data = default_nft_data();1740		create_test_item(collection_id, &data.into());17411742		assert_ok!(Unique::set_collection_permissions(1743			origin1.clone(),1744			collection_id,1745			CollectionPermissions {1746				mint_mode: None,1747				access: Some(AccessMode::AllowList),1748				nesting: None,1749			}1750		));1751		assert_ok!(Unique::add_to_allow_list(1752			origin1.clone(),1753			collection_id,1754			account(2)1755		));17561757		assert_noop!(1758			Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1759				.map_err(|e| e.error),1760			CommonError::<Test>::AddressNotInAllowlist1761		);1762	});1763}17641765#[test]1766fn allow_list_test_2() {1767	new_test_ext().execute_with(|| {1768		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1769		let origin1 = RuntimeOrigin::signed(1);17701771		let data = default_nft_data();1772		create_test_item(collection_id, &data.into());17731774		assert_ok!(Unique::set_collection_permissions(1775			origin1.clone(),1776			collection_id,1777			CollectionPermissions {1778				mint_mode: None,1779				access: Some(AccessMode::AllowList),1780				nesting: None,1781			}1782		));1783		assert_ok!(Unique::add_to_allow_list(1784			origin1.clone(),1785			collection_id,1786			account(1)1787		));1788		assert_ok!(Unique::add_to_allow_list(1789			origin1.clone(),1790			collection_id,1791			account(2)1792		));17931794		// do approve1795		assert_ok!(Unique::approve(1796			origin1.clone(),1797			account(1),1798			collection_id,1799			TokenId(1),1800			11801		));1802		assert_eq!(1803			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1804			account(1)1805		);18061807		assert_ok!(Unique::remove_from_allow_list(1808			origin1.clone(),1809			collection_id,1810			account(1)1811		));18121813		assert_noop!(1814			Unique::transfer_from(1815				origin1,1816				account(1),1817				account(3),1818				CollectionId(1),1819				TokenId(1),1820				11821			)1822			.map_err(|e| e.error),1823			CommonError::<Test>::AddressNotInAllowlist1824		);1825	});1826}18271828// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1829#[test]1830fn allow_list_test_3() {1831	new_test_ext().execute_with(|| {1832		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18331834		let origin1 = RuntimeOrigin::signed(1);18351836		let data = default_nft_data();1837		create_test_item(collection_id, &data.into());18381839		assert_ok!(Unique::set_collection_permissions(1840			origin1.clone(),1841			collection_id,1842			CollectionPermissions {1843				mint_mode: None,1844				access: Some(AccessMode::AllowList),1845				nesting: None,1846			}1847		));1848		assert_ok!(Unique::add_to_allow_list(1849			origin1.clone(),1850			collection_id,1851			account(1)1852		));18531854		assert_noop!(1855			Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1856				.map_err(|e| e.error),1857			CommonError::<Test>::AddressNotInAllowlist1858		);1859	});1860}18611862#[test]1863fn allow_list_test_4() {1864	new_test_ext().execute_with(|| {1865		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18661867		let origin1 = RuntimeOrigin::signed(1);18681869		let data = default_nft_data();1870		create_test_item(collection_id, &data.into());18711872		assert_ok!(Unique::set_collection_permissions(1873			origin1.clone(),1874			collection_id,1875			CollectionPermissions {1876				mint_mode: None,1877				access: Some(AccessMode::AllowList),1878				nesting: None,1879			}1880		));1881		assert_ok!(Unique::add_to_allow_list(1882			origin1.clone(),1883			collection_id,1884			account(1)1885		));1886		assert_ok!(Unique::add_to_allow_list(1887			origin1.clone(),1888			collection_id,1889			account(2)1890		));18911892		// do approve1893		assert_ok!(Unique::approve(1894			origin1.clone(),1895			account(1),1896			collection_id,1897			TokenId(1),1898			11899		));1900		assert_eq!(1901			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1902			account(1)1903		);19041905		assert_ok!(Unique::remove_from_allow_list(1906			origin1.clone(),1907			collection_id,1908			account(2)1909		));19101911		assert_noop!(1912			Unique::transfer_from(1913				origin1,1914				account(1),1915				account(3),1916				collection_id,1917				TokenId(1),1918				11919			)1920			.map_err(|e| e.error),1921			CommonError::<Test>::AddressNotInAllowlist1922		);1923	});1924}19251926// 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)1927#[test]1928fn allow_list_test_5() {1929	new_test_ext().execute_with(|| {1930		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19311932		let origin1 = RuntimeOrigin::signed(1);19331934		let data = default_nft_data();1935		create_test_item(collection_id, &data.into());19361937		assert_ok!(Unique::set_collection_permissions(1938			origin1.clone(),1939			collection_id,1940			CollectionPermissions {1941				mint_mode: None,1942				access: Some(AccessMode::AllowList),1943				nesting: None,1944			}1945		));1946		assert_noop!(1947			Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1948			CommonError::<Test>::AddressNotInAllowlist1949		);1950	});1951}19521953// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1954#[test]1955fn allow_list_test_6() {1956	new_test_ext().execute_with(|| {1957		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19581959		let origin1 = RuntimeOrigin::signed(1);19601961		let data = default_nft_data();1962		create_test_item(collection_id, &data.into());19631964		assert_ok!(Unique::set_collection_permissions(1965			origin1.clone(),1966			collection_id,1967			CollectionPermissions {1968				mint_mode: None,1969				access: Some(AccessMode::AllowList),1970				nesting: None,1971			}1972		));19731974		// do approve1975		assert_noop!(1976			Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1977				.map_err(|e| e.error),1978			CommonError::<Test>::AddressNotInAllowlist1979		);1980	});1981}19821983// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1984//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1985#[test]1986fn allow_list_test_7() {1987	new_test_ext().execute_with(|| {1988		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19891990		let data = default_nft_data();1991		create_test_item(collection_id, &data.into());19921993		let origin1 = RuntimeOrigin::signed(1);19941995		assert_ok!(Unique::set_collection_permissions(1996			origin1.clone(),1997			collection_id,1998			CollectionPermissions {1999				mint_mode: None,2000				access: Some(AccessMode::AllowList),2001				nesting: None,2002			}2003		));2004		assert_ok!(Unique::add_to_allow_list(2005			origin1.clone(),2006			collection_id,2007			account(1)2008		));2009		assert_ok!(Unique::add_to_allow_list(2010			origin1.clone(),2011			collection_id,2012			account(2)2013		));20142015		assert_ok!(Unique::transfer(2016			origin1,2017			account(2),2018			CollectionId(1),2019			TokenId(1),2020			12021		));2022	});2023}20242025#[test]2026fn allow_list_test_8() {2027	new_test_ext().execute_with(|| {2028		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20292030		// Create NFT for account 12031		let data = default_nft_data();2032		create_test_item(collection_id, &data.into());20332034		let origin1 = RuntimeOrigin::signed(1);20352036		// Toggle Allow List mode and add accounts 1 and 22037		assert_ok!(Unique::set_collection_permissions(2038			origin1.clone(),2039			collection_id,2040			CollectionPermissions {2041				mint_mode: None,2042				access: Some(AccessMode::AllowList),2043				nesting: None,2044			}2045		));2046		assert_ok!(Unique::add_to_allow_list(2047			origin1.clone(),2048			collection_id,2049			account(1)2050		));2051		assert_ok!(Unique::add_to_allow_list(2052			origin1.clone(),2053			collection_id,2054			account(2)2055		));20562057		// Sself-approve account 1 for NFT 12058		assert_ok!(Unique::approve(2059			origin1.clone(),2060			account(1),2061			CollectionId(1),2062			TokenId(1),2063			12064		));2065		assert_eq!(2066			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2067			account(1)2068		);20692070		// Transfer from 1 to 22071		assert_ok!(Unique::transfer_from(2072			origin1,2073			account(1),2074			account(2),2075			CollectionId(1),2076			TokenId(1),2077			12078		));2079	});2080}20812082// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2083#[test]2084fn allow_list_test_9() {2085	new_test_ext().execute_with(|| {2086		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2087		let origin1 = RuntimeOrigin::signed(1);20882089		assert_ok!(Unique::set_collection_permissions(2090			origin1.clone(),2091			collection_id,2092			CollectionPermissions {2093				mint_mode: Some(false),2094				access: Some(AccessMode::AllowList),2095				nesting: None,2096			}2097		));20982099		let data = default_nft_data();2100		create_test_item(collection_id, &data.into());2101	});2102}21032104// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2105#[test]2106fn allow_list_test_10() {2107	new_test_ext().execute_with(|| {2108		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21092110		let origin1 = RuntimeOrigin::signed(1);2111		let origin2 = RuntimeOrigin::signed(2);21122113		assert_ok!(Unique::set_collection_permissions(2114			origin1.clone(),2115			collection_id,2116			CollectionPermissions {2117				mint_mode: Some(false),2118				access: Some(AccessMode::AllowList),2119				nesting: None,2120			}2121		));21222123		assert_ok!(Unique::add_collection_admin(2124			origin1,2125			collection_id,2126			account(2)2127		));21282129		assert_ok!(Unique::create_item(2130			origin2,2131			collection_id,2132			account(2),2133			default_nft_data().into()2134		));2135	});2136}21372138// 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.2139#[test]2140fn allow_list_test_11() {2141	new_test_ext().execute_with(|| {2142		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21432144		let origin1 = RuntimeOrigin::signed(1);2145		let origin2 = RuntimeOrigin::signed(2);21462147		assert_ok!(Unique::set_collection_permissions(2148			origin1.clone(),2149			collection_id,2150			CollectionPermissions {2151				mint_mode: Some(false),2152				access: Some(AccessMode::AllowList),2153				nesting: None,2154			}2155		));2156		assert_ok!(Unique::add_to_allow_list(2157			origin1,2158			collection_id,2159			account(2)2160		));21612162		assert_noop!(2163			Unique::create_item(2164				origin2,2165				CollectionId(1),2166				account(2),2167				default_nft_data().into()2168			)2169			.map_err(|e| e.error),2170			CommonError::<Test>::PublicMintingNotAllowed2171		);2172	});2173}21742175// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-allow listed address.2176#[test]2177fn allow_list_test_12() {2178	new_test_ext().execute_with(|| {2179		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21802181		let origin1 = RuntimeOrigin::signed(1);2182		let origin2 = RuntimeOrigin::signed(2);21832184		assert_ok!(Unique::set_collection_permissions(2185			origin1.clone(),2186			collection_id,2187			CollectionPermissions {2188				mint_mode: Some(false),2189				access: Some(AccessMode::AllowList),2190				nesting: None,2191			}2192		));21932194		assert_noop!(2195			Unique::create_item(2196				origin2,2197				CollectionId(1),2198				account(2),2199				default_nft_data().into()2200			)2201			.map_err(|e| e.error),2202			CommonError::<Test>::PublicMintingNotAllowed2203		);2204	});2205}22062207// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2208#[test]2209fn allow_list_test_13() {2210	new_test_ext().execute_with(|| {2211		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22122213		let origin1 = RuntimeOrigin::signed(1);22142215		assert_ok!(Unique::set_collection_permissions(2216			origin1.clone(),2217			collection_id,2218			CollectionPermissions {2219				mint_mode: Some(true),2220				access: Some(AccessMode::AllowList),2221				nesting: None,2222			}2223		));22242225		let data = default_nft_data();2226		create_test_item(collection_id, &data.into());2227	});2228}22292230// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2231#[test]2232fn allow_list_test_14() {2233	new_test_ext().execute_with(|| {2234		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22352236		let origin1 = RuntimeOrigin::signed(1);2237		let origin2 = RuntimeOrigin::signed(2);22382239		assert_ok!(Unique::set_collection_permissions(2240			origin1.clone(),2241			collection_id,2242			CollectionPermissions {2243				mint_mode: Some(true),2244				access: Some(AccessMode::AllowList),2245				nesting: None,2246			}2247		));22482249		assert_ok!(Unique::add_collection_admin(2250			origin1,2251			collection_id,2252			account(2)2253		));22542255		assert_ok!(Unique::create_item(2256			origin2,2257			collection_id,2258			account(2),2259			default_nft_data().into()2260		));2261	});2262}22632264// 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.2265#[test]2266fn allow_list_test_15() {2267	new_test_ext().execute_with(|| {2268		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22692270		let origin1 = RuntimeOrigin::signed(1);2271		let origin2 = RuntimeOrigin::signed(2);22722273		assert_ok!(Unique::set_collection_permissions(2274			origin1.clone(),2275			collection_id,2276			CollectionPermissions {2277				mint_mode: Some(true),2278				access: Some(AccessMode::AllowList),2279				nesting: None,2280			}2281		));22822283		assert_noop!(2284			Unique::create_item(2285				origin2,2286				collection_id,2287				account(2),2288				default_nft_data().into()2289			)2290			.map_err(|e| e.error),2291			CommonError::<Test>::AddressNotInAllowlist2292		);2293	});2294}22952296// 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.2297#[test]2298fn allow_list_test_16() {2299	new_test_ext().execute_with(|| {2300		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23012302		let origin1 = RuntimeOrigin::signed(1);2303		let origin2 = RuntimeOrigin::signed(2);23042305		assert_ok!(Unique::set_collection_permissions(2306			origin1.clone(),2307			collection_id,2308			CollectionPermissions {2309				mint_mode: Some(true),2310				access: Some(AccessMode::AllowList),2311				nesting: None,2312			}2313		));2314		assert_ok!(Unique::add_to_allow_list(2315			origin1,2316			collection_id,2317			account(2)2318		));23192320		assert_ok!(Unique::create_item(2321			origin2,2322			collection_id,2323			account(2),2324			default_nft_data().into()2325		));2326	});2327}23282329// Total number of collections. Positive test2330#[test]2331fn total_number_collections_bound() {2332	new_test_ext().execute_with(|| {2333		create_test_collection(&CollectionMode::NFT, CollectionId(1));2334	});2335}23362337#[test]2338fn create_max_collections() {2339	new_test_ext().execute_with(|| {2340		for i in 1..COLLECTION_NUMBER_LIMIT {2341			create_test_collection(&CollectionMode::NFT, CollectionId(i));2342		}2343	});2344}23452346// Total number of collections. Negative test2347#[test]2348fn total_number_collections_bound_neg() {2349	new_test_ext().execute_with(|| {2350		let origin1 = RuntimeOrigin::signed(1);23512352		for i in 1..=COLLECTION_NUMBER_LIMIT {2353			create_test_collection(&CollectionMode::NFT, CollectionId(i));2354		}23552356		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2357		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2358		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23592360		let data: CreateCollectionData<u64> = CreateCollectionData {2361			name: col_name1.try_into().unwrap(),2362			description: col_desc1.try_into().unwrap(),2363			token_prefix: token_prefix1.try_into().unwrap(),2364			mode: CollectionMode::NFT,2365			..Default::default()2366		};23672368		// 11-th collection in chain. Expects error2369		assert_noop!(2370			Unique::create_collection_ex(origin1, data),2371			CommonError::<Test>::TotalCollectionsLimitExceeded2372		);2373	});2374}23752376// Owned tokens by a single address. Positive test2377#[test]2378fn owned_tokens_bound() {2379	new_test_ext().execute_with(|| {2380		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23812382		let data = default_nft_data();2383		create_test_item(collection_id, &data.clone().into());2384		create_test_item(collection_id, &data.into());2385	});2386}23872388// Owned tokens by a single address. Negotive test2389#[test]2390fn owned_tokens_bound_neg() {2391	new_test_ext().execute_with(|| {2392		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23932394		let origin1 = RuntimeOrigin::signed(1);23952396		for _ in 1..=MAX_TOKEN_OWNERSHIP {2397			let data = default_nft_data();2398			create_test_item(collection_id, &data.clone().into());2399		}24002401		let data = default_nft_data();2402		assert_noop!(2403			Unique::create_item(origin1, CollectionId(1), account(1), data.into())2404				.map_err(|e| e.error),2405			CommonError::<Test>::AccountTokenLimitExceeded2406		);2407	});2408}24092410// Number of collection admins. Positive test2411#[test]2412fn collection_admins_bound() {2413	new_test_ext().execute_with(|| {2414		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24152416		let origin1 = RuntimeOrigin::signed(1);24172418		assert_ok!(Unique::add_collection_admin(2419			origin1.clone(),2420			collection_id,2421			account(2)2422		));2423		assert_ok!(Unique::add_collection_admin(2424			origin1,2425			collection_id,2426			account(3)2427		));2428	});2429}24302431// Number of collection admins. Negotive test2432#[test]2433fn collection_admins_bound_neg() {2434	new_test_ext().execute_with(|| {2435		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24362437		let origin1 = RuntimeOrigin::signed(1);24382439		for i in 0..COLLECTION_ADMINS_LIMIT {2440			assert_ok!(Unique::add_collection_admin(2441				origin1.clone(),2442				collection_id,2443				account((2 + i).into())2444			));2445		}2446		assert_noop!(2447			Unique::add_collection_admin(2448				origin1,2449				collection_id,2450				account((3 + COLLECTION_ADMINS_LIMIT).into())2451			),2452			CommonError::<Test>::CollectionAdminCountExceeded2453		);2454	});2455}2456// #endregion24572458#[test]2459fn collection_transfer_flag_works() {2460	new_test_ext().execute_with(|| {2461		let origin1 = RuntimeOrigin::signed(1);24622463		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2464		assert_ok!(Unique::set_transfers_enabled_flag(2465			origin1,2466			collection_id,2467			true2468		));24692470		let data = default_nft_data();2471		create_test_item(collection_id, &data.into());2472		assert_eq!(2473			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2474			12475		);2476		assert_eq!(2477			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2478			true2479		);24802481		let origin1 = RuntimeOrigin::signed(1);24822483		// default scenario2484		assert_ok!(Unique::transfer(2485			origin1,2486			account(2),2487			collection_id,2488			TokenId(1),2489			12490		));2491		assert_eq!(2492			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2493			false2494		);2495		assert_eq!(2496			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2497			true2498		);2499		assert_eq!(2500			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2501			02502		);2503		assert_eq!(2504			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2505			12506		);2507	});2508}25092510#[test]2511fn collection_transfer_flag_works_neg() {2512	new_test_ext().execute_with(|| {2513		let origin1 = RuntimeOrigin::signed(1);25142515		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2516		assert_ok!(Unique::set_transfers_enabled_flag(2517			origin1,2518			collection_id,2519			false2520		));25212522		let data = default_nft_data();2523		create_test_item(collection_id, &data.into());2524		assert_eq!(2525			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2526			12527		);2528		assert_eq!(2529			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2530			true2531		);25322533		let origin1 = RuntimeOrigin::signed(1);25342535		// default scenario2536		assert_noop!(2537			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2538				.map_err(|e| e.error),2539			CommonError::<Test>::TransferNotAllowed2540		);2541		assert_eq!(2542			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2543			12544		);2545		assert_eq!(2546			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2547			02548		);2549		assert_eq!(2550			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2551			true2552		);2553		assert_eq!(2554			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2555			false2556		);2557	});2558}25592560#[test]2561fn collection_sponsoring() {2562	new_test_ext().execute_with(|| {2563		// default_limits();2564		let user1 = 1_u64;2565		let user2 = 777_u64;2566		let origin1 = RuntimeOrigin::signed(user1);2567		let origin2 = RuntimeOrigin::signed(user2);2568		let account2 = account(user2);25692570		let collection_id =2571			create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2572		assert_ok!(Unique::set_collection_sponsor(2573			origin1.clone(),2574			collection_id,2575			user12576		));2577		assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25782579		// Expect error while have no permissions2580		assert!(Unique::create_item(2581			origin2.clone(),2582			collection_id,2583			account2.clone(),2584			default_nft_data().into()2585		)2586		.is_err());25872588		assert_ok!(Unique::set_collection_permissions(2589			origin1.clone(),2590			collection_id,2591			CollectionPermissions {2592				mint_mode: Some(true),2593				access: Some(AccessMode::AllowList),2594				nesting: None,2595			}2596		));2597		assert_ok!(Unique::add_to_allow_list(2598			origin1.clone(),2599			collection_id,2600			account2.clone()2601		));26022603		assert_ok!(Unique::create_item(2604			origin2,2605			collection_id,2606			account2,2607			default_nft_data().into()2608		));2609	});2610}