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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Tests to be written here18use crate::{Test, TestCrossAccountId, CollectionCreationPrice, RuntimeOrigin, Unique, new_test_ext};19use up_data_structs::{20	COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData,21	CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, TokenId,22	MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionMode, AccessMode, CollectionPermissions,23	PropertyKeyPermission, PropertyPermission, Property, CollectionPropertiesVec,24	CollectionPropertiesPermissionsVec,25};26use frame_support::{assert_noop, assert_ok, assert_err};27use sp_std::convert::TryInto;28use pallet_evm::account::CrossAccountId;29use pallet_common::Error as CommonError;30use pallet_unique::Error as UniqueError;3132fn add_balance(user: u64, value: u64) {33	const DONOR_USER: u64 = 999;34	assert_ok!(<pallet_balances::Pallet<Test>>::set_balance(35		RuntimeOrigin::root(),36		DONOR_USER,37		value,38		039	));40	assert_ok!(<pallet_balances::Pallet<Test>>::force_transfer(41		RuntimeOrigin::root(),42		DONOR_USER,43		user,44		value45	));46}4748fn default_nft_data() -> CreateNftData {49	CreateNftData {50		properties: vec![Property {51			key: b"test-prop".to_vec().try_into().unwrap(),52			value: b"test-nft-prop".to_vec().try_into().unwrap(),53		}]54		.try_into()55		.unwrap(),56	}57}5859fn default_fungible_data() -> CreateFungibleData {60	CreateFungibleData { value: 5 }61}6263fn default_re_fungible_data() -> CreateReFungibleData {64	CreateReFungibleData {65		pieces: 1023,66		properties: vec![Property {67			key: b"test-prop".to_vec().try_into().unwrap(),68			value: b"test-nft-prop".to_vec().try_into().unwrap(),69		}]70		.try_into()71		.unwrap(),72	}73}7475fn create_test_collection_for_owner(76	mode: &CollectionMode,77	owner: u64,78	id: CollectionId,79) -> CollectionId {80	add_balance(owner, CollectionCreationPrice::get() as u64 + 1);8182	let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();83	let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();84	let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();85	let token_property_permissions: CollectionPropertiesPermissionsVec =86		vec![PropertyKeyPermission {87			key: b"test-prop".to_vec().try_into().unwrap(),88			permission: PropertyPermission {89				mutable: true,90				collection_admin: false,91				token_owner: true,92			},93		}]94		.try_into()95		.unwrap();96	let properties: CollectionPropertiesVec = vec![Property {97		key: b"test-collection-prop".to_vec().try_into().unwrap(),98		value: b"test-collection-value".to_vec().try_into().unwrap(),99	}]100	.try_into()101	.unwrap();102103	let data: CreateCollectionData<u64> = CreateCollectionData {104		name: col_name1.try_into().unwrap(),105		description: col_desc1.try_into().unwrap(),106		token_prefix: token_prefix1.try_into().unwrap(),107		mode: mode.clone(),108		token_property_permissions: token_property_permissions.clone(),109		properties: properties.clone(),110		..Default::default()111	};112113	let origin1 = RuntimeOrigin::signed(owner);114	assert_ok!(Unique::create_collection_ex(origin1, data));115116	let saved_col_name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();117	let saved_description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();118	let saved_prefix: Vec<u8> = b"token_prefix1\0".to_vec();119	assert_eq!(120		<pallet_common::CollectionById<Test>>::get(id)121			.unwrap()122			.owner,123		owner124	);125	assert_eq!(126		<pallet_common::CollectionById<Test>>::get(id).unwrap().name,127		saved_col_name128	);129	assert_eq!(130		<pallet_common::CollectionById<Test>>::get(id).unwrap().mode,131		*mode132	);133	assert_eq!(134		<pallet_common::CollectionById<Test>>::get(id)135			.unwrap()136			.description,137		saved_description138	);139	assert_eq!(140		<pallet_common::CollectionById<Test>>::get(id)141			.unwrap()142			.token_prefix,143		saved_prefix144	);145	assert_eq!(146		get_collection_property_permissions(id).as_slice(),147		token_property_permissions.as_slice()148	);149	assert_eq!(150		get_collection_properties(id).as_slice(),151		properties.as_slice()152	);153	id154}155156fn get_collection_property_permissions(collection_id: CollectionId) -> Vec<PropertyKeyPermission> {157	<pallet_common::Pallet<Test>>::property_permissions(collection_id)158		.into_iter()159		.map(|(key, permission)| PropertyKeyPermission { key, permission })160		.collect()161}162163fn get_collection_properties(collection_id: CollectionId) -> Vec<Property> {164	<pallet_common::Pallet<Test>>::collection_properties(collection_id)165		.into_iter()166		.map(|(key, value)| Property { key, value })167		.collect()168}169170fn get_token_properties(collection_id: CollectionId, token_id: TokenId) -> Vec<Property> {171	<pallet_nonfungible::Pallet<Test>>::token_properties((collection_id, token_id))172		.into_iter()173		.map(|(key, value)| Property { key, value })174		.collect()175}176177fn create_test_collection(mode: &CollectionMode, id: CollectionId) -> CollectionId {178	create_test_collection_for_owner(&mode, 1, id)179}180181fn create_test_item(collection_id: CollectionId, data: &CreateItemData) {182	let origin1 = RuntimeOrigin::signed(1);183	assert_ok!(Unique::create_item(184		origin1,185		collection_id,186		account(1),187		data.clone()188	));189}190191fn account(sub: u64) -> TestCrossAccountId {192	TestCrossAccountId::from_sub(sub)193}194195// Use cases tests region196// #region197198#[test]199fn check_not_sufficient_founds() {200	new_test_ext().execute_with(|| {201		let acc: u64 = 1;202		<pallet_balances::Pallet<Test>>::set_balance(RuntimeOrigin::root(), acc, 0, 0).unwrap();203204		let name: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();205		let description: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();206		let token_prefix: Vec<u8> = b"token_prefix1\0".to_vec();207208		let data: CreateCollectionData<<Test as frame_system::Config>::AccountId> =209			CreateCollectionData {210				name: name.try_into().unwrap(),211				description: description.try_into().unwrap(),212				token_prefix: token_prefix.try_into().unwrap(),213				mode: CollectionMode::NFT,214				..Default::default()215			};216217		let result = Unique::create_collection_ex(RuntimeOrigin::signed(acc), data);218		assert_err!(result, <CommonError<Test>>::NotSufficientFounds);219	});220}221222#[test]223fn create_fungible_collection_fails_with_large_decimal_numbers() {224	new_test_ext().execute_with(|| {225		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();226		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();227		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();228229		let data: CreateCollectionData<u64> = CreateCollectionData {230			name: col_name1.try_into().unwrap(),231			description: col_desc1.try_into().unwrap(),232			token_prefix: token_prefix1.try_into().unwrap(),233			mode: CollectionMode::Fungible(MAX_DECIMAL_POINTS + 1),234			..Default::default()235		};236237		let origin1 = RuntimeOrigin::signed(1);238		assert_noop!(239			Unique::create_collection_ex(origin1, data),240			UniqueError::<Test>::CollectionDecimalPointLimitExceeded241		);242	});243}244245#[test]246fn create_nft_item() {247	new_test_ext().execute_with(|| {248		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));249250		let data = default_nft_data();251		create_test_item(collection_id, &data.clone().into());252253		assert_eq!(254			get_token_properties(collection_id, TokenId(1)).as_slice(),255			data.properties.as_slice(),256		);257	});258}259260// Use cases tests region261// #region262#[test]263fn create_nft_multiple_items() {264	new_test_ext().execute_with(|| {265		create_test_collection(&CollectionMode::NFT, CollectionId(1));266267		let origin1 = RuntimeOrigin::signed(1);268269		let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];270271		assert_ok!(Unique::create_multiple_items(272			origin1,273			CollectionId(1),274			account(1),275			items_data276				.clone()277				.into_iter()278				.map(|d| { d.into() })279				.collect()280		));281		for (index, data) in items_data.into_iter().enumerate() {282			assert_eq!(283				get_token_properties(CollectionId(1), TokenId(index as u32 + 1)).as_slice(),284				data.properties.as_slice()285			);286		}287	});288}289290#[test]291fn create_refungible_item() {292	new_test_ext().execute_with(|| {293		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));294295		let data = default_re_fungible_data();296		create_test_item(collection_id, &data.clone().into());297		let balance =298			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1)));299		assert_eq!(balance, 1023);300	});301}302303#[test]304fn create_multiple_refungible_items() {305	new_test_ext().execute_with(|| {306		create_test_collection(&CollectionMode::ReFungible, CollectionId(1));307308		let origin1 = RuntimeOrigin::signed(1);309310		let items_data = vec![311			default_re_fungible_data(),312			default_re_fungible_data(),313			default_re_fungible_data(),314		];315316		assert_ok!(Unique::create_multiple_items(317			origin1,318			CollectionId(1),319			account(1),320			items_data321				.clone()322				.into_iter()323				.map(|d| { d.into() })324				.collect()325		));326		for (index, _data) in items_data.into_iter().enumerate() {327			let balance = <pallet_refungible::Balance<Test>>::get((328				CollectionId(1),329				TokenId((index + 1) as u32),330				account(1),331			));332			assert_eq!(balance, 1023);333		}334	});335}336337#[test]338fn create_fungible_item() {339	new_test_ext().execute_with(|| {340		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));341342		let data = default_fungible_data();343		create_test_item(collection_id, &data.into());344345		assert_eq!(346			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),347			5348		);349	});350}351352//#[test]353// fn create_multiple_fungible_items() {354//     new_test_ext().execute_with(|| {355//         default_limits();356357//         create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));358359//         let origin1 = RuntimeOrigin::signed(1);360361//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];362363//         assert_ok!(Unique::create_multiple_items(364//             origin1.clone(),365//             1,366//             1,367//             items_data.clone().into_iter().map(|d| { d.into() }).collect()368//         ));369370//         for (index, _) in items_data.iter().enumerate() {371//             assert_eq!(Unique::fungible_item_id(1, (index + 1) as TokenId).value, 5);372//         }373//         assert_eq!(Unique::balance_count(1, 1), 3000);374//         assert_eq!(Unique::address_tokens(1, 1), [1, 2, 3]);375//     });376// }377378#[test]379fn transfer_fungible_item() {380	new_test_ext().execute_with(|| {381		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));382383		let origin1 = RuntimeOrigin::signed(1);384		let origin2 = RuntimeOrigin::signed(2);385386		let data = default_fungible_data();387		create_test_item(collection_id, &data.into());388389		assert_eq!(390			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),391			5392		);393394		// change owner scenario395		assert_ok!(Unique::transfer(396			origin1,397			account(2),398			CollectionId(1),399			TokenId(0),400			5401		));402		assert_eq!(403			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(1))),404			0405		);406407		// split item scenario408		assert_ok!(Unique::transfer(409			origin2.clone(),410			account(3),411			CollectionId(1),412			TokenId(0),413			3414		));415416		// split item and new owner has account scenario417		assert_ok!(Unique::transfer(418			origin2,419			account(3),420			CollectionId(1),421			TokenId(0),422			1423		));424		assert_eq!(425			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(2))),426			1427		);428		assert_eq!(429			<pallet_fungible::Balance<Test>>::get((CollectionId(1), account(3))),430			4431		);432	});433}434435#[test]436fn transfer_refungible_item() {437	new_test_ext().execute_with(|| {438		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));439440		// Create RFT 1 in 1023 pieces for account 1441		let data = default_re_fungible_data();442		create_test_item(collection_id, &data.clone().into());443		assert_eq!(444			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),445			1446		);447		assert_eq!(448			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),449			1023450		);451		assert_eq!(452			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),453			true454		);455456		// Account 1 transfers all 1023 pieces of RFT 1 to account 2457		let origin1 = RuntimeOrigin::signed(1);458		let origin2 = RuntimeOrigin::signed(2);459		assert_ok!(Unique::transfer(460			origin1,461			account(2),462			CollectionId(1),463			TokenId(1),464			1023465		));466		assert_eq!(467			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),468			1023469		);470		assert_eq!(471			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),472			0473		);474		assert_eq!(475			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),476			1477		);478		assert_eq!(479			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),480			false481		);482		assert_eq!(483			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),484			true485		);486487		// Account 2 transfers 500 pieces of RFT 1 to account 3488		assert_ok!(Unique::transfer(489			origin2.clone(),490			account(3),491			CollectionId(1),492			TokenId(1),493			500494		));495		assert_eq!(496			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),497			523498		);499		assert_eq!(500			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),501			500502		);503		assert_eq!(504			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),505			1506		);507		assert_eq!(508			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),509			1510		);511		assert_eq!(512			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),513			true514		);515		assert_eq!(516			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),517			true518		);519520		// Account 2 transfers 200 more pieces of RFT 1 to account 3 with pre-existing balance521		assert_ok!(Unique::transfer(522			origin2,523			account(3),524			CollectionId(1),525			TokenId(1),526			200527		));528		assert_eq!(529			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(2))),530			323531		);532		assert_eq!(533			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),534			700535		);536		assert_eq!(537			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(2))),538			1539		);540		assert_eq!(541			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),542			1543		);544		assert_eq!(545			<pallet_refungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),546			true547		);548		assert_eq!(549			<pallet_refungible::Owned<Test>>::get((collection_id, account(3), TokenId(1))),550			true551		);552	});553}554555#[test]556fn transfer_nft_item() {557	new_test_ext().execute_with(|| {558		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));559560		let data = default_nft_data();561		create_test_item(collection_id, &data.into());562		assert_eq!(563			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),564			1565		);566		assert_eq!(567			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),568			true569		);570571		let origin1 = RuntimeOrigin::signed(1);572		// default scenario573		assert_ok!(Unique::transfer(574			origin1,575			account(2),576			CollectionId(1),577			TokenId(1),578			1579		));580		assert_eq!(581			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),582			0583		);584		assert_eq!(585			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),586			1587		);588		assert_eq!(589			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),590			false591		);592		assert_eq!(593			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),594			true595		);596	});597}598599#[test]600fn transfer_nft_item_wrong_value() {601	new_test_ext().execute_with(|| {602		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));603604		let data = default_nft_data();605		create_test_item(collection_id, &data.into());606		assert_eq!(607			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),608			1609		);610		assert_eq!(611			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),612			true613		);614615		let origin1 = RuntimeOrigin::signed(1);616617		assert_noop!(618			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 2)619				.map_err(|e| e.error),620			<pallet_nonfungible::Error::<Test>>::NonfungibleItemsHaveNoAmount621		);622	});623}624625#[test]626fn transfer_nft_item_zero_value() {627	new_test_ext().execute_with(|| {628		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));629630		let data = default_nft_data();631		create_test_item(collection_id, &data.into());632		assert_eq!(633			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),634			1635		);636		assert_eq!(637			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),638			true639		);640641		let origin1 = RuntimeOrigin::signed(1);642643		// Transferring 0 amount works on NFT...644		assert_ok!(Unique::transfer(645			origin1,646			account(2),647			CollectionId(1),648			TokenId(1),649			0650		));651		// ... and results in no transfer652		assert_eq!(653			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),654			1655		);656		assert_eq!(657			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),658			true659		);660	});661}662663#[test]664fn nft_approve_and_transfer_from() {665	new_test_ext().execute_with(|| {666		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));667668		let data = default_nft_data();669		create_test_item(collection_id, &data.into());670671		let origin1 = RuntimeOrigin::signed(1);672		let origin2 = RuntimeOrigin::signed(2);673674		assert_eq!(675			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),676			1677		);678		assert_eq!(679			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),680			true681		);682683		// neg transfer_from684		assert_noop!(685			Unique::transfer_from(686				origin2.clone(),687				account(1),688				account(2),689				CollectionId(1),690				TokenId(1),691				1692			)693			.map_err(|e| e.error),694			CommonError::<Test>::ApprovedValueTooLow695		);696697		// do approve698		assert_ok!(Unique::approve(699			origin1,700			account(2),701			CollectionId(1),702			TokenId(1),703			1704		));705		assert_eq!(706			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),707			account(2)708		);709710		assert_ok!(Unique::transfer_from(711			origin2,712			account(1),713			account(3),714			CollectionId(1),715			TokenId(1),716			1717		));718		assert!(719			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()720		);721	});722}723724#[test]725fn nft_approve_and_transfer_from_allow_list() {726	new_test_ext().execute_with(|| {727		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));728729		let origin1 = RuntimeOrigin::signed(1);730		let origin2 = RuntimeOrigin::signed(2);731732		// Create NFT 1 for account 1733		let data = default_nft_data();734		create_test_item(collection_id, &data.clone().into());735		assert_eq!(736			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),737			1738		);739		assert_eq!(740			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),741			true742		);743744		// Allow allow-list users to mint and add accounts 1, 2, and 3 to allow-list745		assert_ok!(Unique::set_collection_permissions(746			origin1.clone(),747			CollectionId(1),748			CollectionPermissions {749				mint_mode: Some(true),750				access: Some(AccessMode::AllowList),751				nesting: None,752			}753		));754		assert_ok!(Unique::add_to_allow_list(755			origin1.clone(),756			CollectionId(1),757			account(1)758		));759		assert_ok!(Unique::add_to_allow_list(760			origin1.clone(),761			CollectionId(1),762			account(2)763		));764		assert_ok!(Unique::add_to_allow_list(765			origin1.clone(),766			CollectionId(1),767			account(3)768		));769770		// Account 1 approves account 2 for NFT 1771		assert_ok!(Unique::approve(772			origin1.clone(),773			account(2),774			CollectionId(1),775			TokenId(1),776			1777		));778		assert_eq!(779			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),780			account(2)781		);782783		// Account 2 transfers NFT 1 from account 1 to account 3784		assert_ok!(Unique::transfer_from(785			origin2,786			account(1),787			account(3),788			CollectionId(1),789			TokenId(1),790			1791		));792		assert!(793			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).is_none()794		);795	});796}797798#[test]799fn refungible_approve_and_transfer_from() {800	new_test_ext().execute_with(|| {801		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));802803		let origin1 = RuntimeOrigin::signed(1);804		let origin2 = RuntimeOrigin::signed(2);805806		// Create RFT 1 in 1023 pieces for account 1807		let data = default_re_fungible_data();808		create_test_item(collection_id, &data.into());809810		assert_eq!(811			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),812			1813		);814		assert_eq!(815			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),816			1023817		);818		assert_eq!(819			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),820			true821		);822823		// Allow public minting, enable allow-list and add accounts 1, 2, 3 to allow-list824		assert_ok!(Unique::set_collection_permissions(825			origin1.clone(),826			CollectionId(1),827			CollectionPermissions {828				mint_mode: Some(true),829				access: Some(AccessMode::AllowList),830				nesting: None,831			}832		));833		assert_ok!(Unique::add_to_allow_list(834			origin1.clone(),835			CollectionId(1),836			account(1)837		));838		assert_ok!(Unique::add_to_allow_list(839			origin1.clone(),840			CollectionId(1),841			account(2)842		));843		assert_ok!(Unique::add_to_allow_list(844			origin1.clone(),845			CollectionId(1),846			account(3)847		));848849		// Account 1 approves account 2 for 1023 pieces of RFT 1850		assert_ok!(Unique::approve(851			origin1,852			account(2),853			CollectionId(1),854			TokenId(1),855			1023856		));857		assert_eq!(858			<pallet_refungible::Allowance<Test>>::get((859				CollectionId(1),860				TokenId(1),861				account(1),862				account(2)863			)),864			1023865		);866867		// Account 2 transfers 100 pieces of RFT 1 from account 1 to account 3868		assert_ok!(Unique::transfer_from(869			origin2,870			account(1),871			account(3),872			CollectionId(1),873			TokenId(1),874			100875		));876		assert_eq!(877			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),878			1879		);880		assert_eq!(881			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(3))),882			1883		);884		assert_eq!(885			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),886			923887		);888		assert_eq!(889			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(3))),890			100891		);892		assert_eq!(893			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),894			true895		);896		assert_eq!(897			<pallet_refungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),898			true899		);900		assert_eq!(901			<pallet_refungible::Allowance<Test>>::get((902				CollectionId(1),903				TokenId(1),904				account(1),905				account(2)906			)),907			923908		);909	});910}911912#[test]913fn fungible_approve_and_transfer_from() {914	new_test_ext().execute_with(|| {915		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));916917		let data = default_fungible_data();918		create_test_item(collection_id, &data.into());919920		let origin1 = RuntimeOrigin::signed(1);921		let origin2 = RuntimeOrigin::signed(2);922923		assert_ok!(Unique::set_collection_permissions(924			origin1.clone(),925			CollectionId(1),926			CollectionPermissions {927				mint_mode: Some(true),928				access: Some(AccessMode::AllowList),929				nesting: None,930			}931		));932		assert_ok!(Unique::add_to_allow_list(933			origin1.clone(),934			CollectionId(1),935			account(1)936		));937		assert_ok!(Unique::add_to_allow_list(938			origin1.clone(),939			CollectionId(1),940			account(2)941		));942		assert_ok!(Unique::add_to_allow_list(943			origin1.clone(),944			CollectionId(1),945			account(3)946		));947948		// do approve949		assert_ok!(Unique::approve(950			origin1.clone(),951			account(2),952			CollectionId(1),953			TokenId(0),954			5955		));956		assert_eq!(957			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),958			5959		);960		assert_ok!(Unique::approve(961			origin1,962			account(3),963			CollectionId(1),964			TokenId(0),965			5966		));967		assert_eq!(968			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),969			5970		);971		assert_eq!(972			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(3))),973			5974		);975976		assert_ok!(Unique::transfer_from(977			origin2.clone(),978			account(1),979			account(3),980			CollectionId(1),981			TokenId(0),982			4983		));984985		assert_eq!(986			<pallet_fungible::Allowance<Test>>::get((CollectionId(1), account(1), account(2))),987			1988		);989990		assert_noop!(991			Unique::transfer_from(992				origin2,993				account(1),994				account(3),995				CollectionId(1),996				TokenId(0),997				4998			)999			.map_err(|e| e.error),1000			CommonError::<Test>::ApprovedValueTooLow1001		);1002	});1003}10041005#[test]1006fn change_collection_owner() {1007	new_test_ext().execute_with(|| {1008		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10091010		let origin1 = RuntimeOrigin::signed(1);1011		assert_ok!(Unique::change_collection_owner(origin1, collection_id, 2));1012		assert_eq!(1013			<pallet_common::CollectionById<Test>>::get(collection_id)1014				.unwrap()1015				.owner,1016			21017		);1018	});1019}10201021#[test]1022fn destroy_collection() {1023	new_test_ext().execute_with(|| {1024		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10251026		let origin1 = RuntimeOrigin::signed(1);1027		assert_ok!(Unique::destroy_collection(origin1, collection_id));1028	});1029}10301031#[test]1032fn burn_nft_item() {1033	new_test_ext().execute_with(|| {1034		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10351036		let origin1 = RuntimeOrigin::signed(1);10371038		let data = default_nft_data();1039		create_test_item(collection_id, &data.into());10401041		// check balance (collection with id = 1, user id = 1)1042		assert_eq!(1043			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1044			11045		);10461047		// burn item1048		assert_ok!(Unique::burn_item(1049			origin1.clone(),1050			collection_id,1051			TokenId(1),1052			11053		));1054		assert_eq!(1055			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1056			01057		);1058	});1059}10601061#[test]1062fn burn_same_nft_item_twice() {1063	new_test_ext().execute_with(|| {1064		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));10651066		let origin1 = RuntimeOrigin::signed(1);10671068		let data = default_nft_data();1069		create_test_item(collection_id, &data.into());10701071		// check balance (collection with id = 1, user id = 1)1072		assert_eq!(1073			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1074			11075		);10761077		// burn item1078		assert_ok!(Unique::burn_item(1079			origin1.clone(),1080			collection_id,1081			TokenId(1),1082			11083		));10841085		// burn item again1086		assert_noop!(1087			Unique::burn_item(origin1, collection_id, TokenId(1), 1).map_err(|e| e.error),1088			CommonError::<Test>::TokenNotFound1089		);10901091		assert_eq!(1092			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),1093			01094		);1095	});1096}10971098#[test]1099fn burn_fungible_item() {1100	new_test_ext().execute_with(|| {1101		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11021103		let origin1 = RuntimeOrigin::signed(1);1104		assert_ok!(Unique::add_collection_admin(1105			origin1.clone(),1106			collection_id,1107			account(2)1108		));11091110		let data = default_fungible_data();1111		create_test_item(collection_id, &data.into());11121113		// check balance (collection with id = 1, user id = 1)1114		assert_eq!(1115			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1116			51117		);11181119		// burn item1120		assert_ok!(Unique::burn_item(1121			origin1.clone(),1122			CollectionId(1),1123			TokenId(0),1124			51125		));1126		assert_noop!(1127			Unique::burn_item(origin1, CollectionId(1), TokenId(0), 5).map_err(|e| e.error),1128			CommonError::<Test>::TokenValueTooLow1129		);11301131		assert_eq!(1132			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1133			01134		);1135	});1136}11371138#[test]1139fn burn_fungible_item_with_token_id() {1140	new_test_ext().execute_with(|| {1141		let collection_id = create_test_collection(&CollectionMode::Fungible(3), CollectionId(1));11421143		let origin1 = RuntimeOrigin::signed(1);1144		assert_ok!(Unique::add_collection_admin(1145			origin1.clone(),1146			collection_id,1147			account(2)1148		));11491150		let data = default_fungible_data();1151		create_test_item(collection_id, &data.into());11521153		// check balance (collection with id = 1, user id = 1)1154		assert_eq!(1155			<pallet_fungible::Balance<Test>>::get((collection_id, account(1))),1156			51157		);11581159		// Try to burn item using Token ID1160		assert_noop!(1161			Unique::burn_item(origin1, CollectionId(1), TokenId(1), 5).map_err(|e| e.error),1162			<pallet_fungible::Error::<Test>>::FungibleItemsHaveNoId1163		);1164	});1165}1166#[test]1167fn burn_refungible_item() {1168	new_test_ext().execute_with(|| {1169		let collection_id = create_test_collection(&CollectionMode::ReFungible, CollectionId(1));1170		let origin1 = RuntimeOrigin::signed(1);11711172		assert_ok!(Unique::set_collection_permissions(1173			origin1.clone(),1174			collection_id,1175			CollectionPermissions {1176				mint_mode: Some(true),1177				access: Some(AccessMode::AllowList),1178				nesting: None,1179			}1180		));1181		assert_ok!(Unique::add_to_allow_list(1182			origin1.clone(),1183			collection_id,1184			account(1)1185		));11861187		assert_ok!(Unique::add_collection_admin(1188			origin1.clone(),1189			collection_id,1190			account(2)1191		));11921193		let data = default_re_fungible_data();1194		create_test_item(collection_id, &data.into());11951196		// check balance (collection with id = 1, user id = 2)1197		assert_eq!(1198			<pallet_refungible::AccountBalance<Test>>::get((collection_id, account(1))),1199			11200		);1201		assert_eq!(1202			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1203			10231204		);12051206		// burn item1207		assert_ok!(Unique::burn_item(1208			origin1.clone(),1209			collection_id,1210			TokenId(1),1211			10231212		));1213		assert_noop!(1214			Unique::burn_item(origin1, collection_id, TokenId(1), 1023).map_err(|e| e.error),1215			CommonError::<Test>::TokenValueTooLow1216		);12171218		assert_eq!(1219			<pallet_refungible::Balance<Test>>::get((collection_id, TokenId(1), account(1))),1220			01221		);1222	});1223}12241225#[test]1226fn add_collection_admin() {1227	new_test_ext().execute_with(|| {1228		let collection1_id =1229			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1230		let origin1 = RuntimeOrigin::signed(1);12311232		// Add collection admins1233		assert_ok!(Unique::add_collection_admin(1234			origin1.clone(),1235			collection1_id,1236			account(2)1237		));1238		assert_ok!(Unique::add_collection_admin(1239			origin1,1240			collection1_id,1241			account(3)1242		));12431244		// Owner is not an admin by default1245		assert_eq!(1246			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(1))),1247			false1248		);1249		assert!(<pallet_common::IsAdmin<Test>>::get((1250			CollectionId(1),1251			account(2)1252		)));1253		assert!(<pallet_common::IsAdmin<Test>>::get((1254			CollectionId(1),1255			account(3)1256		)));1257	});1258}12591260#[test]1261fn remove_collection_admin() {1262	new_test_ext().execute_with(|| {1263		let collection1_id =1264			create_test_collection_for_owner(&CollectionMode::NFT, 1, CollectionId(1));1265		let origin1 = RuntimeOrigin::signed(1);12661267		// Add collection admins 2 and 31268		assert_ok!(Unique::add_collection_admin(1269			origin1.clone(),1270			collection1_id,1271			account(2)1272		));1273		assert_ok!(Unique::add_collection_admin(1274			origin1.clone(),1275			collection1_id,1276			account(3)1277		));12781279		assert!(<pallet_common::IsAdmin<Test>>::get((1280			CollectionId(1),1281			account(2)1282		)));1283		assert!(<pallet_common::IsAdmin<Test>>::get((1284			CollectionId(1),1285			account(3)1286		)));12871288		// remove admin 31289		assert_ok!(Unique::remove_collection_admin(1290			origin1,1291			CollectionId(1),1292			account(3)1293		));12941295		// 2 is still admin, 3 is not an admin anymore1296		assert!(<pallet_common::IsAdmin<Test>>::get((1297			CollectionId(1),1298			account(2)1299		)));1300		assert_eq!(1301			<pallet_common::IsAdmin<Test>>::get((CollectionId(1), account(3))),1302			false1303		);1304	});1305}13061307#[test]1308fn balance_of() {1309	new_test_ext().execute_with(|| {1310		let nft_collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1311		let fungible_collection_id =1312			create_test_collection(&CollectionMode::Fungible(3), CollectionId(2));1313		let re_fungible_collection_id =1314			create_test_collection(&CollectionMode::ReFungible, CollectionId(3));13151316		// check balance before1317		assert_eq!(1318			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1319			01320		);1321		assert_eq!(1322			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1323			01324		);1325		assert_eq!(1326			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1327			01328		);13291330		let nft_data = default_nft_data();1331		create_test_item(nft_collection_id, &nft_data.into());13321333		let fungible_data = default_fungible_data();1334		create_test_item(fungible_collection_id, &fungible_data.into());13351336		let re_fungible_data = default_re_fungible_data();1337		create_test_item(re_fungible_collection_id, &re_fungible_data.into());13381339		// check balance (collection with id = 1, user id = 1)1340		assert_eq!(1341			<pallet_nonfungible::AccountBalance<Test>>::get((nft_collection_id, account(1))),1342			11343		);1344		assert_eq!(1345			<pallet_fungible::Balance<Test>>::get((fungible_collection_id, account(1))),1346			51347		);1348		assert_eq!(1349			<pallet_refungible::AccountBalance<Test>>::get((re_fungible_collection_id, account(1))),1350			11351		);13521353		assert_eq!(1354			<pallet_nonfungible::Owned<Test>>::get((nft_collection_id, account(1), TokenId(1))),1355			true1356		);1357		assert_eq!(1358			<pallet_refungible::Owned<Test>>::get((1359				re_fungible_collection_id,1360				account(1),1361				TokenId(1)1362			)),1363			true1364		);1365	});1366}13671368#[test]1369fn approve() {1370	new_test_ext().execute_with(|| {1371		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));13721373		let data = default_nft_data();1374		create_test_item(collection_id, &data.into());13751376		let origin1 = RuntimeOrigin::signed(1);13771378		// approve1379		assert_ok!(Unique::approve(1380			origin1,1381			account(2),1382			CollectionId(1),1383			TokenId(1),1384			11385		));1386		assert_eq!(1387			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1388			account(2)1389		);1390	});1391}13921393#[test]1394fn transfer_from() {1395	new_test_ext().execute_with(|| {1396		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1397		let origin1 = RuntimeOrigin::signed(1);1398		let origin2 = RuntimeOrigin::signed(2);13991400		let data = default_nft_data();1401		create_test_item(collection_id, &data.into());14021403		// approve1404		assert_ok!(Unique::approve(1405			origin1.clone(),1406			account(2),1407			CollectionId(1),1408			TokenId(1),1409			11410		));1411		assert_eq!(1412			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1413			account(2)1414		);14151416		assert_ok!(Unique::set_collection_permissions(1417			origin1.clone(),1418			CollectionId(1),1419			CollectionPermissions {1420				mint_mode: Some(true),1421				access: Some(AccessMode::AllowList),1422				nesting: None,1423			}1424		));1425		assert_ok!(Unique::add_to_allow_list(1426			origin1.clone(),1427			CollectionId(1),1428			account(1)1429		));1430		assert_ok!(Unique::add_to_allow_list(1431			origin1.clone(),1432			CollectionId(1),1433			account(2)1434		));1435		assert_ok!(Unique::add_to_allow_list(1436			origin1,1437			CollectionId(1),1438			account(3)1439		));14401441		assert_ok!(Unique::transfer_from(1442			origin2,1443			account(1),1444			account(2),1445			CollectionId(1),1446			TokenId(1),1447			11448		));14491450		// after transfer1451		assert_eq!(1452			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(1))),1453			01454		);1455		assert_eq!(1456			<pallet_nonfungible::AccountBalance<Test>>::get((CollectionId(1), account(2))),1457			11458		);1459	});1460}14611462// #endregion14631464// Coverage tests region1465// #region14661467#[test]1468fn owner_can_add_address_to_allow_list() {1469	new_test_ext().execute_with(|| {1470		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));14711472		let origin1 = RuntimeOrigin::signed(1);1473		assert_ok!(Unique::add_to_allow_list(1474			origin1,1475			collection_id,1476			account(2)1477		));1478		assert!(<pallet_common::Allowlist<Test>>::get((1479			collection_id,1480			account(2)1481		)));1482	});1483}14841485#[test]1486fn admin_can_add_address_to_allow_list() {1487	new_test_ext().execute_with(|| {1488		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1489		let origin1 = RuntimeOrigin::signed(1);1490		let origin2 = RuntimeOrigin::signed(2);14911492		assert_ok!(Unique::add_collection_admin(1493			origin1,1494			collection_id,1495			account(2)1496		));1497		assert_ok!(Unique::add_to_allow_list(1498			origin2,1499			collection_id,1500			account(3)1501		));1502		assert!(<pallet_common::Allowlist<Test>>::get((1503			collection_id,1504			account(3)1505		)));1506	});1507}15081509#[test]1510fn nonprivileged_user_cannot_add_address_to_allow_list() {1511	new_test_ext().execute_with(|| {1512		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15131514		let origin2 = RuntimeOrigin::signed(2);1515		assert_noop!(1516			Unique::add_to_allow_list(origin2, collection_id, account(3)),1517			CommonError::<Test>::NoPermission1518		);1519	});1520}15211522#[test]1523fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {1524	new_test_ext().execute_with(|| {1525		let origin1 = RuntimeOrigin::signed(1);15261527		assert_noop!(1528			Unique::add_to_allow_list(origin1, CollectionId(1), account(2)),1529			CommonError::<Test>::CollectionNotFound1530		);1531	});1532}15331534#[test]1535fn nobody_can_add_address_to_allow_list_of_deleted_collection() {1536	new_test_ext().execute_with(|| {1537		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15381539		let origin1 = RuntimeOrigin::signed(1);1540		assert_ok!(Unique::destroy_collection(origin1.clone(), collection_id));1541		assert_noop!(1542			Unique::add_to_allow_list(origin1, collection_id, account(2)),1543			CommonError::<Test>::CollectionNotFound1544		);1545	});1546}15471548// If address is already added to allow list, nothing happens1549#[test]1550fn address_is_already_added_to_allow_list() {1551	new_test_ext().execute_with(|| {1552		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1553		let origin1 = RuntimeOrigin::signed(1);15541555		assert_ok!(Unique::add_to_allow_list(1556			origin1.clone(),1557			collection_id,1558			account(2)1559		));1560		assert_ok!(Unique::add_to_allow_list(1561			origin1,1562			collection_id,1563			account(2)1564		));1565		assert!(<pallet_common::Allowlist<Test>>::get((1566			collection_id,1567			account(2)1568		)));1569	});1570}15711572#[test]1573fn owner_can_remove_address_from_allow_list() {1574	new_test_ext().execute_with(|| {1575		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));15761577		let origin1 = RuntimeOrigin::signed(1);1578		assert_ok!(Unique::add_to_allow_list(1579			origin1.clone(),1580			collection_id,1581			account(2)1582		));1583		assert_ok!(Unique::remove_from_allow_list(1584			origin1,1585			collection_id,1586			account(2)1587		));1588		assert_eq!(1589			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1590			false1591		);1592	});1593}15941595#[test]1596fn admin_can_remove_address_from_allow_list() {1597	new_test_ext().execute_with(|| {1598		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1599		let origin1 = RuntimeOrigin::signed(1);1600		let origin2 = RuntimeOrigin::signed(2);16011602		// Owner adds admin1603		assert_ok!(Unique::add_collection_admin(1604			origin1.clone(),1605			collection_id,1606			account(2)1607		));16081609		// Owner adds address 3 to allow list1610		assert_ok!(Unique::add_to_allow_list(1611			origin1,1612			collection_id,1613			account(3)1614		));16151616		// Admin removes address 3 from allow list1617		assert_ok!(Unique::remove_from_allow_list(1618			origin2,1619			collection_id,1620			account(3)1621		));1622		assert_eq!(1623			<pallet_common::Allowlist<Test>>::get((collection_id, account(3))),1624			false1625		);1626	});1627}16281629#[test]1630fn nonprivileged_user_cannot_remove_address_from_allow_list() {1631	new_test_ext().execute_with(|| {1632		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1633		let origin1 = RuntimeOrigin::signed(1);1634		let origin2 = RuntimeOrigin::signed(2);16351636		assert_ok!(Unique::add_to_allow_list(1637			origin1,1638			collection_id,1639			account(2)1640		));1641		assert_noop!(1642			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1643			CommonError::<Test>::NoPermission1644		);1645		assert!(<pallet_common::Allowlist<Test>>::get((1646			collection_id,1647			account(2)1648		)));1649	});1650}16511652#[test]1653fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {1654	new_test_ext().execute_with(|| {1655		let origin1 = RuntimeOrigin::signed(1);16561657		assert_noop!(1658			Unique::remove_from_allow_list(origin1, CollectionId(1), account(2)),1659			CommonError::<Test>::CollectionNotFound1660		);1661	});1662}16631664#[test]1665fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {1666	new_test_ext().execute_with(|| {1667		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1668		let origin1 = RuntimeOrigin::signed(1);1669		let origin2 = RuntimeOrigin::signed(2);16701671		// Add account 2 to allow list1672		assert_ok!(Unique::add_to_allow_list(1673			origin1.clone(),1674			collection_id,1675			account(2)1676		));16771678		// Account 2 is in collection allow-list1679		assert!(<pallet_common::Allowlist<Test>>::get((1680			collection_id,1681			account(2)1682		)));16831684		// Destroy collection1685		assert_ok!(Unique::destroy_collection(origin1, collection_id));16861687		// Attempt to remove account 2 from collection allow-list => error1688		assert_noop!(1689			Unique::remove_from_allow_list(origin2, collection_id, account(2)),1690			CommonError::<Test>::CollectionNotFound1691		);16921693		// Account 2 is not found in collection allow-list anyway1694		assert_eq!(1695			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1696			false1697		);1698	});1699}17001701// If address is already removed from allow list, nothing happens1702#[test]1703fn address_is_already_removed_from_allow_list() {1704	new_test_ext().execute_with(|| {1705		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1706		let origin1 = RuntimeOrigin::signed(1);17071708		assert_ok!(Unique::add_to_allow_list(1709			origin1.clone(),1710			collection_id,1711			account(2)1712		));1713		assert_ok!(Unique::remove_from_allow_list(1714			origin1.clone(),1715			collection_id,1716			account(2)1717		));1718		assert_eq!(1719			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1720			false1721		);1722		assert_ok!(Unique::remove_from_allow_list(1723			origin1,1724			collection_id,1725			account(2)1726		));1727		assert_eq!(1728			<pallet_common::Allowlist<Test>>::get((collection_id, account(2))),1729			false1730		);1731	});1732}17331734// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)1735#[test]1736fn allow_list_test_1() {1737	new_test_ext().execute_with(|| {1738		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));17391740		let origin1 = RuntimeOrigin::signed(1);17411742		let data = default_nft_data();1743		create_test_item(collection_id, &data.into());17441745		assert_ok!(Unique::set_collection_permissions(1746			origin1.clone(),1747			collection_id,1748			CollectionPermissions {1749				mint_mode: None,1750				access: Some(AccessMode::AllowList),1751				nesting: None,1752			}1753		));1754		assert_ok!(Unique::add_to_allow_list(1755			origin1.clone(),1756			collection_id,1757			account(2)1758		));17591760		assert_noop!(1761			Unique::transfer(origin1, account(3), CollectionId(1), TokenId(1), 1)1762				.map_err(|e| e.error),1763			CommonError::<Test>::AddressNotInAllowlist1764		);1765	});1766}17671768#[test]1769fn allow_list_test_2() {1770	new_test_ext().execute_with(|| {1771		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));1772		let origin1 = RuntimeOrigin::signed(1);17731774		let data = default_nft_data();1775		create_test_item(collection_id, &data.into());17761777		assert_ok!(Unique::set_collection_permissions(1778			origin1.clone(),1779			collection_id,1780			CollectionPermissions {1781				mint_mode: None,1782				access: Some(AccessMode::AllowList),1783				nesting: None,1784			}1785		));1786		assert_ok!(Unique::add_to_allow_list(1787			origin1.clone(),1788			collection_id,1789			account(1)1790		));1791		assert_ok!(Unique::add_to_allow_list(1792			origin1.clone(),1793			collection_id,1794			account(2)1795		));17961797		// do approve1798		assert_ok!(Unique::approve(1799			origin1.clone(),1800			account(1),1801			collection_id,1802			TokenId(1),1803			11804		));1805		assert_eq!(1806			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1807			account(1)1808		);18091810		assert_ok!(Unique::remove_from_allow_list(1811			origin1.clone(),1812			collection_id,1813			account(1)1814		));18151816		assert_noop!(1817			Unique::transfer_from(1818				origin1,1819				account(1),1820				account(3),1821				CollectionId(1),1822				TokenId(1),1823				11824			)1825			.map_err(|e| e.error),1826			CommonError::<Test>::AddressNotInAllowlist1827		);1828	});1829}18301831// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)1832#[test]1833fn allow_list_test_3() {1834	new_test_ext().execute_with(|| {1835		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18361837		let origin1 = RuntimeOrigin::signed(1);18381839		let data = default_nft_data();1840		create_test_item(collection_id, &data.into());18411842		assert_ok!(Unique::set_collection_permissions(1843			origin1.clone(),1844			collection_id,1845			CollectionPermissions {1846				mint_mode: None,1847				access: Some(AccessMode::AllowList),1848				nesting: None,1849			}1850		));1851		assert_ok!(Unique::add_to_allow_list(1852			origin1.clone(),1853			collection_id,1854			account(1)1855		));18561857		assert_noop!(1858			Unique::transfer(origin1, account(3), collection_id, TokenId(1), 1)1859				.map_err(|e| e.error),1860			CommonError::<Test>::AddressNotInAllowlist1861		);1862	});1863}18641865#[test]1866fn allow_list_test_4() {1867	new_test_ext().execute_with(|| {1868		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));18691870		let origin1 = RuntimeOrigin::signed(1);18711872		let data = default_nft_data();1873		create_test_item(collection_id, &data.into());18741875		assert_ok!(Unique::set_collection_permissions(1876			origin1.clone(),1877			collection_id,1878			CollectionPermissions {1879				mint_mode: None,1880				access: Some(AccessMode::AllowList),1881				nesting: None,1882			}1883		));1884		assert_ok!(Unique::add_to_allow_list(1885			origin1.clone(),1886			collection_id,1887			account(1)1888		));1889		assert_ok!(Unique::add_to_allow_list(1890			origin1.clone(),1891			collection_id,1892			account(2)1893		));18941895		// do approve1896		assert_ok!(Unique::approve(1897			origin1.clone(),1898			account(1),1899			collection_id,1900			TokenId(1),1901			11902		));1903		assert_eq!(1904			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),1905			account(1)1906		);19071908		assert_ok!(Unique::remove_from_allow_list(1909			origin1.clone(),1910			collection_id,1911			account(2)1912		));19131914		assert_noop!(1915			Unique::transfer_from(1916				origin1,1917				account(1),1918				account(3),1919				collection_id,1920				TokenId(1),1921				11922			)1923			.map_err(|e| e.error),1924			CommonError::<Test>::AddressNotInAllowlist1925		);1926	});1927}19281929// 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)1930#[test]1931fn allow_list_test_5() {1932	new_test_ext().execute_with(|| {1933		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19341935		let origin1 = RuntimeOrigin::signed(1);19361937		let data = default_nft_data();1938		create_test_item(collection_id, &data.into());19391940		assert_ok!(Unique::set_collection_permissions(1941			origin1.clone(),1942			collection_id,1943			CollectionPermissions {1944				mint_mode: None,1945				access: Some(AccessMode::AllowList),1946				nesting: None,1947			}1948		));1949		assert_noop!(1950			Unique::burn_item(origin1.clone(), CollectionId(1), TokenId(1), 1).map_err(|e| e.error),1951			CommonError::<Test>::AddressNotInAllowlist1952		);1953	});1954}19551956// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).1957#[test]1958fn allow_list_test_6() {1959	new_test_ext().execute_with(|| {1960		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19611962		let origin1 = RuntimeOrigin::signed(1);19631964		let data = default_nft_data();1965		create_test_item(collection_id, &data.into());19661967		assert_ok!(Unique::set_collection_permissions(1968			origin1.clone(),1969			collection_id,1970			CollectionPermissions {1971				mint_mode: None,1972				access: Some(AccessMode::AllowList),1973				nesting: None,1974			}1975		));19761977		// do approve1978		assert_noop!(1979			Unique::approve(origin1, account(1), CollectionId(1), TokenId(1), 1)1980				.map_err(|e| e.error),1981			CommonError::<Test>::AddressNotInAllowlist1982		);1983	});1984}19851986// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and1987//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)1988#[test]1989fn allow_list_test_7() {1990	new_test_ext().execute_with(|| {1991		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));19921993		let data = default_nft_data();1994		create_test_item(collection_id, &data.into());19951996		let origin1 = RuntimeOrigin::signed(1);19971998		assert_ok!(Unique::set_collection_permissions(1999			origin1.clone(),2000			collection_id,2001			CollectionPermissions {2002				mint_mode: None,2003				access: Some(AccessMode::AllowList),2004				nesting: None,2005			}2006		));2007		assert_ok!(Unique::add_to_allow_list(2008			origin1.clone(),2009			collection_id,2010			account(1)2011		));2012		assert_ok!(Unique::add_to_allow_list(2013			origin1.clone(),2014			collection_id,2015			account(2)2016		));20172018		assert_ok!(Unique::transfer(2019			origin1,2020			account(2),2021			CollectionId(1),2022			TokenId(1),2023			12024		));2025	});2026}20272028#[test]2029fn allow_list_test_8() {2030	new_test_ext().execute_with(|| {2031		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));20322033		// Create NFT for account 12034		let data = default_nft_data();2035		create_test_item(collection_id, &data.into());20362037		let origin1 = RuntimeOrigin::signed(1);20382039		// Toggle Allow List mode and add accounts 1 and 22040		assert_ok!(Unique::set_collection_permissions(2041			origin1.clone(),2042			collection_id,2043			CollectionPermissions {2044				mint_mode: None,2045				access: Some(AccessMode::AllowList),2046				nesting: None,2047			}2048		));2049		assert_ok!(Unique::add_to_allow_list(2050			origin1.clone(),2051			collection_id,2052			account(1)2053		));2054		assert_ok!(Unique::add_to_allow_list(2055			origin1.clone(),2056			collection_id,2057			account(2)2058		));20592060		// Sself-approve account 1 for NFT 12061		assert_ok!(Unique::approve(2062			origin1.clone(),2063			account(1),2064			CollectionId(1),2065			TokenId(1),2066			12067		));2068		assert_eq!(2069			<pallet_nonfungible::Allowance<Test>>::get((CollectionId(1), TokenId(1))).unwrap(),2070			account(1)2071		);20722073		// Transfer from 1 to 22074		assert_ok!(Unique::transfer_from(2075			origin1,2076			account(1),2077			account(2),2078			CollectionId(1),2079			TokenId(1),2080			12081		));2082	});2083}20842085// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.2086#[test]2087fn allow_list_test_9() {2088	new_test_ext().execute_with(|| {2089		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2090		let origin1 = RuntimeOrigin::signed(1);20912092		assert_ok!(Unique::set_collection_permissions(2093			origin1.clone(),2094			collection_id,2095			CollectionPermissions {2096				mint_mode: Some(false),2097				access: Some(AccessMode::AllowList),2098				nesting: None,2099			}2100		));21012102		let data = default_nft_data();2103		create_test_item(collection_id, &data.into());2104	});2105}21062107// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.2108#[test]2109fn allow_list_test_10() {2110	new_test_ext().execute_with(|| {2111		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21122113		let origin1 = RuntimeOrigin::signed(1);2114		let origin2 = RuntimeOrigin::signed(2);21152116		assert_ok!(Unique::set_collection_permissions(2117			origin1.clone(),2118			collection_id,2119			CollectionPermissions {2120				mint_mode: Some(false),2121				access: Some(AccessMode::AllowList),2122				nesting: None,2123			}2124		));21252126		assert_ok!(Unique::add_collection_admin(2127			origin1,2128			collection_id,2129			account(2)2130		));21312132		assert_ok!(Unique::create_item(2133			origin2,2134			collection_id,2135			account(2),2136			default_nft_data().into()2137		));2138	});2139}21402141// 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.2142#[test]2143fn allow_list_test_11() {2144	new_test_ext().execute_with(|| {2145		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21462147		let origin1 = RuntimeOrigin::signed(1);2148		let origin2 = RuntimeOrigin::signed(2);21492150		assert_ok!(Unique::set_collection_permissions(2151			origin1.clone(),2152			collection_id,2153			CollectionPermissions {2154				mint_mode: Some(false),2155				access: Some(AccessMode::AllowList),2156				nesting: None,2157			}2158		));2159		assert_ok!(Unique::add_to_allow_list(2160			origin1,2161			collection_id,2162			account(2)2163		));21642165		assert_noop!(2166			Unique::create_item(2167				origin2,2168				CollectionId(1),2169				account(2),2170				default_nft_data().into()2171			)2172			.map_err(|e| e.error),2173			CommonError::<Test>::PublicMintingNotAllowed2174		);2175	});2176}21772178// 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.2179#[test]2180fn allow_list_test_12() {2181	new_test_ext().execute_with(|| {2182		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));21832184		let origin1 = RuntimeOrigin::signed(1);2185		let origin2 = RuntimeOrigin::signed(2);21862187		assert_ok!(Unique::set_collection_permissions(2188			origin1.clone(),2189			collection_id,2190			CollectionPermissions {2191				mint_mode: Some(false),2192				access: Some(AccessMode::AllowList),2193				nesting: None,2194			}2195		));21962197		assert_noop!(2198			Unique::create_item(2199				origin2,2200				CollectionId(1),2201				account(2),2202				default_nft_data().into()2203			)2204			.map_err(|e| e.error),2205			CommonError::<Test>::PublicMintingNotAllowed2206		);2207	});2208}22092210// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.2211#[test]2212fn allow_list_test_13() {2213	new_test_ext().execute_with(|| {2214		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22152216		let origin1 = RuntimeOrigin::signed(1);22172218		assert_ok!(Unique::set_collection_permissions(2219			origin1.clone(),2220			collection_id,2221			CollectionPermissions {2222				mint_mode: Some(true),2223				access: Some(AccessMode::AllowList),2224				nesting: None,2225			}2226		));22272228		let data = default_nft_data();2229		create_test_item(collection_id, &data.into());2230	});2231}22322233// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.2234#[test]2235fn allow_list_test_14() {2236	new_test_ext().execute_with(|| {2237		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22382239		let origin1 = RuntimeOrigin::signed(1);2240		let origin2 = RuntimeOrigin::signed(2);22412242		assert_ok!(Unique::set_collection_permissions(2243			origin1.clone(),2244			collection_id,2245			CollectionPermissions {2246				mint_mode: Some(true),2247				access: Some(AccessMode::AllowList),2248				nesting: None,2249			}2250		));22512252		assert_ok!(Unique::add_collection_admin(2253			origin1,2254			collection_id,2255			account(2)2256		));22572258		assert_ok!(Unique::create_item(2259			origin2,2260			collection_id,2261			account(2),2262			default_nft_data().into()2263		));2264	});2265}22662267// 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.2268#[test]2269fn allow_list_test_15() {2270	new_test_ext().execute_with(|| {2271		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));22722273		let origin1 = RuntimeOrigin::signed(1);2274		let origin2 = RuntimeOrigin::signed(2);22752276		assert_ok!(Unique::set_collection_permissions(2277			origin1.clone(),2278			collection_id,2279			CollectionPermissions {2280				mint_mode: Some(true),2281				access: Some(AccessMode::AllowList),2282				nesting: None,2283			}2284		));22852286		assert_noop!(2287			Unique::create_item(2288				origin2,2289				collection_id,2290				account(2),2291				default_nft_data().into()2292			)2293			.map_err(|e| e.error),2294			CommonError::<Test>::AddressNotInAllowlist2295		);2296	});2297}22982299// 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.2300#[test]2301fn allow_list_test_16() {2302	new_test_ext().execute_with(|| {2303		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23042305		let origin1 = RuntimeOrigin::signed(1);2306		let origin2 = RuntimeOrigin::signed(2);23072308		assert_ok!(Unique::set_collection_permissions(2309			origin1.clone(),2310			collection_id,2311			CollectionPermissions {2312				mint_mode: Some(true),2313				access: Some(AccessMode::AllowList),2314				nesting: None,2315			}2316		));2317		assert_ok!(Unique::add_to_allow_list(2318			origin1,2319			collection_id,2320			account(2)2321		));23222323		assert_ok!(Unique::create_item(2324			origin2,2325			collection_id,2326			account(2),2327			default_nft_data().into()2328		));2329	});2330}23312332// Total number of collections. Positive test2333#[test]2334fn total_number_collections_bound() {2335	new_test_ext().execute_with(|| {2336		create_test_collection(&CollectionMode::NFT, CollectionId(1));2337	});2338}23392340#[test]2341fn create_max_collections() {2342	new_test_ext().execute_with(|| {2343		for i in 1..COLLECTION_NUMBER_LIMIT {2344			create_test_collection(&CollectionMode::NFT, CollectionId(i));2345		}2346	});2347}23482349// Total number of collections. Negative test2350#[test]2351fn total_number_collections_bound_neg() {2352	new_test_ext().execute_with(|| {2353		let origin1 = RuntimeOrigin::signed(1);23542355		for i in 1..=COLLECTION_NUMBER_LIMIT {2356			create_test_collection(&CollectionMode::NFT, CollectionId(i));2357		}23582359		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();2360		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();2361		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();23622363		let data: CreateCollectionData<u64> = CreateCollectionData {2364			name: col_name1.try_into().unwrap(),2365			description: col_desc1.try_into().unwrap(),2366			token_prefix: token_prefix1.try_into().unwrap(),2367			mode: CollectionMode::NFT,2368			..Default::default()2369		};23702371		// 11-th collection in chain. Expects error2372		assert_noop!(2373			Unique::create_collection_ex(origin1, data),2374			CommonError::<Test>::TotalCollectionsLimitExceeded2375		);2376	});2377}23782379// Owned tokens by a single address. Positive test2380#[test]2381fn owned_tokens_bound() {2382	new_test_ext().execute_with(|| {2383		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23842385		let data = default_nft_data();2386		create_test_item(collection_id, &data.clone().into());2387		create_test_item(collection_id, &data.into());2388	});2389}23902391// Owned tokens by a single address. Negotive test2392#[test]2393fn owned_tokens_bound_neg() {2394	new_test_ext().execute_with(|| {2395		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));23962397		let origin1 = RuntimeOrigin::signed(1);23982399		for _ in 1..=MAX_TOKEN_OWNERSHIP {2400			let data = default_nft_data();2401			create_test_item(collection_id, &data.clone().into());2402		}24032404		let data = default_nft_data();2405		assert_noop!(2406			Unique::create_item(origin1, CollectionId(1), account(1), data.into())2407				.map_err(|e| e.error),2408			CommonError::<Test>::AccountTokenLimitExceeded2409		);2410	});2411}24122413// Number of collection admins. Positive test2414#[test]2415fn collection_admins_bound() {2416	new_test_ext().execute_with(|| {2417		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24182419		let origin1 = RuntimeOrigin::signed(1);24202421		assert_ok!(Unique::add_collection_admin(2422			origin1.clone(),2423			collection_id,2424			account(2)2425		));2426		assert_ok!(Unique::add_collection_admin(2427			origin1,2428			collection_id,2429			account(3)2430		));2431	});2432}24332434// Number of collection admins. Negotive test2435#[test]2436fn collection_admins_bound_neg() {2437	new_test_ext().execute_with(|| {2438		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));24392440		let origin1 = RuntimeOrigin::signed(1);24412442		for i in 0..COLLECTION_ADMINS_LIMIT {2443			assert_ok!(Unique::add_collection_admin(2444				origin1.clone(),2445				collection_id,2446				account((2 + i).into())2447			));2448		}2449		assert_noop!(2450			Unique::add_collection_admin(2451				origin1,2452				collection_id,2453				account((3 + COLLECTION_ADMINS_LIMIT).into())2454			),2455			CommonError::<Test>::CollectionAdminCountExceeded2456		);2457	});2458}2459// #endregion24602461#[test]2462fn collection_transfer_flag_works() {2463	new_test_ext().execute_with(|| {2464		let origin1 = RuntimeOrigin::signed(1);24652466		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2467		assert_ok!(Unique::set_transfers_enabled_flag(2468			origin1,2469			collection_id,2470			true2471		));24722473		let data = default_nft_data();2474		create_test_item(collection_id, &data.into());2475		assert_eq!(2476			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2477			12478		);2479		assert_eq!(2480			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2481			true2482		);24832484		let origin1 = RuntimeOrigin::signed(1);24852486		// default scenario2487		assert_ok!(Unique::transfer(2488			origin1,2489			account(2),2490			collection_id,2491			TokenId(1),2492			12493		));2494		assert_eq!(2495			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2496			false2497		);2498		assert_eq!(2499			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2500			true2501		);2502		assert_eq!(2503			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2504			02505		);2506		assert_eq!(2507			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2508			12509		);2510	});2511}25122513#[test]2514fn collection_transfer_flag_works_neg() {2515	new_test_ext().execute_with(|| {2516		let origin1 = RuntimeOrigin::signed(1);25172518		let collection_id = create_test_collection(&CollectionMode::NFT, CollectionId(1));2519		assert_ok!(Unique::set_transfers_enabled_flag(2520			origin1,2521			collection_id,2522			false2523		));25242525		let data = default_nft_data();2526		create_test_item(collection_id, &data.into());2527		assert_eq!(2528			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2529			12530		);2531		assert_eq!(2532			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2533			true2534		);25352536		let origin1 = RuntimeOrigin::signed(1);25372538		// default scenario2539		assert_noop!(2540			Unique::transfer(origin1, account(2), CollectionId(1), TokenId(1), 1)2541				.map_err(|e| e.error),2542			CommonError::<Test>::TransferNotAllowed2543		);2544		assert_eq!(2545			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(1))),2546			12547		);2548		assert_eq!(2549			<pallet_nonfungible::AccountBalance<Test>>::get((collection_id, account(2))),2550			02551		);2552		assert_eq!(2553			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(1), TokenId(1))),2554			true2555		);2556		assert_eq!(2557			<pallet_nonfungible::Owned<Test>>::get((collection_id, account(2), TokenId(1))),2558			false2559		);2560	});2561}25622563#[test]2564fn collection_sponsoring() {2565	new_test_ext().execute_with(|| {2566		// default_limits();2567		let user1 = 1_u64;2568		let user2 = 777_u64;2569		let origin1 = RuntimeOrigin::signed(user1);2570		let origin2 = RuntimeOrigin::signed(user2);2571		let account2 = account(user2);25722573		let collection_id =2574			create_test_collection_for_owner(&CollectionMode::NFT, user1, CollectionId(1));2575		assert_ok!(Unique::set_collection_sponsor(2576			origin1.clone(),2577			collection_id,2578			user12579		));2580		assert_ok!(Unique::confirm_sponsorship(origin1.clone(), collection_id));25812582		// Expect error while have no permissions2583		assert!(Unique::create_item(2584			origin2.clone(),2585			collection_id,2586			account2.clone(),2587			default_nft_data().into()2588		)2589		.is_err());25902591		assert_ok!(Unique::set_collection_permissions(2592			origin1.clone(),2593			collection_id,2594			CollectionPermissions {2595				mint_mode: Some(true),2596				access: Some(AccessMode::AllowList),2597				nesting: None,2598			}2599		));2600		assert_ok!(Unique::add_to_allow_list(2601			origin1.clone(),2602			collection_id,2603			account2.clone()2604		));26052606		assert_ok!(Unique::create_item(2607			origin2,2608			collection_id,2609			account2,2610			default_nft_data().into()2611		));2612	});2613}