git.delta.rocks / unique-network / refs/commits / 455ab69b4262

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, CollectionMode};5use nft_data_structs::{6	COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, 7	CreateNftData, CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, 8	MetaUpdatePermission, TokenId,9};1011use frame_support::{assert_noop, assert_ok};12use sp_std::convert::TryInto;1314fn default_nft_data() -> CreateNftData {15	CreateNftData {16		const_data: vec![1, 2, 3].try_into().unwrap(),17		variable_data: vec![3, 2, 1].try_into().unwrap(),18	}19}2021fn default_fungible_data() -> CreateFungibleData {22	CreateFungibleData { value: 5 }23}2425fn default_re_fungible_data() -> CreateReFungibleData {26	CreateReFungibleData {27		const_data: vec![1, 2, 3].try_into().unwrap(),28		variable_data: vec![3, 2, 1].try_into().unwrap(),29		pieces: 1023,30	}31}3233fn create_test_collection_for_owner(34	mode: &CollectionMode,35	owner: u64,36	id: CollectionId,37) -> CollectionId {38	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();39	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();40	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4142	let origin1 = Origin::signed(owner);43	assert_ok!(TemplateModule::create_collection(44		origin1,45		col_name1,46		col_desc1,47		token_prefix1,48		mode.clone()49	));5051	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();52	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();53	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();54	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().owner, owner);55	assert_eq!(56		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,57		saved_col_name58	);59	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().mode, *mode);60	assert_eq!(61		<pallet_common::CollectionById<Test>>::get(id).unwrap().description,62		saved_description63	);64	assert_eq!(65		<pallet_common::CollectionById<Test>>::get(id).unwrap().token_prefix,66		saved_prefix67	);68	id69}7071fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {72	create_test_collection_for_owner(&mode, 1, id)73}7475fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {76	let origin1 = Origin::signed(1);77	assert_ok!(TemplateModule::create_item(78		origin1,79		collection_id,80		account(1),81		data.clone()82	));83}8485fn account(sub: u64) -> TestCrossAccountId {86	TestCrossAccountId::from_sub(sub)87}8889// Use cases tests region90// #region9192#[test]93fn set_version_schema() {94	new_test_ext().execute_with(|| {95		let origin1 = Origin::signed(1);96		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));9798		assert_ok!(TemplateModule::set_schema_version(99			origin1,100			collection_id,101			SchemaVersion::Unique102		));103		assert_eq!(104			<pallet_common::CollectionById<Test>>::get(collection_id)105				.unwrap()106				.schema_version,107			SchemaVersion::Unique108		);109	});110}111112#[test]113fn create_fungible_collection_fails_with_large_decimal_numbers() {114	new_test_ext().execute_with(|| {115		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();116		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();117		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();118119		let origin1 = Origin::signed(1);120		assert_noop!(121			TemplateModule::create_collection(122				origin1,123				col_name1,124				col_desc1,125				token_prefix1,126				CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)127			),128			Error::<Test>::CollectionDecimalPointLimitExceeded129		);130	});131}132133#[test]134fn create_nft_item() {135	new_test_ext().execute_with(|| {136		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));137138		let data = default_nft_data();139		create_test_item(collection_id, &data.clone().into());140141		let item = <pallet_nonfungible::TokenData<Test>>::get((collection_id, 1)).unwrap();142		assert_eq!(item.const_data, data.const_data.into_inner());143		assert_eq!(item.variable_data, data.variable_data.into_inner());144	});145}146147// Use cases tests region148// #region149#[test]150fn create_nft_multiple_items() {151	new_test_ext().execute_with(|| {152		create_test_collection(&CollectionMode::NFT, CollectionId(1));153154		let origin1 = Origin::signed(1);155156		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];157158		assert_ok!(TemplateModule::create_multiple_items(159			origin1,160			CollectionId(1),161			account(1),162			items_data163				.clone()164				.into_iter()165				.map(|d| { d.into() })166				.collect()167		));168		for (index, data) in items_data.into_iter().enumerate() {169			let item = <pallet_nonfungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32))).unwrap();170			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());171			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());172		}173	});174}175176#[test]177fn create_refungible_item() {178	new_test_ext().execute_with(|| {179		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));180181		let data = default_re_fungible_data();182		create_test_item(collection_id, &data.clone().into());183		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));184		let balance = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));185		assert_eq!(item.const_data, data.const_data.into_inner());186		assert_eq!(item.variable_data, data.variable_data.into_inner());187		assert_eq!(balance, 1023);188	});189}190191#[test]192fn create_multiple_refungible_items() {193	new_test_ext().execute_with(|| {194		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));195196		let origin1 = Origin::signed(1);197198		let items_data = vec![199			default_re_fungible_data(),200			default_re_fungible_data(),201			default_re_fungible_data(),202		];203204		assert_ok!(TemplateModule::create_multiple_items(205			origin1,206			CollectionId(1),207			account(1),208			items_data209				.clone()210				.into_iter()211				.map(|d| { d.into() })212				.collect()213		));214		for (index, data) in items_data.into_iter().enumerate() {215			let item = <pallet_refungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32)));216			let balance = <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));217			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());218			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());219			assert_eq!(balance, 1023);220		}221	});222}223224#[test]225fn create_fungible_item() {226	new_test_ext().execute_with(|| {227		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));228229		let data = default_fungible_data();230		create_test_item(collection_id, &data.into());231232		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);233	});234}235236//#[test]237// fn create_multiple_fungible_items() {238//     new_test_ext().execute_with(|| {239//         default_limits();240241//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));242243//         let origin1 = Origin::signed(1);244245//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];246247//         assert_ok!(TemplateModule::create_multiple_items(248//             origin1.clone(),249//             1,250//             1,251//             items_data.clone().into_iter().map(|d| { d.into() }).collect()252//         ));253254//         for (index, _) in items_data.iter().enumerate() {255//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);256//         }257//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);258//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);259//     });260// }261262#[test]263fn transfer_fungible_item() {264	new_test_ext().execute_with(|| {265		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));266267		let origin1 = Origin::signed(1);268		let origin2 = Origin::signed(2);269270		let data = default_fungible_data();271		create_test_item(collection_id, &data.into());272273		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 5);274275		// change owner scenario276		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(0), 5));277		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 0);278279		// split item scenario280		assert_ok!(TemplateModule::transfer(281			origin2.clone(),282			account(3),283			CollectionId(1),284			TokenId(0),285			3286		));287288		// split item and new owner has account scenario289		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(0), 1));290		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))), 1);291		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))), 4);292	});293}294295#[test]296fn transfer_refungible_item() {297	new_test_ext().execute_with(|| {298		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));299300		// Create RFT 1 in 1023 pieces for account 1301		let data = default_re_fungible_data();302		create_test_item(collection_id, &data.clone().into());303		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));304		assert_eq!(item.const_data, data.const_data.into_inner());305		assert_eq!(item.variable_data, data.variable_data.into_inner());306		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);307		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);308		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);309310		// Account 1 transfers all 1023 pieces of RFT 1 to account 2311		let origin1 = Origin::signed(1);312		let origin2 = Origin::signed(2);313		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1023));314		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 1023);315		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);316		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);317		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);318		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);319320		// Account 2 transfers 500 pieces of RFT 1 to account 3321		assert_ok!(TemplateModule::transfer(322			origin2.clone(),323			account(3),324			CollectionId(1),325			TokenId(1),326			500327		));328		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 523);329		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 500);330		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);331		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);332		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);333		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);334335		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance336		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(1), 200));337		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 323);338		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 700);339		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);340		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);341		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);342		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);343	});344}345346#[test]347fn transfer_nft_item() {348	new_test_ext().execute_with(|| {349		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));350351		let data = default_nft_data();352		create_test_item(collection_id, &data.into());353		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);354		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);355356357		let origin1 = Origin::signed(1);358		// default scenario359		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));360		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);361		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);362		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);363		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);364	});365}366367#[test]368fn transfer_nft_item_wrong_value() {369	new_test_ext().execute_with(|| {370		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));371372		let data = default_nft_data();373		create_test_item(collection_id, &data.into());374		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);375		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);376377		let origin1 = Origin::signed(1);378379		assert_noop!(380			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2).map_err(|e| e.error),381			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount382		);383	});384}385386#[test]387fn transfer_nft_item_zero_value() {388	new_test_ext().execute_with(|| {389		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));390391		let data = default_nft_data();392		create_test_item(collection_id, &data.into());393		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);394		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);395396		let origin1 = Origin::signed(1);397398		// Transferring 0 amount works on NFT...399		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 0));400		// ... and results in no transfer401		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);402		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);403	});404}405406#[test]407fn nft_approve_and_transfer_from() {408	new_test_ext().execute_with(|| {409		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));410411		let data = default_nft_data();412		create_test_item(collection_id, &data.into());413414		let origin1 = Origin::signed(1);415		let origin2 = Origin::signed(2);416417		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);418		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);419420		// neg transfer_from421		assert_noop!(422			TemplateModule::transfer_from(origin2.clone(), account(1), account(2), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),423			CommonError::<Test>::TokenValueNotEnough424		);425426		// do approve427		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));428		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));429430		assert_ok!(TemplateModule::transfer_from(431			origin2,432			account(1),433			account(3),434			CollectionId(1),435			TokenId(1),436			1437		));438		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());439	});440}441442#[test]443fn nft_approve_and_transfer_from_allow_list() {444	new_test_ext().execute_with(|| {445		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));446447		let origin1 = Origin::signed(1);448		let origin2 = Origin::signed(2);449450		// Create NFT 1 for account 1451		let data = default_nft_data();452		create_test_item(collection_id, &data.clone().into());453		assert_eq!(454			&<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1))).unwrap().const_data,455			&data.const_data.into_inner()456		);457		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);458		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);459460		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list461		assert_ok!(TemplateModule::set_mint_permission(462			origin1.clone(),463			CollectionId(1),464			true465		));466		assert_ok!(TemplateModule::set_public_access_mode(467			origin1.clone(),468			CollectionId(1),469			AccessMode::AllowList470		));471		assert_ok!(TemplateModule::add_to_allow_list(472			origin1.clone(),473			CollectionId(1),474			account(1)475		));476		assert_ok!(TemplateModule::add_to_allow_list(477			origin1.clone(),478			CollectionId(1),479			account(2)480		));481		assert_ok!(TemplateModule::add_to_allow_list(482			origin1.clone(),483			CollectionId(1),484			account(3)485		));486487		// Account 1 approves account 2 for NFT 1 488		assert_ok!(TemplateModule::approve(489			origin1.clone(),490			account(2),491			CollectionId(1),492			TokenId(1),493			1494		));495		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));496497		// Account 2 transfers NFT 1 from account 1 to account 3498		assert_ok!(TemplateModule::transfer_from(499			origin2,500			account(1),501			account(3),502			CollectionId(1),503			TokenId(1),504			1505		));506		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());507	});508}509510#[test]511fn refungible_approve_and_transfer_from() {512	new_test_ext().execute_with(|| {513		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));514515		let origin1 = Origin::signed(1);516		let origin2 = Origin::signed(2);517518		// Create RFT 1 in 1023 pieces for account 1519		let data = default_re_fungible_data();520		create_test_item(collection_id, &data.into());521522		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);523		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);524		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);525526		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list527		assert_ok!(TemplateModule::set_mint_permission(528			origin1.clone(),529			CollectionId(1),530			true531		));532		assert_ok!(TemplateModule::set_public_access_mode(533			origin1.clone(),534			CollectionId(1),535			AccessMode::AllowList536		));537		assert_ok!(TemplateModule::add_to_allow_list(538			origin1.clone(),539			CollectionId(1),540			account(1)541		));542		assert_ok!(TemplateModule::add_to_allow_list(543			origin1.clone(),544			CollectionId(1),545			account(2)546		));547		assert_ok!(TemplateModule::add_to_allow_list(548			origin1.clone(),549			CollectionId(1),550			account(3)551		));552553		// Account 1 approves account 2 for 1023 pieces of RFT 1554		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1023));555		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 1023);556557		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3558		assert_ok!(TemplateModule::transfer_from(559			origin2,560			account(1),561			account(3),562			CollectionId(1),563			TokenId(1),564			100565		));566		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);567		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);568		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 923);569		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 100);570		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);571		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);572		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 923);573	});574}575576#[test]577fn fungible_approve_and_transfer_from() {578	new_test_ext().execute_with(|| {579		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));580581		let data = default_fungible_data();582		create_test_item(collection_id, &data.into());583584		let origin1 = Origin::signed(1);585		let origin2 = Origin::signed(2);586587		assert_ok!(TemplateModule::set_mint_permission(588			origin1.clone(),589			CollectionId(1),590			true591		));592		assert_ok!(TemplateModule::set_public_access_mode(593			origin1.clone(),594			CollectionId(1),595			AccessMode::AllowList596		));597		assert_ok!(TemplateModule::add_to_allow_list(598			origin1.clone(),599			CollectionId(1),600			account(1)601		));602		assert_ok!(TemplateModule::add_to_allow_list(603			origin1.clone(),604			CollectionId(1),605			account(2)606		));607		assert_ok!(TemplateModule::add_to_allow_list(608			origin1.clone(),609			CollectionId(1),610			account(3)611		));612613		// do approve614		assert_ok!(TemplateModule::approve(615			origin1.clone(),616			account(2),617			CollectionId(1),618			TokenId(0),619			5620		));621		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);622		assert_ok!(TemplateModule::approve(origin1, account(3), CollectionId(1), TokenId(0), 5));623		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);624		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))), 5);625626		assert_ok!(TemplateModule::transfer_from(627			origin2.clone(),628			account(1),629			account(3),630			CollectionId(1),631			TokenId(0),632			4633		));634635		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 1);636637		assert_noop!(638			TemplateModule::transfer_from(origin2, account(1), account(3), CollectionId(1), TokenId(0), 4).map_err(|e| e.error),639			CommonError::<Test>::TokenValueNotEnough640		);641	});642}643644#[test]645fn change_collection_owner() {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::change_collection_owner(651			origin1,652			collection_id,653			2654		));655		assert_eq!(656			<pallet_common::CollectionById<Test>>::get(collection_id).unwrap().owner,657			2658		);659	});660}661662#[test]663fn destroy_collection() {664	new_test_ext().execute_with(|| {665		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));666667		let origin1 = Origin::signed(1);668		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));669	});670}671672#[test]673fn burn_nft_item() {674	new_test_ext().execute_with(|| {675		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));676677		let origin1 = Origin::signed(1);678679		let data = default_nft_data();680		create_test_item(collection_id, &data.into());681682		// check balance (collection with id = 1, user id = 1)683		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);684685		// burn item686		assert_ok!(TemplateModule::burn_item(687			origin1.clone(),688			collection_id,689			TokenId(1),690			1691		));692		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);693	});694}695696#[test]697fn burn_same_nft_item_twice() {698	new_test_ext().execute_with(|| {699		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));700701		let origin1 = Origin::signed(1);702703		let data = default_nft_data();704		create_test_item(collection_id, &data.into());705706		// check balance (collection with id = 1, user id = 1)707		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);708709		// burn item710		assert_ok!(TemplateModule::burn_item(711			origin1.clone(),712			collection_id,713			TokenId(1),714			1715		));716		717		// burn item again718		assert_noop!(719			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),720			CommonError::<Test>::TokenNotFound721		);722723		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);724	});725}726727#[test]728fn burn_fungible_item() {729	new_test_ext().execute_with(|| {730		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));731732		let origin1 = Origin::signed(1);733		assert_ok!(TemplateModule::add_collection_admin(734			origin1.clone(),735			collection_id,736			account(2)737		));738739		let data = default_fungible_data();740		create_test_item(collection_id, &data.into());741742		// check balance (collection with id = 1, user id = 1)743		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);744745		// burn item746		assert_ok!(TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(0), 5));747		assert_noop!(748			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),749			CommonError::<Test>::TokenValueTooLow750		);751752		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 0);753	});754}755756#[test]757fn burn_fungible_item_with_token_id() {758	new_test_ext().execute_with(|| {759		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));760761		let origin1 = Origin::signed(1);762		assert_ok!(TemplateModule::add_collection_admin(763			origin1.clone(),764			collection_id,765			account(2)766		));767768		let data = default_fungible_data();769		create_test_item(collection_id, &data.into());770771		// check balance (collection with id = 1, user id = 1)772		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);773774		// Try to burn item using Token ID775		assert_noop!(776			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),777			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId778		);779	});780}781#[test]782fn burn_refungible_item() {783	new_test_ext().execute_with(|| {784		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));785		let origin1 = Origin::signed(1);786787		assert_ok!(TemplateModule::set_mint_permission(788			origin1.clone(),789			collection_id,790			true791		));792		assert_ok!(TemplateModule::set_public_access_mode(793			origin1.clone(),794			collection_id,795			AccessMode::AllowList796		));797		assert_ok!(TemplateModule::add_to_allow_list(798			origin1.clone(),799			collection_id,800			account(1)801		));802803		assert_ok!(TemplateModule::add_collection_admin(804			origin1.clone(),805			collection_id,806			account(2)807		));808809		let data = default_re_fungible_data();810		create_test_item(collection_id, &data.into());811812		// check balance (collection with id = 1, user id = 2)813		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);814		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);815816		// burn item817		assert_ok!(TemplateModule::burn_item(origin1.clone(), collection_id, TokenId(1), 1023));818		assert_noop!(819			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),820			CommonError::<Test>::TokenValueTooLow821		);822823		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 0);824	});825}826827#[test]828fn add_collection_admin() {829	new_test_ext().execute_with(|| {830		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));831		let origin1 = Origin::signed(1);832833		// Add collection admins834		assert_ok!(TemplateModule::add_collection_admin(835			origin1.clone(),836			collection1_id,837			account(2)838		));839		assert_ok!(TemplateModule::add_collection_admin(840			origin1,841			collection1_id,842			account(3)843		));844845		// Owner is not an admin by default846		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))), false);847		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));848		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));849	});850}851852#[test]853fn remove_collection_admin() {854	new_test_ext().execute_with(|| {855		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));856		let origin1 = Origin::signed(1);857		let origin2 = Origin::signed(2);858859		// Add collection admins 2 and 3860		assert_ok!(TemplateModule::add_collection_admin(861			origin1.clone(),862			collection1_id,863			account(2)864		));865		assert_ok!(TemplateModule::add_collection_admin(866			origin1,867			collection1_id,868			account(3)869		));870871		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));872		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));873874		// remove admin 3875		assert_ok!(TemplateModule::remove_collection_admin(876			origin2,877			CollectionId(1),878			account(3)879		));880881		// 2 is still admin, 3 is not an admin anymore882		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));883		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))), false);884	});885}886887#[test]888fn balance_of() {889	new_test_ext().execute_with(|| {890		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));891		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));892		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(3));893894		// check balance before895		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 0);896		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 0);897		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 0);898899		let nft_data = default_nft_data();900		create_test_item(nft_collection_id, &nft_data.into());901902		let fungible_data = default_fungible_data();903		create_test_item(fungible_collection_id, &fungible_data.into());904905		let re_fungible_data = default_re_fungible_data();906		create_test_item(re_fungible_collection_id, &re_fungible_data.into());907908		// check balance (collection with id = 1, user id = 1)909		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 1);910		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 5);911		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 1);912913		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))), true);914		assert_eq!(<pallet_refungible::Owned<Test>>::get((re_fungible_collection_id, account(1), TokenId(1))), true);915	});916}917918#[test]919fn approve() {920	new_test_ext().execute_with(|| {921		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));922923		let data = default_nft_data();924		create_test_item(collection_id, &data.into());925926		let origin1 = Origin::signed(1);927928		// approve929		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));930		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));931	});932}933934#[test]935fn transfer_from() {936	new_test_ext().execute_with(|| {937		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));938		let origin1 = Origin::signed(1);939		let origin2 = Origin::signed(2);940941		let data = default_nft_data();942		create_test_item(collection_id, &data.into());943944		// approve945		assert_ok!(TemplateModule::approve(946			origin1.clone(),947			account(2),948			CollectionId(1),949			TokenId(1),950			1951		));952		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));953954		assert_ok!(TemplateModule::set_mint_permission(955			origin1.clone(),956			CollectionId(1),957			true958		));959		assert_ok!(TemplateModule::set_public_access_mode(960			origin1.clone(),961			CollectionId(1),962			AccessMode::AllowList963		));964		assert_ok!(TemplateModule::add_to_allow_list(965			origin1.clone(),966			CollectionId(1),967			account(1)968		));969		assert_ok!(TemplateModule::add_to_allow_list(970			origin1.clone(),971			CollectionId(1),972			account(2)973		));974		assert_ok!(TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(3)));975976		assert_ok!(TemplateModule::transfer_from(977			origin2,978			account(1),979			account(2),980			CollectionId(1),981			TokenId(1),982			1983		));984985		// after transfer986		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))), 0);987		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))), 1);988	});989}990991// #endregion992993// Coverage tests region994// #region995996#[test]997fn owner_can_add_address_to_allow_list() {998	new_test_ext().execute_with(|| {999		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10001001		let origin1 = Origin::signed(1);1002		assert_ok!(TemplateModule::add_to_allow_list(1003			origin1,1004			collection_id,1005			account(2)1006		));1007		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1008	});1009}10101011#[test]1012fn admin_can_add_address_to_allow_list() {1013	new_test_ext().execute_with(|| {1014		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1015		let origin1 = Origin::signed(1);1016		let origin2 = Origin::signed(2);10171018		assert_ok!(TemplateModule::add_collection_admin(1019			origin1,1020			collection_id,1021			account(2)1022		));1023		assert_ok!(TemplateModule::add_to_allow_list(1024			origin2,1025			collection_id,1026			account(3)1027		));1028		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))));1029	});1030}10311032#[test]1033fn nonprivileged_user_cannot_add_address_to_allow_list() {1034	new_test_ext().execute_with(|| {1035		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10361037		let origin2 = Origin::signed(2);1038		assert_noop!(1039			TemplateModule::add_to_allow_list(origin2, collection_id, account(3)),1040			CommonError::<Test>::NoPermission1041		);1042	});1043}10441045#[test]1046fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1047	new_test_ext().execute_with(|| {1048		let origin1 = Origin::signed(1);10491050		assert_noop!(1051			TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(2)),1052			CommonError::<Test>::CollectionNotFound1053		);1054	});1055}10561057#[test]1058fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1059	new_test_ext().execute_with(|| {1060		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10611062		let origin1 = Origin::signed(1);1063		assert_ok!(TemplateModule::destroy_collection(1064			origin1.clone(),1065			collection_id1066		));1067		assert_noop!(1068			TemplateModule::add_to_allow_list(origin1, collection_id, account(2)),1069			CommonError::<Test>::CollectionNotFound1070		);1071	});1072}10731074// If address is already added to allow list, nothing happens1075#[test]1076fn address_is_already_added_to_allow_list() {1077	new_test_ext().execute_with(|| {1078		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1079		let origin1 = Origin::signed(1);10801081		assert_ok!(TemplateModule::add_to_allow_list(1082			origin1.clone(),1083			collection_id,1084			account(2)1085		));1086		assert_ok!(TemplateModule::add_to_allow_list(1087			origin1,1088			collection_id,1089			account(2)1090		));1091		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1092	});1093}10941095#[test]1096fn owner_can_remove_address_from_allow_list() {1097	new_test_ext().execute_with(|| {1098		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10991100		let origin1 = Origin::signed(1);1101		assert_ok!(TemplateModule::add_to_allow_list(1102			origin1.clone(),1103			collection_id,1104			account(2)1105		));1106		assert_ok!(TemplateModule::remove_from_allow_list(1107			origin1,1108			collection_id,1109			account(2)1110		));1111		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1112	});1113}11141115#[test]1116fn admin_can_remove_address_from_allow_list() {1117	new_test_ext().execute_with(|| {1118		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1119		let origin1 = Origin::signed(1);1120		let origin2 = Origin::signed(2);11211122		// Owner adds admin1123		assert_ok!(TemplateModule::add_collection_admin(1124			origin1.clone(),1125			collection_id,1126			account(2)1127		));11281129		// Owner adds address 3 to allow list1130		assert_ok!(TemplateModule::add_to_allow_list(1131			origin1,1132			collection_id,1133			account(3)1134		));11351136		// Admin removes address 3 from allow list1137		assert_ok!(TemplateModule::remove_from_allow_list(1138			origin2,1139			collection_id,1140			account(3)1141		));1142		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))), false);1143	});1144}11451146#[test]1147fn nonprivileged_user_cannot_remove_address_from_allow_list() {1148	new_test_ext().execute_with(|| {1149		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1150		let origin1 = Origin::signed(1);1151		let origin2 = Origin::signed(2);11521153		assert_ok!(TemplateModule::add_to_allow_list(1154			origin1,1155			collection_id,1156			account(2)1157		));1158		assert_noop!(1159			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1160			CommonError::<Test>::NoPermission1161		);1162		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1163	});1164}11651166#[test]1167fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1168	new_test_ext().execute_with(|| {1169		let origin1 = Origin::signed(1);11701171		assert_noop!(1172			TemplateModule::remove_from_allow_list(origin1, CollectionId(1), account(2)),1173			CommonError::<Test>::CollectionNotFound1174		);1175	});1176}11771178#[test]1179fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1180	new_test_ext().execute_with(|| {1181		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1182		let origin1 = Origin::signed(1);1183		let origin2 = Origin::signed(2);11841185		// Add account 2 to allow list1186		assert_ok!(TemplateModule::add_to_allow_list(1187			origin1.clone(),1188			collection_id,1189			account(2)1190		));11911192		// Account 2 is in collection allow-list1193		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));11941195		// Destroy collection1196		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));11971198		// Attempt to remove account 2 from collection allow-list => error1199		assert_noop!(1200			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1201			CommonError::<Test>::CollectionNotFound1202		);12031204		// Account 2 is not found in collection allow-list anyway1205		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1206	});1207}12081209// If address is already removed from allow list, nothing happens1210#[test]1211fn address_is_already_removed_from_allow_list() {1212	new_test_ext().execute_with(|| {1213		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1214		let origin1 = Origin::signed(1);12151216		assert_ok!(TemplateModule::add_to_allow_list(1217			origin1.clone(),1218			collection_id,1219			account(2)1220		));1221		assert_ok!(TemplateModule::remove_from_allow_list(1222			origin1.clone(),1223			collection_id,1224			account(2)1225		));1226		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1227		assert_ok!(TemplateModule::remove_from_allow_list(1228			origin1,1229			collection_id,1230			account(2)1231		));1232		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1233	});1234}12351236// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1237#[test]1238fn allow_list_test_1() {1239	new_test_ext().execute_with(|| {1240		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));12411242		let origin1 = Origin::signed(1);12431244		let data = default_nft_data();1245		create_test_item(collection_id, &data.into());12461247		assert_ok!(TemplateModule::set_public_access_mode(1248			origin1.clone(),1249			collection_id,1250			AccessMode::AllowList1251		));1252		assert_ok!(TemplateModule::add_to_allow_list(1253			origin1.clone(),1254			collection_id,1255			account(2)1256		));12571258		assert_noop!(1259			TemplateModule::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1260			CommonError::<Test>::AddressNotInAllowlist1261		);1262	});1263}12641265#[test]1266fn allow_list_test_2() {1267	new_test_ext().execute_with(|| {1268		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1269		let origin1 = Origin::signed(1);12701271		let data = default_nft_data();1272		create_test_item(collection_id, &data.into());12731274		assert_ok!(TemplateModule::set_public_access_mode(1275			origin1.clone(),1276			collection_id,1277			AccessMode::AllowList1278		));1279		assert_ok!(TemplateModule::add_to_allow_list(1280			origin1.clone(),1281			collection_id,1282			account(1)1283		));1284		assert_ok!(TemplateModule::add_to_allow_list(1285			origin1.clone(),1286			collection_id,1287			account(2)1288		));12891290		// do approve1291		assert_ok!(TemplateModule::approve(1292			origin1.clone(),1293			account(1),1294			collection_id,1295			TokenId(1),1296			11297		));1298		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));12991300		assert_ok!(TemplateModule::remove_from_allow_list(1301			origin1.clone(),1302			collection_id,1303			account(1)1304		));13051306		assert_noop!(1307			TemplateModule::transfer_from(origin1, account(1), account(3), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1308			CommonError::<Test>::AddressNotInAllowlist1309		);1310	});1311}13121313// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1314#[test]1315fn allow_list_test_3() {1316	new_test_ext().execute_with(|| {1317		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13181319		let origin1 = Origin::signed(1);13201321		let data = default_nft_data();1322		create_test_item(collection_id, &data.into());13231324		assert_ok!(TemplateModule::set_public_access_mode(1325			origin1.clone(),1326			collection_id,1327			AccessMode::AllowList1328		));1329		assert_ok!(TemplateModule::add_to_allow_list(1330			origin1.clone(),1331			collection_id,1332			account(1)1333		));13341335		assert_noop!(1336			TemplateModule::transfer(origin1, account(3), collection_id, TokenId(1), 1).map_err(|e| e.error),1337			CommonError::<Test>::AddressNotInAllowlist1338		);1339	});1340}13411342#[test]1343fn allow_list_test_4() {1344	new_test_ext().execute_with(|| {1345		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13461347		let origin1 = Origin::signed(1);13481349		let data = default_nft_data();1350		create_test_item(collection_id, &data.into());13511352		assert_ok!(TemplateModule::set_public_access_mode(1353			origin1.clone(),1354			collection_id,1355			AccessMode::AllowList1356		));1357		assert_ok!(TemplateModule::add_to_allow_list(1358			origin1.clone(),1359			collection_id,1360			account(1)1361		));1362		assert_ok!(TemplateModule::add_to_allow_list(1363			origin1.clone(),1364			collection_id,1365			account(2)1366		));13671368		// do approve1369		assert_ok!(TemplateModule::approve(1370			origin1.clone(),1371			account(1),1372			collection_id,1373			TokenId(1),1374			11375		));1376		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));13771378		assert_ok!(TemplateModule::remove_from_allow_list(1379			origin1.clone(),1380			collection_id,1381			account(2)1382		));13831384		assert_noop!(1385			TemplateModule::transfer_from(origin1, account(1), account(3), collection_id, TokenId(1), 1).map_err(|e| e.error),1386			CommonError::<Test>::AddressNotInAllowlist1387		);1388	});1389}13901391// 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)1392#[test]1393fn allow_list_test_5() {1394	new_test_ext().execute_with(|| {1395		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13961397		let origin1 = Origin::signed(1);13981399		let data = default_nft_data();1400		create_test_item(collection_id, &data.into());14011402		assert_ok!(TemplateModule::set_public_access_mode(1403			origin1.clone(),1404			collection_id,1405			AccessMode::AllowList1406		));1407		assert_noop!(1408			TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1409			CommonError::<Test>::AddressNotInAllowlist1410		);1411	});1412}14131414// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1415#[test]1416fn allow_list_test_6() {1417	new_test_ext().execute_with(|| {1418		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14191420		let origin1 = Origin::signed(1);14211422		let data = default_nft_data();1423		create_test_item(collection_id, &data.into());14241425		assert_ok!(TemplateModule::set_public_access_mode(1426			origin1.clone(),1427			collection_id,1428			AccessMode::AllowList1429		));14301431		// do approve1432		assert_noop!(1433			TemplateModule::approve(origin1, account(1), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1434			CommonError::<Test>::AddressNotInAllowlist1435		);1436	});1437}14381439// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1440//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1441#[test]1442fn allow_list_test_7() {1443	new_test_ext().execute_with(|| {1444		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14451446		let data = default_nft_data();1447		create_test_item(collection_id, &data.into());14481449		let origin1 = Origin::signed(1);14501451		assert_ok!(TemplateModule::set_public_access_mode(1452			origin1.clone(),1453			collection_id,1454			AccessMode::AllowList1455		));1456		assert_ok!(TemplateModule::add_to_allow_list(1457			origin1.clone(),1458			collection_id,1459			account(1)1460		));1461		assert_ok!(TemplateModule::add_to_allow_list(1462			origin1.clone(),1463			collection_id,1464			account(2)1465		));14661467		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));1468	});1469}14701471#[test]1472fn allow_list_test_8() {1473	new_test_ext().execute_with(|| {1474		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14751476		// Create NFT for account 11477		let data = default_nft_data();1478		create_test_item(collection_id, &data.into());14791480		let origin1 = Origin::signed(1);14811482		// Toggle Allow List mode and add accounts 1 and 21483		assert_ok!(TemplateModule::set_public_access_mode(1484			origin1.clone(),1485			collection_id,1486			AccessMode::AllowList1487		));1488		assert_ok!(TemplateModule::add_to_allow_list(1489			origin1.clone(),1490			collection_id,1491			account(1)1492		));1493		assert_ok!(TemplateModule::add_to_allow_list(1494			origin1.clone(),1495			collection_id,1496			account(2)1497		));14981499		// Sself-approve account 1 for NFT 11500		assert_ok!(TemplateModule::approve(1501			origin1.clone(),1502			account(1),1503			CollectionId(1), 1504			TokenId(1),1505			11506		));1507		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));15081509		// Transfer from 1 to 21510		assert_ok!(TemplateModule::transfer_from(1511			origin1,1512			account(1),1513			account(2),1514			CollectionId(1), 1515			TokenId(1),1516			11517		));1518	});1519}15201521// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.1522#[test]1523fn allow_list_test_9() {1524	new_test_ext().execute_with(|| {1525		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1526		let origin1 = Origin::signed(1);15271528		assert_ok!(TemplateModule::set_public_access_mode(1529			origin1.clone(),1530			collection_id,1531			AccessMode::AllowList1532		));1533		assert_ok!(TemplateModule::set_mint_permission(1534			origin1,1535			collection_id,1536			false1537		));15381539		let data = default_nft_data();1540		create_test_item(collection_id, &data.into());1541	});1542}15431544// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.1545#[test]1546fn allow_list_test_10() {1547	new_test_ext().execute_with(|| {1548		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15491550		let origin1 = Origin::signed(1);1551		let origin2 = Origin::signed(2);15521553		assert_ok!(TemplateModule::set_public_access_mode(1554			origin1.clone(),1555			collection_id,1556			AccessMode::AllowList1557		));1558		assert_ok!(TemplateModule::set_mint_permission(1559			origin1.clone(),1560			collection_id,1561			false1562		));15631564		assert_ok!(TemplateModule::add_collection_admin(1565			origin1,1566			collection_id,1567			account(2)1568		));15691570		assert_ok!(TemplateModule::create_item(1571			origin2,1572			collection_id,1573			account(2),1574			default_nft_data().into()1575		));1576	});1577}15781579// 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.1580#[test]1581fn allow_list_test_11() {1582	new_test_ext().execute_with(|| {1583		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15841585		let origin1 = Origin::signed(1);1586		let origin2 = Origin::signed(2);15871588		assert_ok!(TemplateModule::set_public_access_mode(1589			origin1.clone(),1590			collection_id,1591			AccessMode::AllowList1592		));1593		assert_ok!(TemplateModule::set_mint_permission(1594			origin1.clone(),1595			collection_id,1596			false1597		));1598		assert_ok!(TemplateModule::add_to_allow_list(1599			origin1,1600			collection_id,1601			account(2)1602		));16031604		assert_noop!(1605			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()).map_err(|e| e.error),1606			CommonError::<Test>::PublicMintingNotAllowed1607		);1608	});1609}16101611// 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.1612#[test]1613fn allow_list_test_12() {1614	new_test_ext().execute_with(|| {1615		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16161617		let origin1 = Origin::signed(1);1618		let origin2 = Origin::signed(2);16191620		assert_ok!(TemplateModule::set_public_access_mode(1621			origin1.clone(),1622			collection_id,1623			AccessMode::AllowList1624		));1625		assert_ok!(TemplateModule::set_mint_permission(1626			origin1,1627			collection_id,1628			false1629		));16301631		assert_noop!(1632			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()).map_err(|e| e.error),1633			CommonError::<Test>::PublicMintingNotAllowed1634		);1635	});1636}16371638// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.1639#[test]1640fn allow_list_test_13() {1641	new_test_ext().execute_with(|| {1642		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16431644		let origin1 = Origin::signed(1);16451646		assert_ok!(TemplateModule::set_public_access_mode(1647			origin1.clone(),1648			collection_id,1649			AccessMode::AllowList1650		));1651		assert_ok!(TemplateModule::set_mint_permission(1652			origin1,1653			collection_id,1654			true1655		));16561657		let data = default_nft_data();1658		create_test_item(collection_id, &data.into());1659	});1660}16611662// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.1663#[test]1664fn allow_list_test_14() {1665	new_test_ext().execute_with(|| {1666		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16671668		let origin1 = Origin::signed(1);1669		let origin2 = Origin::signed(2);16701671		assert_ok!(TemplateModule::set_public_access_mode(1672			origin1.clone(),1673			collection_id,1674			AccessMode::AllowList1675		));1676		assert_ok!(TemplateModule::set_mint_permission(1677			origin1.clone(),1678			collection_id,1679			true1680		));16811682		assert_ok!(TemplateModule::add_collection_admin(1683			origin1,1684			collection_id,1685			account(2)1686		));16871688		assert_ok!(TemplateModule::create_item(1689			origin2,1690			collection_id,1691			account(2),1692			default_nft_data().into()1693		));1694	});1695}16961697// 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.1698#[test]1699fn allow_list_test_15() {1700	new_test_ext().execute_with(|| {1701		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17021703		let origin1 = Origin::signed(1);1704		let origin2 = Origin::signed(2);17051706		assert_ok!(TemplateModule::set_public_access_mode(1707			origin1.clone(),1708			collection_id,1709			AccessMode::AllowList1710		));1711		assert_ok!(TemplateModule::set_mint_permission(1712			origin1,1713			collection_id,1714			true1715		));17161717		assert_noop!(1718			TemplateModule::create_item(origin2, collection_id, account(2), default_nft_data().into()).map_err(|e| e.error),1719			CommonError::<Test>::AddressNotInAllowlist1720		);1721	});1722}17231724// 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.1725#[test]1726fn allow_list_test_16() {1727	new_test_ext().execute_with(|| {1728		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17291730		let origin1 = Origin::signed(1);1731		let origin2 = Origin::signed(2);17321733		assert_ok!(TemplateModule::set_public_access_mode(1734			origin1.clone(),1735			collection_id,1736			AccessMode::AllowList1737		));1738		assert_ok!(TemplateModule::set_mint_permission(1739			origin1.clone(),1740			collection_id,1741			true1742		));1743		assert_ok!(TemplateModule::add_to_allow_list(1744			origin1,1745			collection_id,1746			account(2)1747		));17481749		assert_ok!(TemplateModule::create_item(1750			origin2,1751			collection_id,1752			account(2),1753			default_nft_data().into()1754		));1755	});1756}17571758// Total number of collections. Positive test1759#[test]1760fn total_number_collections_bound() {1761	new_test_ext().execute_with(|| {1762		create_test_collection(&CollectionMode::NFT, CollectionId(1));1763	});1764}17651766#[test]1767fn create_max_collections() {1768	new_test_ext().execute_with(|| {1769		for i in 1..=COLLECTION_NUMBER_LIMIT {1770			create_test_collection(&CollectionMode::NFT, CollectionId(i));1771		}1772	});1773}17741775// Total number of collections. Negative test1776#[test]1777fn total_number_collections_bound_neg() {1778	new_test_ext().execute_with(|| {1779		let origin1 = Origin::signed(1);17801781		for i in 1..=COLLECTION_NUMBER_LIMIT {1782			create_test_collection(&CollectionMode::NFT, CollectionId(i));1783		}17841785		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1786		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1787		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();17881789		// 11-th collection in chain. Expects error1790		assert_noop!(1791			TemplateModule::create_collection(1792				origin1,1793				col_name1,1794				col_desc1,1795				token_prefix1,1796				CollectionMode::NFT1797			),1798			CommonError::<Test>::TotalCollectionsLimitExceeded1799		);1800	});1801}18021803// Owned tokens by a single address. Positive test1804#[test]1805fn owned_tokens_bound() {1806	new_test_ext().execute_with(|| {1807		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18081809		let data = default_nft_data();1810		create_test_item(collection_id, &data.clone().into());1811		create_test_item(collection_id, &data.into());1812	});1813}18141815// Owned tokens by a single address. Negotive test1816#[test]1817fn owned_tokens_bound_neg() {1818	new_test_ext().execute_with(|| {1819		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18201821		let origin1 = Origin::signed(1);18221823		for _ in 1..=MAX_TOKEN_OWNERSHIP {1824			let data = default_nft_data();1825			create_test_item(collection_id, &data.clone().into());1826		}18271828		let data = default_nft_data();1829		assert_noop!(1830			TemplateModule::create_item(origin1, CollectionId(1), account(1), data.into()).map_err(|e| e.error),1831			CommonError::<Test>::AccountTokenLimitExceeded1832		);1833	});1834}18351836// Number of collection admins. Positive test1837#[test]1838fn collection_admins_bound() {1839	new_test_ext().execute_with(|| {1840		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18411842		let origin1 = Origin::signed(1);18431844		assert_ok!(TemplateModule::add_collection_admin(1845			origin1.clone(),1846			collection_id,1847			account(2)1848		));1849		assert_ok!(TemplateModule::add_collection_admin(1850			origin1,1851			collection_id,1852			account(3)1853		));1854	});1855}18561857// Number of collection admins. Negotive test1858#[test]1859fn collection_admins_bound_neg() {1860	new_test_ext().execute_with(|| {1861		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18621863		let origin1 = Origin::signed(1);18641865		for i in 0..COLLECTION_ADMINS_LIMIT {1866			assert_ok!(TemplateModule::add_collection_admin(1867				origin1.clone(),1868				collection_id,1869				account((2 + i).into())1870			));1871		}1872		assert_noop!(1873			TemplateModule::add_collection_admin(1874				origin1,1875				collection_id,1876				account((3 + COLLECTION_ADMINS_LIMIT).into())1877			),1878			CommonError::<Test>::CollectionAdminCountExceeded1879		);1880	});1881}1882// #endregion18831884#[test]1885fn set_const_on_chain_schema() {1886	new_test_ext().execute_with(|| {1887		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18881889		let origin1 = Origin::signed(1);1890		assert_ok!(TemplateModule::set_const_on_chain_schema(1891			origin1,1892			collection_id,1893			b"test const on chain schema".to_vec()1894		));18951896		assert_eq!(1897			<pallet_common::CollectionById<Test>>::get(collection_id)1898				.unwrap()1899				.const_on_chain_schema,1900			b"test const on chain schema".to_vec()1901		);1902		assert_eq!(1903			<pallet_common::CollectionById<Test>>::get(collection_id)1904				.unwrap()1905				.variable_on_chain_schema,1906			b"".to_vec()1907		);1908	});1909}19101911#[test]1912fn set_variable_on_chain_schema() {1913	new_test_ext().execute_with(|| {1914		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19151916		let origin1 = Origin::signed(1);1917		assert_ok!(TemplateModule::set_variable_on_chain_schema(1918			origin1,1919			collection_id,1920			b"test variable on chain schema".to_vec()1921		));19221923		assert_eq!(1924			<pallet_common::CollectionById<Test>>::get(collection_id)1925				.unwrap()1926				.const_on_chain_schema,1927			b"".to_vec()1928		);1929		assert_eq!(1930			<pallet_common::CollectionById<Test>>::get(collection_id)1931				.unwrap()1932				.variable_on_chain_schema,1933			b"test variable on chain schema".to_vec()1934		);1935	});1936}19371938#[test]1939fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1940	new_test_ext().execute_with(|| {1941		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19421943		let origin1 = Origin::signed(1);19441945		let data = default_nft_data();1946		create_test_item(CollectionId(1), &data.into());19471948		let variable_data = b"test data".to_vec();1949		assert_ok!(TemplateModule::set_variable_meta_data(1950			origin1,1951			collection_id,1952			TokenId(1),1953			variable_data.clone()1954		));19551956		assert_eq!(1957			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))1958				.unwrap()1959				.variable_data,1960			variable_data1961		);1962	});1963}19641965#[test]1966fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1967	new_test_ext().execute_with(|| {1968		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));19691970		let origin1 = Origin::signed(1);19711972		let data = default_re_fungible_data();1973		create_test_item(collection_id, &data.into());19741975		let variable_data = b"test data".to_vec();1976		assert_ok!(TemplateModule::set_variable_meta_data(1977			origin1,1978			collection_id,1979			TokenId(1),1980			variable_data.clone()1981		));19821983		assert_eq!(1984			<pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)))1985				.variable_data,1986			variable_data1987		);1988	});1989}19901991#[test]1992fn set_variable_meta_data_on_fungible_token_fails() {1993	new_test_ext().execute_with(|| {1994		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));19951996		let origin1 = Origin::signed(1);19971998		let data = default_fungible_data();1999		create_test_item(collection_id, &data.into());20002001		let variable_data = b"test data".to_vec();2002		assert_noop!(2003			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(0), variable_data).map_err(|e| e.error),2004			<pallet_fungible::Error<Test>>::FungibleItemsDontHaveData2005		);2006	});2007}20082009#[test]2010fn set_variable_meta_data_on_fungible_token_with_token_id_fails() {2011	new_test_ext().execute_with(|| {2012		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));20132014		let origin1 = Origin::signed(1);20152016		let data = default_fungible_data();2017		create_test_item(collection_id, &data.into());20182019		let variable_data = b"test data".to_vec();2020		assert_noop!(2021			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2022			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId2023		);2024	});2025}20262027#[test]2028fn set_variable_meta_data_on_nft_token_fails_for_big_data() {2029	new_test_ext().execute_with(|| {2030		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20312032		let origin1 = Origin::signed(1);20332034		let data = default_nft_data();2035		create_test_item(collection_id, &data.into());20362037		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2038		assert_noop!(2039			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2040			CommonError::<Test>::TokenVariableDataLimitExceeded2041		);2042	});2043}20442045#[test]2046fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {2047	new_test_ext().execute_with(|| {2048		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));20492050		let origin1 = Origin::signed(1);20512052		let data = default_re_fungible_data();2053		create_test_item(collection_id, &data.into());20542055		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2056		assert_noop!(2057			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2058			CommonError::<Test>::TokenVariableDataLimitExceeded2059		);2060	});2061}20622063#[test]2064fn set_variable_meta_data_on_nft_with_item_owner_permission_flag() {2065	new_test_ext().execute_with(|| {2066		//default_limits();20672068		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20692070		let origin1 = Origin::signed(1);20712072		let data = default_nft_data();2073		create_test_item(collection_id, &data.into());20742075		assert_ok!(TemplateModule::set_meta_update_permission_flag(2076			origin1.clone(),2077			collection_id,2078			MetaUpdatePermission::ItemOwner,2079		));20802081		let variable_data = b"ten chars.".to_vec();2082		assert_ok!(TemplateModule::set_variable_meta_data(2083			origin1,2084			collection_id,2085			TokenId(1),2086			variable_data.clone()2087		));20882089		assert_eq!(2090			<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1)))2091				.unwrap()2092				.variable_data,2093			variable_data2094		);2095	});2096}20972098#[test]2099fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() {2100	new_test_ext().execute_with(|| {2101		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));21022103		let origin1 = Origin::signed(1);21042105		assert_ok!(TemplateModule::set_mint_permission(2106			origin1.clone(),2107			collection_id,2108			true2109		));2110		assert_ok!(TemplateModule::add_to_allow_list(2111			origin1.clone(),2112			collection_id,2113			account(1)2114		));21152116		let data = default_nft_data();2117		create_test_item(collection_id, &data.into());21182119		assert_ok!(TemplateModule::set_meta_update_permission_flag(2120			origin1.clone(),2121			collection_id,2122			MetaUpdatePermission::ItemOwner,2123		));21242125		let variable_data = b"1234567890123".to_vec();2126		assert_noop!(2127			TemplateModule::set_variable_meta_data(2128				origin1,2129				collection_id,2130				TokenId(1),2131				variable_data.clone()2132			).map_err(|e| e.error),2133			CommonError::<Test>::TokenVariableDataLimitExceeded2134		);2135	})2136}21372138#[test]2139fn collection_transfer_flag_works() {2140	new_test_ext().execute_with(|| {2141		let origin1 = Origin::signed(1);21422143		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2144		assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, collection_id, true));21452146		let data = default_nft_data();2147		create_test_item(collection_id, &data.into());2148		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2149		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);21502151		let origin1 = Origin::signed(1);21522153		// default scenario2154		assert_ok!(TemplateModule::transfer(origin1, account(2), collection_id, TokenId(1), 1));2155		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);2156		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);2157		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);2158		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);2159	});2160}21612162#[test]2163fn set_variable_meta_data_on_nft_with_admin_flag() {2164	new_test_ext().execute_with(|| {2165		// default_limits();21662167		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));21682169		let origin1 = Origin::signed(1);2170		let origin2 = Origin::signed(2);21712172		assert_ok!(TemplateModule::set_mint_permission(2173			origin2.clone(),2174			collection_id,2175			true2176		));2177		assert_ok!(TemplateModule::add_to_allow_list(2178			origin2.clone(),2179			collection_id,2180			account(1)2181		));21822183		assert_ok!(TemplateModule::add_collection_admin(2184			origin2.clone(),2185			collection_id,2186			account(1)2187		));21882189		let data = default_nft_data();2190		create_test_item(collection_id, &data.into());21912192		assert_ok!(TemplateModule::set_meta_update_permission_flag(2193			origin2.clone(),2194			collection_id,2195			MetaUpdatePermission::Admin,2196		));21972198		let variable_data = b"test.".to_vec();2199		assert_ok!(TemplateModule::set_variable_meta_data(2200			origin1,2201			collection_id,2202			TokenId(1),2203			variable_data.clone()2204		));22052206		assert_eq!(2207			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))2208				.unwrap()2209				.variable_data,2210			variable_data2211		);2212	});2213}22142215#[test]2216fn set_variable_meta_data_on_nft_with_admin_flag_neg() {2217	new_test_ext().execute_with(|| {2218		// default_limits();22192220		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));22212222		let origin1 = Origin::signed(1);2223		let origin2 = Origin::signed(2);22242225		assert_ok!(TemplateModule::set_mint_permission(2226			origin2.clone(),2227			collection_id,2228			true2229		));2230		assert_ok!(TemplateModule::add_to_allow_list(2231			origin2.clone(),2232			collection_id,2233			account(1)2234		));22352236		let data = default_nft_data();2237		create_test_item(collection_id, &data.into());22382239		assert_ok!(TemplateModule::set_meta_update_permission_flag(2240			origin2.clone(),2241			collection_id,2242			MetaUpdatePermission::Admin,2243		));22442245		let variable_data = b"test.".to_vec();2246		assert_noop!(2247			TemplateModule::set_variable_meta_data(2248				origin1,2249				collection_id,2250				TokenId(1),2251				variable_data.clone()2252			).map_err(|e| e.error),2253			CommonError::<Test>::NoPermission2254		);2255	});2256}22572258#[test]2259fn set_variable_meta_flag_after_freeze() {2260	new_test_ext().execute_with(|| {2261		// default_limits();22622263		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));22642265		let origin2 = Origin::signed(2);22662267		assert_ok!(TemplateModule::set_meta_update_permission_flag(2268			origin2.clone(),2269			collection_id,2270			MetaUpdatePermission::None,2271		));2272		assert_noop!(2273			TemplateModule::set_meta_update_permission_flag(2274				origin2.clone(),2275				collection_id,2276				MetaUpdatePermission::Admin2277			),2278			CommonError::<Test>::MetadataFlagFrozen2279		);2280	});2281}22822283#[test]2284fn set_variable_meta_data_on_nft_with_none_flag_neg() {2285	new_test_ext().execute_with(|| {2286		// default_limits();22872288		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));2289		let origin1 = Origin::signed(1);22902291		let data = default_nft_data();2292		create_test_item(collection_id, &data.into());22932294		assert_ok!(TemplateModule::set_meta_update_permission_flag(2295			origin1.clone(),2296			collection_id,2297			MetaUpdatePermission::None,2298		));22992300		let variable_data = b"test.".to_vec();2301		assert_noop!(2302			TemplateModule::set_variable_meta_data(2303				origin1.clone(),2304				collection_id,2305				TokenId(1),2306				variable_data.clone()2307			).map_err(|e| e.error),2308			CommonError::<Test>::NoPermission2309		);2310	});2311}23122313#[test]2314fn collection_transfer_flag_works_neg() {2315	new_test_ext().execute_with(|| {2316		let origin1 = Origin::signed(1);23172318		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2319		assert_ok!(TemplateModule::set_transfers_enabled_flag(2320			origin1, collection_id, false2321		));23222323		let data = default_nft_data();2324		create_test_item(collection_id, &data.into());2325		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2326		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);23272328		let origin1 = Origin::signed(1);23292330		// default scenario2331		assert_noop!(2332			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),2333			CommonError::<Test>::TransferNotAllowed2334		);2335		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2336		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 0);2337		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);2338		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), false);2339	});2340}