git.delta.rocks / unique-network / refs/commits / 859444d47d73

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};10// use crate::{AccessMode, CollectionMode, Ownership, CreateItemData};11// use up_data_structs::{12// 	CreateNftData, CreateFungibleData, CreateReFungibleData, CollectionId, TokenId,13// 	MAX_DECIMAL_POINTS,14// };1516use frame_support::{assert_noop, assert_ok};17use sp_std::convert::TryInto;1819fn default_nft_data() -> CreateNftData {20	CreateNftData {21		const_data: vec![1, 2, 3].try_into().unwrap(),22		variable_data: vec![3, 2, 1].try_into().unwrap(),23	}24}2526fn default_fungible_data() -> CreateFungibleData {27	CreateFungibleData { value: 5 }28}2930fn default_re_fungible_data() -> CreateReFungibleData {31	CreateReFungibleData {32		const_data: vec![1, 2, 3].try_into().unwrap(),33		variable_data: vec![3, 2, 1].try_into().unwrap(),34		pieces: 1023,35	}36}3738fn create_test_collection_for_owner(39	mode: &CollectionMode,40	owner: u64,41	id: CollectionId,42) -> CollectionId {43	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();44	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();45	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();4647	let origin1 = Origin::signed(owner);48	assert_ok!(TemplateModule::create_collection(49		origin1,50		col_name1,51		col_desc1,52		token_prefix1,53		mode.clone()54	));5556	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();57	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();58	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();59	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().owner, owner);60	assert_eq!(61		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,62		saved_col_name63	);64	assert_eq!(<pallet_common::CollectionById<Test>>::get(id).unwrap().mode, *mode);65	assert_eq!(66		<pallet_common::CollectionById<Test>>::get(id).unwrap().description,67		saved_description68	);69	assert_eq!(70		<pallet_common::CollectionById<Test>>::get(id).unwrap().token_prefix,71		saved_prefix72	);73	id74}7576fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {77	create_test_collection_for_owner(&mode, 1, id)78}7980fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {81	let origin1 = Origin::signed(1);82	assert_ok!(TemplateModule::create_item(83		origin1,84		collection_id,85		account(1),86		data.clone()87	));88}8990fn account(sub: u64) -> TestCrossAccountId {91	TestCrossAccountId::from_sub(sub)92}9394// Use cases tests region95// #region9697#[test]98fn set_version_schema() {99	new_test_ext().execute_with(|| {100		let origin1 = Origin::signed(1);101		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));102103		assert_ok!(TemplateModule::set_schema_version(104			origin1,105			collection_id,106			SchemaVersion::Unique107		));108		assert_eq!(109			<pallet_common::CollectionById<Test>>::get(collection_id)110				.unwrap()111				.schema_version,112			SchemaVersion::Unique113		);114	});115}116117#[test]118fn create_fungible_collection_fails_with_large_decimal_numbers() {119	new_test_ext().execute_with(|| {120		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();121		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();122		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();123124		let origin1 = Origin::signed(1);125		assert_noop!(126			TemplateModule::create_collection(127				origin1,128				col_name1,129				col_desc1,130				token_prefix1,131				CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)132			),133			Error::<Test>::CollectionDecimalPointLimitExceeded134		);135	});136}137138#[test]139fn create_nft_item() {140	new_test_ext().execute_with(|| {141		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));142143		let data = default_nft_data();144		create_test_item(collection_id, &data.clone().into());145146		let item = <pallet_nonfungible::TokenData<Test>>::get((collection_id, 1)).unwrap();147		assert_eq!(item.const_data, data.const_data.into_inner());148		assert_eq!(item.variable_data, data.variable_data.into_inner());149	});150}151152// Use cases tests region153// #region154#[test]155fn create_nft_multiple_items() {156	new_test_ext().execute_with(|| {157		create_test_collection(&CollectionMode::NFT, CollectionId(1));158159		let origin1 = Origin::signed(1);160161		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];162163		assert_ok!(TemplateModule::create_multiple_items(164			origin1,165			CollectionId(1),166			account(1),167			items_data168				.clone()169				.into_iter()170				.map(|d| { d.into() })171				.collect()172		));173		for (index, data) in items_data.into_iter().enumerate() {174			let item = <pallet_nonfungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32))).unwrap();175			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());176			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());177		}178	});179}180181#[test]182fn create_refungible_item() {183	new_test_ext().execute_with(|| {184		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));185186		let data = default_re_fungible_data();187		create_test_item(collection_id, &data.clone().into());188		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));189		let balance = <pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));190		assert_eq!(item.const_data, data.const_data.into_inner());191		assert_eq!(item.variable_data, data.variable_data.into_inner());192		assert_eq!(balance, 1023);193	});194}195196#[test]197fn create_multiple_refungible_items() {198	new_test_ext().execute_with(|| {199		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));200201		let origin1 = Origin::signed(1);202203		let items_data = vec![204			default_re_fungible_data(),205			default_re_fungible_data(),206			default_re_fungible_data(),207		];208209		assert_ok!(TemplateModule::create_multiple_items(210			origin1,211			CollectionId(1),212			account(1),213			items_data214				.clone()215				.into_iter()216				.map(|d| { d.into() })217				.collect()218		));219		for (index, data) in items_data.into_iter().enumerate() {220			let item = <pallet_refungible::TokenData<Test>>::get((CollectionId(1), TokenId((index + 1) as u32)));221			let balance = <pallet_refungible::Balance<Test>>::get((CollectionId(1), TokenId(1), account(1)));222			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());223			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());224			assert_eq!(balance, 1023);225		}226	});227}228229#[test]230fn create_fungible_item() {231	new_test_ext().execute_with(|| {232		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));233234		let data = default_fungible_data();235		create_test_item(collection_id, &data.into());236237		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);238	});239}240241//#[test]242// fn create_multiple_fungible_items() {243//     new_test_ext().execute_with(|| {244//         default_limits();245246//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));247248//         let origin1 = Origin::signed(1);249250//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];251252//         assert_ok!(TemplateModule::create_multiple_items(253//             origin1.clone(),254//             1,255//             1,256//             items_data.clone().into_iter().map(|d| { d.into() }).collect()257//         ));258259//         for (index, _) in items_data.iter().enumerate() {260//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);261//         }262//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);263//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);264//     });265// }266267#[test]268fn transfer_fungible_item() {269	new_test_ext().execute_with(|| {270		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));271272		let origin1 = Origin::signed(1);273		let origin2 = Origin::signed(2);274275		let data = default_fungible_data();276		create_test_item(collection_id, &data.into());277278		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 5);279280		// change owner scenario281		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(0), 5));282		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))), 0);283284		// split item scenario285		assert_ok!(TemplateModule::transfer(286			origin2.clone(),287			account(3),288			CollectionId(1),289			TokenId(0),290			3291		));292293		// split item and new owner has account scenario294		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(0), 1));295		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))), 1);296		assert_eq!(<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))), 4);297	});298}299300#[test]301fn transfer_refungible_item() {302	new_test_ext().execute_with(|| {303		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));304305		// Create RFT 1 in 1023 pieces for account 1306		let data = default_re_fungible_data();307		create_test_item(collection_id, &data.clone().into());308		let item = <pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)));309		assert_eq!(item.const_data, data.const_data.into_inner());310		assert_eq!(item.variable_data, data.variable_data.into_inner());311		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);312		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);313		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);314315		// Account 1 transfers all 1023 pieces of RFT 1 to account 2316		let origin1 = Origin::signed(1);317		let origin2 = Origin::signed(2);318		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1023));319		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 1023);320		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);321		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);322		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);323		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);324325		// Account 2 transfers 500 pieces of RFT 1 to account 3326		assert_ok!(TemplateModule::transfer(327			origin2.clone(),328			account(3),329			CollectionId(1),330			TokenId(1),331			500332		));333		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 523);334		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 500);335		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);336		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);337		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);338		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);339340		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance341		assert_ok!(TemplateModule::transfer(origin2, account(3), CollectionId(1), TokenId(1), 200));342		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))), 323);343		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 700);344		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);345		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);346		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);347		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))), true);348	});349}350351#[test]352fn transfer_nft_item() {353	new_test_ext().execute_with(|| {354		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));355356		let data = default_nft_data();357		create_test_item(collection_id, &data.into());358		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);359		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);360361362		let origin1 = Origin::signed(1);363		// default scenario364		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));365		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);366		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);367		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);368		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);369	});370}371372#[test]373fn transfer_nft_item_wrong_value() {374	new_test_ext().execute_with(|| {375		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));376377		let data = default_nft_data();378		create_test_item(collection_id, &data.into());379		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);380		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);381382		let origin1 = Origin::signed(1);383384		assert_noop!(385			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2).map_err(|e| e.error),386			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount387		);388	});389}390391#[test]392fn transfer_nft_item_zero_value() {393	new_test_ext().execute_with(|| {394		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));395396		let data = default_nft_data();397		create_test_item(collection_id, &data.into());398		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);399		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);400401		let origin1 = Origin::signed(1);402403		// Transferring 0 amount works on NFT...404		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 0));405		// ... and results in no transfer406		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);407		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);408	});409}410411#[test]412fn nft_approve_and_transfer_from() {413	new_test_ext().execute_with(|| {414		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));415416		let data = default_nft_data();417		create_test_item(collection_id, &data.into());418419		let origin1 = Origin::signed(1);420		let origin2 = Origin::signed(2);421422		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);423		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);424425		// neg transfer_from426		assert_noop!(427			TemplateModule::transfer_from(origin2.clone(), account(1), account(2), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),428			CommonError::<Test>::TokenValueNotEnough429		);430431		// do approve432		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));433		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));434435		assert_ok!(TemplateModule::transfer_from(436			origin2,437			account(1),438			account(3),439			CollectionId(1),440			TokenId(1),441			1442		));443		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());444	});445}446447#[test]448fn nft_approve_and_transfer_from_allow_list() {449	new_test_ext().execute_with(|| {450		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));451452		let origin1 = Origin::signed(1);453		let origin2 = Origin::signed(2);454455		// Create NFT 1 for account 1456		let data = default_nft_data();457		create_test_item(collection_id, &data.clone().into());458		assert_eq!(459			&<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1))).unwrap().const_data,460			&data.const_data.into_inner()461		);462		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);463		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);464465		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list466		assert_ok!(TemplateModule::set_mint_permission(467			origin1.clone(),468			CollectionId(1),469			true470		));471		assert_ok!(TemplateModule::set_public_access_mode(472			origin1.clone(),473			CollectionId(1),474			AccessMode::AllowList475		));476		assert_ok!(TemplateModule::add_to_allow_list(477			origin1.clone(),478			CollectionId(1),479			account(1)480		));481		assert_ok!(TemplateModule::add_to_allow_list(482			origin1.clone(),483			CollectionId(1),484			account(2)485		));486		assert_ok!(TemplateModule::add_to_allow_list(487			origin1.clone(),488			CollectionId(1),489			account(3)490		));491492		// Account 1 approves account 2 for NFT 1 493		assert_ok!(TemplateModule::approve(494			origin1.clone(),495			account(2),496			CollectionId(1),497			TokenId(1),498			1499		));500		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));501502		// Account 2 transfers NFT 1 from account 1 to account 3503		assert_ok!(TemplateModule::transfer_from(504			origin2,505			account(1),506			account(3),507			CollectionId(1),508			TokenId(1),509			1510		));511		assert!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none());512	});513}514515#[test]516fn refungible_approve_and_transfer_from() {517	new_test_ext().execute_with(|| {518		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));519520		let origin1 = Origin::signed(1);521		let origin2 = Origin::signed(2);522523		// Create RFT 1 in 1023 pieces for account 1524		let data = default_re_fungible_data();525		create_test_item(collection_id, &data.into());526527		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);528		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);529		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);530531		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list532		assert_ok!(TemplateModule::set_mint_permission(533			origin1.clone(),534			CollectionId(1),535			true536		));537		assert_ok!(TemplateModule::set_public_access_mode(538			origin1.clone(),539			CollectionId(1),540			AccessMode::AllowList541		));542		assert_ok!(TemplateModule::add_to_allow_list(543			origin1.clone(),544			CollectionId(1),545			account(1)546		));547		assert_ok!(TemplateModule::add_to_allow_list(548			origin1.clone(),549			CollectionId(1),550			account(2)551		));552		assert_ok!(TemplateModule::add_to_allow_list(553			origin1.clone(),554			CollectionId(1),555			account(3)556		));557558		// Account 1 approves account 2 for 1023 pieces of RFT 1559		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1023));560		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 1023);561562		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3563		assert_ok!(TemplateModule::transfer_from(564			origin2,565			account(1),566			account(3),567			CollectionId(1),568			TokenId(1),569			100570		));571		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);572		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))), 1);573		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 923);574		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))), 100);575		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);576		assert_eq!(<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);577		assert_eq!(<pallet_refungible::Allowance<Test>>::get((CollectionId(1), TokenId(1), account(1), account(2))), 923);578	});579}580581#[test]582fn fungible_approve_and_transfer_from() {583	new_test_ext().execute_with(|| {584		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));585586		let data = default_fungible_data();587		create_test_item(collection_id, &data.into());588589		let origin1 = Origin::signed(1);590		let origin2 = Origin::signed(2);591592		assert_ok!(TemplateModule::set_mint_permission(593			origin1.clone(),594			CollectionId(1),595			true596		));597		assert_ok!(TemplateModule::set_public_access_mode(598			origin1.clone(),599			CollectionId(1),600			AccessMode::AllowList601		));602		assert_ok!(TemplateModule::add_to_allow_list(603			origin1.clone(),604			CollectionId(1),605			account(1)606		));607		assert_ok!(TemplateModule::add_to_allow_list(608			origin1.clone(),609			CollectionId(1),610			account(2)611		));612		assert_ok!(TemplateModule::add_to_allow_list(613			origin1.clone(),614			CollectionId(1),615			account(3)616		));617618		// do approve619		assert_ok!(TemplateModule::approve(620			origin1.clone(),621			account(2),622			CollectionId(1),623			TokenId(0),624			5625		));626		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);627		assert_ok!(TemplateModule::approve(origin1, account(3), CollectionId(1), TokenId(0), 5));628		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 5);629		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))), 5);630631		assert_ok!(TemplateModule::transfer_from(632			origin2.clone(),633			account(1),634			account(3),635			CollectionId(1),636			TokenId(0),637			4638		));639640		assert_eq!(<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))), 1);641642		assert_noop!(643			TemplateModule::transfer_from(origin2, account(1), account(3), CollectionId(1), TokenId(0), 4).map_err(|e| e.error),644			CommonError::<Test>::TokenValueNotEnough645		);646	});647}648649#[test]650fn change_collection_owner() {651	new_test_ext().execute_with(|| {652		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));653654		let origin1 = Origin::signed(1);655		assert_ok!(TemplateModule::change_collection_owner(656			origin1,657			collection_id,658			2659		));660		assert_eq!(661			<pallet_common::CollectionById<Test>>::get(collection_id).unwrap().owner,662			2663		);664	});665}666667#[test]668fn destroy_collection() {669	new_test_ext().execute_with(|| {670		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));671672		let origin1 = Origin::signed(1);673		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));674	});675}676677#[test]678fn burn_nft_item() {679	new_test_ext().execute_with(|| {680		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));681682		let origin1 = Origin::signed(1);683684		let data = default_nft_data();685		create_test_item(collection_id, &data.into());686687		// check balance (collection with id = 1, user id = 1)688		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);689690		// burn item691		assert_ok!(TemplateModule::burn_item(692			origin1.clone(),693			collection_id,694			TokenId(1),695			1696		));697		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);698	});699}700701#[test]702fn burn_same_nft_item_twice() {703	new_test_ext().execute_with(|| {704		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));705706		let origin1 = Origin::signed(1);707708		let data = default_nft_data();709		create_test_item(collection_id, &data.into());710711		// check balance (collection with id = 1, user id = 1)712		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);713714		// burn item715		assert_ok!(TemplateModule::burn_item(716			origin1.clone(),717			collection_id,718			TokenId(1),719			1720		));721		722		// burn item again723		assert_noop!(724			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),725			CommonError::<Test>::TokenNotFound726		);727728		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);729	});730}731732#[test]733fn burn_fungible_item() {734	new_test_ext().execute_with(|| {735		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));736737		let origin1 = Origin::signed(1);738		assert_ok!(TemplateModule::add_collection_admin(739			origin1.clone(),740			collection_id,741			account(2)742		));743744		let data = default_fungible_data();745		create_test_item(collection_id, &data.into());746747		// check balance (collection with id = 1, user id = 1)748		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);749750		// burn item751		assert_ok!(TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(0), 5));752		assert_noop!(753			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),754			CommonError::<Test>::TokenValueTooLow755		);756757		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 0);758	});759}760761#[test]762fn burn_fungible_item_with_token_id() {763	new_test_ext().execute_with(|| {764		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));765766		let origin1 = Origin::signed(1);767		assert_ok!(TemplateModule::add_collection_admin(768			origin1.clone(),769			collection_id,770			account(2)771		));772773		let data = default_fungible_data();774		create_test_item(collection_id, &data.into());775776		// check balance (collection with id = 1, user id = 1)777		assert_eq!(<pallet_fungible::Balance<Test>>::get((collection_id, account(1))), 5);778779		// Try to burn item using Token ID780		assert_noop!(781			TemplateModule::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),782			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId783		);784	});785}786#[test]787fn burn_refungible_item() {788	new_test_ext().execute_with(|| {789		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));790		let origin1 = Origin::signed(1);791792		assert_ok!(TemplateModule::set_mint_permission(793			origin1.clone(),794			collection_id,795			true796		));797		assert_ok!(TemplateModule::set_public_access_mode(798			origin1.clone(),799			collection_id,800			AccessMode::AllowList801		));802		assert_ok!(TemplateModule::add_to_allow_list(803			origin1.clone(),804			collection_id,805			account(1)806		));807808		assert_ok!(TemplateModule::add_collection_admin(809			origin1.clone(),810			collection_id,811			account(2)812		));813814		let data = default_re_fungible_data();815		create_test_item(collection_id, &data.into());816817		// check balance (collection with id = 1, user id = 2)818		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);819		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 1023);820821		// burn item822		assert_ok!(TemplateModule::burn_item(origin1.clone(), collection_id, TokenId(1), 1023));823		assert_noop!(824			TemplateModule::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),825			CommonError::<Test>::TokenValueTooLow826		);827828		assert_eq!(<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))), 0);829	});830}831832#[test]833fn add_collection_admin() {834	new_test_ext().execute_with(|| {835		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));836		let origin1 = Origin::signed(1);837838		// Add collection admins839		assert_ok!(TemplateModule::add_collection_admin(840			origin1.clone(),841			collection1_id,842			account(2)843		));844		assert_ok!(TemplateModule::add_collection_admin(845			origin1,846			collection1_id,847			account(3)848		));849850		// Owner is not an admin by default851		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))), false);852		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));853		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));854	});855}856857#[test]858fn remove_collection_admin() {859	new_test_ext().execute_with(|| {860		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));861		let origin1 = Origin::signed(1);862		let origin2 = Origin::signed(2);863864		// Add collection admins 2 and 3865		assert_ok!(TemplateModule::add_collection_admin(866			origin1.clone(),867			collection1_id,868			account(2)869		));870		assert_ok!(TemplateModule::add_collection_admin(871			origin1,872			collection1_id,873			account(3)874		));875876		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));877		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))));878879		// remove admin 3880		assert_ok!(TemplateModule::remove_collection_admin(881			origin2,882			CollectionId(1),883			account(3)884		));885886		// 2 is still admin, 3 is not an admin anymore887		assert!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(2))));888		assert_eq!(<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))), false);889	});890}891892#[test]893fn balance_of() {894	new_test_ext().execute_with(|| {895		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));896		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));897		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(3));898899		// check balance before900		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 0);901		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 0);902		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 0);903904		let nft_data = default_nft_data();905		create_test_item(nft_collection_id, &nft_data.into());906907		let fungible_data = default_fungible_data();908		create_test_item(fungible_collection_id, &fungible_data.into());909910		let re_fungible_data = default_re_fungible_data();911		create_test_item(re_fungible_collection_id, &re_fungible_data.into());912913		// check balance (collection with id = 1, user id = 1)914		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))), 1);915		assert_eq!(<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))), 5);916		assert_eq!(<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))), 1);917918		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))), true);919		assert_eq!(<pallet_refungible::Owned<Test>>::get((re_fungible_collection_id, account(1), TokenId(1))), true);920	});921}922923#[test]924fn approve() {925	new_test_ext().execute_with(|| {926		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));927928		let data = default_nft_data();929		create_test_item(collection_id, &data.into());930931		let origin1 = Origin::signed(1);932933		// approve934		assert_ok!(TemplateModule::approve(origin1, account(2), CollectionId(1), TokenId(1), 1));935		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));936	});937}938939#[test]940fn transfer_from() {941	new_test_ext().execute_with(|| {942		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));943		let origin1 = Origin::signed(1);944		let origin2 = Origin::signed(2);945946		let data = default_nft_data();947		create_test_item(collection_id, &data.into());948949		// approve950		assert_ok!(TemplateModule::approve(951			origin1.clone(),952			account(2),953			CollectionId(1),954			TokenId(1),955			1956		));957		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(2));958959		assert_ok!(TemplateModule::set_mint_permission(960			origin1.clone(),961			CollectionId(1),962			true963		));964		assert_ok!(TemplateModule::set_public_access_mode(965			origin1.clone(),966			CollectionId(1),967			AccessMode::AllowList968		));969		assert_ok!(TemplateModule::add_to_allow_list(970			origin1.clone(),971			CollectionId(1),972			account(1)973		));974		assert_ok!(TemplateModule::add_to_allow_list(975			origin1.clone(),976			CollectionId(1),977			account(2)978		));979		assert_ok!(TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(3)));980981		assert_ok!(TemplateModule::transfer_from(982			origin2,983			account(1),984			account(2),985			CollectionId(1),986			TokenId(1),987			1988		));989990		// after transfer991		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))), 0);992		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))), 1);993	});994}995996// #endregion997998// Coverage tests region999// #region10001001#[test]1002fn owner_can_add_address_to_allow_list() {1003	new_test_ext().execute_with(|| {1004		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10051006		let origin1 = Origin::signed(1);1007		assert_ok!(TemplateModule::add_to_allow_list(1008			origin1,1009			collection_id,1010			account(2)1011		));1012		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1013	});1014}10151016#[test]1017fn admin_can_add_address_to_allow_list() {1018	new_test_ext().execute_with(|| {1019		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1020		let origin1 = Origin::signed(1);1021		let origin2 = Origin::signed(2);10221023		assert_ok!(TemplateModule::add_collection_admin(1024			origin1,1025			collection_id,1026			account(2)1027		));1028		assert_ok!(TemplateModule::add_to_allow_list(1029			origin2,1030			collection_id,1031			account(3)1032		));1033		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))));1034	});1035}10361037#[test]1038fn nonprivileged_user_cannot_add_address_to_allow_list() {1039	new_test_ext().execute_with(|| {1040		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10411042		let origin2 = Origin::signed(2);1043		assert_noop!(1044			TemplateModule::add_to_allow_list(origin2, collection_id, account(3)),1045			CommonError::<Test>::NoPermission1046		);1047	});1048}10491050#[test]1051fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1052	new_test_ext().execute_with(|| {1053		let origin1 = Origin::signed(1);10541055		assert_noop!(1056			TemplateModule::add_to_allow_list(origin1, CollectionId(1), account(2)),1057			CommonError::<Test>::CollectionNotFound1058		);1059	});1060}10611062#[test]1063fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1064	new_test_ext().execute_with(|| {1065		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10661067		let origin1 = Origin::signed(1);1068		assert_ok!(TemplateModule::destroy_collection(1069			origin1.clone(),1070			collection_id1071		));1072		assert_noop!(1073			TemplateModule::add_to_allow_list(origin1, collection_id, account(2)),1074			CommonError::<Test>::CollectionNotFound1075		);1076	});1077}10781079// If address is already added to allow list, nothing happens1080#[test]1081fn address_is_already_added_to_allow_list() {1082	new_test_ext().execute_with(|| {1083		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1084		let origin1 = Origin::signed(1);10851086		assert_ok!(TemplateModule::add_to_allow_list(1087			origin1.clone(),1088			collection_id,1089			account(2)1090		));1091		assert_ok!(TemplateModule::add_to_allow_list(1092			origin1,1093			collection_id,1094			account(2)1095		));1096		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1097	});1098}10991100#[test]1101fn owner_can_remove_address_from_allow_list() {1102	new_test_ext().execute_with(|| {1103		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));11041105		let origin1 = Origin::signed(1);1106		assert_ok!(TemplateModule::add_to_allow_list(1107			origin1.clone(),1108			collection_id,1109			account(2)1110		));1111		assert_ok!(TemplateModule::remove_from_allow_list(1112			origin1,1113			collection_id,1114			account(2)1115		));1116		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1117	});1118}11191120#[test]1121fn admin_can_remove_address_from_allow_list() {1122	new_test_ext().execute_with(|| {1123		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1124		let origin1 = Origin::signed(1);1125		let origin2 = Origin::signed(2);11261127		// Owner adds admin1128		assert_ok!(TemplateModule::add_collection_admin(1129			origin1.clone(),1130			collection_id,1131			account(2)1132		));11331134		// Owner adds address 3 to allow list1135		assert_ok!(TemplateModule::add_to_allow_list(1136			origin1,1137			collection_id,1138			account(3)1139		));11401141		// Admin removes address 3 from allow list1142		assert_ok!(TemplateModule::remove_from_allow_list(1143			origin2,1144			collection_id,1145			account(3)1146		));1147		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(3))), false);1148	});1149}11501151#[test]1152fn nonprivileged_user_cannot_remove_address_from_allow_list() {1153	new_test_ext().execute_with(|| {1154		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1155		let origin1 = Origin::signed(1);1156		let origin2 = Origin::signed(2);11571158		assert_ok!(TemplateModule::add_to_allow_list(1159			origin1,1160			collection_id,1161			account(2)1162		));1163		assert_noop!(1164			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1165			CommonError::<Test>::NoPermission1166		);1167		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));1168	});1169}11701171#[test]1172fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1173	new_test_ext().execute_with(|| {1174		let origin1 = Origin::signed(1);11751176		assert_noop!(1177			TemplateModule::remove_from_allow_list(origin1, CollectionId(1), account(2)),1178			CommonError::<Test>::CollectionNotFound1179		);1180	});1181}11821183#[test]1184fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1185	new_test_ext().execute_with(|| {1186		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1187		let origin1 = Origin::signed(1);1188		let origin2 = Origin::signed(2);11891190		// Add account 2 to allow list1191		assert_ok!(TemplateModule::add_to_allow_list(1192			origin1.clone(),1193			collection_id,1194			account(2)1195		));11961197		// Account 2 is in collection allow-list1198		assert!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))));11991200		// Destroy collection1201		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));12021203		// Attempt to remove account 2 from collection allow-list => error1204		assert_noop!(1205			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),1206			CommonError::<Test>::CollectionNotFound1207		);12081209		// Account 2 is not found in collection allow-list anyway1210		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1211	});1212}12131214// If address is already removed from allow list, nothing happens1215#[test]1216fn address_is_already_removed_from_allow_list() {1217	new_test_ext().execute_with(|| {1218		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1219		let origin1 = Origin::signed(1);12201221		assert_ok!(TemplateModule::add_to_allow_list(1222			origin1.clone(),1223			collection_id,1224			account(2)1225		));1226		assert_ok!(TemplateModule::remove_from_allow_list(1227			origin1.clone(),1228			collection_id,1229			account(2)1230		));1231		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1232		assert_ok!(TemplateModule::remove_from_allow_list(1233			origin1,1234			collection_id,1235			account(2)1236		));1237		assert_eq!(<pallet_common::Allowlist<Test>>::get((collection_id, account(2))), false);1238	});1239}12401241// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1242#[test]1243fn allow_list_test_1() {1244	new_test_ext().execute_with(|| {1245		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));12461247		let origin1 = Origin::signed(1);12481249		let data = default_nft_data();1250		create_test_item(collection_id, &data.into());12511252		assert_ok!(TemplateModule::set_public_access_mode(1253			origin1.clone(),1254			collection_id,1255			AccessMode::AllowList1256		));1257		assert_ok!(TemplateModule::add_to_allow_list(1258			origin1.clone(),1259			collection_id,1260			account(2)1261		));12621263		assert_noop!(1264			TemplateModule::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1265			CommonError::<Test>::AddressNotInAllowlist1266		);1267	});1268}12691270#[test]1271fn allow_list_test_2() {1272	new_test_ext().execute_with(|| {1273		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1274		let origin1 = Origin::signed(1);12751276		let data = default_nft_data();1277		create_test_item(collection_id, &data.into());12781279		assert_ok!(TemplateModule::set_public_access_mode(1280			origin1.clone(),1281			collection_id,1282			AccessMode::AllowList1283		));1284		assert_ok!(TemplateModule::add_to_allow_list(1285			origin1.clone(),1286			collection_id,1287			account(1)1288		));1289		assert_ok!(TemplateModule::add_to_allow_list(1290			origin1.clone(),1291			collection_id,1292			account(2)1293		));12941295		// do approve1296		assert_ok!(TemplateModule::approve(1297			origin1.clone(),1298			account(1),1299			collection_id,1300			TokenId(1),1301			11302		));1303		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));13041305		assert_ok!(TemplateModule::remove_from_allow_list(1306			origin1.clone(),1307			collection_id,1308			account(1)1309		));13101311		assert_noop!(1312			TemplateModule::transfer_from(origin1, account(1), account(3), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1313			CommonError::<Test>::AddressNotInAllowlist1314		);1315	});1316}13171318// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1319#[test]1320fn allow_list_test_3() {1321	new_test_ext().execute_with(|| {1322		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13231324		let origin1 = Origin::signed(1);13251326		let data = default_nft_data();1327		create_test_item(collection_id, &data.into());13281329		assert_ok!(TemplateModule::set_public_access_mode(1330			origin1.clone(),1331			collection_id,1332			AccessMode::AllowList1333		));1334		assert_ok!(TemplateModule::add_to_allow_list(1335			origin1.clone(),1336			collection_id,1337			account(1)1338		));13391340		assert_noop!(1341			TemplateModule::transfer(origin1, account(3), collection_id, TokenId(1), 1).map_err(|e| e.error),1342			CommonError::<Test>::AddressNotInAllowlist1343		);1344	});1345}13461347#[test]1348fn allow_list_test_4() {1349	new_test_ext().execute_with(|| {1350		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13511352		let origin1 = Origin::signed(1);13531354		let data = default_nft_data();1355		create_test_item(collection_id, &data.into());13561357		assert_ok!(TemplateModule::set_public_access_mode(1358			origin1.clone(),1359			collection_id,1360			AccessMode::AllowList1361		));1362		assert_ok!(TemplateModule::add_to_allow_list(1363			origin1.clone(),1364			collection_id,1365			account(1)1366		));1367		assert_ok!(TemplateModule::add_to_allow_list(1368			origin1.clone(),1369			collection_id,1370			account(2)1371		));13721373		// do approve1374		assert_ok!(TemplateModule::approve(1375			origin1.clone(),1376			account(1),1377			collection_id,1378			TokenId(1),1379			11380		));1381		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));13821383		assert_ok!(TemplateModule::remove_from_allow_list(1384			origin1.clone(),1385			collection_id,1386			account(2)1387		));13881389		assert_noop!(1390			TemplateModule::transfer_from(origin1, account(1), account(3), collection_id, TokenId(1), 1).map_err(|e| e.error),1391			CommonError::<Test>::AddressNotInAllowlist1392		);1393	});1394}13951396// 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)1397#[test]1398fn allow_list_test_5() {1399	new_test_ext().execute_with(|| {1400		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14011402		let origin1 = Origin::signed(1);14031404		let data = default_nft_data();1405		create_test_item(collection_id, &data.into());14061407		assert_ok!(TemplateModule::set_public_access_mode(1408			origin1.clone(),1409			collection_id,1410			AccessMode::AllowList1411		));1412		assert_noop!(1413			TemplateModule::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1414			CommonError::<Test>::AddressNotInAllowlist1415		);1416	});1417}14181419// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1420#[test]1421fn allow_list_test_6() {1422	new_test_ext().execute_with(|| {1423		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14241425		let origin1 = Origin::signed(1);14261427		let data = default_nft_data();1428		create_test_item(collection_id, &data.into());14291430		assert_ok!(TemplateModule::set_public_access_mode(1431			origin1.clone(),1432			collection_id,1433			AccessMode::AllowList1434		));14351436		// do approve1437		assert_noop!(1438			TemplateModule::approve(origin1, account(1), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1439			CommonError::<Test>::AddressNotInAllowlist1440		);1441	});1442}14431444// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1445//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1446#[test]1447fn allow_list_test_7() {1448	new_test_ext().execute_with(|| {1449		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14501451		let data = default_nft_data();1452		create_test_item(collection_id, &data.into());14531454		let origin1 = Origin::signed(1);14551456		assert_ok!(TemplateModule::set_public_access_mode(1457			origin1.clone(),1458			collection_id,1459			AccessMode::AllowList1460		));1461		assert_ok!(TemplateModule::add_to_allow_list(1462			origin1.clone(),1463			collection_id,1464			account(1)1465		));1466		assert_ok!(TemplateModule::add_to_allow_list(1467			origin1.clone(),1468			collection_id,1469			account(2)1470		));14711472		assert_ok!(TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1));1473	});1474}14751476#[test]1477fn allow_list_test_8() {1478	new_test_ext().execute_with(|| {1479		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14801481		// Create NFT for account 11482		let data = default_nft_data();1483		create_test_item(collection_id, &data.into());14841485		let origin1 = Origin::signed(1);14861487		// Toggle Allow List mode and add accounts 1 and 21488		assert_ok!(TemplateModule::set_public_access_mode(1489			origin1.clone(),1490			collection_id,1491			AccessMode::AllowList1492		));1493		assert_ok!(TemplateModule::add_to_allow_list(1494			origin1.clone(),1495			collection_id,1496			account(1)1497		));1498		assert_ok!(TemplateModule::add_to_allow_list(1499			origin1.clone(),1500			collection_id,1501			account(2)1502		));15031504		// Sself-approve account 1 for NFT 11505		assert_ok!(TemplateModule::approve(1506			origin1.clone(),1507			account(1),1508			CollectionId(1), 1509			TokenId(1),1510			11511		));1512		assert_eq!(<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(), account(1));15131514		// Transfer from 1 to 21515		assert_ok!(TemplateModule::transfer_from(1516			origin1,1517			account(1),1518			account(2),1519			CollectionId(1), 1520			TokenId(1),1521			11522		));1523	});1524}15251526// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.1527#[test]1528fn allow_list_test_9() {1529	new_test_ext().execute_with(|| {1530		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1531		let origin1 = Origin::signed(1);15321533		assert_ok!(TemplateModule::set_public_access_mode(1534			origin1.clone(),1535			collection_id,1536			AccessMode::AllowList1537		));1538		assert_ok!(TemplateModule::set_mint_permission(1539			origin1,1540			collection_id,1541			false1542		));15431544		let data = default_nft_data();1545		create_test_item(collection_id, &data.into());1546	});1547}15481549// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.1550#[test]1551fn allow_list_test_10() {1552	new_test_ext().execute_with(|| {1553		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15541555		let origin1 = Origin::signed(1);1556		let origin2 = Origin::signed(2);15571558		assert_ok!(TemplateModule::set_public_access_mode(1559			origin1.clone(),1560			collection_id,1561			AccessMode::AllowList1562		));1563		assert_ok!(TemplateModule::set_mint_permission(1564			origin1.clone(),1565			collection_id,1566			false1567		));15681569		assert_ok!(TemplateModule::add_collection_admin(1570			origin1,1571			collection_id,1572			account(2)1573		));15741575		assert_ok!(TemplateModule::create_item(1576			origin2,1577			collection_id,1578			account(2),1579			default_nft_data().into()1580		));1581	});1582}15831584// 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.1585#[test]1586fn allow_list_test_11() {1587	new_test_ext().execute_with(|| {1588		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15891590		let origin1 = Origin::signed(1);1591		let origin2 = Origin::signed(2);15921593		assert_ok!(TemplateModule::set_public_access_mode(1594			origin1.clone(),1595			collection_id,1596			AccessMode::AllowList1597		));1598		assert_ok!(TemplateModule::set_mint_permission(1599			origin1.clone(),1600			collection_id,1601			false1602		));1603		assert_ok!(TemplateModule::add_to_allow_list(1604			origin1,1605			collection_id,1606			account(2)1607		));16081609		assert_noop!(1610			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()).map_err(|e| e.error),1611			CommonError::<Test>::PublicMintingNotAllowed1612		);1613	});1614}16151616// 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.1617#[test]1618fn allow_list_test_12() {1619	new_test_ext().execute_with(|| {1620		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16211622		let origin1 = Origin::signed(1);1623		let origin2 = Origin::signed(2);16241625		assert_ok!(TemplateModule::set_public_access_mode(1626			origin1.clone(),1627			collection_id,1628			AccessMode::AllowList1629		));1630		assert_ok!(TemplateModule::set_mint_permission(1631			origin1,1632			collection_id,1633			false1634		));16351636		assert_noop!(1637			TemplateModule::create_item(origin2, CollectionId(1), account(2), default_nft_data().into()).map_err(|e| e.error),1638			CommonError::<Test>::PublicMintingNotAllowed1639		);1640	});1641}16421643// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.1644#[test]1645fn allow_list_test_13() {1646	new_test_ext().execute_with(|| {1647		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16481649		let origin1 = Origin::signed(1);16501651		assert_ok!(TemplateModule::set_public_access_mode(1652			origin1.clone(),1653			collection_id,1654			AccessMode::AllowList1655		));1656		assert_ok!(TemplateModule::set_mint_permission(1657			origin1,1658			collection_id,1659			true1660		));16611662		let data = default_nft_data();1663		create_test_item(collection_id, &data.into());1664	});1665}16661667// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.1668#[test]1669fn allow_list_test_14() {1670	new_test_ext().execute_with(|| {1671		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));16721673		let origin1 = Origin::signed(1);1674		let origin2 = Origin::signed(2);16751676		assert_ok!(TemplateModule::set_public_access_mode(1677			origin1.clone(),1678			collection_id,1679			AccessMode::AllowList1680		));1681		assert_ok!(TemplateModule::set_mint_permission(1682			origin1.clone(),1683			collection_id,1684			true1685		));16861687		assert_ok!(TemplateModule::add_collection_admin(1688			origin1,1689			collection_id,1690			account(2)1691		));16921693		assert_ok!(TemplateModule::create_item(1694			origin2,1695			collection_id,1696			account(2),1697			default_nft_data().into()1698		));1699	});1700}17011702// 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.1703#[test]1704fn allow_list_test_15() {1705	new_test_ext().execute_with(|| {1706		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17071708		let origin1 = Origin::signed(1);1709		let origin2 = Origin::signed(2);17101711		assert_ok!(TemplateModule::set_public_access_mode(1712			origin1.clone(),1713			collection_id,1714			AccessMode::AllowList1715		));1716		assert_ok!(TemplateModule::set_mint_permission(1717			origin1,1718			collection_id,1719			true1720		));17211722		assert_noop!(1723			TemplateModule::create_item(origin2, collection_id, account(2), default_nft_data().into()).map_err(|e| e.error),1724			CommonError::<Test>::AddressNotInAllowlist1725		);1726	});1727}17281729// 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.1730#[test]1731fn allow_list_test_16() {1732	new_test_ext().execute_with(|| {1733		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17341735		let origin1 = Origin::signed(1);1736		let origin2 = Origin::signed(2);17371738		assert_ok!(TemplateModule::set_public_access_mode(1739			origin1.clone(),1740			collection_id,1741			AccessMode::AllowList1742		));1743		assert_ok!(TemplateModule::set_mint_permission(1744			origin1.clone(),1745			collection_id,1746			true1747		));1748		assert_ok!(TemplateModule::add_to_allow_list(1749			origin1,1750			collection_id,1751			account(2)1752		));17531754		assert_ok!(TemplateModule::create_item(1755			origin2,1756			collection_id,1757			account(2),1758			default_nft_data().into()1759		));1760	});1761}17621763// Total number of collections. Positive test1764#[test]1765fn total_number_collections_bound() {1766	new_test_ext().execute_with(|| {1767		create_test_collection(&CollectionMode::NFT, CollectionId(1));1768	});1769}17701771#[test]1772fn create_max_collections() {1773	new_test_ext().execute_with(|| {1774		for i in 1..=COLLECTION_NUMBER_LIMIT {1775			create_test_collection(&CollectionMode::NFT, CollectionId(i));1776		}1777	});1778}17791780// Total number of collections. Negative test1781#[test]1782fn total_number_collections_bound_neg() {1783	new_test_ext().execute_with(|| {1784		let origin1 = Origin::signed(1);17851786		for i in 1..=COLLECTION_NUMBER_LIMIT {1787			create_test_collection(&CollectionMode::NFT, CollectionId(i));1788		}17891790		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1791		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1792		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();17931794		// 11-th collection in chain. Expects error1795		assert_noop!(1796			TemplateModule::create_collection(1797				origin1,1798				col_name1,1799				col_desc1,1800				token_prefix1,1801				CollectionMode::NFT1802			),1803			CommonError::<Test>::TotalCollectionsLimitExceeded1804		);1805	});1806}18071808// Owned tokens by a single address. Positive test1809#[test]1810fn owned_tokens_bound() {1811	new_test_ext().execute_with(|| {1812		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18131814		let data = default_nft_data();1815		create_test_item(collection_id, &data.clone().into());1816		create_test_item(collection_id, &data.into());1817	});1818}18191820// Owned tokens by a single address. Negotive test1821#[test]1822fn owned_tokens_bound_neg() {1823	new_test_ext().execute_with(|| {1824		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18251826		let origin1 = Origin::signed(1);18271828		for _ in 1..=MAX_TOKEN_OWNERSHIP {1829			let data = default_nft_data();1830			create_test_item(collection_id, &data.clone().into());1831		}18321833		let data = default_nft_data();1834		assert_noop!(1835			TemplateModule::create_item(origin1, CollectionId(1), account(1), data.into()).map_err(|e| e.error),1836			CommonError::<Test>::AccountTokenLimitExceeded1837		);1838	});1839}18401841// Number of collection admins. Positive test1842#[test]1843fn collection_admins_bound() {1844	new_test_ext().execute_with(|| {1845		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18461847		let origin1 = Origin::signed(1);18481849		assert_ok!(TemplateModule::add_collection_admin(1850			origin1.clone(),1851			collection_id,1852			account(2)1853		));1854		assert_ok!(TemplateModule::add_collection_admin(1855			origin1,1856			collection_id,1857			account(3)1858		));1859	});1860}18611862// Number of collection admins. Negotive test1863#[test]1864fn collection_admins_bound_neg() {1865	new_test_ext().execute_with(|| {1866		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18671868		let origin1 = Origin::signed(1);18691870		for i in 0..COLLECTION_ADMINS_LIMIT {1871			assert_ok!(TemplateModule::add_collection_admin(1872				origin1.clone(),1873				collection_id,1874				account((2 + i).into())1875			));1876		}1877		assert_noop!(1878			TemplateModule::add_collection_admin(1879				origin1,1880				collection_id,1881				account((3 + COLLECTION_ADMINS_LIMIT).into())1882			),1883			CommonError::<Test>::CollectionAdminCountExceeded1884		);1885	});1886}1887// #endregion18881889#[test]1890fn set_const_on_chain_schema() {1891	new_test_ext().execute_with(|| {1892		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18931894		let origin1 = Origin::signed(1);1895		assert_ok!(TemplateModule::set_const_on_chain_schema(1896			origin1,1897			collection_id,1898			b"test const on chain schema".to_vec()1899		));19001901		assert_eq!(1902			<pallet_common::CollectionById<Test>>::get(collection_id)1903				.unwrap()1904				.const_on_chain_schema,1905			b"test const on chain schema".to_vec()1906		);1907		assert_eq!(1908			<pallet_common::CollectionById<Test>>::get(collection_id)1909				.unwrap()1910				.variable_on_chain_schema,1911			b"".to_vec()1912		);1913	});1914}19151916#[test]1917fn set_variable_on_chain_schema() {1918	new_test_ext().execute_with(|| {1919		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19201921		let origin1 = Origin::signed(1);1922		assert_ok!(TemplateModule::set_variable_on_chain_schema(1923			origin1,1924			collection_id,1925			b"test variable on chain schema".to_vec()1926		));19271928		assert_eq!(1929			<pallet_common::CollectionById<Test>>::get(collection_id)1930				.unwrap()1931				.const_on_chain_schema,1932			b"".to_vec()1933		);1934		assert_eq!(1935			<pallet_common::CollectionById<Test>>::get(collection_id)1936				.unwrap()1937				.variable_on_chain_schema,1938			b"test variable on chain schema".to_vec()1939		);1940	});1941}19421943#[test]1944fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1945	new_test_ext().execute_with(|| {1946		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19471948		let origin1 = Origin::signed(1);19491950		let data = default_nft_data();1951		create_test_item(CollectionId(1), &data.into());19521953		let variable_data = b"test data".to_vec();1954		assert_ok!(TemplateModule::set_variable_meta_data(1955			origin1,1956			collection_id,1957			TokenId(1),1958			variable_data.clone()1959		));19601961		assert_eq!(1962			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))1963				.unwrap()1964				.variable_data,1965			variable_data1966		);1967	});1968}19691970#[test]1971fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1972	new_test_ext().execute_with(|| {1973		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));19741975		let origin1 = Origin::signed(1);19761977		let data = default_re_fungible_data();1978		create_test_item(collection_id, &data.into());19791980		let variable_data = b"test data".to_vec();1981		assert_ok!(TemplateModule::set_variable_meta_data(1982			origin1,1983			collection_id,1984			TokenId(1),1985			variable_data.clone()1986		));19871988		assert_eq!(1989			<pallet_refungible::TokenData<Test>>::get((collection_id, TokenId(1)))1990				.variable_data,1991			variable_data1992		);1993	});1994}19951996#[test]1997fn set_variable_meta_data_on_fungible_token_fails() {1998	new_test_ext().execute_with(|| {1999		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));20002001		let origin1 = Origin::signed(1);20022003		let data = default_fungible_data();2004		create_test_item(collection_id, &data.into());20052006		let variable_data = b"test data".to_vec();2007		assert_noop!(2008			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(0), variable_data).map_err(|e| e.error),2009			<pallet_fungible::Error<Test>>::FungibleItemsDontHaveData2010		);2011	});2012}20132014#[test]2015fn set_variable_meta_data_on_fungible_token_with_token_id_fails() {2016	new_test_ext().execute_with(|| {2017		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));20182019		let origin1 = Origin::signed(1);20202021		let data = default_fungible_data();2022		create_test_item(collection_id, &data.into());20232024		let variable_data = b"test data".to_vec();2025		assert_noop!(2026			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2027			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId2028		);2029	});2030}20312032#[test]2033fn set_variable_meta_data_on_nft_token_fails_for_big_data() {2034	new_test_ext().execute_with(|| {2035		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20362037		let origin1 = Origin::signed(1);20382039		let data = default_nft_data();2040		create_test_item(collection_id, &data.into());20412042		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2043		assert_noop!(2044			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2045			CommonError::<Test>::TokenVariableDataLimitExceeded2046		);2047	});2048}20492050#[test]2051fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {2052	new_test_ext().execute_with(|| {2053		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));20542055		let origin1 = Origin::signed(1);20562057		let data = default_re_fungible_data();2058		create_test_item(collection_id, &data.into());20592060		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2061		assert_noop!(2062			TemplateModule::set_variable_meta_data(origin1, collection_id, TokenId(1), variable_data).map_err(|e| e.error),2063			CommonError::<Test>::TokenVariableDataLimitExceeded2064		);2065	});2066}20672068#[test]2069fn set_variable_meta_data_on_nft_with_item_owner_permission_flag() {2070	new_test_ext().execute_with(|| {2071		//default_limits();20722073		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20742075		let origin1 = Origin::signed(1);20762077		let data = default_nft_data();2078		create_test_item(collection_id, &data.into());20792080		assert_ok!(TemplateModule::set_meta_update_permission_flag(2081			origin1.clone(),2082			collection_id,2083			MetaUpdatePermission::ItemOwner,2084		));20852086		let variable_data = b"ten chars.".to_vec();2087		assert_ok!(TemplateModule::set_variable_meta_data(2088			origin1,2089			collection_id,2090			TokenId(1),2091			variable_data.clone()2092		));20932094		assert_eq!(2095			<pallet_nonfungible::TokenData<Test>>::get((collection_id, TokenId(1)))2096				.unwrap()2097				.variable_data,2098			variable_data2099		);2100	});2101}21022103#[test]2104fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() {2105	new_test_ext().execute_with(|| {2106		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));21072108		let origin1 = Origin::signed(1);21092110		assert_ok!(TemplateModule::set_mint_permission(2111			origin1.clone(),2112			collection_id,2113			true2114		));2115		assert_ok!(TemplateModule::add_to_allow_list(2116			origin1.clone(),2117			collection_id,2118			account(1)2119		));21202121		let data = default_nft_data();2122		create_test_item(collection_id, &data.into());21232124		assert_ok!(TemplateModule::set_meta_update_permission_flag(2125			origin1.clone(),2126			collection_id,2127			MetaUpdatePermission::ItemOwner,2128		));21292130		let variable_data = b"1234567890123".to_vec();2131		assert_noop!(2132			TemplateModule::set_variable_meta_data(2133				origin1,2134				collection_id,2135				TokenId(1),2136				variable_data.clone()2137			).map_err(|e| e.error),2138			CommonError::<Test>::TokenVariableDataLimitExceeded2139		);2140	})2141}21422143#[test]2144fn collection_transfer_flag_works() {2145	new_test_ext().execute_with(|| {2146		let origin1 = Origin::signed(1);21472148		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2149		assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, collection_id, true));21502151		let data = default_nft_data();2152		create_test_item(collection_id, &data.into());2153		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2154		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);21552156		let origin1 = Origin::signed(1);21572158		// default scenario2159		assert_ok!(TemplateModule::transfer(origin1, account(2), collection_id, TokenId(1), 1));2160		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), false);2161		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), true);2162		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 0);2163		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 1);2164	});2165}21662167#[test]2168fn set_variable_meta_data_on_nft_with_admin_flag() {2169	new_test_ext().execute_with(|| {2170		// default_limits();21712172		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));21732174		let origin1 = Origin::signed(1);2175		let origin2 = Origin::signed(2);21762177		assert_ok!(TemplateModule::set_mint_permission(2178			origin2.clone(),2179			collection_id,2180			true2181		));2182		assert_ok!(TemplateModule::add_to_allow_list(2183			origin2.clone(),2184			collection_id,2185			account(1)2186		));21872188		assert_ok!(TemplateModule::add_collection_admin(2189			origin2.clone(),2190			collection_id,2191			account(1)2192		));21932194		let data = default_nft_data();2195		create_test_item(collection_id, &data.into());21962197		assert_ok!(TemplateModule::set_meta_update_permission_flag(2198			origin2.clone(),2199			collection_id,2200			MetaUpdatePermission::Admin,2201		));22022203		let variable_data = b"test.".to_vec();2204		assert_ok!(TemplateModule::set_variable_meta_data(2205			origin1,2206			collection_id,2207			TokenId(1),2208			variable_data.clone()2209		));22102211		assert_eq!(2212			<pallet_nonfungible::TokenData<Test>>::get((collection_id, 1))2213				.unwrap()2214				.variable_data,2215			variable_data2216		);2217	});2218}22192220#[test]2221fn set_variable_meta_data_on_nft_with_admin_flag_neg() {2222	new_test_ext().execute_with(|| {2223		// default_limits();22242225		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));22262227		let origin1 = Origin::signed(1);2228		let origin2 = Origin::signed(2);22292230		assert_ok!(TemplateModule::set_mint_permission(2231			origin2.clone(),2232			collection_id,2233			true2234		));2235		assert_ok!(TemplateModule::add_to_allow_list(2236			origin2.clone(),2237			collection_id,2238			account(1)2239		));22402241		let data = default_nft_data();2242		create_test_item(collection_id, &data.into());22432244		assert_ok!(TemplateModule::set_meta_update_permission_flag(2245			origin2.clone(),2246			collection_id,2247			MetaUpdatePermission::Admin,2248		));22492250		let variable_data = b"test.".to_vec();2251		assert_noop!(2252			TemplateModule::set_variable_meta_data(2253				origin1,2254				collection_id,2255				TokenId(1),2256				variable_data.clone()2257			).map_err(|e| e.error),2258			CommonError::<Test>::NoPermission2259		);2260	});2261}22622263#[test]2264fn set_variable_meta_flag_after_freeze() {2265	new_test_ext().execute_with(|| {2266		// default_limits();22672268		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, CollectionId(1));22692270		let origin2 = Origin::signed(2);22712272		assert_ok!(TemplateModule::set_meta_update_permission_flag(2273			origin2.clone(),2274			collection_id,2275			MetaUpdatePermission::None,2276		));2277		assert_noop!(2278			TemplateModule::set_meta_update_permission_flag(2279				origin2.clone(),2280				collection_id,2281				MetaUpdatePermission::Admin2282			),2283			CommonError::<Test>::MetadataFlagFrozen2284		);2285	});2286}22872288#[test]2289fn set_variable_meta_data_on_nft_with_none_flag_neg() {2290	new_test_ext().execute_with(|| {2291		// default_limits();22922293		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));2294		let origin1 = Origin::signed(1);22952296		let data = default_nft_data();2297		create_test_item(collection_id, &data.into());22982299		assert_ok!(TemplateModule::set_meta_update_permission_flag(2300			origin1.clone(),2301			collection_id,2302			MetaUpdatePermission::None,2303		));23042305		let variable_data = b"test.".to_vec();2306		assert_noop!(2307			TemplateModule::set_variable_meta_data(2308				origin1.clone(),2309				collection_id,2310				TokenId(1),2311				variable_data.clone()2312			).map_err(|e| e.error),2313			CommonError::<Test>::NoPermission2314		);2315	});2316}23172318#[test]2319fn collection_transfer_flag_works_neg() {2320	new_test_ext().execute_with(|| {2321		let origin1 = Origin::signed(1);23222323		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2324		assert_ok!(TemplateModule::set_transfers_enabled_flag(2325			origin1, collection_id, false2326		));23272328		let data = default_nft_data();2329		create_test_item(collection_id, &data.into());2330		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2331		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);23322333		let origin1 = Origin::signed(1);23342335		// default scenario2336		assert_noop!(2337			TemplateModule::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),2338			CommonError::<Test>::TransferNotAllowed2339		);2340		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))), 1);2341		assert_eq!(<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))), 0);2342		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))), true);2343		assert_eq!(<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))), false);2344	});2345}