git.delta.rocks / unique-network / refs/commits / 35ede417a4d0

1// Tests to be written here2use super::*;3use crate::mock::*;4use crate::{AccessMode, CollectionMode, Ownership, CreateItemData};5use nft_data_structs::{6	CreateNftData, CreateFungibleData, CreateReFungibleData, CollectionId, TokenId,7	MAX_DECIMAL_POINTS,8};9use frame_support::{assert_noop, assert_ok};10use sp_std::convert::TryInto;1112fn default_nft_data() -> CreateNftData {13	CreateNftData {14		const_data: vec![1, 2, 3].try_into().unwrap(),15		variable_data: vec![3, 2, 1].try_into().unwrap(),16	}17}1819fn default_fungible_data() -> CreateFungibleData {20	CreateFungibleData { value: 5 }21}2223fn default_re_fungible_data() -> CreateReFungibleData {24	CreateReFungibleData {25		const_data: vec![1, 2, 3].try_into().unwrap(),26		variable_data: vec![3, 2, 1].try_into().unwrap(),27		pieces: 1023,28	}29}3031fn create_test_collection_for_owner(32	mode: &CollectionMode,33	owner: u64,34	id: CollectionId,35) -> CollectionId {36	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();37	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();38	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();3940	let origin1 = Origin::signed(owner);41	assert_ok!(TemplateModule::create_collection(42		origin1,43		col_name1,44		col_desc1,45		token_prefix1,46		mode.clone()47	));4849	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();50	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();51	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();52	assert_eq!(TemplateModule::collection_id(id).unwrap().owner, owner);53	assert_eq!(54		TemplateModule::collection_id(id).unwrap().name,55		saved_col_name56	);57	assert_eq!(TemplateModule::collection_id(id).unwrap().mode, *mode);58	assert_eq!(59		TemplateModule::collection_id(id).unwrap().description,60		saved_description61	);62	assert_eq!(63		TemplateModule::collection_id(id).unwrap().token_prefix,64		saved_prefix65	);66	id67}6869fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {70	create_test_collection_for_owner(&mode, 1, id)71}7273fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {74	let origin1 = Origin::signed(1);75	assert_ok!(TemplateModule::create_item(76		origin1,77		collection_id,78		account(1),79		data.clone()80	));81}8283fn account(sub: u64) -> TestCrossAccountId {84	TestCrossAccountId::from_sub(sub)85}8687// Use cases tests region88// #region8990#[test]91fn set_version_schema() {92	new_test_ext().execute_with(|| {93		let origin1 = Origin::signed(1);94		let collection_id = create_test_collection(&CollectionMode::NFT, 1);9596		assert_ok!(TemplateModule::set_schema_version(97			origin1,98			collection_id,99			SchemaVersion::Unique100		));101		assert_eq!(102			TemplateModule::collection_id(collection_id)103				.unwrap()104				.schema_version,105			SchemaVersion::Unique106		);107	});108}109110#[test]111fn create_fungible_collection_fails_with_large_decimal_numbers() {112	new_test_ext().execute_with(|| {113		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();114		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();115		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();116117		let origin1 = Origin::signed(1);118		assert_noop!(119			TemplateModule::create_collection(120				origin1,121				col_name1,122				col_desc1,123				token_prefix1,124				CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1)125			),126			Error::<Test>::CollectionDecimalPointLimitExceeded127		);128	});129}130131#[test]132fn create_nft_item() {133	new_test_ext().execute_with(|| {134		let collection_id = create_test_collection(&CollectionMode::NFT, 1);135136		let data = default_nft_data();137		create_test_item(collection_id, &data.clone().into());138		let item = TemplateModule::nft_item_id(collection_id, 1).unwrap();139		assert_eq!(item.const_data, data.const_data.into_inner());140		assert_eq!(item.variable_data, data.variable_data.into_inner());141	});142}143144// Use cases tests region145// #region146#[test]147fn create_nft_multiple_items() {148	new_test_ext().execute_with(|| {149		create_test_collection(&CollectionMode::NFT, 1);150151		let origin1 = Origin::signed(1);152153		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];154155		assert_ok!(TemplateModule::create_multiple_items(156			origin1,157			1,158			account(1),159			items_data160				.clone()161				.into_iter()162				.map(|d| { d.into() })163				.collect()164		));165		for (index, data) in items_data.into_iter().enumerate() {166			let item = TemplateModule::nft_item_id(1, (index + 1) as TokenId).unwrap();167			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());168			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());169		}170	});171}172173#[test]174fn create_refungible_item() {175	new_test_ext().execute_with(|| {176		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);177178		let data = default_re_fungible_data();179		create_test_item(collection_id, &data.clone().into());180		let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap();181		assert_eq!(item.const_data, data.const_data.into_inner());182		assert_eq!(item.variable_data, data.variable_data.into_inner());183		assert_eq!(184			item.owner[0],185			Ownership {186				owner: account(1),187				fraction: 1023188			}189		);190	});191}192193#[test]194fn create_multiple_refungible_items() {195	new_test_ext().execute_with(|| {196		create_test_collection(&CollectionMode::ReFungible, 1);197198		let origin1 = Origin::signed(1);199200		let items_data = vec![201			default_re_fungible_data(),202			default_re_fungible_data(),203			default_re_fungible_data(),204		];205206		assert_ok!(TemplateModule::create_multiple_items(207			origin1,208			1,209			account(1),210			items_data211				.clone()212				.into_iter()213				.map(|d| { d.into() })214				.collect()215		));216		for (index, data) in items_data.into_iter().enumerate() {217			let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId).unwrap();218			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());219			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());220			assert_eq!(221				item.owner[0],222				Ownership {223					owner: account(1),224					fraction: 1023225				}226			);227		}228	});229}230231#[test]232fn create_fungible_item() {233	new_test_ext().execute_with(|| {234		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);235236		let data = default_fungible_data();237		create_test_item(collection_id, &data.into());238239		assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).value, 5);240	});241}242243//#[test]244// fn create_multiple_fungible_items() {245//     new_test_ext().execute_with(|| {246//         default_limits();247248//         create_test_collection(&CollectionMode::Fungible(3), 1);249250//         let origin1 = Origin::signed(1);251252//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];253254//         assert_ok!(TemplateModule::create_multiple_items(255//             origin1.clone(),256//             1,257//             1,258//             items_data.clone().into_iter().map(|d| { d.into() }).collect()259//         ));260261//         for (index, _) in items_data.iter().enumerate() {262//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);263//         }264//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);265//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);266//     });267// }268269#[test]270fn transfer_fungible_item() {271	new_test_ext().execute_with(|| {272		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);273274		let origin1 = Origin::signed(1);275		let origin2 = Origin::signed(2);276277		let data = default_fungible_data();278		create_test_item(collection_id, &data.into());279280		assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 5);281		assert_eq!(TemplateModule::balance_count(1, 1), 5);282283		// change owner scenario284		assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 5));285		assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 0);286		assert_eq!(TemplateModule::balance_count(1, 1), 0);287		assert_eq!(TemplateModule::balance_count(1, 2), 5);288289		// split item scenario290		assert_ok!(TemplateModule::transfer(291			origin2.clone(),292			account(3),293			1,294			1,295			3296		));297		assert_eq!(TemplateModule::balance_count(1, 2), 2);298		assert_eq!(TemplateModule::balance_count(1, 3), 3);299300		// split item and new owner has account scenario301		assert_ok!(TemplateModule::transfer(origin2, account(3), 1, 1, 1));302		assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 1);303		assert_eq!(TemplateModule::fungible_item_id(1, 3).value, 4);304		assert_eq!(TemplateModule::balance_count(1, 2), 1);305		assert_eq!(TemplateModule::balance_count(1, 3), 4);306	});307}308309#[test]310fn transfer_refungible_item() {311	new_test_ext().execute_with(|| {312		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);313314		let data = default_re_fungible_data();315		create_test_item(collection_id, &data.clone().into());316317		let origin1 = Origin::signed(1);318		let origin2 = Origin::signed(2);319		{320			let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap();321			assert_eq!(item.const_data, data.const_data.into_inner());322			assert_eq!(item.variable_data, data.variable_data.into_inner());323			assert_eq!(324				item.owner[0],325				Ownership {326					owner: account(1),327					fraction: 1023328				}329			);330		}331		assert_eq!(TemplateModule::balance_count(1, 1), 1023);332		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);333334		// change owner scenario335		assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1023));336		assert_eq!(337			TemplateModule::refungible_item_id(1, 1).unwrap().owner[0],338			Ownership {339				owner: account(2),340				fraction: 1023341			}342		);343		assert_eq!(TemplateModule::balance_count(1, 1), 0);344		assert_eq!(TemplateModule::balance_count(1, 2), 1023);345		// assert_eq!(TemplateModule::address_tokens(1, 1), []);346		assert_eq!(TemplateModule::address_tokens(1, 2), [1]);347348		// split item scenario349		assert_ok!(TemplateModule::transfer(350			origin2.clone(),351			account(3),352			1,353			1,354			500355		));356		{357			let item = TemplateModule::refungible_item_id(1, 1).unwrap();358			assert_eq!(359				item.owner[0],360				Ownership {361					owner: account(2),362					fraction: 523363				}364			);365			assert_eq!(366				item.owner[1],367				Ownership {368					owner: account(3),369					fraction: 500370				}371			);372		}373		assert_eq!(TemplateModule::balance_count(1, 2), 523);374		assert_eq!(TemplateModule::balance_count(1, 3), 500);375		assert_eq!(TemplateModule::address_tokens(1, 2), [1]);376		assert_eq!(TemplateModule::address_tokens(1, 3), [1]);377378		// split item and new owner has account scenario379		assert_ok!(TemplateModule::transfer(origin2, account(3), 1, 1, 200));380		{381			let item = TemplateModule::refungible_item_id(1, 1).unwrap();382			assert_eq!(383				item.owner[0],384				Ownership {385					owner: account(2),386					fraction: 323387				}388			);389			assert_eq!(390				item.owner[1],391				Ownership {392					owner: account(3),393					fraction: 700394				}395			);396		}397		assert_eq!(TemplateModule::balance_count(1, 2), 323);398		assert_eq!(TemplateModule::balance_count(1, 3), 700);399		assert_eq!(TemplateModule::address_tokens(1, 2), [1]);400		assert_eq!(TemplateModule::address_tokens(1, 3), [1]);401	});402}403404#[test]405fn transfer_nft_item() {406	new_test_ext().execute_with(|| {407		let collection_id = create_test_collection(&CollectionMode::NFT, 1);408409		let data = default_nft_data();410		create_test_item(collection_id, &data.into());411		assert_eq!(TemplateModule::balance_count(1, 1), 1);412		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);413414		let origin1 = Origin::signed(1);415		// default scenario416		assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1000));417		assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(2));418		assert_eq!(TemplateModule::balance_count(1, 1), 0);419		assert_eq!(TemplateModule::balance_count(1, 2), 1);420		// assert_eq!(TemplateModule::address_tokens(1, 1), []);421		assert_eq!(TemplateModule::address_tokens(1, 2), [1]);422	});423}424425#[test]426fn nft_approve_and_transfer_from() {427	new_test_ext().execute_with(|| {428		let collection_id = create_test_collection(&CollectionMode::NFT, 1);429430		let data = default_nft_data();431		create_test_item(collection_id, &data.into());432433		let origin1 = Origin::signed(1);434		let origin2 = Origin::signed(2);435436		assert_eq!(TemplateModule::balance_count(1, 1), 1);437		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);438439		// neg transfer440		assert_noop!(441			TemplateModule::transfer_from(origin2.clone(), account(1), account(2), 1, 1, 1),442			Error::<Test>::NoPermission443		);444445		// do approve446		assert_ok!(TemplateModule::approve(origin1, account(2), 1, 1, 5));447		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);448		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);449450		assert_ok!(TemplateModule::transfer_from(451			origin2,452			account(1),453			account(3),454			1,455			1,456			1457		));458		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);459	});460}461462#[test]463fn nft_approve_and_transfer_from_white_list() {464	new_test_ext().execute_with(|| {465		let collection_id = create_test_collection(&CollectionMode::NFT, 1);466467		let origin1 = Origin::signed(1);468		let origin2 = Origin::signed(2);469470		let data = default_nft_data();471		create_test_item(collection_id, &data.clone().into());472473		assert_eq!(474			&TemplateModule::nft_item_id(1, 1).unwrap().const_data,475			&data.const_data.into_inner()476		);477		assert_eq!(TemplateModule::balance_count(1, 1), 1);478		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);479480		assert_ok!(TemplateModule::set_mint_permission(481			origin1.clone(),482			1,483			true484		));485		assert_ok!(TemplateModule::set_public_access_mode(486			origin1.clone(),487			1,488			AccessMode::WhiteList489		));490		assert_ok!(TemplateModule::add_to_white_list(491			origin1.clone(),492			1,493			account(1)494		));495		assert_ok!(TemplateModule::add_to_white_list(496			origin1.clone(),497			1,498			account(2)499		));500		assert_ok!(TemplateModule::add_to_white_list(501			origin1.clone(),502			1,503			account(3)504		));505506		// do approve507		assert_ok!(TemplateModule::approve(508			origin1.clone(),509			account(2),510			1,511			1,512			5513		));514		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);515		assert_ok!(TemplateModule::approve(origin1, account(3), 1, 1, 5));516		assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);517518		assert_ok!(TemplateModule::transfer_from(519			origin2,520			account(1),521			account(3),522			1,523			1,524			1525		));526		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);527	});528}529530#[test]531fn refungible_approve_and_transfer_from() {532	new_test_ext().execute_with(|| {533		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);534535		let origin1 = Origin::signed(1);536		let origin2 = Origin::signed(2);537538		let data = default_re_fungible_data();539		create_test_item(collection_id, &data.into());540541		assert_eq!(TemplateModule::balance_count(1, 1), 1023);542		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);543544		assert_ok!(TemplateModule::set_mint_permission(545			origin1.clone(),546			1,547			true548		));549		assert_ok!(TemplateModule::set_public_access_mode(550			origin1.clone(),551			1,552			AccessMode::WhiteList553		));554		assert_ok!(TemplateModule::add_to_white_list(555			origin1.clone(),556			1,557			account(1)558		));559		assert_ok!(TemplateModule::add_to_white_list(560			origin1.clone(),561			1,562			account(2)563		));564		assert_ok!(TemplateModule::add_to_white_list(565			origin1.clone(),566			1,567			account(3)568		));569570		// do approve571		assert_ok!(TemplateModule::approve(origin1, account(2), 1, 1, 1023));572		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1023);573574		assert_ok!(TemplateModule::transfer_from(575			origin2,576			account(1),577			account(3),578			1,579			1,580			100581		));582		assert_eq!(TemplateModule::balance_count(1, 1), 923);583		assert_eq!(TemplateModule::balance_count(1, 3), 100);584		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);585		assert_eq!(TemplateModule::address_tokens(1, 3), [1]);586587		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 923);588	});589}590591#[test]592fn fungible_approve_and_transfer_from() {593	new_test_ext().execute_with(|| {594		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);595596		let data = default_fungible_data();597		create_test_item(collection_id, &data.into());598599		let origin1 = Origin::signed(1);600		let origin2 = Origin::signed(2);601602		assert_eq!(TemplateModule::balance_count(1, 1), 5);603604		assert_ok!(TemplateModule::set_mint_permission(605			origin1.clone(),606			1,607			true608		));609		assert_ok!(TemplateModule::set_public_access_mode(610			origin1.clone(),611			1,612			AccessMode::WhiteList613		));614		assert_ok!(TemplateModule::add_to_white_list(615			origin1.clone(),616			1,617			account(1)618		));619		assert_ok!(TemplateModule::add_to_white_list(620			origin1.clone(),621			1,622			account(2)623		));624		assert_ok!(TemplateModule::add_to_white_list(625			origin1.clone(),626			1,627			account(3)628		));629630		// do approve631		assert_ok!(TemplateModule::approve(632			origin1.clone(),633			account(2),634			1,635			1,636			5637		));638		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);639		assert_ok!(TemplateModule::approve(origin1, account(3), 1, 1, 5));640		assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);641		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);642643		assert_ok!(TemplateModule::transfer_from(644			origin2.clone(),645			account(1),646			account(3),647			1,648			1,649			4650		));651		assert_eq!(TemplateModule::balance_count(1, 1), 1);652		assert_eq!(TemplateModule::balance_count(1, 3), 4);653654		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);655656		assert_noop!(657			TemplateModule::transfer_from(origin2, account(1), account(3), 1, 1, 4),658			Error::<Test>::NoPermission659		);660	});661}662663#[test]664fn change_collection_owner() {665	new_test_ext().execute_with(|| {666		let collection_id = create_test_collection(&CollectionMode::NFT, 1);667668		let origin1 = Origin::signed(1);669		assert_ok!(TemplateModule::change_collection_owner(670			origin1,671			collection_id,672			2673		));674		assert_eq!(675			TemplateModule::collection_id(collection_id).unwrap().owner,676			2677		);678	});679}680681#[test]682fn destroy_collection() {683	new_test_ext().execute_with(|| {684		let collection_id = create_test_collection(&CollectionMode::NFT, 1);685686		let origin1 = Origin::signed(1);687		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));688	});689}690691#[test]692fn burn_nft_item() {693	new_test_ext().execute_with(|| {694		let collection_id = create_test_collection(&CollectionMode::NFT, 1);695696		let origin1 = Origin::signed(1);697		assert_ok!(TemplateModule::add_collection_admin(698			origin1.clone(),699			collection_id,700			account(2)701		));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!(TemplateModule::balance_count(1, 1), 1);708709		// burn item710		assert_ok!(TemplateModule::burn_item(711			origin1.clone(),712			1,713			1,714			account(1),715			5716		));717		assert_noop!(718			TemplateModule::burn_item(origin1, 1, 1, account(1), 5),719			Error::<Test>::TokenNotFound720		);721722		assert_eq!(TemplateModule::balance_count(1, 1), 0);723	});724}725726#[test]727fn burn_fungible_item() {728	new_test_ext().execute_with(|| {729		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);730731		let origin1 = Origin::signed(1);732		assert_ok!(TemplateModule::add_collection_admin(733			origin1.clone(),734			collection_id,735			account(2)736		));737738		let data = default_fungible_data();739		create_test_item(collection_id, &data.into());740741		// check balance (collection with id = 1, user id = 1)742		assert_eq!(TemplateModule::balance_count(1, 1), 5);743744		// burn item745		assert_ok!(TemplateModule::burn_item(746			origin1.clone(),747			1,748			1,749			account(1),750			5751		));752		assert_noop!(753			TemplateModule::burn_item(origin1, 1, 1, account(1), 5),754			Error::<Test>::TokenValueNotEnough755		);756757		assert_eq!(TemplateModule::balance_count(1, 1), 0);758	});759}760761#[test]762fn burn_refungible_item() {763	new_test_ext().execute_with(|| {764		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);765		let origin1 = Origin::signed(1);766767		assert_ok!(TemplateModule::set_mint_permission(768			origin1.clone(),769			collection_id,770			true771		));772		assert_ok!(TemplateModule::set_public_access_mode(773			origin1.clone(),774			collection_id,775			AccessMode::WhiteList776		));777		assert_ok!(TemplateModule::add_to_white_list(778			origin1.clone(),779			1,780			account(1)781		));782783		assert_ok!(TemplateModule::add_collection_admin(784			origin1.clone(),785			1,786			account(2)787		));788789		let data = default_re_fungible_data();790		create_test_item(collection_id, &data.into());791792		// check balance (collection with id = 1, user id = 2)793		assert_eq!(TemplateModule::balance_count(1, 1), 1023);794795		// burn item796		assert_ok!(TemplateModule::burn_item(797			origin1.clone(),798			1,799			1,800			account(1),801			1023802		));803		assert_noop!(804			TemplateModule::burn_item(origin1, 1, 1, account(1), 1023),805			Error::<Test>::TokenNotFound806		);807808		assert_eq!(TemplateModule::balance_count(1, 1), 0);809	});810}811812#[test]813fn add_collection_admin() {814	new_test_ext().execute_with(|| {815		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);816		create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);817		create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);818819		let origin1 = Origin::signed(1);820821		// collection admin822		assert_ok!(TemplateModule::add_collection_admin(823			origin1.clone(),824			collection1_id,825			account(2)826		));827		assert_ok!(TemplateModule::add_collection_admin(828			origin1,829			collection1_id,830			account(3)831		));832833		assert!(TemplateModule::admin_list_collection(collection1_id).contains(&account(2)),);834		assert!(TemplateModule::admin_list_collection(collection1_id).contains(&account(3)),);835	});836}837838#[test]839fn remove_collection_admin() {840	new_test_ext().execute_with(|| {841		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);842		create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);843		create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);844845		let origin1 = Origin::signed(1);846		let origin2 = Origin::signed(2);847848		// collection admin849		assert_ok!(TemplateModule::add_collection_admin(850			origin1.clone(),851			collection1_id,852			account(2)853		));854		assert_ok!(TemplateModule::add_collection_admin(855			origin1,856			collection1_id,857			account(3)858		));859860		assert!(TemplateModule::admin_list_collection(1).contains(&account(2)),);861		assert!(TemplateModule::admin_list_collection(1).contains(&account(3)),);862863		// remove admin864		assert_ok!(TemplateModule::remove_collection_admin(865			origin2,866			1,867			account(3)868		));869		assert!(!TemplateModule::admin_list_collection(1).contains(&account(3)),);870	});871}872873#[test]874fn balance_of() {875	new_test_ext().execute_with(|| {876		let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);877		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);878		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, 3);879880		// check balance before881		assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);882		assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);883		assert_eq!(884			TemplateModule::balance_count(re_fungible_collection_id, 1),885			0886		);887888		let nft_data = default_nft_data();889		create_test_item(nft_collection_id, &nft_data.into());890891		let fungible_data = default_fungible_data();892		create_test_item(fungible_collection_id, &fungible_data.into());893894		let re_fungible_data = default_re_fungible_data();895		create_test_item(re_fungible_collection_id, &re_fungible_data.into());896897		// check balance (collection with id = 1, user id = 1)898		assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);899		assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 5);900		assert_eq!(901			TemplateModule::balance_count(re_fungible_collection_id, 1),902			1023903		);904		assert_eq!(905			TemplateModule::nft_item_id(nft_collection_id, 1)906				.unwrap()907				.owner,908			account(1)909		);910		assert_eq!(911			TemplateModule::fungible_item_id(fungible_collection_id, 1).value,912			5913		);914		assert_eq!(915			TemplateModule::refungible_item_id(re_fungible_collection_id, 1)916				.unwrap()917				.owner[0]918				.owner,919			account(1)920		);921	});922}923924#[test]925fn approve() {926	new_test_ext().execute_with(|| {927		let collection_id = create_test_collection(&CollectionMode::NFT, 1);928929		let data = default_nft_data();930		create_test_item(collection_id, &data.into());931932		let origin1 = Origin::signed(1);933934		// approve935		assert_ok!(TemplateModule::approve(origin1, account(2), 1, 1, 1));936		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);937	});938}939940#[test]941fn transfer_from() {942	new_test_ext().execute_with(|| {943		let collection_id = create_test_collection(&CollectionMode::NFT, 1);944		let origin1 = Origin::signed(1);945		let origin2 = Origin::signed(2);946947		let data = default_nft_data();948		create_test_item(collection_id, &data.into());949950		// approve951		assert_ok!(TemplateModule::approve(952			origin1.clone(),953			account(2),954			1,955			1,956			1957		));958		assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);959960		assert_ok!(TemplateModule::set_mint_permission(961			origin1.clone(),962			1,963			true964		));965		assert_ok!(TemplateModule::set_public_access_mode(966			origin1.clone(),967			1,968			AccessMode::WhiteList969		));970		assert_ok!(TemplateModule::add_to_white_list(971			origin1.clone(),972			1,973			account(1)974		));975		assert_ok!(TemplateModule::add_to_white_list(976			origin1.clone(),977			1,978			account(2)979		));980		assert_ok!(TemplateModule::add_to_white_list(origin1, 1, account(3)));981982		assert_ok!(TemplateModule::transfer_from(983			origin2,984			account(1),985			account(2),986			1,987			1,988			1989		));990991		// after transfer992		assert_eq!(TemplateModule::balance_count(1, 1), 0);993		assert_eq!(TemplateModule::balance_count(1, 2), 1);994	});995}996997// #endregion998999// Coverage tests region1000// #region10011002#[test]1003fn owner_can_add_address_to_white_list() {1004	new_test_ext().execute_with(|| {1005		let collection_id = create_test_collection(&CollectionMode::NFT, 1);10061007		let origin1 = Origin::signed(1);1008		assert_ok!(TemplateModule::add_to_white_list(1009			origin1,1010			collection_id,1011			account(2)1012		));1013		assert!(TemplateModule::white_list(collection_id, 2));1014	});1015}10161017#[test]1018fn admin_can_add_address_to_white_list() {1019	new_test_ext().execute_with(|| {1020		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1021		let origin1 = Origin::signed(1);1022		let origin2 = Origin::signed(2);10231024		assert_ok!(TemplateModule::add_collection_admin(1025			origin1,1026			collection_id,1027			account(2)1028		));1029		assert_ok!(TemplateModule::add_to_white_list(1030			origin2,1031			collection_id,1032			account(3)1033		));1034		assert!(TemplateModule::white_list(collection_id, 3));1035	});1036}10371038#[test]1039fn nonprivileged_user_cannot_add_address_to_white_list() {1040	new_test_ext().execute_with(|| {1041		let collection_id = create_test_collection(&CollectionMode::NFT, 1);10421043		let origin2 = Origin::signed(2);1044		assert_noop!(1045			TemplateModule::add_to_white_list(origin2, collection_id, account(3)),1046			Error::<Test>::NoPermission1047		);1048	});1049}10501051#[test]1052fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {1053	new_test_ext().execute_with(|| {1054		let origin1 = Origin::signed(1);10551056		assert_noop!(1057			TemplateModule::add_to_white_list(origin1, 1, account(2)),1058			Error::<Test>::CollectionNotFound1059		);1060	});1061}10621063#[test]1064fn nobody_can_add_address_to_white_list_of_deleted_collection() {1065	new_test_ext().execute_with(|| {1066		let collection_id = create_test_collection(&CollectionMode::NFT, 1);10671068		let origin1 = Origin::signed(1);1069		assert_ok!(TemplateModule::destroy_collection(1070			origin1.clone(),1071			collection_id1072		));1073		assert_noop!(1074			TemplateModule::add_to_white_list(origin1, collection_id, account(2)),1075			Error::<Test>::CollectionNotFound1076		);1077	});1078}10791080// If address is already added to white list, nothing happens1081#[test]1082fn address_is_already_added_to_white_list() {1083	new_test_ext().execute_with(|| {1084		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1085		let origin1 = Origin::signed(1);10861087		assert_ok!(TemplateModule::add_to_white_list(1088			origin1.clone(),1089			collection_id,1090			account(2)1091		));1092		assert_ok!(TemplateModule::add_to_white_list(1093			origin1,1094			collection_id,1095			account(2)1096		));1097		assert!(TemplateModule::white_list(collection_id, 2));1098	});1099}11001101#[test]1102fn owner_can_remove_address_from_white_list() {1103	new_test_ext().execute_with(|| {1104		let collection_id = create_test_collection(&CollectionMode::NFT, 1);11051106		let origin1 = Origin::signed(1);1107		assert_ok!(TemplateModule::add_to_white_list(1108			origin1.clone(),1109			collection_id,1110			account(2)1111		));1112		assert_ok!(TemplateModule::remove_from_white_list(1113			origin1,1114			collection_id,1115			account(2)1116		));1117		assert!(!TemplateModule::white_list(collection_id, 2));1118	});1119}11201121#[test]1122fn admin_can_remove_address_from_white_list() {1123	new_test_ext().execute_with(|| {1124		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1125		let origin1 = Origin::signed(1);1126		let origin2 = Origin::signed(2);11271128		assert_ok!(TemplateModule::add_collection_admin(1129			origin1.clone(),1130			collection_id,1131			account(2)1132		));11331134		assert_ok!(TemplateModule::add_to_white_list(1135			origin1,1136			collection_id,1137			account(3)1138		));1139		assert_ok!(TemplateModule::remove_from_white_list(1140			origin2,1141			collection_id,1142			account(3)1143		));1144		assert!(!TemplateModule::white_list(collection_id, 3));1145	});1146}11471148#[test]1149fn nonprivileged_user_cannot_remove_address_from_white_list() {1150	new_test_ext().execute_with(|| {1151		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1152		let origin1 = Origin::signed(1);1153		let origin2 = Origin::signed(2);11541155		assert_ok!(TemplateModule::add_to_white_list(1156			origin1,1157			collection_id,1158			account(2)1159		));1160		assert_noop!(1161			TemplateModule::remove_from_white_list(origin2, collection_id, account(2)),1162			Error::<Test>::NoPermission1163		);1164		assert!(TemplateModule::white_list(collection_id, 2));1165	});1166}11671168#[test]1169fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1170	new_test_ext().execute_with(|| {1171		let origin1 = Origin::signed(1);11721173		assert_noop!(1174			TemplateModule::remove_from_white_list(origin1, 1, account(2)),1175			Error::<Test>::CollectionNotFound1176		);1177	});1178}11791180#[test]1181fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1182	new_test_ext().execute_with(|| {1183		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1184		let origin1 = Origin::signed(1);1185		let origin2 = Origin::signed(2);11861187		assert_ok!(TemplateModule::add_to_white_list(1188			origin1.clone(),1189			collection_id,1190			account(2)1191		));1192		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));1193		assert_noop!(1194			TemplateModule::remove_from_white_list(origin2, collection_id, account(2)),1195			Error::<Test>::CollectionNotFound1196		);1197		assert!(!TemplateModule::white_list(collection_id, 2));1198	});1199}12001201// If address is already removed from white list, nothing happens1202#[test]1203fn address_is_already_removed_from_white_list() {1204	new_test_ext().execute_with(|| {1205		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1206		let origin1 = Origin::signed(1);12071208		assert_ok!(TemplateModule::add_to_white_list(1209			origin1.clone(),1210			collection_id,1211			account(2)1212		));1213		assert_ok!(TemplateModule::remove_from_white_list(1214			origin1.clone(),1215			collection_id,1216			account(2)1217		));1218		assert_ok!(TemplateModule::remove_from_white_list(1219			origin1,1220			collection_id,1221			account(2)1222		));1223		assert!(!TemplateModule::white_list(collection_id, 2));1224	});1225}12261227// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1228#[test]1229fn white_list_test_1() {1230	new_test_ext().execute_with(|| {1231		let collection_id = create_test_collection(&CollectionMode::NFT, 1);12321233		let origin1 = Origin::signed(1);12341235		let data = default_nft_data();1236		create_test_item(collection_id, &data.into());12371238		assert_ok!(TemplateModule::set_public_access_mode(1239			origin1.clone(),1240			collection_id,1241			AccessMode::WhiteList1242		));1243		assert_ok!(TemplateModule::add_to_white_list(1244			origin1.clone(),1245			collection_id,1246			account(2)1247		));12481249		assert_noop!(1250			TemplateModule::transfer(origin1, account(3), 1, 1, 1),1251			Error::<Test>::AddresNotInWhiteList1252		);1253	});1254}12551256#[test]1257fn white_list_test_2() {1258	new_test_ext().execute_with(|| {1259		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1260		let origin1 = Origin::signed(1);12611262		let data = default_nft_data();1263		create_test_item(collection_id, &data.into());12641265		assert_ok!(TemplateModule::set_public_access_mode(1266			origin1.clone(),1267			collection_id,1268			AccessMode::WhiteList1269		));1270		assert_ok!(TemplateModule::add_to_white_list(1271			origin1.clone(),1272			1,1273			account(1)1274		));1275		assert_ok!(TemplateModule::add_to_white_list(1276			origin1.clone(),1277			1,1278			account(2)1279		));12801281		// do approve1282		assert_ok!(TemplateModule::approve(1283			origin1.clone(),1284			account(1),1285			1,1286			1,1287			11288		));1289		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);12901291		assert_ok!(TemplateModule::remove_from_white_list(1292			origin1.clone(),1293			1,1294			account(1)1295		));12961297		assert_noop!(1298			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),1299			Error::<Test>::AddresNotInWhiteList1300		);1301	});1302}13031304// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1305#[test]1306fn white_list_test_3() {1307	new_test_ext().execute_with(|| {1308		let collection_id = create_test_collection(&CollectionMode::NFT, 1);13091310		let origin1 = Origin::signed(1);13111312		let data = default_nft_data();1313		create_test_item(collection_id, &data.into());13141315		assert_ok!(TemplateModule::set_public_access_mode(1316			origin1.clone(),1317			collection_id,1318			AccessMode::WhiteList1319		));1320		assert_ok!(TemplateModule::add_to_white_list(1321			origin1.clone(),1322			1,1323			account(1)1324		));13251326		assert_noop!(1327			TemplateModule::transfer(origin1, account(3), 1, 1, 1),1328			Error::<Test>::AddresNotInWhiteList1329		);1330	});1331}13321333#[test]1334fn white_list_test_4() {1335	new_test_ext().execute_with(|| {1336		let collection_id = create_test_collection(&CollectionMode::NFT, 1);13371338		let origin1 = Origin::signed(1);13391340		let data = default_nft_data();1341		create_test_item(collection_id, &data.into());13421343		assert_ok!(TemplateModule::set_public_access_mode(1344			origin1.clone(),1345			collection_id,1346			AccessMode::WhiteList1347		));1348		assert_ok!(TemplateModule::add_to_white_list(1349			origin1.clone(),1350			collection_id,1351			account(1)1352		));1353		assert_ok!(TemplateModule::add_to_white_list(1354			origin1.clone(),1355			collection_id,1356			account(2)1357		));13581359		// do approve1360		assert_ok!(TemplateModule::approve(1361			origin1.clone(),1362			account(1),1363			1,1364			1,1365			11366		));1367		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);13681369		assert_ok!(TemplateModule::remove_from_white_list(1370			origin1.clone(),1371			collection_id,1372			account(2)1373		));13741375		assert_noop!(1376			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),1377			Error::<Test>::AddresNotInWhiteList1378		);1379	});1380}13811382// If Public Access mode is set to WhiteList, tokens can’t be destroyed by a non-whitelisted address (even if it owned them before enabling WhiteList mode)1383#[test]1384fn white_list_test_5() {1385	new_test_ext().execute_with(|| {1386		let collection_id = create_test_collection(&CollectionMode::NFT, 1);13871388		let origin1 = Origin::signed(1);13891390		let data = default_nft_data();1391		create_test_item(collection_id, &data.into());13921393		assert_ok!(TemplateModule::set_public_access_mode(1394			origin1.clone(),1395			collection_id,1396			AccessMode::WhiteList1397		));1398		assert_noop!(1399			TemplateModule::burn_item(origin1.clone(), 1, 1, account(1), 5),1400			Error::<Test>::AddresNotInWhiteList1401		);1402	});1403}14041405// If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).1406#[test]1407fn white_list_test_6() {1408	new_test_ext().execute_with(|| {1409		let collection_id = create_test_collection(&CollectionMode::NFT, 1);14101411		let origin1 = Origin::signed(1);14121413		let data = default_nft_data();1414		create_test_item(collection_id, &data.into());14151416		assert_ok!(TemplateModule::set_public_access_mode(1417			origin1.clone(),1418			collection_id,1419			AccessMode::WhiteList1420		));14211422		// do approve1423		assert_noop!(1424			TemplateModule::approve(origin1, account(1), 1, 1, 5),1425			Error::<Test>::AddresNotInWhiteList1426		);1427	});1428}14291430// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1431//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1432#[test]1433fn white_list_test_7() {1434	new_test_ext().execute_with(|| {1435		let collection_id = create_test_collection(&CollectionMode::NFT, 1);14361437		let data = default_nft_data();1438		create_test_item(collection_id, &data.into());14391440		let origin1 = Origin::signed(1);14411442		assert_ok!(TemplateModule::set_public_access_mode(1443			origin1.clone(),1444			collection_id,1445			AccessMode::WhiteList1446		));1447		assert_ok!(TemplateModule::add_to_white_list(1448			origin1.clone(),1449			collection_id,1450			account(1)1451		));1452		assert_ok!(TemplateModule::add_to_white_list(1453			origin1.clone(),1454			collection_id,1455			account(2)1456		));14571458		assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1));1459	});1460}14611462#[test]1463fn white_list_test_8() {1464	new_test_ext().execute_with(|| {1465		let collection_id = create_test_collection(&CollectionMode::NFT, 1);14661467		let data = default_nft_data();1468		create_test_item(collection_id, &data.into());14691470		let origin1 = Origin::signed(1);14711472		assert_ok!(TemplateModule::set_public_access_mode(1473			origin1.clone(),1474			collection_id,1475			AccessMode::WhiteList1476		));1477		assert_ok!(TemplateModule::add_to_white_list(1478			origin1.clone(),1479			collection_id,1480			account(1)1481		));1482		assert_ok!(TemplateModule::add_to_white_list(1483			origin1.clone(),1484			collection_id,1485			account(2)1486		));14871488		// do approve1489		assert_ok!(TemplateModule::approve(1490			origin1.clone(),1491			account(1),1492			1,1493			1,1494			51495		));1496		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 5);14971498		assert_ok!(TemplateModule::transfer_from(1499			origin1,1500			account(1),1501			account(2),1502			1,1503			1,1504			11505		));1506	});1507}15081509// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1510#[test]1511fn white_list_test_9() {1512	new_test_ext().execute_with(|| {1513		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1514		let origin1 = Origin::signed(1);15151516		assert_ok!(TemplateModule::set_public_access_mode(1517			origin1.clone(),1518			collection_id,1519			AccessMode::WhiteList1520		));1521		assert_ok!(TemplateModule::set_mint_permission(1522			origin1,1523			collection_id,1524			false1525		));15261527		let data = default_nft_data();1528		create_test_item(collection_id, &data.into());1529	});1530}15311532// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1533#[test]1534fn white_list_test_10() {1535	new_test_ext().execute_with(|| {1536		let collection_id = create_test_collection(&CollectionMode::NFT, 1);15371538		let origin1 = Origin::signed(1);1539		let origin2 = Origin::signed(2);15401541		assert_ok!(TemplateModule::set_public_access_mode(1542			origin1.clone(),1543			collection_id,1544			AccessMode::WhiteList1545		));1546		assert_ok!(TemplateModule::set_mint_permission(1547			origin1.clone(),1548			collection_id,1549			false1550		));15511552		assert_ok!(TemplateModule::add_collection_admin(1553			origin1,1554			collection_id,1555			account(2)1556		));15571558		assert_ok!(TemplateModule::create_item(1559			origin2,1560			collection_id,1561			account(2),1562			default_nft_data().into()1563		));1564	});1565}15661567// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and white listed address.1568#[test]1569fn white_list_test_11() {1570	new_test_ext().execute_with(|| {1571		let collection_id = create_test_collection(&CollectionMode::NFT, 1);15721573		let origin1 = Origin::signed(1);1574		let origin2 = Origin::signed(2);15751576		assert_ok!(TemplateModule::set_public_access_mode(1577			origin1.clone(),1578			collection_id,1579			AccessMode::WhiteList1580		));1581		assert_ok!(TemplateModule::set_mint_permission(1582			origin1.clone(),1583			collection_id,1584			false1585		));1586		assert_ok!(TemplateModule::add_to_white_list(1587			origin1,1588			collection_id,1589			account(2)1590		));15911592		assert_noop!(1593			TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()),1594			Error::<Test>::PublicMintingNotAllowed1595		);1596	});1597}15981599// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-white listed address.1600#[test]1601fn white_list_test_12() {1602	new_test_ext().execute_with(|| {1603		let collection_id = create_test_collection(&CollectionMode::NFT, 1);16041605		let origin1 = Origin::signed(1);1606		let origin2 = Origin::signed(2);16071608		assert_ok!(TemplateModule::set_public_access_mode(1609			origin1.clone(),1610			collection_id,1611			AccessMode::WhiteList1612		));1613		assert_ok!(TemplateModule::set_mint_permission(1614			origin1,1615			collection_id,1616			false1617		));16181619		assert_noop!(1620			TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()),1621			Error::<Test>::PublicMintingNotAllowed1622		);1623	});1624}16251626// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1627#[test]1628fn white_list_test_13() {1629	new_test_ext().execute_with(|| {1630		let collection_id = create_test_collection(&CollectionMode::NFT, 1);16311632		let origin1 = Origin::signed(1);16331634		assert_ok!(TemplateModule::set_public_access_mode(1635			origin1.clone(),1636			collection_id,1637			AccessMode::WhiteList1638		));1639		assert_ok!(TemplateModule::set_mint_permission(1640			origin1,1641			collection_id,1642			true1643		));16441645		let data = default_nft_data();1646		create_test_item(collection_id, &data.into());1647	});1648}16491650// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1651#[test]1652fn white_list_test_14() {1653	new_test_ext().execute_with(|| {1654		let collection_id = create_test_collection(&CollectionMode::NFT, 1);16551656		let origin1 = Origin::signed(1);1657		let origin2 = Origin::signed(2);16581659		assert_ok!(TemplateModule::set_public_access_mode(1660			origin1.clone(),1661			collection_id,1662			AccessMode::WhiteList1663		));1664		assert_ok!(TemplateModule::set_mint_permission(1665			origin1.clone(),1666			collection_id,1667			true1668		));16691670		assert_ok!(TemplateModule::add_collection_admin(1671			origin1,1672			collection_id,1673			account(2)1674		));16751676		assert_ok!(TemplateModule::create_item(1677			origin2,1678			1,1679			account(2),1680			default_nft_data().into()1681		));1682	});1683}16841685// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-white listed address.1686#[test]1687fn white_list_test_15() {1688	new_test_ext().execute_with(|| {1689		let collection_id = create_test_collection(&CollectionMode::NFT, 1);16901691		let origin1 = Origin::signed(1);1692		let origin2 = Origin::signed(2);16931694		assert_ok!(TemplateModule::set_public_access_mode(1695			origin1.clone(),1696			collection_id,1697			AccessMode::WhiteList1698		));1699		assert_ok!(TemplateModule::set_mint_permission(1700			origin1,1701			collection_id,1702			true1703		));17041705		assert_noop!(1706			TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()),1707			Error::<Test>::AddresNotInWhiteList1708		);1709	});1710}17111712// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by non-privileged and white listed address.1713#[test]1714fn white_list_test_16() {1715	new_test_ext().execute_with(|| {1716		let collection_id = create_test_collection(&CollectionMode::NFT, 1);17171718		let origin1 = Origin::signed(1);1719		let origin2 = Origin::signed(2);17201721		assert_ok!(TemplateModule::set_public_access_mode(1722			origin1.clone(),1723			collection_id,1724			AccessMode::WhiteList1725		));1726		assert_ok!(TemplateModule::set_mint_permission(1727			origin1.clone(),1728			collection_id,1729			true1730		));1731		assert_ok!(TemplateModule::add_to_white_list(1732			origin1,1733			collection_id,1734			account(2)1735		));17361737		assert_ok!(TemplateModule::create_item(1738			origin2,1739			1,1740			account(2),1741			default_nft_data().into()1742		));1743	});1744}17451746// Total number of collections. Positive test1747#[test]1748fn total_number_collections_bound() {1749	new_test_ext().execute_with(|| {1750		create_test_collection(&CollectionMode::NFT, 1);1751	});1752}17531754// Total number of collections. Negotive test1755#[test]1756fn total_number_collections_bound_neg() {1757	new_test_ext().execute_with(|| {1758		let origin1 = Origin::signed(1);17591760		for i in 0..COLLECTION_NUMBER_LIMIT {1761			create_test_collection(&CollectionMode::NFT, i + 1);1762		}17631764		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1765		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1766		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();17671768		// 11-th collection in chain. Expects error1769		assert_noop!(1770			TemplateModule::create_collection(1771				origin1,1772				col_name1,1773				col_desc1,1774				token_prefix1,1775				CollectionMode::NFT1776			),1777			Error::<Test>::TotalCollectionsLimitExceeded1778		);1779	});1780}17811782// Owned tokens by a single address. Positive test1783#[test]1784fn owned_tokens_bound() {1785	new_test_ext().execute_with(|| {1786		let collection_id = create_test_collection(&CollectionMode::NFT, 1);17871788		let data = default_nft_data();1789		create_test_item(collection_id, &data.clone().into());1790		create_test_item(collection_id, &data.into());1791	});1792}17931794// Owned tokens by a single address. Negotive test1795#[test]1796fn owned_tokens_bound_neg() {1797	new_test_ext().execute_with(|| {1798		let collection_id = create_test_collection(&CollectionMode::NFT, 1);17991800		let origin1 = Origin::signed(1);18011802		for _ in 0..ACCOUNT_TOKEN_OWNERSHIP_LIMIT {1803			let data = default_nft_data();1804			create_test_item(collection_id, &data.clone().into());1805		}18061807		let data = default_nft_data();1808		assert_noop!(1809			TemplateModule::create_item(origin1, 1, account(1), data.into()),1810			Error::<Test>::AccountTokenLimitExceeded1811		);1812	});1813}18141815// Number of collection admins. Positive test1816#[test]1817fn collection_admins_bound() {1818	new_test_ext().execute_with(|| {1819		let collection_id = create_test_collection(&CollectionMode::NFT, 1);18201821		let origin1 = Origin::signed(1);18221823		assert_ok!(TemplateModule::add_collection_admin(1824			origin1.clone(),1825			collection_id,1826			account(2)1827		));1828		assert_ok!(TemplateModule::add_collection_admin(1829			origin1,1830			collection_id,1831			account(3)1832		));1833	});1834}18351836// Number of collection admins. Negotive test1837#[test]1838fn collection_admins_bound_neg() {1839	new_test_ext().execute_with(|| {1840		let collection_id = create_test_collection(&CollectionMode::NFT, 1);18411842		let origin1 = Origin::signed(1);18431844		for i in 0..COLLECTION_ADMINS_LIMIT {1845			assert_ok!(TemplateModule::add_collection_admin(1846				origin1.clone(),1847				collection_id,1848				account(2 + i)1849			));1850		}1851		assert_noop!(1852			TemplateModule::add_collection_admin(1853				origin1,1854				collection_id,1855				account(3 + COLLECTION_ADMINS_LIMIT)1856			),1857			Error::<Test>::CollectionAdminsLimitExceeded1858		);1859	});1860}1861// #endregion18621863#[test]1864fn set_const_on_chain_schema() {1865	new_test_ext().execute_with(|| {1866		let collection_id = create_test_collection(&CollectionMode::NFT, 1);18671868		let origin1 = Origin::signed(1);1869		assert_ok!(TemplateModule::set_const_on_chain_schema(1870			origin1,1871			collection_id,1872			b"test const on chain schema".to_vec()1873		));18741875		assert_eq!(1876			TemplateModule::collection_id(collection_id)1877				.unwrap()1878				.const_on_chain_schema,1879			b"test const on chain schema".to_vec()1880		);1881		assert_eq!(1882			TemplateModule::collection_id(collection_id)1883				.unwrap()1884				.variable_on_chain_schema,1885			b"".to_vec()1886		);1887	});1888}18891890#[test]1891fn set_variable_on_chain_schema() {1892	new_test_ext().execute_with(|| {1893		let collection_id = create_test_collection(&CollectionMode::NFT, 1);18941895		let origin1 = Origin::signed(1);1896		assert_ok!(TemplateModule::set_variable_on_chain_schema(1897			origin1,1898			collection_id,1899			b"test variable on chain schema".to_vec()1900		));19011902		assert_eq!(1903			TemplateModule::collection_id(collection_id)1904				.unwrap()1905				.const_on_chain_schema,1906			b"".to_vec()1907		);1908		assert_eq!(1909			TemplateModule::collection_id(collection_id)1910				.unwrap()1911				.variable_on_chain_schema,1912			b"test variable on chain schema".to_vec()1913		);1914	});1915}19161917#[test]1918fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1919	new_test_ext().execute_with(|| {1920		let collection_id = create_test_collection(&CollectionMode::NFT, 1);19211922		let origin1 = Origin::signed(1);19231924		let data = default_nft_data();1925		create_test_item(1, &data.into());19261927		let variable_data = b"test data".to_vec();1928		assert_ok!(TemplateModule::set_variable_meta_data(1929			origin1,1930			collection_id,1931			1,1932			variable_data.clone()1933		));19341935		assert_eq!(1936			TemplateModule::nft_item_id(collection_id, 1)1937				.unwrap()1938				.variable_data,1939			variable_data1940		);1941	});1942}19431944#[test]1945fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1946	new_test_ext().execute_with(|| {1947		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);19481949		let origin1 = Origin::signed(1);19501951		let data = default_re_fungible_data();1952		create_test_item(1, &data.into());19531954		let variable_data = b"test data".to_vec();1955		assert_ok!(TemplateModule::set_variable_meta_data(1956			origin1,1957			collection_id,1958			1,1959			variable_data.clone()1960		));19611962		assert_eq!(1963			TemplateModule::refungible_item_id(collection_id, 1)1964				.unwrap()1965				.variable_data,1966			variable_data1967		);1968	});1969}19701971#[test]1972fn set_variable_meta_data_on_fungible_token_fails() {1973	new_test_ext().execute_with(|| {1974		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);19751976		let origin1 = Origin::signed(1);19771978		let data = default_fungible_data();1979		create_test_item(1, &data.into());19801981		let variable_data = b"test data".to_vec();1982		assert_noop!(1983			TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data),1984			Error::<Test>::CantStoreMetadataInFungibleTokens1985		);1986	});1987}19881989#[test]1990fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1991	new_test_ext().execute_with(|| {1992		let collection_id = create_test_collection(&CollectionMode::NFT, 1);19931994		let origin1 = Origin::signed(1);19951996		let data = default_nft_data();1997		create_test_item(1, &data.into());19981999		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2000		assert_noop!(2001			TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data),2002			Error::<Test>::TokenVariableDataLimitExceeded2003		);2004	});2005}20062007#[test]2008fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {2009	new_test_ext().execute_with(|| {2010		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);20112012		let origin1 = Origin::signed(1);20132014		let data = default_re_fungible_data();2015		create_test_item(1, &data.into());20162017		let variable_data = b"test set_variable_meta_data method, bigger than limits.".to_vec();2018		assert_noop!(2019			TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data),2020			Error::<Test>::TokenVariableDataLimitExceeded2021		);2022	});2023}20242025#[test]2026fn set_variable_meta_data_on_nft_with_item_owner_permission_flag() {2027	new_test_ext().execute_with(|| {2028		//default_limits();20292030		let collection_id = create_test_collection(&CollectionMode::NFT, 1);20312032		let origin1 = Origin::signed(1);20332034		let data = default_nft_data();2035		create_test_item(1, &data.into());20362037		assert_ok!(TemplateModule::set_meta_update_permission_flag(2038			origin1.clone(),2039			collection_id,2040			MetaUpdatePermission::ItemOwner,2041		));20422043		let variable_data = b"ten chars.".to_vec();2044		assert_ok!(TemplateModule::set_variable_meta_data(2045			origin1,2046			collection_id,2047			1,2048			variable_data.clone()2049		));20502051		assert_eq!(2052			TemplateModule::nft_item_id(collection_id, 1)2053				.unwrap()2054				.variable_data,2055			variable_data2056		);2057	});2058}20592060#[test]2061fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() {2062	new_test_ext().execute_with(|| {2063		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);20642065		let origin1 = Origin::signed(1);20662067		assert_ok!(TemplateModule::set_mint_permission(2068			origin1.clone(),2069			collection_id,2070			true2071		));2072		assert_ok!(TemplateModule::add_to_white_list(2073			origin1.clone(),2074			collection_id,2075			account(1)2076		));20772078		let data = default_nft_data();2079		create_test_item(1, &data.into());20802081		assert_ok!(TemplateModule::set_meta_update_permission_flag(2082			origin1.clone(),2083			collection_id,2084			MetaUpdatePermission::ItemOwner,2085		));20862087		let variable_data = b"1234567890123".to_vec();2088		assert_noop!(2089			TemplateModule::set_variable_meta_data(2090				origin1,2091				collection_id,2092				1,2093				variable_data.clone()2094			),2095			Error::<Test>::TokenVariableDataLimitExceeded2096		);2097	})2098}20992100#[test]2101fn collection_transfer_flag_works() {2102	new_test_ext().execute_with(|| {2103		let origin1 = Origin::signed(1);21042105		let collection_id = create_test_collection(&CollectionMode::NFT, 1);2106		assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, 1, true));21072108		let data = default_nft_data();2109		create_test_item(collection_id, &data.into());2110		assert_eq!(TemplateModule::balance_count(1, 1), 1);2111		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);21122113		let origin1 = Origin::signed(1);21142115		// default scenario2116		assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1000));2117		assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(2));2118		assert_eq!(TemplateModule::balance_count(1, 1), 0);2119		assert_eq!(TemplateModule::balance_count(1, 2), 1);21202121		assert_eq!(TemplateModule::address_tokens(1, 2), [1]);2122	});2123}21242125#[test]2126fn set_variable_meta_data_on_nft_with_admin_flag() {2127	new_test_ext().execute_with(|| {2128		// default_limits();21292130		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);21312132		let origin1 = Origin::signed(1);2133		let origin2 = Origin::signed(2);21342135		assert_ok!(TemplateModule::set_mint_permission(2136			origin2.clone(),2137			collection_id,2138			true2139		));2140		assert_ok!(TemplateModule::add_to_white_list(2141			origin2.clone(),2142			collection_id,2143			account(1)2144		));21452146		assert_ok!(TemplateModule::add_collection_admin(2147			origin2.clone(),2148			collection_id,2149			account(1)2150		));21512152		let data = default_nft_data();2153		create_test_item(1, &data.into());21542155		assert_ok!(TemplateModule::set_meta_update_permission_flag(2156			origin2.clone(),2157			collection_id,2158			MetaUpdatePermission::Admin,2159		));21602161		let variable_data = b"test.".to_vec();2162		assert_ok!(TemplateModule::set_variable_meta_data(2163			origin1,2164			collection_id,2165			1,2166			variable_data.clone()2167		));21682169		assert_eq!(2170			TemplateModule::nft_item_id(collection_id, 1)2171				.unwrap()2172				.variable_data,2173			variable_data2174		);2175	});2176}21772178#[test]2179fn set_variable_meta_data_on_nft_with_admin_flag_neg() {2180	new_test_ext().execute_with(|| {2181		// default_limits();21822183		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);21842185		let origin1 = Origin::signed(1);2186		let origin2 = Origin::signed(2);21872188		assert_ok!(TemplateModule::set_mint_permission(2189			origin2.clone(),2190			collection_id,2191			true2192		));2193		assert_ok!(TemplateModule::add_to_white_list(2194			origin2.clone(),2195			collection_id,2196			account(1)2197		));21982199		let data = default_nft_data();2200		create_test_item(1, &data.into());22012202		assert_ok!(TemplateModule::set_meta_update_permission_flag(2203			origin2.clone(),2204			collection_id,2205			MetaUpdatePermission::Admin,2206		));22072208		let variable_data = b"test.".to_vec();2209		assert_noop!(2210			TemplateModule::set_variable_meta_data(2211				origin1,2212				collection_id,2213				1,2214				variable_data.clone()2215			),2216			Error::<Test>::NoPermission2217		);2218	});2219}22202221#[test]2222fn set_variable_meta_flag_after_freeze() {2223	new_test_ext().execute_with(|| {2224		// default_limits();22252226		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);22272228		let origin2 = Origin::signed(2);22292230		assert_ok!(TemplateModule::set_meta_update_permission_flag(2231			origin2.clone(),2232			collection_id,2233			MetaUpdatePermission::None,2234		));2235		assert_noop!(2236			TemplateModule::set_meta_update_permission_flag(2237				origin2.clone(),2238				collection_id,2239				MetaUpdatePermission::Admin2240			),2241			Error::<Test>::MetadataFlagFrozen2242		);2243	});2244}22452246#[test]2247fn set_variable_meta_data_on_nft_with_none_flag_neg() {2248	new_test_ext().execute_with(|| {2249		// default_limits();22502251		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);2252		let origin1 = Origin::signed(1);22532254		let data = default_nft_data();2255		create_test_item(1, &data.into());22562257		assert_ok!(TemplateModule::set_meta_update_permission_flag(2258			origin1.clone(),2259			collection_id,2260			MetaUpdatePermission::None,2261		));22622263		let variable_data = b"test.".to_vec();2264		assert_noop!(2265			TemplateModule::set_variable_meta_data(2266				origin1.clone(),2267				collection_id,2268				1,2269				variable_data.clone()2270			),2271			Error::<Test>::MetadataUpdateDenied2272		);2273	});2274}22752276#[test]2277fn collection_transfer_flag_works_neg() {2278	new_test_ext().execute_with(|| {2279		let origin1 = Origin::signed(1);22802281		let collection_id = create_test_collection(&CollectionMode::NFT, 1);2282		assert_ok!(TemplateModule::set_transfers_enabled_flag(2283			origin1, 1, false2284		));22852286		let data = default_nft_data();2287		create_test_item(collection_id, &data.into());2288		assert_eq!(TemplateModule::balance_count(1, 1), 1);2289		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);22902291		let origin1 = Origin::signed(1);22922293		// default scenario2294		assert_noop!(2295			TemplateModule::transfer(origin1, account(2), 1, 1, 1000),2296			Error::<Test>::TransferNotAllowed2297		);2298		assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(1));2299		assert_eq!(TemplateModule::balance_count(1, 1), 1);2300		assert_eq!(TemplateModule::balance_count(1, 2), 0);23012302		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);2303	});2304}