git.delta.rocks / unique-network / refs/commits / 8a37f3ec9fdf

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, CollectionMode};5use up_data_structs::{6	COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, 7	CreateNftData, CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, 8	MetaUpdatePermission, TokenId,9};10use frame_support::{assert_noop, assert_ok};11use sp_std::convert::TryInto;1213fn default_nft_data() -> CreateNftData {14	CreateNftData {15		const_data: vec![1, 2, 3].try_into().unwrap(),16		variable_data: vec![3, 2, 1].try_into().unwrap(),17	}18}1920fn default_fungible_data() -> CreateFungibleData {21	CreateFungibleData { value: 5 }22}2324fn default_re_fungible_data() -> CreateReFungibleData {25	CreateReFungibleData {26		const_data: vec![1, 2, 3].try_into().unwrap(),27		variable_data: vec![3, 2, 1].try_into().unwrap(),28		pieces: 1023,29	}30}3132fn create_test_collection_for_owner(33	mode: &CollectionMode,34	owner: u64,35	id: CollectionId,36) -> CollectionId {37	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();38	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();39	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4041	let origin1 = Origin::signed(owner);42	assert_ok!(TemplateModule::create_collection(43		origin1,44		col_name1,45		col_desc1,46		token_prefix1,47		mode.clone()48	));4950	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();51	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();52	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();53	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().owner, owner);54	assert_eq!(55		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,56		saved_col_name57	);58	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().mode, *mode);59	assert_eq!(60		<pallet_common::CollectionById<Test>>::get(id).unwrap().description,61		saved_description62	);63	assert_eq!(64		<pallet_common::CollectionById<Test>>::get(id).unwrap().token_prefix,65		saved_prefix66	);67	id68}6970fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {71	create_test_collection_for_owner(&mode, 1, id)72}7374fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {75	let origin1 = Origin::signed(1);76	assert_ok!(TemplateModule::create_item(77		origin1,78		collection_id,79		account(1),80		data.clone()81	));82}8384fn account(sub: u64) -> TestCrossAccountId {85	TestCrossAccountId::from_sub(sub)86}8788// Use cases tests region89// #region9091#[test]92fn set_version_schema() {93	new_test_ext().execute_with(|| {94		let origin1 = Origin::signed(1);95		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));9697		assert_ok!(TemplateModule::set_schema_version(98			origin1,99			collection_id,100			SchemaVersion::Unique101		));102		assert_eq!(103			<pallet_common::CollectionById<Test>>::get(collection_id)104				.unwrap()105				.schema_version,106			SchemaVersion::Unique107		);108	});109}110111#[test]112fn create_fungible_collection_fails_with_large_decimal_numbers() {113	new_test_ext().execute_with(|| {114		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();115		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();116		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();117118		let origin1 = Origin::signed(1);119		assert_noop!(120			TemplateModule::create_collection(121				origin1,122				col_name1,123				col_desc1,124				token_prefix1,125				CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)126			),127			Error::<Test>::CollectionDecimalPointLimitExceeded128		);129	});130}131132#[test]133fn create_nft_item() {134	new_test_ext().execute_with(|| {135		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));136137		let data = default_nft_data();138		create_test_item(collection_id, &data.clone().into());139140		let item = <pallet_nonfungible::TokenData<Test>>::get((collection_id, 1)).unwrap();141		assert_eq!(item.const_data, data.const_data.into_inner());142		assert_eq!(item.variable_data, data.variable_data.into_inner());143	});144}145146// Use cases tests region147// #region148#[test]149fn create_nft_multiple_items() {150	new_test_ext().execute_with(|| {151		create_test_collection(&CollectionMode::NFT, CollectionId(1));152153		let origin1 = Origin::signed(1);154155		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];156157		assert_ok!(TemplateModule::create_multiple_items(158			origin1,159			CollectionId(1),160			account(1),161			items_data162				.clone()163				.into_iter()164				.map(|d| { d.into() })165				.collect()166		));167		for (index, data) in items_data.into_iter().enumerate() {168			let item = <pallet_nonfungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32))).unwrap();169			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());170			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());171		}172	});173}174175#[test]176fn create_refungible_item() {177	new_test_ext().execute_with(|| {178		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));179180		let data = default_re_fungible_data();181		create_test_item(collection_id, &data.clone().into());182		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));183		let balance = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));184		assert_eq!(item.const_data, data.const_data.into_inner());185		assert_eq!(item.variable_data, data.variable_data.into_inner());186		assert_eq!(balance, 1023);187	});188}189190#[test]191fn create_multiple_refungible_items() {192	new_test_ext().execute_with(|| {193		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));194195		let origin1 = Origin::signed(1);196197		let items_data = vec![198			default_re_fungible_data(),199			default_re_fungible_data(),200			default_re_fungible_data(),201		];202203		assert_ok!(TemplateModule::create_multiple_items(204			origin1,205			CollectionId(1),206			account(1),207			items_data208				.clone()209				.into_iter()210				.map(|d| { d.into() })211				.collect()212		));213		for (index, data) in items_data.into_iter().enumerate() {214			let item = <pallet_refungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32)));215			let balance = <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));216			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());217			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());218			assert_eq!(balance, 1023);219		}220	});221}222223#[test]224fn create_fungible_item() {225	new_test_ext().execute_with(|| {226		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));227228		let data = default_fungible_data();229		create_test_item(collection_id, &data.into());230231		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);232	});233}234235//#[test]236// fn create_multiple_fungible_items() {237//     new_test_ext().execute_with(|| {238//         default_limits();239240//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));241242//         let origin1 = Origin::signed(1);243244//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];245246//         assert_ok!(TemplateModule::create_multiple_items(247//             origin1.clone(),248//             1,249//             1,250//             items_data.clone().into_iter().map(|d| { d.into() }).collect()251//         ));252253//         for (index, _) in items_data.iter().enumerate() {254//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);255//         }256//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);257//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);258//     });259// }260261#[test]262fn transfer_fungible_item() {263	new_test_ext().execute_with(|| {264		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));265266		let origin1 = Origin::signed(1);267		let origin2 = Origin::signed(2);268269		let data = default_fungible_data();270		create_test_item(collection_id, &data.into());271272		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 5);273274		// change owner scenario275		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(0), 5));276		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 0);277278		// split item scenario279		assert_ok!(TemplateModule::transfer(280			origin2.clone(),281			account(3),282			CollectionId(1),283			TokenId(0),284			3285		));286287		// split item and new owner has account scenario288		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(0), 1));289		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))), 1);290		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))), 4);291	});292}293294#[test]295fn transfer_refungible_item() {296	new_test_ext().execute_with(|| {297		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));298299		// Create RFT 1 in 1023 pieces for account 1300		let data = default_re_fungible_data();301		create_test_item(collection_id, &data.clone().into());302		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));303		assert_eq!(item.const_data, data.const_data.into_inner());304		assert_eq!(item.variable_data, data.variable_data.into_inner());305		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);306		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);307		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);308309		// Account 1 transfers all 1023 pieces of RFT 1 to account 2310		let origin1 = Origin::signed(1);311		let origin2 = Origin::signed(2);312		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1023));313		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 1023);314		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);315		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);316		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);317		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);318319		// Account 2 transfers 500 pieces of RFT 1 to account 3320		assert_ok!(TemplateModule::transfer(321			origin2.clone(),322			account(3),323			CollectionId(1),324			TokenId(1),325			500326		));327		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 523);328		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 500);329		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);330		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);331		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);332		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);333334		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance335		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(1), 200));336		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 323);337		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 700);338		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);339		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);340		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);341		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);342	});343}344345#[test]346fn transfer_nft_item() {347	new_test_ext().execute_with(|| {348		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));349350		let data = default_nft_data();351		create_test_item(collection_id, &data.into());352		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);353		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);354355356		let origin1 = Origin::signed(1);357		// default scenario358		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));359		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);360		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);361		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);362		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);363	});364}365366#[test]367fn transfer_nft_item_wrong_value() {368	new_test_ext().execute_with(|| {369		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));370371		let data = default_nft_data();372		create_test_item(collection_id, &data.into());373		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);374		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);375376		let origin1 = Origin::signed(1);377378		assert_noop!(379			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2).map_err(|e| e.error),380			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount381		);382	});383}384385#[test]386fn transfer_nft_item_zero_value() {387	new_test_ext().execute_with(|| {388		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));389390		let data = default_nft_data();391		create_test_item(collection_id, &data.into());392		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);393		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);394395		let origin1 = Origin::signed(1);396397		// Transferring 0 amount works on NFT...398		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 0));399		// ... and results in no transfer400		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);401		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);402	});403}404405#[test]406fn nft_approve_and_transfer_from() {407	new_test_ext().execute_with(|| {408		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));409410		let data = default_nft_data();411		create_test_item(collection_id, &data.into());412413		let origin1 = Origin::signed(1);414		let origin2 = Origin::signed(2);415416		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);417		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);418419		// neg transfer_from420		assert_noop!(421			TemplateModule::transfer_from(origin2.clone(), account(1), account(2), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),422			CommonError::<Test>::TokenValueNotEnough423		);424425		// do approve426		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));427		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));428429		assert_ok!(TemplateModule::transfer_from(430			origin2,431			account(1),432			account(3),433			CollectionId(1),434			TokenId(1),435			1436		));437		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());438	});439}440441#[test]442fn nft_approve_and_transfer_from_allow_list() {443	new_test_ext().execute_with(|| {444		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));445446		let origin1 = Origin::signed(1);447		let origin2 = Origin::signed(2);448449		// Create NFT 1 for account 1450		let data = default_nft_data();451		create_test_item(collection_id, &data.clone().into());452		assert_eq!(453			&<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1))).unwrap().const_data,454			&data.const_data.into_inner()455		);456		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);457		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);458459		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list460		assert_ok!(TemplateModule::set_mint_permission(461			origin1.clone(),462			CollectionId(1),463			true464		));465		assert_ok!(TemplateModule::set_public_access_mode(466			origin1.clone(),467			CollectionId(1),468			AccessMode::AllowList469		));470		assert_ok!(TemplateModule::add_to_allow_list(471			origin1.clone(),472			CollectionId(1),473			account(1)474		));475		assert_ok!(TemplateModule::add_to_allow_list(476			origin1.clone(),477			CollectionId(1),478			account(2)479		));480		assert_ok!(TemplateModule::add_to_allow_list(481			origin1.clone(),482			CollectionId(1),483			account(3)484		));485486		// Account 1 approves account 2 for NFT 1 487		assert_ok!(TemplateModule::approve(488			origin1.clone(),489			account(2),490			CollectionId(1),491			TokenId(1),492			1493		));494		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));495496		// Account 2 transfers NFT 1 from account 1 to account 3497		assert_ok!(TemplateModule::transfer_from(498			origin2,499			account(1),500			account(3),501			CollectionId(1),502			TokenId(1),503			1504		));505		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());506	});507}508509#[test]510fn refungible_approve_and_transfer_from() {511	new_test_ext().execute_with(|| {512		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));513514		let origin1 = Origin::signed(1);515		let origin2 = Origin::signed(2);516517		// Create RFT 1 in 1023 pieces for account 1518		let data = default_re_fungible_data();519		create_test_item(collection_id, &data.into());520521		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);522		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);523		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);524525		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list526		assert_ok!(TemplateModule::set_mint_permission(527			origin1.clone(),528			CollectionId(1),529			true530		));531		assert_ok!(TemplateModule::set_public_access_mode(532			origin1.clone(),533			CollectionId(1),534			AccessMode::AllowList535		));536		assert_ok!(TemplateModule::add_to_allow_list(537			origin1.clone(),538			CollectionId(1),539			account(1)540		));541		assert_ok!(TemplateModule::add_to_allow_list(542			origin1.clone(),543			CollectionId(1),544			account(2)545		));546		assert_ok!(TemplateModule::add_to_allow_list(547			origin1.clone(),548			CollectionId(1),549			account(3)550		));551552		// Account 1 approves account 2 for 1023 pieces of RFT 1553		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1023));554		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 1023);555556		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3557		assert_ok!(TemplateModule::transfer_from(558			origin2,559			account(1),560			account(3),561			CollectionId(1),562			TokenId(1),563			100564		));565		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);566		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);567		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 923);568		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 100);569		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);570		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);571		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 923);572	});573}574575#[test]576fn fungible_approve_and_transfer_from() {577	new_test_ext().execute_with(|| {578		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));579580		let data = default_fungible_data();581		create_test_item(collection_id, &data.into());582583		let origin1 = Origin::signed(1);584		let origin2 = Origin::signed(2);585586		assert_ok!(TemplateModule::set_mint_permission(587			origin1.clone(),588			CollectionId(1),589			true590		));591		assert_ok!(TemplateModule::set_public_access_mode(592			origin1.clone(),593			CollectionId(1),594			AccessMode::AllowList595		));596		assert_ok!(TemplateModule::add_to_allow_list(597			origin1.clone(),598			CollectionId(1),599			account(1)600		));601		assert_ok!(TemplateModule::add_to_allow_list(602			origin1.clone(),603			CollectionId(1),604			account(2)605		));606		assert_ok!(TemplateModule::add_to_allow_list(607			origin1.clone(),608			CollectionId(1),609			account(3)610		));611612		// do approve613		assert_ok!(TemplateModule::approve(614			origin1.clone(),615			account(2),616			CollectionId(1),617			TokenId(0),618			5619		));620		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);621		assert_ok!(TemplateModule::approve(origin1, account(3), CollectionId(1), TokenId(0), 5));622		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);623		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))), 5);624625		assert_ok!(TemplateModule::transfer_from(626			origin2.clone(),627			account(1),628			account(3),629			CollectionId(1),630			TokenId(0),631			4632		));633634		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 1);635636		assert_noop!(637			TemplateModule::transfer_from(origin2, account(1), account(3), CollectionId(1), TokenId(0), 4).map_err(|e| e.error),638			CommonError::<Test>::TokenValueNotEnough639		);640	});641}642643#[test]644fn change_collection_owner() {645	new_test_ext().execute_with(|| {646		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));647648		let origin1 = Origin::signed(1);649		assert_ok!(TemplateModule::change_collection_owner(650			origin1,651			collection_id,652			2653		));654		assert_eq!(655			<pallet_common::CollectionById<Test>>::get(collection_id).unwrap().owner,656			2657		);658	});659}660661#[test]662fn destroy_collection() {663	new_test_ext().execute_with(|| {664		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));665666		let origin1 = Origin::signed(1);667		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));668	});669}670671#[test]672fn burn_nft_item() {673	new_test_ext().execute_with(|| {674		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));675676		let origin1 = Origin::signed(1);677678		let data = default_nft_data();679		create_test_item(collection_id, &data.into());680681		// check balance (collection with id = 1, user id = 1)682		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);683684		// burn item685		assert_ok!(TemplateModule::burn_item(686			origin1.clone(),687			collection_id,688			TokenId(1),689			1690		));691		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);692	});693}694695#[test]696fn burn_same_nft_item_twice() {697	new_test_ext().execute_with(|| {698		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));699700		let origin1 = Origin::signed(1);701702		let data = default_nft_data();703		create_test_item(collection_id, &data.into());704705		// check balance (collection with id = 1, user id = 1)706		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);707708		// burn item709		assert_ok!(TemplateModule::burn_item(710			origin1.clone(),711			collection_id,712			TokenId(1),713			1714		));715		716		// burn item again717		assert_noop!(718			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),719			CommonError::<Test>::TokenNotFound720		);721722		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);723	});724}725726#[test]727fn burn_fungible_item() {728	new_test_ext().execute_with(|| {729		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));730731		let origin1 = Origin::signed(1);732		assert_ok!(TemplateModule::add_collection_admin(733			origin1.clone(),734			collection_id,735			account(2)736		));737738		let data = default_fungible_data();739		create_test_item(collection_id, &data.into());740741		// check balance (collection with id = 1, user id = 1)742		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);743744		// burn item745		assert_ok!(TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(0), 5));746		assert_noop!(747			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),748			CommonError::<Test>::TokenValueTooLow749		);750751		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 0);752	});753}754755#[test]756fn burn_fungible_item_with_token_id() {757	new_test_ext().execute_with(|| {758		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));759760		let origin1 = Origin::signed(1);761		assert_ok!(TemplateModule::add_collection_admin(762			origin1.clone(),763			collection_id,764			account(2)765		));766767		let data = default_fungible_data();768		create_test_item(collection_id, &data.into());769770		// check balance (collection with id = 1, user id = 1)771		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);772773		// Try to burn item using Token ID774		assert_noop!(775			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),776			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId777		);778	});779}780#[test]781fn burn_refungible_item() {782	new_test_ext().execute_with(|| {783		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));784		let origin1 = Origin::signed(1);785786		assert_ok!(TemplateModule::set_mint_permission(787			origin1.clone(),788			collection_id,789			true790		));791		assert_ok!(TemplateModule::set_public_access_mode(792			origin1.clone(),793			collection_id,794			AccessMode::AllowList795		));796		assert_ok!(TemplateModule::add_to_allow_list(797			origin1.clone(),798			collection_id,799			account(1)800		));801802		assert_ok!(TemplateModule::add_collection_admin(803			origin1.clone(),804			collection_id,805			account(2)806		));807808		let data = default_re_fungible_data();809		create_test_item(collection_id, &data.into());810811		// check balance (collection with id = 1, user id = 2)812		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);813		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);814815		// burn item816		assert_ok!(TemplateModule::burn_item(origin1.clone(), collection_id, TokenId(1), 1023));817		assert_noop!(818			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),819			CommonError::<Test>::TokenValueTooLow820		);821822		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 0);823	});824}825826#[test]827fn add_collection_admin() {828	new_test_ext().execute_with(|| {829		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));830		let origin1 = Origin::signed(1);831832		// Add collection admins833		assert_ok!(TemplateModule::add_collection_admin(834			origin1.clone(),835			collection1_id,836			account(2)837		));838		assert_ok!(TemplateModule::add_collection_admin(839			origin1,840			collection1_id,841			account(3)842		));843844		// Owner is not an admin by default845		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))), false);846		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));847		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));848	});849}850851#[test]852fn remove_collection_admin() {853	new_test_ext().execute_with(|| {854		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));855		let origin1 = Origin::signed(1);856		let origin2 = Origin::signed(2);857858		// Add collection admins 2 and 3859		assert_ok!(TemplateModule::add_collection_admin(860			origin1.clone(),861			collection1_id,862			account(2)863		));864		assert_ok!(TemplateModule::add_collection_admin(865			origin1,866			collection1_id,867			account(3)868		));869870		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));871		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));872873		// remove admin 3874		assert_ok!(TemplateModule::remove_collection_admin(875			origin2,876			CollectionId(1),877			account(3)878		));879880		// 2 is still admin, 3 is not an admin anymore881		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));882		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))), false);883	});884}885886#[test]887fn balance_of() {888	new_test_ext().execute_with(|| {889		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));890		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));891		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(3));892893		// check balance before894		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 0);895		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 0);896		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 0);897898		let nft_data = default_nft_data();899		create_test_item(nft_collection_id, &nft_data.into());900901		let fungible_data = default_fungible_data();902		create_test_item(fungible_collection_id, &fungible_data.into());903904		let re_fungible_data = default_re_fungible_data();905		create_test_item(re_fungible_collection_id, &re_fungible_data.into());906907		// check balance (collection with id = 1, user id = 1)908		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 1);909		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 5);910		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 1);911912		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))), true);913		assert_eq!(<pallet_refungible::Owned<Test>>::get((re_fungible_collection_id, account(1), TokenId(1))), true);914	});915}916917#[test]918fn approve() {919	new_test_ext().execute_with(|| {920		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));921922		let data = default_nft_data();923		create_test_item(collection_id, &data.into());924925		let origin1 = Origin::signed(1);926927		// approve928		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));929		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));930	});931}932933#[test]934fn transfer_from() {935	new_test_ext().execute_with(|| {936		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));937		let origin1 = Origin::signed(1);938		let origin2 = Origin::signed(2);939940		let data = default_nft_data();941		create_test_item(collection_id, &data.into());942943		// approve944		assert_ok!(TemplateModule::approve(945			origin1.clone(),946			account(2),947			CollectionId(1),948			TokenId(1),949			1950		));951		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));952953		assert_ok!(TemplateModule::set_mint_permission(954			origin1.clone(),955			CollectionId(1),956			true957		));958		assert_ok!(TemplateModule::set_public_access_mode(959			origin1.clone(),960			CollectionId(1),961			AccessMode::AllowList962		));963		assert_ok!(TemplateModule::add_to_allow_list(964			origin1.clone(),965			CollectionId(1),966			account(1)967		));968		assert_ok!(TemplateModule::add_to_allow_list(969			origin1.clone(),970			CollectionId(1),971			account(2)972		));973		assert_ok!(TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(3)));974975		assert_ok!(TemplateModule::transfer_from(976			origin2,977			account(1),978			account(2),979			CollectionId(1),980			TokenId(1),981			1982		));983984		// after transfer985		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))), 0);986		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))), 1);987	});988}989990// #endregion991992// Coverage tests region993// #region994995#[test]996fn owner_can_add_address_to_allow_list() {997	new_test_ext().execute_with(|| {998		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));9991000		let origin1 = Origin::signed(1);1001		assert_ok!(TemplateModule::add_to_allow_list(1002			origin1,1003			collection_id,1004			account(2)1005		));1006		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1007	});1008}10091010#[test]1011fn admin_can_add_address_to_allow_list() {1012	new_test_ext().execute_with(|| {1013		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1014		let origin1 = Origin::signed(1);1015		let origin2 = Origin::signed(2);10161017		assert_ok!(TemplateModule::add_collection_admin(1018			origin1,1019			collection_id,1020			account(2)1021		));1022		assert_ok!(TemplateModule::add_to_allow_list(1023			origin2,1024			collection_id,1025			account(3)1026		));1027		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))));1028	});1029}10301031#[test]1032fn nonprivileged_user_cannot_add_address_to_allow_list() {1033	new_test_ext().execute_with(|| {1034		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10351036		let origin2 = Origin::signed(2);1037		assert_noop!(1038			TemplateModule::add_to_allow_list(origin2, collection_id, account(3)),1039			CommonError::<Test>::NoPermission1040		);1041	});1042}10431044#[test]1045fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1046	new_test_ext().execute_with(|| {1047		let origin1 = Origin::signed(1);10481049		assert_noop!(1050			TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(2)),1051			CommonError::<Test>::CollectionNotFound1052		);1053	});1054}10551056#[test]1057fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1058	new_test_ext().execute_with(|| {1059		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10601061		let origin1 = Origin::signed(1);1062		assert_ok!(TemplateModule::destroy_collection(1063			origin1.clone(),1064			collection_id1065		));1066		assert_noop!(1067			TemplateModule::add_to_allow_list(origin1, collection_id, account(2)),1068			CommonError::<Test>::CollectionNotFound1069		);1070	});1071}10721073// If address is already added to allow list, nothing happens1074#[test]1075fn address_is_already_added_to_allow_list() {1076	new_test_ext().execute_with(|| {1077		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1078		let origin1 = Origin::signed(1);10791080		assert_ok!(TemplateModule::add_to_allow_list(1081			origin1.clone(),1082			collection_id,1083			account(2)1084		));1085		assert_ok!(TemplateModule::add_to_allow_list(1086			origin1,1087			collection_id,1088			account(2)1089		));1090		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1091	});1092}10931094#[test]1095fn owner_can_remove_address_from_allow_list() {1096	new_test_ext().execute_with(|| {1097		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10981099		let origin1 = Origin::signed(1);1100		assert_ok!(TemplateModule::add_to_allow_list(1101			origin1.clone(),1102			collection_id,1103			account(2)1104		));1105		assert_ok!(TemplateModule::remove_from_allow_list(1106			origin1,1107			collection_id,1108			account(2)1109		));1110		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1111	});1112}11131114#[test]1115fn admin_can_remove_address_from_allow_list() {1116	new_test_ext().execute_with(|| {1117		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1118		let origin1 = Origin::signed(1);1119		let origin2 = Origin::signed(2);11201121		// Owner adds admin1122		assert_ok!(TemplateModule::add_collection_admin(1123			origin1.clone(),1124			collection_id,1125			account(2)1126		));11271128		// Owner adds address 3 to allow list1129		assert_ok!(TemplateModule::add_to_allow_list(1130			origin1,1131			collection_id,1132			account(3)1133		));11341135		// Admin removes address 3 from allow list1136		assert_ok!(TemplateModule::remove_from_allow_list(1137			origin2,1138			collection_id,1139			account(3)1140		));1141		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))), false);1142	});1143}11441145#[test]1146fn nonprivileged_user_cannot_remove_address_from_allow_list() {1147	new_test_ext().execute_with(|| {1148		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1149		let origin1 = Origin::signed(1);1150		let origin2 = Origin::signed(2);11511152		assert_ok!(TemplateModule::add_to_allow_list(1153			origin1,1154			collection_id,1155			account(2)1156		));1157		assert_noop!(1158			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1159			CommonError::<Test>::NoPermission1160		);1161		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1162	});1163}11641165#[test]1166fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1167	new_test_ext().execute_with(|| {1168		let origin1 = Origin::signed(1);11691170		assert_noop!(1171			TemplateModule::remove_from_allow_list(origin1, CollectionId(1), account(2)),1172			CommonError::<Test>::CollectionNotFound1173		);1174	});1175}11761177#[test]1178fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1179	new_test_ext().execute_with(|| {1180		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1181		let origin1 = Origin::signed(1);1182		let origin2 = Origin::signed(2);11831184		// Add account 2 to allow list1185		assert_ok!(TemplateModule::add_to_allow_list(1186			origin1.clone(),1187			collection_id,1188			account(2)1189		));11901191		// Account 2 is in collection allow-list1192		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));11931194		// Destroy collection1195		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));11961197		// Attempt to remove account 2 from collection allow-list => error1198		assert_noop!(1199			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1200			CommonError::<Test>::CollectionNotFound1201		);12021203		// Account 2 is not found in collection allow-list anyway1204		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1205	});1206}12071208// If address is already removed from allow list, nothing happens1209#[test]1210fn address_is_already_removed_from_allow_list() {1211	new_test_ext().execute_with(|| {1212		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1213		let origin1 = Origin::signed(1);12141215		assert_ok!(TemplateModule::add_to_allow_list(1216			origin1.clone(),1217			collection_id,1218			account(2)1219		));1220		assert_ok!(TemplateModule::remove_from_allow_list(1221			origin1.clone(),1222			collection_id,1223			account(2)1224		));1225		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1226		assert_ok!(TemplateModule::remove_from_allow_list(1227			origin1,1228			collection_id,1229			account(2)1230		));1231		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1232	});1233}12341235// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1236#[test]1237fn allow_list_test_1() {1238	new_test_ext().execute_with(|| {1239		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));12401241		let origin1 = Origin::signed(1);12421243		let data = default_nft_data();1244		create_test_item(collection_id, &data.into());12451246		assert_ok!(TemplateModule::set_public_access_mode(1247			origin1.clone(),1248			collection_id,1249			AccessMode::AllowList1250		));1251		assert_ok!(TemplateModule::add_to_allow_list(1252			origin1.clone(),1253			collection_id,1254			account(2)1255		));12561257		assert_noop!(1258			TemplateModule::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1259			CommonError::<Test>::AddressNotInAllowlist1260		);1261	});1262}12631264#[test]1265fn allow_list_test_2() {1266	new_test_ext().execute_with(|| {1267		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1268		let origin1 = Origin::signed(1);12691270		let data = default_nft_data();1271		create_test_item(collection_id, &data.into());12721273		assert_ok!(TemplateModule::set_public_access_mode(1274			origin1.clone(),1275			collection_id,1276			AccessMode::AllowList1277		));1278		assert_ok!(TemplateModule::add_to_allow_list(1279			origin1.clone(),1280			collection_id,1281			account(1)1282		));1283		assert_ok!(TemplateModule::add_to_allow_list(1284			origin1.clone(),1285			collection_id,1286			account(2)1287		));12881289		// do approve1290		assert_ok!(TemplateModule::approve(1291			origin1.clone(),1292			account(1),1293			collection_id,1294			TokenId(1),1295			11296		));1297		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));12981299		assert_ok!(TemplateModule::remove_from_allow_list(1300			origin1.clone(),1301			collection_id,1302			account(1)1303		));13041305		assert_noop!(1306			TemplateModule::transfer_from(origin1, account(1), account(3), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1307			CommonError::<Test>::AddressNotInAllowlist1308		);1309	});1310}13111312// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1313#[test]1314fn allow_list_test_3() {1315	new_test_ext().execute_with(|| {1316		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13171318		let origin1 = Origin::signed(1);13191320		let data = default_nft_data();1321		create_test_item(collection_id, &data.into());13221323		assert_ok!(TemplateModule::set_public_access_mode(1324			origin1.clone(),1325			collection_id,1326			AccessMode::AllowList1327		));1328		assert_ok!(TemplateModule::add_to_allow_list(1329			origin1.clone(),1330			collection_id,1331			account(1)1332		));13331334		assert_noop!(1335			TemplateModule::transfer(origin1, account(3), collection_id, TokenId(1), 1).map_err(|e| e.error),1336			CommonError::<Test>::AddressNotInAllowlist1337		);1338	});1339}13401341#[test]1342fn allow_list_test_4() {1343	new_test_ext().execute_with(|| {1344		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13451346		let origin1 = Origin::signed(1);13471348		let data = default_nft_data();1349		create_test_item(collection_id, &data.into());13501351		assert_ok!(TemplateModule::set_public_access_mode(1352			origin1.clone(),1353			collection_id,1354			AccessMode::AllowList1355		));1356		assert_ok!(TemplateModule::add_to_allow_list(1357			origin1.clone(),1358			collection_id,1359			account(1)1360		));1361		assert_ok!(TemplateModule::add_to_allow_list(1362			origin1.clone(),1363			collection_id,1364			account(2)1365		));13661367		// do approve1368		assert_ok!(TemplateModule::approve(1369			origin1.clone(),1370			account(1),1371			collection_id,1372			TokenId(1),1373			11374		));1375		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));13761377		assert_ok!(TemplateModule::remove_from_allow_list(1378			origin1.clone(),1379			collection_id,1380			account(2)1381		));13821383		assert_noop!(1384			TemplateModule::transfer_from(origin1, account(1), account(3), collection_id, TokenId(1), 1).map_err(|e| e.error),1385			CommonError::<Test>::AddressNotInAllowlist1386		);1387	});1388}13891390// 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)1391#[test]1392fn allow_list_test_5() {1393	new_test_ext().execute_with(|| {1394		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13951396		let origin1 = Origin::signed(1);13971398		let data = default_nft_data();1399		create_test_item(collection_id, &data.into());14001401		assert_ok!(TemplateModule::set_public_access_mode(1402			origin1.clone(),1403			collection_id,1404			AccessMode::AllowList1405		));1406		assert_noop!(1407			TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1408			CommonError::<Test>::AddressNotInAllowlist1409		);1410	});1411}14121413// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1414#[test]1415fn allow_list_test_6() {1416	new_test_ext().execute_with(|| {1417		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14181419		let origin1 = Origin::signed(1);14201421		let data = default_nft_data();1422		create_test_item(collection_id, &data.into());14231424		assert_ok!(TemplateModule::set_public_access_mode(1425			origin1.clone(),1426			collection_id,1427			AccessMode::AllowList1428		));14291430		// do approve1431		assert_noop!(1432			TemplateModule::approve(origin1, account(1), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1433			CommonError::<Test>::AddressNotInAllowlist1434		);1435	});1436}14371438// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1439//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1440#[test]1441fn allow_list_test_7() {1442	new_test_ext().execute_with(|| {1443		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14441445		let data = default_nft_data();1446		create_test_item(collection_id, &data.into());14471448		let origin1 = Origin::signed(1);14491450		assert_ok!(TemplateModule::set_public_access_mode(1451			origin1.clone(),1452			collection_id,1453			AccessMode::AllowList1454		));1455		assert_ok!(TemplateModule::add_to_allow_list(1456			origin1.clone(),1457			collection_id,1458			account(1)1459		));1460		assert_ok!(TemplateModule::add_to_allow_list(1461			origin1.clone(),1462			collection_id,1463			account(2)1464		));14651466		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));1467	});1468}14691470#[test]1471fn allow_list_test_8() {1472	new_test_ext().execute_with(|| {1473		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14741475		// Create NFT for account 11476		let data = default_nft_data();1477		create_test_item(collection_id, &data.into());14781479		let origin1 = Origin::signed(1);14801481		// Toggle Allow List mode and add accounts 1 and 21482		assert_ok!(TemplateModule::set_public_access_mode(1483			origin1.clone(),1484			collection_id,1485			AccessMode::AllowList1486		));1487		assert_ok!(TemplateModule::add_to_allow_list(1488			origin1.clone(),1489			collection_id,1490			account(1)1491		));1492		assert_ok!(TemplateModule::add_to_allow_list(1493			origin1.clone(),1494			collection_id,1495			account(2)1496		));14971498		// Sself-approve account 1 for NFT 11499		assert_ok!(TemplateModule::approve(1500			origin1.clone(),1501			account(1),1502			CollectionId(1), 1503			TokenId(1),1504			11505		));1506		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));15071508		// Transfer from 1 to 21509		assert_ok!(TemplateModule::transfer_from(1510			origin1,1511			account(1),1512			account(2),1513			CollectionId(1), 1514			TokenId(1),1515			11516		));1517	});1518}15191520// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.1521#[test]1522fn allow_list_test_9() {1523	new_test_ext().execute_with(|| {1524		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1525		let origin1 = Origin::signed(1);15261527		assert_ok!(TemplateModule::set_public_access_mode(1528			origin1.clone(),1529			collection_id,1530			AccessMode::AllowList1531		));1532		assert_ok!(TemplateModule::set_mint_permission(1533			origin1,1534			collection_id,1535			false1536		));15371538		let data = default_nft_data();1539		create_test_item(collection_id, &data.into());1540	});1541}15421543// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.1544#[test]1545fn allow_list_test_10() {1546	new_test_ext().execute_with(|| {1547		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15481549		let origin1 = Origin::signed(1);1550		let origin2 = Origin::signed(2);15511552		assert_ok!(TemplateModule::set_public_access_mode(1553			origin1.clone(),1554			collection_id,1555			AccessMode::AllowList1556		));1557		assert_ok!(TemplateModule::set_mint_permission(1558			origin1.clone(),1559			collection_id,1560			false1561		));15621563		assert_ok!(TemplateModule::add_collection_admin(1564			origin1,1565			collection_id,1566			account(2)1567		));15681569		assert_ok!(TemplateModule::create_item(1570			origin2,1571			collection_id,1572			account(2),1573			default_nft_data().into()1574		));1575	});1576}15771578// 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.1579#[test]1580fn allow_list_test_11() {1581	new_test_ext().execute_with(|| {1582		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15831584		let origin1 = Origin::signed(1);1585		let origin2 = Origin::signed(2);15861587		assert_ok!(TemplateModule::set_public_access_mode(1588			origin1.clone(),1589			collection_id,1590			AccessMode::AllowList1591		));1592		assert_ok!(TemplateModule::set_mint_permission(1593			origin1.clone(),1594			collection_id,1595			false1596		));1597		assert_ok!(TemplateModule::add_to_allow_list(1598			origin1,1599			collection_id,1600			account(2)1601		));16021603		assert_noop!(1604			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()).map_err(|e| e.error),1605			CommonError::<Test>::PublicMintingNotAllowed1606		);1607	});1608}16091610// 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.1611#[test]1612fn allow_list_test_12() {1613	new_test_ext().execute_with(|| {1614		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16151616		let origin1 = Origin::signed(1);1617		let origin2 = Origin::signed(2);16181619		assert_ok!(TemplateModule::set_public_access_mode(1620			origin1.clone(),1621			collection_id,1622			AccessMode::AllowList1623		));1624		assert_ok!(TemplateModule::set_mint_permission(1625			origin1,1626			collection_id,1627			false1628		));16291630		assert_noop!(1631			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()).map_err(|e| e.error),1632			CommonError::<Test>::PublicMintingNotAllowed1633		);1634	});1635}16361637// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.1638#[test]1639fn allow_list_test_13() {1640	new_test_ext().execute_with(|| {1641		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16421643		let origin1 = Origin::signed(1);16441645		assert_ok!(TemplateModule::set_public_access_mode(1646			origin1.clone(),1647			collection_id,1648			AccessMode::AllowList1649		));1650		assert_ok!(TemplateModule::set_mint_permission(1651			origin1,1652			collection_id,1653			true1654		));16551656		let data = default_nft_data();1657		create_test_item(collection_id, &data.into());1658	});1659}16601661// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.1662#[test]1663fn allow_list_test_14() {1664	new_test_ext().execute_with(|| {1665		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16661667		let origin1 = Origin::signed(1);1668		let origin2 = Origin::signed(2);16691670		assert_ok!(TemplateModule::set_public_access_mode(1671			origin1.clone(),1672			collection_id,1673			AccessMode::AllowList1674		));1675		assert_ok!(TemplateModule::set_mint_permission(1676			origin1.clone(),1677			collection_id,1678			true1679		));16801681		assert_ok!(TemplateModule::add_collection_admin(1682			origin1,1683			collection_id,1684			account(2)1685		));16861687		assert_ok!(TemplateModule::create_item(1688			origin2,1689			collection_id,1690			account(2),1691			default_nft_data().into()1692		));1693	});1694}16951696// 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.1697#[test]1698fn allow_list_test_15() {1699	new_test_ext().execute_with(|| {1700		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17011702		let origin1 = Origin::signed(1);1703		let origin2 = Origin::signed(2);17041705		assert_ok!(TemplateModule::set_public_access_mode(1706			origin1.clone(),1707			collection_id,1708			AccessMode::AllowList1709		));1710		assert_ok!(TemplateModule::set_mint_permission(1711			origin1,1712			collection_id,1713			true1714		));17151716		assert_noop!(1717			TemplateModule::create_item(origin2, collection_id, account(2), default_nft_data().into()).map_err(|e| e.error),1718			CommonError::<Test>::AddressNotInAllowlist1719		);1720	});1721}17221723// 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.1724#[test]1725fn allow_list_test_16() {1726	new_test_ext().execute_with(|| {1727		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17281729		let origin1 = Origin::signed(1);1730		let origin2 = Origin::signed(2);17311732		assert_ok!(TemplateModule::set_public_access_mode(1733			origin1.clone(),1734			collection_id,1735			AccessMode::AllowList1736		));1737		assert_ok!(TemplateModule::set_mint_permission(1738			origin1.clone(),1739			collection_id,1740			true1741		));1742		assert_ok!(TemplateModule::add_to_allow_list(1743			origin1,1744			collection_id,1745			account(2)1746		));17471748		assert_ok!(TemplateModule::create_item(1749			origin2,1750			collection_id,1751			account(2),1752			default_nft_data().into()1753		));1754	});1755}17561757// Total number of collections. Positive test1758#[test]1759fn total_number_collections_bound() {1760	new_test_ext().execute_with(|| {1761		create_test_collection(&CollectionMode::NFT, CollectionId(1));1762	});1763}17641765#[test]1766fn create_max_collections() {1767	new_test_ext().execute_with(|| {1768		for i in 1..=COLLECTION_NUMBER_LIMIT {1769			create_test_collection(&CollectionMode::NFT, CollectionId(i));1770		}1771	});1772}17731774// Total number of collections. Negative test1775#[test]1776fn total_number_collections_bound_neg() {1777	new_test_ext().execute_with(|| {1778		let origin1 = Origin::signed(1);17791780		for i in 1..=COLLECTION_NUMBER_LIMIT {1781			create_test_collection(&CollectionMode::NFT, CollectionId(i));1782		}17831784		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1785		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1786		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();17871788		// 11-th collection in chain. Expects error1789		assert_noop!(1790			TemplateModule::create_collection(1791				origin1,1792				col_name1,1793				col_desc1,1794				token_prefix1,1795				CollectionMode::NFT1796			),1797			CommonError::<Test>::TotalCollectionsLimitExceeded1798		);1799	});1800}18011802// Owned tokens by a single address. Positive test1803#[test]1804fn owned_tokens_bound() {1805	new_test_ext().execute_with(|| {1806		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18071808		let data = default_nft_data();1809		create_test_item(collection_id, &data.clone().into());1810		create_test_item(collection_id, &data.into());1811	});1812}18131814// Owned tokens by a single address. Negotive test1815#[test]1816fn owned_tokens_bound_neg() {1817	new_test_ext().execute_with(|| {1818		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18191820		let origin1 = Origin::signed(1);18211822		for _ in 1..=MAX_TOKEN_OWNERSHIP {1823			let data = default_nft_data();1824			create_test_item(collection_id, &data.clone().into());1825		}18261827		let data = default_nft_data();1828		assert_noop!(1829			TemplateModule::create_item(origin1, CollectionId(1), account(1), data.into()).map_err(|e| e.error),1830			CommonError::<Test>::AccountTokenLimitExceeded1831		);1832	});1833}18341835// Number of collection admins. Positive test1836#[test]1837fn collection_admins_bound() {1838	new_test_ext().execute_with(|| {1839		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18401841		let origin1 = Origin::signed(1);18421843		assert_ok!(TemplateModule::add_collection_admin(1844			origin1.clone(),1845			collection_id,1846			account(2)1847		));1848		assert_ok!(TemplateModule::add_collection_admin(1849			origin1,1850			collection_id,1851			account(3)1852		));1853	});1854}18551856// Number of collection admins. Negotive test1857#[test]1858fn collection_admins_bound_neg() {1859	new_test_ext().execute_with(|| {1860		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18611862		let origin1 = Origin::signed(1);18631864		for i in 0..COLLECTION_ADMINS_LIMIT {1865			assert_ok!(TemplateModule::add_collection_admin(1866				origin1.clone(),1867				collection_id,1868				account((2 + i).into())1869			));1870		}1871		assert_noop!(1872			TemplateModule::add_collection_admin(1873				origin1,1874				collection_id,1875				account((3 + COLLECTION_ADMINS_LIMIT).into())1876			),1877			CommonError::<Test>::CollectionAdminCountExceeded1878		);1879	});1880}1881// #endregion18821883#[test]1884fn set_const_on_chain_schema() {1885	new_test_ext().execute_with(|| {1886		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18871888		let origin1 = Origin::signed(1);1889		assert_ok!(TemplateModule::set_const_on_chain_schema(1890			origin1,1891			collection_id,1892			b"test const on chain schema".to_vec()1893		));18941895		assert_eq!(1896			<pallet_common::CollectionById<Test>>::get(collection_id)1897				.unwrap()1898				.const_on_chain_schema,1899			b"test const on chain schema".to_vec()1900		);1901		assert_eq!(1902			<pallet_common::CollectionById<Test>>::get(collection_id)1903				.unwrap()1904				.variable_on_chain_schema,1905			b"".to_vec()1906		);1907	});1908}19091910#[test]1911fn set_variable_on_chain_schema() {1912	new_test_ext().execute_with(|| {1913		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19141915		let origin1 = Origin::signed(1);1916		assert_ok!(TemplateModule::set_variable_on_chain_schema(1917			origin1,1918			collection_id,1919			b"test variable on chain schema".to_vec()1920		));19211922		assert_eq!(1923			<pallet_common::CollectionById<Test>>::get(collection_id)1924				.unwrap()1925				.const_on_chain_schema,1926			b"".to_vec()1927		);1928		assert_eq!(1929			<pallet_common::CollectionById<Test>>::get(collection_id)1930				.unwrap()1931				.variable_on_chain_schema,1932			b"test variable on chain schema".to_vec()1933		);1934	});1935}19361937#[test]1938fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1939	new_test_ext().execute_with(|| {1940		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19411942		let origin1 = Origin::signed(1);19431944		let data = default_nft_data();1945		create_test_item(CollectionId(1), &data.into());19461947		let variable_data = b"test data".to_vec();1948		assert_ok!(TemplateModule::set_variable_meta_data(1949			origin1,1950			collection_id,1951			TokenId(1),1952			variable_data.clone()1953		));19541955		assert_eq!(1956			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))1957				.unwrap()1958				.variable_data,1959			variable_data1960		);1961	});1962}19631964#[test]1965fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1966	new_test_ext().execute_with(|| {1967		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));19681969		let origin1 = Origin::signed(1);19701971		let data = default_re_fungible_data();1972		create_test_item(collection_id, &data.into());19731974		let variable_data = b"test data".to_vec();1975		assert_ok!(TemplateModule::set_variable_meta_data(1976			origin1,1977			collection_id,1978			TokenId(1),1979			variable_data.clone()1980		));19811982		assert_eq!(1983			<pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)))1984				.variable_data,1985			variable_data1986		);1987	});1988}19891990#[test]1991fn set_variable_meta_data_on_fungible_token_fails() {1992	new_test_ext().execute_with(|| {1993		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));19941995		let origin1 = Origin::signed(1);19961997		let data = default_fungible_data();1998		create_test_item(collection_id, &data.into());19992000		let variable_data = b"test data".to_vec();2001		assert_noop!(2002			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(0), variable_data).map_err(|e| e.error),2003			<pallet_fungible::Error<Test>>::FungibleItemsDontHaveData2004		);2005	});2006}20072008#[test]2009fn set_variable_meta_data_on_nft_token_fails_for_big_data() {2010	new_test_ext().execute_with(|| {2011		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20122013		let origin1 = Origin::signed(1);20142015		let data = default_nft_data();2016		create_test_item(collection_id, &data.into());20172018		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2019		assert_noop!(2020			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2021			CommonError::<Test>::TokenVariableDataLimitExceeded2022		);2023	});2024}20252026#[test]2027fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {2028	new_test_ext().execute_with(|| {2029		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));20302031		let origin1 = Origin::signed(1);20322033		let data = default_re_fungible_data();2034		create_test_item(collection_id, &data.into());20352036		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2037		assert_noop!(2038			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2039			CommonError::<Test>::TokenVariableDataLimitExceeded2040		);2041	});2042}20432044#[test]2045fn set_variable_meta_data_on_nft_with_item_owner_permission_flag() {2046	new_test_ext().execute_with(|| {2047		//default_limits();20482049		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20502051		let origin1 = Origin::signed(1);20522053		let data = default_nft_data();2054		create_test_item(collection_id, &data.into());20552056		assert_ok!(TemplateModule::set_meta_update_permission_flag(2057			origin1.clone(),2058			collection_id,2059			MetaUpdatePermission::ItemOwner,2060		));20612062		let variable_data = b"ten chars.".to_vec();2063		assert_ok!(TemplateModule::set_variable_meta_data(2064			origin1,2065			collection_id,2066			TokenId(1),2067			variable_data.clone()2068		));20692070		assert_eq!(2071			<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1)))2072				.unwrap()2073				.variable_data,2074			variable_data2075		);2076	});2077}20782079#[test]2080fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() {2081	new_test_ext().execute_with(|| {2082		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));20832084		let origin1 = Origin::signed(1);20852086		assert_ok!(TemplateModule::set_mint_permission(2087			origin1.clone(),2088			collection_id,2089			true2090		));2091		assert_ok!(TemplateModule::add_to_allow_list(2092			origin1.clone(),2093			collection_id,2094			account(1)2095		));20962097		let data = default_nft_data();2098		create_test_item(collection_id, &data.into());20992100		assert_ok!(TemplateModule::set_meta_update_permission_flag(2101			origin1.clone(),2102			collection_id,2103			MetaUpdatePermission::ItemOwner,2104		));21052106		let variable_data = b"1234567890123".to_vec();2107		assert_noop!(2108			TemplateModule::set_variable_meta_data(2109				origin1,2110				collection_id,2111				TokenId(1),2112				variable_data.clone()2113			).map_err(|e| e.error),2114			CommonError::<Test>::TokenVariableDataLimitExceeded2115		);2116	})2117}21182119#[test]2120fn collection_transfer_flag_works() {2121	new_test_ext().execute_with(|| {2122		let origin1 = Origin::signed(1);21232124		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2125		assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, collection_id, true));21262127		let data = default_nft_data();2128		create_test_item(collection_id, &data.into());2129		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2130		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);21312132		let origin1 = Origin::signed(1);21332134		// default scenario2135		assert_ok!(TemplateModule::transfer(origin1, account(2), collection_id, TokenId(1), 1));2136		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);2137		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);2138		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);2139		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);2140	});2141}21422143#[test]2144fn set_variable_meta_data_on_nft_with_admin_flag() {2145	new_test_ext().execute_with(|| {2146		// default_limits();21472148		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));21492150		let origin1 = Origin::signed(1);2151		let origin2 = Origin::signed(2);21522153		assert_ok!(TemplateModule::set_mint_permission(2154			origin2.clone(),2155			collection_id,2156			true2157		));2158		assert_ok!(TemplateModule::add_to_allow_list(2159			origin2.clone(),2160			collection_id,2161			account(1)2162		));21632164		assert_ok!(TemplateModule::add_collection_admin(2165			origin2.clone(),2166			collection_id,2167			account(1)2168		));21692170		let data = default_nft_data();2171		create_test_item(collection_id, &data.into());21722173		assert_ok!(TemplateModule::set_meta_update_permission_flag(2174			origin2.clone(),2175			collection_id,2176			MetaUpdatePermission::Admin,2177		));21782179		let variable_data = b"test.".to_vec();2180		assert_ok!(TemplateModule::set_variable_meta_data(2181			origin1,2182			collection_id,2183			TokenId(1),2184			variable_data.clone()2185		));21862187		assert_eq!(2188			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))2189				.unwrap()2190				.variable_data,2191			variable_data2192		);2193	});2194}21952196#[test]2197fn set_variable_meta_data_on_nft_with_admin_flag_neg() {2198	new_test_ext().execute_with(|| {2199		// default_limits();22002201		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));22022203		let origin1 = Origin::signed(1);2204		let origin2 = Origin::signed(2);22052206		assert_ok!(TemplateModule::set_mint_permission(2207			origin2.clone(),2208			collection_id,2209			true2210		));2211		assert_ok!(TemplateModule::add_to_allow_list(2212			origin2.clone(),2213			collection_id,2214			account(1)2215		));22162217		let data = default_nft_data();2218		create_test_item(collection_id, &data.into());22192220		assert_ok!(TemplateModule::set_meta_update_permission_flag(2221			origin2.clone(),2222			collection_id,2223			MetaUpdatePermission::Admin,2224		));22252226		let variable_data = b"test.".to_vec();2227		assert_noop!(2228			TemplateModule::set_variable_meta_data(2229				origin1,2230				collection_id,2231				TokenId(1),2232				variable_data.clone()2233			).map_err(|e| e.error),2234			CommonError::<Test>::NoPermission2235		);2236	});2237}22382239#[test]2240fn set_variable_meta_flag_after_freeze() {2241	new_test_ext().execute_with(|| {2242		// default_limits();22432244		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));22452246		let origin2 = Origin::signed(2);22472248		assert_ok!(TemplateModule::set_meta_update_permission_flag(2249			origin2.clone(),2250			collection_id,2251			MetaUpdatePermission::None,2252		));2253		assert_noop!(2254			TemplateModule::set_meta_update_permission_flag(2255				origin2.clone(),2256				collection_id,2257				MetaUpdatePermission::Admin2258			),2259			CommonError::<Test>::MetadataFlagFrozen2260		);2261	});2262}22632264#[test]2265fn set_variable_meta_data_on_nft_with_none_flag_neg() {2266	new_test_ext().execute_with(|| {2267		// default_limits();22682269		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));2270		let origin1 = Origin::signed(1);22712272		let data = default_nft_data();2273		create_test_item(collection_id, &data.into());22742275		assert_ok!(TemplateModule::set_meta_update_permission_flag(2276			origin1.clone(),2277			collection_id,2278			MetaUpdatePermission::None,2279		));22802281		let variable_data = b"test.".to_vec();2282		assert_noop!(2283			TemplateModule::set_variable_meta_data(2284				origin1.clone(),2285				collection_id,2286				TokenId(1),2287				variable_data.clone()2288			).map_err(|e| e.error),2289			CommonError::<Test>::NoPermission2290		);2291	});2292}22932294#[test]2295fn collection_transfer_flag_works_neg() {2296	new_test_ext().execute_with(|| {2297		let origin1 = Origin::signed(1);22982299		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2300		assert_ok!(TemplateModule::set_transfers_enabled_flag(2301			origin1, collection_id, false2302		));23032304		let data = default_nft_data();2305		create_test_item(collection_id, &data.into());2306		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2307		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);23082309		let origin1 = Origin::signed(1);23102311		// default scenario2312		assert_noop!(2313			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),2314			CommonError::<Test>::TransferNotAllowed2315		);2316		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2317		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 0);2318		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);2319		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), false);2320	});2321}