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

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, CollectionMode};5use nft_data_structs::{6	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, CreateFungibleData, 7	CreateNftData, CreateReFungibleData, ExistenceRequirement, MAX_COLLECTION_DESCRIPTION_LENGTH, 8	MAX_COLLECTION_NAME_LENGTH, MAX_DECIMAL_POINTS, MAX_TOKEN_PREFIX_LENGTH, COLLECTION_ADMINS_LIMIT, 9	MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight, WithdrawReasons,10};1112use frame_support::{assert_noop, assert_ok};13use sp_std::convert::TryInto;1415fn default_nft_data() -> CreateNftData {16	CreateNftData {17		const_data: vec![1, 2, 3].try_into().unwrap(),18		variable_data: vec![3, 2, 1].try_into().unwrap(),19	}20}2122fn default_fungible_data() -> CreateFungibleData {23	CreateFungibleData { value: 5 }24}2526fn default_re_fungible_data() -> CreateReFungibleData {27	CreateReFungibleData {28		const_data: vec![1, 2, 3].try_into().unwrap(),29		variable_data: vec![3, 2, 1].try_into().unwrap(),30		pieces: 1023,31	}32}3334fn create_test_collection_for_owner(35	mode: &CollectionMode,36	owner: u64,37	id: CollectionId,38) -> CollectionId {39	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();40	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();41	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4243	let origin1 = Origin::signed(owner);44	assert_ok!(TemplateModule::create_collection(45		origin1,46		col_name1,47		col_desc1,48		token_prefix1,49		mode.clone()50	));5152	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();53	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();54	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();55	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().owner, owner);56	assert_eq!(57		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,58		saved_col_name59	);60	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().mode, *mode);61	assert_eq!(62		<pallet_common::CollectionById<Test>>::get(id).unwrap().description,63		saved_description64	);65	assert_eq!(66		<pallet_common::CollectionById<Test>>::get(id).unwrap().token_prefix,67		saved_prefix68	);69	id70}7172fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {73	create_test_collection_for_owner(&mode, 1, id)74}7576fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {77	let origin1 = Origin::signed(1);78	assert_ok!(TemplateModule::create_item(79		origin1,80		collection_id,81		account(1),82		data.clone()83	));84}8586fn account(sub: u64) -> TestCrossAccountId {87	TestCrossAccountId::from_sub(sub)88}8990// Use cases tests region91// #region9293#[test]94fn set_version_schema() {95	new_test_ext().execute_with(|| {96		let origin1 = Origin::signed(1);97		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));9899		assert_ok!(TemplateModule::set_schema_version(100			origin1,101			collection_id,102			SchemaVersion::Unique103		));104		assert_eq!(105			<pallet_common::CollectionById<Test>>::get(collection_id)106				.unwrap()107				.schema_version,108			SchemaVersion::Unique109		);110	});111}112113#[test]114fn create_fungible_collection_fails_with_large_decimal_numbers() {115	new_test_ext().execute_with(|| {116		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();117		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();118		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();119120		let origin1 = Origin::signed(1);121		assert_noop!(122			TemplateModule::create_collection(123				origin1,124				col_name1,125				col_desc1,126				token_prefix1,127				CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)128			),129			Error::<Test>::CollectionDecimalPointLimitExceeded130		);131	});132}133134#[test]135fn create_nft_item() {136	new_test_ext().execute_with(|| {137		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));138139		let data = default_nft_data();140		create_test_item(collection_id, &data.clone().into());141142		let item = <pallet_nonfungible::TokenData<Test>>::get((collection_id, 1)).unwrap();143		assert_eq!(item.const_data, data.const_data.into_inner());144		assert_eq!(item.variable_data, data.variable_data.into_inner());145	});146}147148// Use cases tests region149// #region150#[test]151fn create_nft_multiple_items() {152	new_test_ext().execute_with(|| {153		create_test_collection(&CollectionMode::NFT, CollectionId(1));154155		let origin1 = Origin::signed(1);156157		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];158159		assert_ok!(TemplateModule::create_multiple_items(160			origin1,161			CollectionId(1),162			account(1),163			items_data164				.clone()165				.into_iter()166				.map(|d| { d.into() })167				.collect()168		));169		for (index, data) in items_data.into_iter().enumerate() {170			let item = <pallet_nonfungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32))).unwrap();171			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());172			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());173		}174	});175}176177#[test]178fn create_refungible_item() {179	new_test_ext().execute_with(|| {180		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));181182		let data = default_re_fungible_data();183		create_test_item(collection_id, &data.clone().into());184		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));185		let balance = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));186		assert_eq!(item.const_data, data.const_data.into_inner());187		assert_eq!(item.variable_data, data.variable_data.into_inner());188		assert_eq!(balance, 1023);189	});190}191192#[test]193fn create_multiple_refungible_items() {194	new_test_ext().execute_with(|| {195		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));196197		let origin1 = Origin::signed(1);198199		let items_data = vec![200			default_re_fungible_data(),201			default_re_fungible_data(),202			default_re_fungible_data(),203		];204205		assert_ok!(TemplateModule::create_multiple_items(206			origin1,207			CollectionId(1),208			account(1),209			items_data210				.clone()211				.into_iter()212				.map(|d| { d.into() })213				.collect()214		));215		for (index, data) in items_data.into_iter().enumerate() {216			let item = <pallet_nonfungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32))).unwrap();217			let balance = <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));218			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());219			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());220			assert_eq!(balance, 1023);221		}222	});223}224225#[test]226fn create_fungible_item() {227	new_test_ext().execute_with(|| {228		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));229230		let data = default_fungible_data();231		create_test_item(collection_id, &data.into());232233		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);234	});235}236237//#[test]238// fn create_multiple_fungible_items() {239//     new_test_ext().execute_with(|| {240//         default_limits();241242//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));243244//         let origin1 = Origin::signed(1);245246//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];247248//         assert_ok!(TemplateModule::create_multiple_items(249//             origin1.clone(),250//             1,251//             1,252//             items_data.clone().into_iter().map(|d| { d.into() }).collect()253//         ));254255//         for (index, _) in items_data.iter().enumerate() {256//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);257//         }258//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);259//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);260//     });261// }262263#[test]264fn transfer_fungible_item() {265	new_test_ext().execute_with(|| {266		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));267268		let origin1 = Origin::signed(1);269		let origin2 = Origin::signed(2);270271		let data = default_fungible_data();272		create_test_item(collection_id, &data.into());273274		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 5);275276		// change owner scenario277		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 5));278		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 0);279280		// split item scenario281		assert_ok!(TemplateModule::transfer(282			origin2.clone(),283			account(3),284			CollectionId(1),285			TokenId(1),286			3287		));288289		// split item and new owner has account scenario290		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(1), 1));291		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))), 1);292		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))), 4);293	});294}295296#[test]297fn transfer_refungible_item() {298	new_test_ext().execute_with(|| {299		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));300301		let data = default_re_fungible_data();302		create_test_item(collection_id, &data.clone().into());303304		let origin1 = Origin::signed(1);305		let origin2 = Origin::signed(2);306		{307			let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));308			let balance = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));309			assert_eq!(item.const_data, data.const_data.into_inner());310			assert_eq!(item.variable_data, data.variable_data.into_inner());311			assert_eq!(balance, 1023);312		}313		314		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1023);315		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);316317		// change owner scenario318		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1023));319320		let balance2 = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2)));321		assert_eq!(balance2, 1023);322		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);323		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1023);324		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);325		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);326327		// split item scenario328		assert_ok!(TemplateModule::transfer(329			origin2.clone(),330			account(3),331			CollectionId(1),332			TokenId(1),333			500334		));335		{336			let item = <pallet_refungible::TokenData<Test>>::get((CollectionId(1), TokenId(1)));337			let balance2 = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2)));338			let balance3 = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3)));339			assert_eq!(balance2, 523);340			assert_eq!(balance3, 500);341		}342		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 523);343		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 500);344		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);345		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);346347		// split item and new owner has account scenario348		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(1), 200));349		{350			let item = <pallet_refungible::TokenData<Test>>::get((CollectionId(1), TokenId(1)));351			let balance2 = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2)));352			let balance3 = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3)));353			assert_eq!(balance2, 323);354			assert_eq!(balance3, 700);355		}356		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 323);357		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 700);358		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);359		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);360	});361}362363#[test]364fn transfer_nft_item() {365	new_test_ext().execute_with(|| {366		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));367368		let data = default_nft_data();369		create_test_item(collection_id, &data.into());370		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);371		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);372373374		let origin1 = Origin::signed(1);375		// default scenario376		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1000));377		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);378		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);379		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);380		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);381	});382}383384#[test]385fn nft_approve_and_transfer_from() {386	new_test_ext().execute_with(|| {387		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));388389		let data = default_nft_data();390		create_test_item(collection_id, &data.into());391392		let origin1 = Origin::signed(1);393		let origin2 = Origin::signed(2);394395		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);396		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);397398		// neg transfer399		assert_noop!(400			TemplateModule::transfer_from(origin2.clone(), account(1), account(2), CollectionId(1), TokenId(1), 1),401			CommonError::<Test>::NoPermission402		);403404		// do approve405		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 5));406		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));407408		assert_ok!(TemplateModule::transfer_from(409			origin2,410			account(1),411			account(3),412			CollectionId(1),413			TokenId(1),414			1415		));416		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());417	});418}419420#[test]421fn nft_approve_and_transfer_from_allow_list() {422	new_test_ext().execute_with(|| {423		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));424425		let origin1 = Origin::signed(1);426		let origin2 = Origin::signed(2);427428		let data = default_nft_data();429		create_test_item(collection_id, &data.clone().into());430431		assert_eq!(432			&<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1))).unwrap().const_data,433			&data.const_data.into_inner()434		);435		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);436		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);437438		assert_ok!(TemplateModule::set_mint_permission(439			origin1.clone(),440			CollectionId(1),441			true442		));443		assert_ok!(TemplateModule::set_public_access_mode(444			origin1.clone(),445			CollectionId(1),446			AccessMode::AllowList447		));448		assert_ok!(TemplateModule::add_to_allow_list(449			origin1.clone(),450			CollectionId(1),451			account(1)452		));453		assert_ok!(TemplateModule::add_to_allow_list(454			origin1.clone(),455			CollectionId(1),456			account(2)457		));458		assert_ok!(TemplateModule::add_to_allow_list(459			origin1.clone(),460			CollectionId(1),461			account(3)462		));463464		// do approve465		assert_ok!(TemplateModule::approve(466			origin1.clone(),467			account(2),468			CollectionId(1),469			TokenId(1),470			5471		));472		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));473		assert_ok!(TemplateModule::approve(origin1, account(3), CollectionId(1), TokenId(1), 5));474		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(3));475476		assert_ok!(TemplateModule::transfer_from(477			origin2,478			account(1),479			account(3),480			CollectionId(1),481			TokenId(1),482			1483		));484		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());485	});486}487488#[test]489fn refungible_approve_and_transfer_from() {490	new_test_ext().execute_with(|| {491		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));492493		let origin1 = Origin::signed(1);494		let origin2 = Origin::signed(2);495496		let data = default_re_fungible_data();497		create_test_item(collection_id, &data.into());498499		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1023);500		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);501502		assert_ok!(TemplateModule::set_mint_permission(503			origin1.clone(),504			CollectionId(1),505			true506		));507		assert_ok!(TemplateModule::set_public_access_mode(508			origin1.clone(),509			CollectionId(1),510			AccessMode::AllowList511		));512		assert_ok!(TemplateModule::add_to_allow_list(513			origin1.clone(),514			CollectionId(1),515			account(1)516		));517		assert_ok!(TemplateModule::add_to_allow_list(518			origin1.clone(),519			CollectionId(1),520			account(2)521		));522		assert_ok!(TemplateModule::add_to_allow_list(523			origin1.clone(),524			CollectionId(1),525			account(3)526		));527528		// do approve529		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1023));530		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 1023);531532		assert_ok!(TemplateModule::transfer_from(533			origin2,534			account(1),535			account(3),536			CollectionId(1),537			TokenId(1),538			100539		));540		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 923);541		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 100);542		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);543		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(3))), true);544		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 923);545	});546}547548#[test]549fn fungible_approve_and_transfer_from() {550	new_test_ext().execute_with(|| {551		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));552553		let data = default_fungible_data();554		create_test_item(collection_id, &data.into());555556		let origin1 = Origin::signed(1);557		let origin2 = Origin::signed(2);558559		assert_ok!(TemplateModule::set_mint_permission(560			origin1.clone(),561			CollectionId(1),562			true563		));564		assert_ok!(TemplateModule::set_public_access_mode(565			origin1.clone(),566			CollectionId(1),567			AccessMode::AllowList568		));569		assert_ok!(TemplateModule::add_to_allow_list(570			origin1.clone(),571			CollectionId(1),572			account(1)573		));574		assert_ok!(TemplateModule::add_to_allow_list(575			origin1.clone(),576			CollectionId(1),577			account(2)578		));579		assert_ok!(TemplateModule::add_to_allow_list(580			origin1.clone(),581			CollectionId(1),582			account(3)583		));584585		// do approve586		assert_ok!(TemplateModule::approve(587			origin1.clone(),588			account(2),589			CollectionId(1),590			TokenId(1),591			5592		));593		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);594		assert_ok!(TemplateModule::approve(origin1, account(3), CollectionId(1), TokenId(1), 5));595		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);596		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))), 5);597598		assert_ok!(TemplateModule::transfer_from(599			origin2.clone(),600			account(1),601			account(3),602			CollectionId(1),603			TokenId(1),604			4605		));606607		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 1);608609		assert_noop!(610			TemplateModule::transfer_from(origin2, account(1), account(3), CollectionId(1), TokenId(1), 4),611			CommonError::<Test>::NoPermission612		);613	});614}615616#[test]617fn change_collection_owner() {618	new_test_ext().execute_with(|| {619		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));620621		let origin1 = Origin::signed(1);622		assert_ok!(TemplateModule::change_collection_owner(623			origin1,624			collection_id,625			2626		));627		assert_eq!(628			<pallet_common::CollectionById<Test>>::get(collection_id).unwrap().owner,629			2630		);631	});632}633634#[test]635fn destroy_collection() {636	new_test_ext().execute_with(|| {637		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));638639		let origin1 = Origin::signed(1);640		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));641	});642}643644#[test]645fn burn_nft_item() {646	new_test_ext().execute_with(|| {647		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));648649		let origin1 = Origin::signed(1);650		assert_ok!(TemplateModule::add_collection_admin(651			origin1.clone(),652			collection_id,653			account(2)654		));655656		let data = default_nft_data();657		create_test_item(collection_id, &data.into());658659		// check balance (collection with id = 1, user id = 1)660		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);661662		// burn item663		assert_ok!(TemplateModule::burn_item(664			origin1.clone(),665			collection_id,666			TokenId(1),667			1668		));669		assert_noop!(670			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1),671			CommonError::<Test>::TokenNotFound672		);673674		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);675	});676}677678#[test]679fn burn_fungible_item() {680	new_test_ext().execute_with(|| {681		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));682683		let origin1 = Origin::signed(1);684		assert_ok!(TemplateModule::add_collection_admin(685			origin1.clone(),686			collection_id,687			account(2)688		));689690		let data = default_fungible_data();691		create_test_item(collection_id, &data.into());692693		// check balance (collection with id = 1, user id = 1)694		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);695696		// burn item697		assert_ok!(TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 5));698		assert_noop!(699			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(1), 5),700			CommonError::<Test>::TokenValueNotEnough701		);702703		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 0);704	});705}706707#[test]708fn burn_refungible_item() {709	new_test_ext().execute_with(|| {710		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));711		let origin1 = Origin::signed(1);712713		assert_ok!(TemplateModule::set_mint_permission(714			origin1.clone(),715			collection_id,716			true717		));718		assert_ok!(TemplateModule::set_public_access_mode(719			origin1.clone(),720			collection_id,721			AccessMode::AllowList722		));723		assert_ok!(TemplateModule::add_to_allow_list(724			origin1.clone(),725			collection_id,726			account(1)727		));728729		assert_ok!(TemplateModule::add_collection_admin(730			origin1.clone(),731			collection_id,732			account(2)733		));734735		let data = default_re_fungible_data();736		create_test_item(collection_id, &data.into());737738		// check balance (collection with id = 1, user id = 2)739		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1023);740		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);741742		// burn item743		assert_ok!(TemplateModule::burn_item(origin1.clone(), collection_id, TokenId(1), 1023));744		assert_noop!(745			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1023),746			CommonError::<Test>::TokenNotFound747		);748749		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 0);750	});751}752753#[test]754fn add_collection_admin() {755	new_test_ext().execute_with(|| {756		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));757		create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(2));758		create_test_collection_for_owner(&CollectionMode::NFT, 3, CollectionId(3));759760		let origin1 = Origin::signed(1);761762		// collection admin763		assert_ok!(TemplateModule::add_collection_admin(764			origin1.clone(),765			collection1_id,766			account(2)767		));768		assert_ok!(TemplateModule::add_collection_admin(769			origin1,770			collection1_id,771			account(3)772		));773774		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))));775		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));776		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));777	});778}779780#[test]781fn remove_collection_admin() {782	new_test_ext().execute_with(|| {783		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));784		create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(2));785		create_test_collection_for_owner(&CollectionMode::NFT, 3, CollectionId(3));786787		let origin1 = Origin::signed(1);788		let origin2 = Origin::signed(2);789790		// collection admin791		assert_ok!(TemplateModule::add_collection_admin(792			origin1.clone(),793			collection1_id,794			account(2)795		));796		assert_ok!(TemplateModule::add_collection_admin(797			origin1,798			collection1_id,799			account(3)800		));801802		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));803		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));804805		// remove admin806		assert_ok!(TemplateModule::remove_collection_admin(807			origin2,808			CollectionId(1),809			account(3)810		));811		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));812		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))), false);813	});814}815816#[test]817fn balance_of() {818	new_test_ext().execute_with(|| {819		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));820		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));821		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(3));822823		// check balance before824		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 0);825		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 0);826		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 0);827828		let nft_data = default_nft_data();829		create_test_item(nft_collection_id, &nft_data.into());830831		let fungible_data = default_fungible_data();832		create_test_item(fungible_collection_id, &fungible_data.into());833834		let re_fungible_data = default_re_fungible_data();835		create_test_item(re_fungible_collection_id, &re_fungible_data.into());836837		// check balance (collection with id = 1, user id = 1)838		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 1);839		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 5);840		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 1023);841842		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))), true);843		assert_eq!(<pallet_refungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))), true);844	});845}846847#[test]848fn approve() {849	new_test_ext().execute_with(|| {850		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));851852		let data = default_nft_data();853		create_test_item(collection_id, &data.into());854855		let origin1 = Origin::signed(1);856857		// approve858		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));859		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));860	});861}862863#[test]864fn transfer_from() {865	new_test_ext().execute_with(|| {866		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));867		let origin1 = Origin::signed(1);868		let origin2 = Origin::signed(2);869870		let data = default_nft_data();871		create_test_item(collection_id, &data.into());872873		// approve874		assert_ok!(TemplateModule::approve(875			origin1.clone(),876			account(2),877			CollectionId(1),878			TokenId(1),879			1880		));881		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));882883		assert_ok!(TemplateModule::set_mint_permission(884			origin1.clone(),885			CollectionId(1),886			true887		));888		assert_ok!(TemplateModule::set_public_access_mode(889			origin1.clone(),890			CollectionId(1),891			AccessMode::AllowList892		));893		assert_ok!(TemplateModule::add_to_allow_list(894			origin1.clone(),895			CollectionId(1),896			account(1)897		));898		assert_ok!(TemplateModule::add_to_allow_list(899			origin1.clone(),900			CollectionId(1),901			account(2)902		));903		assert_ok!(TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(3)));904905		assert_ok!(TemplateModule::transfer_from(906			origin2,907			account(1),908			account(2),909			CollectionId(1),910			TokenId(1),911			1912		));913914		// after transfer915		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))), 0);916		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))), 1);917	});918}919920// #endregion921922// Coverage tests region923// #region924925#[test]926fn owner_can_add_address_to_allow_list() {927	new_test_ext().execute_with(|| {928		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));929930		let origin1 = Origin::signed(1);931		assert_ok!(TemplateModule::add_to_allow_list(932			origin1,933			collection_id,934			account(2)935		));936		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));937	});938}939940#[test]941fn admin_can_add_address_to_allow_list() {942	new_test_ext().execute_with(|| {943		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));944		let origin1 = Origin::signed(1);945		let origin2 = Origin::signed(2);946947		assert_ok!(TemplateModule::add_collection_admin(948			origin1,949			collection_id,950			account(2)951		));952		assert_ok!(TemplateModule::add_to_allow_list(953			origin2,954			collection_id,955			account(3)956		));957		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))));958	});959}960961#[test]962fn nonprivileged_user_cannot_add_address_to_allow_list() {963	new_test_ext().execute_with(|| {964		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));965966		let origin2 = Origin::signed(2);967		assert_noop!(968			TemplateModule::add_to_allow_list(origin2, collection_id, account(3)),969			CommonError::<Test>::NoPermission970		);971	});972}973974#[test]975fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {976	new_test_ext().execute_with(|| {977		let origin1 = Origin::signed(1);978979		assert_noop!(980			TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(2)),981			CommonError::<Test>::CollectionNotFound982		);983	});984}985986#[test]987fn nobody_can_add_address_to_allow_list_of_deleted_collection() {988	new_test_ext().execute_with(|| {989		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));990991		let origin1 = Origin::signed(1);992		assert_ok!(TemplateModule::destroy_collection(993			origin1.clone(),994			collection_id995		));996		assert_noop!(997			TemplateModule::add_to_allow_list(origin1, collection_id, account(2)),998			CommonError::<Test>::CollectionNotFound999		);1000	});1001}10021003// If address is already added to allow list, nothing happens1004#[test]1005fn address_is_already_added_to_allow_list() {1006	new_test_ext().execute_with(|| {1007		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1008		let origin1 = Origin::signed(1);10091010		assert_ok!(TemplateModule::add_to_allow_list(1011			origin1.clone(),1012			collection_id,1013			account(2)1014		));1015		assert_ok!(TemplateModule::add_to_allow_list(1016			origin1,1017			collection_id,1018			account(2)1019		));1020		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1021	});1022}10231024#[test]1025fn owner_can_remove_address_from_allow_list() {1026	new_test_ext().execute_with(|| {1027		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10281029		let origin1 = Origin::signed(1);1030		assert_ok!(TemplateModule::add_to_allow_list(1031			origin1.clone(),1032			collection_id,1033			account(2)1034		));1035		assert_ok!(TemplateModule::remove_from_allow_list(1036			origin1,1037			collection_id,1038			account(2)1039		));1040		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1041	});1042}10431044#[test]1045fn admin_can_remove_address_from_allow_list() {1046	new_test_ext().execute_with(|| {1047		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1048		let origin1 = Origin::signed(1);1049		let origin2 = Origin::signed(2);10501051		assert_ok!(TemplateModule::add_collection_admin(1052			origin1.clone(),1053			collection_id,1054			account(2)1055		));10561057		assert_ok!(TemplateModule::add_to_allow_list(1058			origin1,1059			collection_id,1060			account(3)1061		));1062		assert_ok!(TemplateModule::remove_from_allow_list(1063			origin2,1064			collection_id,1065			account(3)1066		));1067		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))));1068	});1069}10701071#[test]1072fn nonprivileged_user_cannot_remove_address_from_allow_list() {1073	new_test_ext().execute_with(|| {1074		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1075		let origin1 = Origin::signed(1);1076		let origin2 = Origin::signed(2);10771078		assert_ok!(TemplateModule::add_to_allow_list(1079			origin1,1080			collection_id,1081			account(2)1082		));1083		assert_noop!(1084			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1085			CommonError::<Test>::NoPermission1086		);1087		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1088	});1089}10901091#[test]1092fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1093	new_test_ext().execute_with(|| {1094		let origin1 = Origin::signed(1);10951096		assert_noop!(1097			TemplateModule::remove_from_allow_list(origin1, CollectionId(1), account(2)),1098			CommonError::<Test>::CollectionNotFound1099		);1100	});1101}11021103#[test]1104fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1105	new_test_ext().execute_with(|| {1106		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1107		let origin1 = Origin::signed(1);1108		let origin2 = Origin::signed(2);11091110		assert_ok!(TemplateModule::add_to_allow_list(1111			origin1.clone(),1112			collection_id,1113			account(2)1114		));1115		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));1116		assert_noop!(1117			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1118			CommonError::<Test>::CollectionNotFound1119		);1120		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1121	});1122}11231124// If address is already removed from allow list, nothing happens1125#[test]1126fn address_is_already_removed_from_allow_list() {1127	new_test_ext().execute_with(|| {1128		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1129		let origin1 = Origin::signed(1);11301131		assert_ok!(TemplateModule::add_to_allow_list(1132			origin1.clone(),1133			collection_id,1134			account(2)1135		));1136		assert_ok!(TemplateModule::remove_from_allow_list(1137			origin1.clone(),1138			collection_id,1139			account(2)1140		));1141		assert_ok!(TemplateModule::remove_from_allow_list(1142			origin1,1143			collection_id,1144			account(2)1145		));1146		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1147	});1148}11491150// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1151#[test]1152fn allow_list_test_1() {1153	new_test_ext().execute_with(|| {1154		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));11551156		let origin1 = Origin::signed(1);11571158		let data = default_nft_data();1159		create_test_item(collection_id, &data.into());11601161		assert_ok!(TemplateModule::set_public_access_mode(1162			origin1.clone(),1163			collection_id,1164			AccessMode::AllowList1165		));1166		assert_ok!(TemplateModule::add_to_allow_list(1167			origin1.clone(),1168			collection_id,1169			account(2)1170		));11711172		assert_noop!(1173			TemplateModule::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1),1174			CommonError::<Test>::AddressNotInAllowlist1175		);1176	});1177}11781179#[test]1180fn allow_list_test_2() {1181	new_test_ext().execute_with(|| {1182		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1183		let origin1 = Origin::signed(1);11841185		let data = default_nft_data();1186		create_test_item(collection_id, &data.into());11871188		assert_ok!(TemplateModule::set_public_access_mode(1189			origin1.clone(),1190			collection_id,1191			AccessMode::AllowList1192		));1193		assert_ok!(TemplateModule::add_to_allow_list(1194			origin1.clone(),1195			collection_id,1196			account(1)1197		));1198		assert_ok!(TemplateModule::add_to_allow_list(1199			origin1.clone(),1200			collection_id,1201			account(2)1202		));12031204		// do approve1205		assert_ok!(TemplateModule::approve(1206			origin1.clone(),1207			account(1),1208			collection_id,1209			TokenId(1),1210			11211		));1212		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));12131214		assert_ok!(TemplateModule::remove_from_allow_list(1215			origin1.clone(),1216			collection_id,1217			account(1)1218		));12191220		assert_noop!(1221			TemplateModule::transfer_from(origin1, account(1), account(3), CollectionId(1), TokenId(1), 1),1222			CommonError::<Test>::AddressNotInAllowlist1223		);1224	});1225}12261227// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1228#[test]1229fn allow_list_test_3() {1230	new_test_ext().execute_with(|| {1231		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));12321233		let origin1 = Origin::signed(1);12341235		let data = default_nft_data();1236		create_test_item(collection_id, &data.into());12371238		assert_ok!(TemplateModule::set_public_access_mode(1239			origin1.clone(),1240			collection_id,1241			AccessMode::AllowList1242		));1243		assert_ok!(TemplateModule::add_to_allow_list(1244			origin1.clone(),1245			collection_id,1246			account(1)1247		));12481249		assert_noop!(1250			TemplateModule::transfer(origin1, account(3), collection_id, TokenId(1), 1),1251			CommonError::<Test>::AddressNotInAllowlist1252		);1253	});1254}12551256#[test]1257fn allow_list_test_4() {1258	new_test_ext().execute_with(|| {1259		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));12601261		let origin1 = Origin::signed(1);12621263		let data = default_nft_data();1264		create_test_item(collection_id, &data.into());12651266		assert_ok!(TemplateModule::set_public_access_mode(1267			origin1.clone(),1268			collection_id,1269			AccessMode::AllowList1270		));1271		assert_ok!(TemplateModule::add_to_allow_list(1272			origin1.clone(),1273			collection_id,1274			account(1)1275		));1276		assert_ok!(TemplateModule::add_to_allow_list(1277			origin1.clone(),1278			collection_id,1279			account(2)1280		));12811282		// do approve1283		assert_ok!(TemplateModule::approve(1284			origin1.clone(),1285			account(1),1286			collection_id,1287			TokenId(1),1288			11289		));1290		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));12911292		assert_ok!(TemplateModule::remove_from_allow_list(1293			origin1.clone(),1294			collection_id,1295			account(2)1296		));12971298		assert_noop!(1299			TemplateModule::transfer_from(origin1, account(1), account(3), collection_id, TokenId(1), 1),1300			CommonError::<Test>::AddressNotInAllowlist1301		);1302	});1303}13041305// 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)1306#[test]1307fn allow_list_test_5() {1308	new_test_ext().execute_with(|| {1309		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13101311		let origin1 = Origin::signed(1);13121313		let data = default_nft_data();1314		create_test_item(collection_id, &data.into());13151316		assert_ok!(TemplateModule::set_public_access_mode(1317			origin1.clone(),1318			collection_id,1319			AccessMode::AllowList1320		));1321		assert_noop!(1322			TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 5),1323			CommonError::<Test>::AddressNotInAllowlist1324		);1325	});1326}13271328// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1329#[test]1330fn allow_list_test_6() {1331	new_test_ext().execute_with(|| {1332		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13331334		let origin1 = Origin::signed(1);13351336		let data = default_nft_data();1337		create_test_item(collection_id, &data.into());13381339		assert_ok!(TemplateModule::set_public_access_mode(1340			origin1.clone(),1341			collection_id,1342			AccessMode::AllowList1343		));13441345		// do approve1346		assert_noop!(1347			TemplateModule::approve(origin1, account(1), CollectionId(1), TokenId(1), 5),1348			CommonError::<Test>::AddressNotInAllowlist1349		);1350	});1351}13521353// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1354//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1355#[test]1356fn allow_list_test_7() {1357	new_test_ext().execute_with(|| {1358		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13591360		let data = default_nft_data();1361		create_test_item(collection_id, &data.into());13621363		let origin1 = Origin::signed(1);13641365		assert_ok!(TemplateModule::set_public_access_mode(1366			origin1.clone(),1367			collection_id,1368			AccessMode::AllowList1369		));1370		assert_ok!(TemplateModule::add_to_allow_list(1371			origin1.clone(),1372			collection_id,1373			account(1)1374		));1375		assert_ok!(TemplateModule::add_to_allow_list(1376			origin1.clone(),1377			collection_id,1378			account(2)1379		));13801381		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));1382	});1383}13841385#[test]1386fn allow_list_test_8() {1387	new_test_ext().execute_with(|| {1388		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13891390		let data = default_nft_data();1391		create_test_item(collection_id, &data.into());13921393		let origin1 = Origin::signed(1);13941395		assert_ok!(TemplateModule::set_public_access_mode(1396			origin1.clone(),1397			collection_id,1398			AccessMode::AllowList1399		));1400		assert_ok!(TemplateModule::add_to_allow_list(1401			origin1.clone(),1402			collection_id,1403			account(1)1404		));1405		assert_ok!(TemplateModule::add_to_allow_list(1406			origin1.clone(),1407			collection_id,1408			account(2)1409		));14101411		// do approve1412		assert_ok!(TemplateModule::approve(1413			origin1.clone(),1414			account(1),1415			CollectionId(1), 1416			TokenId(1),1417			51418		));1419		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));14201421		assert_ok!(TemplateModule::transfer_from(1422			origin1,1423			account(1),1424			account(2),1425			CollectionId(1), 1426			TokenId(1),1427			11428		));1429	});1430}14311432// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.1433#[test]1434fn allow_list_test_9() {1435	new_test_ext().execute_with(|| {1436		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1437		let origin1 = Origin::signed(1);14381439		assert_ok!(TemplateModule::set_public_access_mode(1440			origin1.clone(),1441			collection_id,1442			AccessMode::AllowList1443		));1444		assert_ok!(TemplateModule::set_mint_permission(1445			origin1,1446			collection_id,1447			false1448		));14491450		let data = default_nft_data();1451		create_test_item(collection_id, &data.into());1452	});1453}14541455// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.1456#[test]1457fn allow_list_test_10() {1458	new_test_ext().execute_with(|| {1459		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14601461		let origin1 = Origin::signed(1);1462		let origin2 = Origin::signed(2);14631464		assert_ok!(TemplateModule::set_public_access_mode(1465			origin1.clone(),1466			collection_id,1467			AccessMode::AllowList1468		));1469		assert_ok!(TemplateModule::set_mint_permission(1470			origin1.clone(),1471			collection_id,1472			false1473		));14741475		assert_ok!(TemplateModule::add_collection_admin(1476			origin1,1477			collection_id,1478			account(2)1479		));14801481		assert_ok!(TemplateModule::create_item(1482			origin2,1483			collection_id,1484			account(2),1485			default_nft_data().into()1486		));1487	});1488}14891490// 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.1491#[test]1492fn allow_list_test_11() {1493	new_test_ext().execute_with(|| {1494		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14951496		let origin1 = Origin::signed(1);1497		let origin2 = Origin::signed(2);14981499		assert_ok!(TemplateModule::set_public_access_mode(1500			origin1.clone(),1501			collection_id,1502			AccessMode::AllowList1503		));1504		assert_ok!(TemplateModule::set_mint_permission(1505			origin1.clone(),1506			collection_id,1507			false1508		));1509		assert_ok!(TemplateModule::add_to_allow_list(1510			origin1,1511			collection_id,1512			account(2)1513		));15141515		assert_noop!(1516			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()),1517			CommonError::<Test>::PublicMintingNotAllowed1518		);1519	});1520}15211522// 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.1523#[test]1524fn allow_list_test_12() {1525	new_test_ext().execute_with(|| {1526		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15271528		let origin1 = Origin::signed(1);1529		let origin2 = Origin::signed(2);15301531		assert_ok!(TemplateModule::set_public_access_mode(1532			origin1.clone(),1533			collection_id,1534			AccessMode::AllowList1535		));1536		assert_ok!(TemplateModule::set_mint_permission(1537			origin1,1538			collection_id,1539			false1540		));15411542		assert_noop!(1543			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()),1544			CommonError::<Test>::PublicMintingNotAllowed1545		);1546	});1547}15481549// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.1550#[test]1551fn allow_list_test_13() {1552	new_test_ext().execute_with(|| {1553		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15541555		let origin1 = Origin::signed(1);15561557		assert_ok!(TemplateModule::set_public_access_mode(1558			origin1.clone(),1559			collection_id,1560			AccessMode::AllowList1561		));1562		assert_ok!(TemplateModule::set_mint_permission(1563			origin1,1564			collection_id,1565			true1566		));15671568		let data = default_nft_data();1569		create_test_item(collection_id, &data.into());1570	});1571}15721573// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.1574#[test]1575fn allow_list_test_14() {1576	new_test_ext().execute_with(|| {1577		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15781579		let origin1 = Origin::signed(1);1580		let origin2 = Origin::signed(2);15811582		assert_ok!(TemplateModule::set_public_access_mode(1583			origin1.clone(),1584			collection_id,1585			AccessMode::AllowList1586		));1587		assert_ok!(TemplateModule::set_mint_permission(1588			origin1.clone(),1589			collection_id,1590			true1591		));15921593		assert_ok!(TemplateModule::add_collection_admin(1594			origin1,1595			collection_id,1596			account(2)1597		));15981599		assert_ok!(TemplateModule::create_item(1600			origin2,1601			collection_id,1602			account(2),1603			default_nft_data().into()1604		));1605	});1606}16071608// 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.1609#[test]1610fn allow_list_test_15() {1611	new_test_ext().execute_with(|| {1612		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16131614		let origin1 = Origin::signed(1);1615		let origin2 = Origin::signed(2);16161617		assert_ok!(TemplateModule::set_public_access_mode(1618			origin1.clone(),1619			collection_id,1620			AccessMode::AllowList1621		));1622		assert_ok!(TemplateModule::set_mint_permission(1623			origin1,1624			collection_id,1625			true1626		));16271628		assert_noop!(1629			TemplateModule::create_item(origin2, collection_id, account(2), default_nft_data().into()),1630			CommonError::<Test>::AddressNotInAllowlist1631		);1632	});1633}16341635// 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.1636#[test]1637fn allow_list_test_16() {1638	new_test_ext().execute_with(|| {1639		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16401641		let origin1 = Origin::signed(1);1642		let origin2 = Origin::signed(2);16431644		assert_ok!(TemplateModule::set_public_access_mode(1645			origin1.clone(),1646			collection_id,1647			AccessMode::AllowList1648		));1649		assert_ok!(TemplateModule::set_mint_permission(1650			origin1.clone(),1651			collection_id,1652			true1653		));1654		assert_ok!(TemplateModule::add_to_allow_list(1655			origin1,1656			collection_id,1657			account(2)1658		));16591660		assert_ok!(TemplateModule::create_item(1661			origin2,1662			collection_id,1663			account(2),1664			default_nft_data().into()1665		));1666	});1667}16681669// Total number of collections. Positive test1670#[test]1671fn total_number_collections_bound() {1672	new_test_ext().execute_with(|| {1673		create_test_collection(&CollectionMode::NFT, CollectionId(1));1674	});1675}16761677// Total number of collections. Negotive test1678#[test]1679fn total_number_collections_bound_neg() {1680	new_test_ext().execute_with(|| {1681		let origin1 = Origin::signed(1);16821683		for i in 0..COLLECTION_NUMBER_LIMIT {1684			create_test_collection(&CollectionMode::NFT, CollectionId(i + 1));1685		}16861687		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1688		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1689		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();16901691		// 11-th collection in chain. Expects error1692		assert_noop!(1693			TemplateModule::create_collection(1694				origin1,1695				col_name1,1696				col_desc1,1697				token_prefix1,1698				CollectionMode::NFT1699			),1700			CommonError::<Test>::TotalCollectionsLimitExceeded1701		);1702	});1703}17041705// Owned tokens by a single address. Positive test1706#[test]1707fn owned_tokens_bound() {1708	new_test_ext().execute_with(|| {1709		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17101711		let data = default_nft_data();1712		create_test_item(collection_id, &data.clone().into());1713		create_test_item(collection_id, &data.into());1714	});1715}17161717// Owned tokens by a single address. Negotive test1718#[test]1719fn owned_tokens_bound_neg() {1720	new_test_ext().execute_with(|| {1721		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17221723		let origin1 = Origin::signed(1);17241725		for _ in 0..MAX_TOKEN_OWNERSHIP {1726			let data = default_nft_data();1727			create_test_item(collection_id, &data.clone().into());1728		}17291730		let data = default_nft_data();1731		assert_noop!(1732			TemplateModule::create_item(origin1, CollectionId(1), account(1), data.into()),1733			CommonError::<Test>::AccountTokenLimitExceeded1734		);1735	});1736}17371738// Number of collection admins. Positive test1739#[test]1740fn collection_admins_bound() {1741	new_test_ext().execute_with(|| {1742		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17431744		let origin1 = Origin::signed(1);17451746		assert_ok!(TemplateModule::add_collection_admin(1747			origin1.clone(),1748			collection_id,1749			account(2)1750		));1751		assert_ok!(TemplateModule::add_collection_admin(1752			origin1,1753			collection_id,1754			account(3)1755		));1756	});1757}17581759// Number of collection admins. Negotive test1760#[test]1761fn collection_admins_bound_neg() {1762	new_test_ext().execute_with(|| {1763		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17641765		let origin1 = Origin::signed(1);17661767		for i in 0..COLLECTION_ADMINS_LIMIT {1768			assert_ok!(TemplateModule::add_collection_admin(1769				origin1.clone(),1770				collection_id,1771				account((2 + i).into())1772			));1773		}1774		assert_noop!(1775			TemplateModule::add_collection_admin(1776				origin1,1777				collection_id,1778				account((3 + COLLECTION_ADMINS_LIMIT).into())1779			),1780			CommonError::<Test>::CollectionAdminCountExceeded1781		);1782	});1783}1784// #endregion17851786#[test]1787fn set_const_on_chain_schema() {1788	new_test_ext().execute_with(|| {1789		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17901791		let origin1 = Origin::signed(1);1792		assert_ok!(TemplateModule::set_const_on_chain_schema(1793			origin1,1794			collection_id,1795			b"test const on chain schema".to_vec()1796		));17971798		assert_eq!(1799			<pallet_common::CollectionById<Test>>::get(collection_id)1800				.unwrap()1801				.const_on_chain_schema,1802			b"test const on chain schema".to_vec()1803		);1804		assert_eq!(1805			<pallet_common::CollectionById<Test>>::get(collection_id)1806				.unwrap()1807				.variable_on_chain_schema,1808			b"".to_vec()1809		);1810	});1811}18121813#[test]1814fn set_variable_on_chain_schema() {1815	new_test_ext().execute_with(|| {1816		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18171818		let origin1 = Origin::signed(1);1819		assert_ok!(TemplateModule::set_variable_on_chain_schema(1820			origin1,1821			collection_id,1822			b"test variable on chain schema".to_vec()1823		));18241825		assert_eq!(1826			<pallet_common::CollectionById<Test>>::get(collection_id)1827				.unwrap()1828				.const_on_chain_schema,1829			b"".to_vec()1830		);1831		assert_eq!(1832			<pallet_common::CollectionById<Test>>::get(collection_id)1833				.unwrap()1834				.variable_on_chain_schema,1835			b"test variable on chain schema".to_vec()1836		);1837	});1838}18391840#[test]1841fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1842	new_test_ext().execute_with(|| {1843		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18441845		let origin1 = Origin::signed(1);18461847		let data = default_nft_data();1848		create_test_item(CollectionId(1), &data.into());18491850		let variable_data = b"test data".to_vec();1851		assert_ok!(TemplateModule::set_variable_meta_data(1852			origin1,1853			collection_id,1854			TokenId(1),1855			variable_data.clone()1856		));18571858		assert_eq!(1859			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))1860				.unwrap()1861				.variable_data,1862			variable_data1863		);1864	});1865}18661867#[test]1868fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1869	new_test_ext().execute_with(|| {1870		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));18711872		let origin1 = Origin::signed(1);18731874		let data = default_re_fungible_data();1875		create_test_item(collection_id, &data.into());18761877		let variable_data = b"test data".to_vec();1878		assert_ok!(TemplateModule::set_variable_meta_data(1879			origin1,1880			collection_id,1881			TokenId(1),1882			variable_data.clone()1883		));18841885		assert_eq!(1886			<pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)))1887				.variable_data,1888			variable_data1889		);1890	});1891}18921893#[test]1894fn set_variable_meta_data_on_fungible_token_fails() {1895	new_test_ext().execute_with(|| {1896		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));18971898		let origin1 = Origin::signed(1);18991900		let data = default_fungible_data();1901		create_test_item(collection_id, &data.into());19021903		let variable_data = b"test data".to_vec();1904		assert_noop!(1905			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data),1906			<pallet_fungible::Error<Test>>::FungibleItemsDontHaveData1907		);1908	});1909}19101911#[test]1912fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1913	new_test_ext().execute_with(|| {1914		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19151916		let origin1 = Origin::signed(1);19171918		let data = default_nft_data();1919		create_test_item(collection_id, &data.into());19201921		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1922		assert_noop!(1923			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data),1924			CommonError::<Test>::TokenVariableDataLimitExceeded1925		);1926	});1927}19281929#[test]1930fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1931	new_test_ext().execute_with(|| {1932		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));19331934		let origin1 = Origin::signed(1);19351936		let data = default_re_fungible_data();1937		create_test_item(collection_id, &data.into());19381939		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();1940		assert_noop!(1941			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data),1942			CommonError::<Test>::TokenVariableDataLimitExceeded1943		);1944	});1945}19461947#[test]1948fn set_variable_meta_data_on_nft_with_item_owner_permission_flag() {1949	new_test_ext().execute_with(|| {1950		//default_limits();19511952		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19531954		let origin1 = Origin::signed(1);19551956		let data = default_nft_data();1957		create_test_item(collection_id, &data.into());19581959		assert_ok!(TemplateModule::set_meta_update_permission_flag(1960			origin1.clone(),1961			collection_id,1962			MetaUpdatePermission::ItemOwner,1963		));19641965		let variable_data = b"ten chars.".to_vec();1966		assert_ok!(TemplateModule::set_variable_meta_data(1967			origin1,1968			collection_id,1969			TokenId(1),1970			variable_data.clone()1971		));19721973		assert_eq!(1974			<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1)))1975				.unwrap()1976				.variable_data,1977			variable_data1978		);1979	});1980}19811982#[test]1983fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() {1984	new_test_ext().execute_with(|| {1985		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));19861987		let origin1 = Origin::signed(1);19881989		assert_ok!(TemplateModule::set_mint_permission(1990			origin1.clone(),1991			collection_id,1992			true1993		));1994		assert_ok!(TemplateModule::add_to_allow_list(1995			origin1.clone(),1996			collection_id,1997			account(1)1998		));19992000		let data = default_nft_data();2001		create_test_item(collection_id, &data.into());20022003		assert_ok!(TemplateModule::set_meta_update_permission_flag(2004			origin1.clone(),2005			collection_id,2006			MetaUpdatePermission::ItemOwner,2007		));20082009		let variable_data = b"1234567890123".to_vec();2010		assert_noop!(2011			TemplateModule::set_variable_meta_data(2012				origin1,2013				collection_id,2014				TokenId(1),2015				variable_data.clone()2016			),2017			CommonError::<Test>::TokenVariableDataLimitExceeded2018		);2019	})2020}20212022#[test]2023fn collection_transfer_flag_works() {2024	new_test_ext().execute_with(|| {2025		let origin1 = Origin::signed(1);20262027		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2028		assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, collection_id, true));20292030		let data = default_nft_data();2031		create_test_item(collection_id, &data.into());2032		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2033		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);20342035		let origin1 = Origin::signed(1);20362037		// default scenario2038		assert_ok!(TemplateModule::transfer(origin1, account(2), collection_id, TokenId(1), 1000));2039		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);2040		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);2041		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);2042		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);2043	});2044}20452046#[test]2047fn set_variable_meta_data_on_nft_with_admin_flag() {2048	new_test_ext().execute_with(|| {2049		// default_limits();20502051		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));20522053		let origin1 = Origin::signed(1);2054		let origin2 = Origin::signed(2);20552056		assert_ok!(TemplateModule::set_mint_permission(2057			origin2.clone(),2058			collection_id,2059			true2060		));2061		assert_ok!(TemplateModule::add_to_allow_list(2062			origin2.clone(),2063			collection_id,2064			account(1)2065		));20662067		assert_ok!(TemplateModule::add_collection_admin(2068			origin2.clone(),2069			collection_id,2070			account(1)2071		));20722073		let data = default_nft_data();2074		create_test_item(collection_id, &data.into());20752076		assert_ok!(TemplateModule::set_meta_update_permission_flag(2077			origin2.clone(),2078			collection_id,2079			MetaUpdatePermission::Admin,2080		));20812082		let variable_data = b"test.".to_vec();2083		assert_ok!(TemplateModule::set_variable_meta_data(2084			origin1,2085			collection_id,2086			TokenId(1),2087			variable_data.clone()2088		));20892090		assert_eq!(2091			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))2092				.unwrap()2093				.variable_data,2094			variable_data2095		);2096	});2097}20982099#[test]2100fn set_variable_meta_data_on_nft_with_admin_flag_neg() {2101	new_test_ext().execute_with(|| {2102		// default_limits();21032104		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));21052106		let origin1 = Origin::signed(1);2107		let origin2 = Origin::signed(2);21082109		assert_ok!(TemplateModule::set_mint_permission(2110			origin2.clone(),2111			collection_id,2112			true2113		));2114		assert_ok!(TemplateModule::add_to_allow_list(2115			origin2.clone(),2116			collection_id,2117			account(1)2118		));21192120		let data = default_nft_data();2121		create_test_item(collection_id, &data.into());21222123		assert_ok!(TemplateModule::set_meta_update_permission_flag(2124			origin2.clone(),2125			collection_id,2126			MetaUpdatePermission::Admin,2127		));21282129		let variable_data = b"test.".to_vec();2130		assert_noop!(2131			TemplateModule::set_variable_meta_data(2132				origin1,2133				collection_id,2134				TokenId(1),2135				variable_data.clone()2136			),2137			CommonError::<Test>::NoPermission2138		);2139	});2140}21412142#[test]2143fn set_variable_meta_flag_after_freeze() {2144	new_test_ext().execute_with(|| {2145		// default_limits();21462147		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));21482149		let origin2 = Origin::signed(2);21502151		assert_ok!(TemplateModule::set_meta_update_permission_flag(2152			origin2.clone(),2153			collection_id,2154			MetaUpdatePermission::None,2155		));2156		assert_noop!(2157			TemplateModule::set_meta_update_permission_flag(2158				origin2.clone(),2159				collection_id,2160				MetaUpdatePermission::Admin2161			),2162			CommonError::<Test>::MetadataFlagFrozen2163		);2164	});2165}21662167#[test]2168fn set_variable_meta_data_on_nft_with_none_flag_neg() {2169	new_test_ext().execute_with(|| {2170		// default_limits();21712172		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));2173		let origin1 = Origin::signed(1);21742175		let data = default_nft_data();2176		create_test_item(collection_id, &data.into());21772178		assert_ok!(TemplateModule::set_meta_update_permission_flag(2179			origin1.clone(),2180			collection_id,2181			MetaUpdatePermission::None,2182		));21832184		let variable_data = b"test.".to_vec();2185		assert_noop!(2186			TemplateModule::set_variable_meta_data(2187				origin1.clone(),2188				collection_id,2189				TokenId(1),2190				variable_data.clone()2191			),2192			CommonError::<Test>::NoPermission2193		);2194	});2195}21962197#[test]2198fn collection_transfer_flag_works_neg() {2199	new_test_ext().execute_with(|| {2200		let origin1 = Origin::signed(1);22012202		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2203		assert_ok!(TemplateModule::set_transfers_enabled_flag(2204			origin1, collection_id, false2205		));22062207		let data = default_nft_data();2208		create_test_item(collection_id, &data.into());2209		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2210		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);22112212		let origin1 = Origin::signed(1);22132214		// default scenario2215		assert_noop!(2216			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1000),2217			CommonError::<Test>::TransferNotAllowed2218		);2219		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2220		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 0);2221		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);2222		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), false);2223	});2224}