git.delta.rocks / unique-network / refs/commits / 5c283c1e8412

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// Original license:18// This file is part of Substrate.1920// Copyright (C) 2019-2022 Parity Technologies (UK) Ltd.21// SPDX-License-Identifier: Apache-2.02223// Licensed under the Apache License, Version 2.0 (the "License");24// you may not use this file except in compliance with the License.25// You may obtain a copy of the License at26//27// 	http://www.apache.org/licenses/LICENSE-2.028//29// Unless required by applicable law or agreed to in writing, software30// distributed under the License is distributed on an "AS IS" BASIS,31// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.32// See the License for the specific language governing permissions and33// limitations under the License.3435// Tests for Identity Pallet3637use super::*;38use crate as pallet_identity;3940use codec::{Decode, Encode};41use frame_support::{42	assert_noop, assert_ok, ord_parameter_types, parameter_types,43	traits::{ConstU32, ConstU64, EitherOfDiverse},44	BoundedVec,45};46use frame_system::{EnsureRoot, EnsureSignedBy};47use sp_core::H256;48use sp_runtime::{49	testing::Header,50	traits::{BadOrigin, BlakeTwo256, IdentityLookup},51};5253type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;54type Block = frame_system::mocking::MockBlock<Test>;5556frame_support::construct_runtime!(57	pub enum Test where58		Block = Block,59		NodeBlock = Block,60		UncheckedExtrinsic = UncheckedExtrinsic,61	{62		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},63		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},64		Identity: pallet_identity::{Pallet, Call, Storage, Event<T>},65	}66);6768parameter_types! {69	pub BlockWeights: frame_system::limits::BlockWeights =70		frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::from_ref_time(1024));71}72impl frame_system::Config for Test {73	type BaseCallFilter = frame_support::traits::Everything;74	type BlockWeights = ();75	type BlockLength = ();76	type RuntimeOrigin = RuntimeOrigin;77	type Index = u64;78	type BlockNumber = u64;79	type Hash = H256;80	type RuntimeCall = RuntimeCall;81	type Hashing = BlakeTwo256;82	type AccountId = u64;83	type Lookup = IdentityLookup<Self::AccountId>;84	type Header = Header;85	type RuntimeEvent = RuntimeEvent;86	type BlockHashCount = ConstU64<250>;87	type DbWeight = ();88	type Version = ();89	type PalletInfo = PalletInfo;90	type AccountData = pallet_balances::AccountData<u64>;91	type OnNewAccount = ();92	type OnKilledAccount = ();93	type SystemWeightInfo = ();94	type SS58Prefix = ();95	type OnSetCode = ();96	type MaxConsumers = ConstU32<16>;97}9899impl pallet_balances::Config for Test {100	type Balance = u64;101	type RuntimeEvent = RuntimeEvent;102	type DustRemoval = ();103	type ExistentialDeposit = ConstU64<1>;104	type AccountStore = System;105	type MaxLocks = ();106	type MaxReserves = ();107	type ReserveIdentifier = [u8; 8];108	type WeightInfo = ();109	type HoldIdentifier = ();110	type FreezeIdentifier = ();111	type MaxHolds = ();112	type MaxFreezes = ();113}114115parameter_types! {116	pub const MaxAdditionalFields: u32 = 2;117	pub const MaxRegistrars: u32 = 20;118}119120ord_parameter_types! {121	pub const One: u64 = 1;122	pub const Two: u64 = 2;123}124type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<One, u64>>;125type EnsureTwoOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<Two, u64>>;126impl pallet_identity::Config for Test {127	type RuntimeEvent = RuntimeEvent;128	type Currency = Balances;129	type Slashed = ();130	type BasicDeposit = ConstU64<10>;131	type FieldDeposit = ConstU64<10>;132	type SubAccountDeposit = ConstU64<10>;133	type MaxSubAccounts = ConstU32<2>;134	type MaxAdditionalFields = MaxAdditionalFields;135	type MaxRegistrars = MaxRegistrars;136	type RegistrarOrigin = EnsureOneOrRoot;137	type ForceOrigin = EnsureTwoOrRoot;138	type WeightInfo = ();139}140141pub fn new_test_ext() -> sp_io::TestExternalities {142	let mut t = frame_system::GenesisConfig::default()143		.build_storage::<Test>()144		.unwrap();145	pallet_balances::GenesisConfig::<Test> {146		balances: vec![(1, 10), (2, 10), (3, 10), (10, 100), (20, 100), (30, 100)],147	}148	.assimilate_storage(&mut t)149	.unwrap();150	t.into()151}152153fn ten() -> IdentityInfo<MaxAdditionalFields> {154	IdentityInfo {155		display: Data::Raw(b"ten".to_vec().try_into().unwrap()),156		legal: Data::Raw(b"The Right Ordinal Ten, Esq.".to_vec().try_into().unwrap()),157		..Default::default()158	}159}160161fn twenty() -> IdentityInfo<MaxAdditionalFields> {162	IdentityInfo {163		display: Data::Raw(b"twenty".to_vec().try_into().unwrap()),164		legal: Data::Raw(165			b"The Right Ordinal Twenty, Esq."166				.to_vec()167				.try_into()168				.unwrap(),169		),170		..Default::default()171	}172}173174#[test]175fn editing_subaccounts_should_work() {176	new_test_ext().execute_with(|| {177		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());178179		assert_noop!(180			Identity::add_sub(RuntimeOrigin::signed(10), 20, data(1)),181			Error::<Test>::NoIdentity182		);183184		assert_ok!(Identity::set_identity(185			RuntimeOrigin::signed(10),186			Box::new(ten())187		));188189		// first sub account190		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));191		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(1))));192		assert_eq!(Balances::free_balance(10), 80);193194		// second sub account195		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 2, data(2)));196		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(1))));197		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));198		assert_eq!(Balances::free_balance(10), 70);199200		// third sub account is too many201		assert_noop!(202			Identity::add_sub(RuntimeOrigin::signed(10), 3, data(3)),203			Error::<Test>::TooManySubAccounts204		);205206		// rename first sub account207		assert_ok!(Identity::rename_sub(RuntimeOrigin::signed(10), 1, data(11)));208		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(11))));209		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));210		assert_eq!(Balances::free_balance(10), 70);211212		// remove first sub account213		assert_ok!(Identity::remove_sub(RuntimeOrigin::signed(10), 1));214		assert_eq!(SuperOf::<Test>::get(1), None);215		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));216		assert_eq!(Balances::free_balance(10), 80);217218		// add third sub account219		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 3, data(3)));220		assert_eq!(SuperOf::<Test>::get(1), None);221		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));222		assert_eq!(SuperOf::<Test>::get(3), Some((10, data(3))));223		assert_eq!(Balances::free_balance(10), 70);224	});225}226227#[test]228fn resolving_subaccount_ownership_works() {229	new_test_ext().execute_with(|| {230		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());231232		assert_ok!(Identity::set_identity(233			RuntimeOrigin::signed(10),234			Box::new(ten())235		));236		assert_ok!(Identity::set_identity(237			RuntimeOrigin::signed(20),238			Box::new(twenty())239		));240241		// 10 claims 1 as a subaccount242		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));243		assert_eq!(Balances::free_balance(1), 10);244		assert_eq!(Balances::free_balance(10), 80);245		assert_eq!(Balances::reserved_balance(10), 20);246		// 20 cannot claim 1 now247		assert_noop!(248			Identity::add_sub(RuntimeOrigin::signed(20), 1, data(1)),249			Error::<Test>::AlreadyClaimed250		);251		// 1 wants to be with 20 so it quits from 10252		assert_ok!(Identity::quit_sub(RuntimeOrigin::signed(1)));253		// 1 gets the 10 that 10 paid.254		assert_eq!(Balances::free_balance(1), 20);255		assert_eq!(Balances::free_balance(10), 80);256		assert_eq!(Balances::reserved_balance(10), 10);257		// 20 can claim 1 now258		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(20), 1, data(1)));259	});260}261262#[test]263fn trailing_zeros_decodes_into_default_data() {264	let encoded = Data::Raw(b"Hello".to_vec().try_into().unwrap()).encode();265	assert!(<(Data, Data)>::decode(&mut &encoded[..]).is_err());266	let input = &mut &encoded[..];267	let (a, b) = <(Data, Data)>::decode(&mut AppendZerosInput::new(input)).unwrap();268	assert_eq!(a, Data::Raw(b"Hello".to_vec().try_into().unwrap()));269	assert_eq!(b, Data::None);270}271272#[test]273fn adding_registrar_should_work() {274	new_test_ext().execute_with(|| {275		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));276		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));277		let fields = IdentityFields(IdentityField::Display | IdentityField::Legal);278		assert_ok!(Identity::set_fields(RuntimeOrigin::signed(3), 0, fields));279		assert_eq!(280			Identity::registrars(),281			vec![Some(RegistrarInfo {282				account: 3,283				fee: 10,284				fields285			})]286		);287	});288}289290#[test]291fn amount_of_registrars_is_limited() {292	new_test_ext().execute_with(|| {293		for i in 1..MaxRegistrars::get() + 1 {294			assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), i as u64));295		}296		let last_registrar = MaxRegistrars::get() as u64 + 1;297		assert_noop!(298			Identity::add_registrar(RuntimeOrigin::signed(1), last_registrar),299			Error::<Test>::TooManyRegistrars300		);301	});302}303304#[test]305fn registration_should_work() {306	new_test_ext().execute_with(|| {307		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));308		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));309		let mut three_fields = ten();310		three_fields311			.additional312			.try_push(Default::default())313			.unwrap();314		three_fields315			.additional316			.try_push(Default::default())317			.unwrap();318		assert!(three_fields319			.additional320			.try_push(Default::default())321			.is_err());322		assert_ok!(Identity::set_identity(323			RuntimeOrigin::signed(10),324			Box::new(ten())325		));326		assert_eq!(Identity::identity(10).unwrap().info, ten());327		assert_eq!(Balances::free_balance(10), 90);328		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));329		assert_eq!(Balances::free_balance(10), 100);330		assert_noop!(331			Identity::clear_identity(RuntimeOrigin::signed(10)),332			Error::<Test>::NotNamed333		);334	});335}336337#[test]338fn uninvited_judgement_should_work() {339	new_test_ext().execute_with(|| {340		assert_noop!(341			Identity::provide_judgement(342				RuntimeOrigin::signed(3),343				0,344				10,345				Judgement::Reasonable,346				H256::random()347			),348			Error::<Test>::InvalidIndex349		);350351		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));352		assert_noop!(353			Identity::provide_judgement(354				RuntimeOrigin::signed(3),355				0,356				10,357				Judgement::Reasonable,358				H256::random()359			),360			Error::<Test>::InvalidTarget361		);362363		assert_ok!(Identity::set_identity(364			RuntimeOrigin::signed(10),365			Box::new(ten())366		));367		assert_noop!(368			Identity::provide_judgement(369				RuntimeOrigin::signed(3),370				0,371				10,372				Judgement::Reasonable,373				H256::random()374			),375			Error::<Test>::JudgementForDifferentIdentity376		);377378		let identity_hash = BlakeTwo256::hash_of(&ten());379380		assert_noop!(381			Identity::provide_judgement(382				RuntimeOrigin::signed(10),383				0,384				10,385				Judgement::Reasonable,386				identity_hash387			),388			Error::<Test>::InvalidIndex389		);390		assert_noop!(391			Identity::provide_judgement(392				RuntimeOrigin::signed(3),393				0,394				10,395				Judgement::FeePaid(1),396				identity_hash397			),398			Error::<Test>::InvalidJudgement399		);400401		assert_ok!(Identity::provide_judgement(402			RuntimeOrigin::signed(3),403			0,404			10,405			Judgement::Reasonable,406			identity_hash407		));408		assert_eq!(409			Identity::identity(10).unwrap().judgements,410			vec![(0, Judgement::Reasonable)]411		);412	});413}414415#[test]416fn clearing_judgement_should_work() {417	new_test_ext().execute_with(|| {418		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));419		assert_ok!(Identity::set_identity(420			RuntimeOrigin::signed(10),421			Box::new(ten())422		));423		assert_ok!(Identity::provide_judgement(424			RuntimeOrigin::signed(3),425			0,426			10,427			Judgement::Reasonable,428			BlakeTwo256::hash_of(&ten())429		));430		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));431		assert_eq!(Identity::identity(10), None);432	});433}434435#[test]436fn killing_slashing_should_work() {437	new_test_ext().execute_with(|| {438		assert_ok!(Identity::set_identity(439			RuntimeOrigin::signed(10),440			Box::new(ten())441		));442		assert_noop!(443			Identity::kill_identity(RuntimeOrigin::signed(1), 10),444			BadOrigin445		);446		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));447		assert_eq!(Identity::identity(10), None);448		assert_eq!(Balances::free_balance(10), 90);449		assert_noop!(450			Identity::kill_identity(RuntimeOrigin::signed(2), 10),451			Error::<Test>::NotNamed452		);453	});454}455456#[test]457fn setting_subaccounts_should_work() {458	new_test_ext().execute_with(|| {459		let mut subs = vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))];460		assert_noop!(461			Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()),462			Error::<Test>::NotFound463		);464465		assert_ok!(Identity::set_identity(466			RuntimeOrigin::signed(10),467			Box::new(ten())468		));469		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));470		assert_eq!(Balances::free_balance(10), 80);471		assert_eq!(Identity::subs_of(10), (10, vec![20].try_into().unwrap()));472		assert_eq!(473			Identity::super_of(20),474			Some((10, Data::Raw(vec![40; 1].try_into().unwrap())))475		);476477		// push another item and re-set it.478		subs.push((30, Data::Raw(vec![50; 1].try_into().unwrap())));479		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));480		assert_eq!(Balances::free_balance(10), 70);481		assert_eq!(482			Identity::subs_of(10),483			(20, vec![20, 30].try_into().unwrap())484		);485		assert_eq!(486			Identity::super_of(20),487			Some((10, Data::Raw(vec![40; 1].try_into().unwrap())))488		);489		assert_eq!(490			Identity::super_of(30),491			Some((10, Data::Raw(vec![50; 1].try_into().unwrap())))492		);493494		// switch out one of the items and re-set.495		subs[0] = (40, Data::Raw(vec![60; 1].try_into().unwrap()));496		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));497		assert_eq!(Balances::free_balance(10), 70); // no change in the balance498		assert_eq!(499			Identity::subs_of(10),500			(20, vec![40, 30].try_into().unwrap())501		);502		assert_eq!(Identity::super_of(20), None);503		assert_eq!(504			Identity::super_of(30),505			Some((10, Data::Raw(vec![50; 1].try_into().unwrap())))506		);507		assert_eq!(508			Identity::super_of(40),509			Some((10, Data::Raw(vec![60; 1].try_into().unwrap())))510		);511512		// clear513		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), vec![]));514		assert_eq!(Balances::free_balance(10), 90);515		assert_eq!(Identity::subs_of(10), (0, BoundedVec::default()));516		assert_eq!(Identity::super_of(30), None);517		assert_eq!(Identity::super_of(40), None);518519		subs.push((20, Data::Raw(vec![40; 1].try_into().unwrap())));520		assert_noop!(521			Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()),522			Error::<Test>::TooManySubAccounts523		);524	});525}526527#[test]528fn clearing_account_should_remove_subaccounts_and_refund() {529	new_test_ext().execute_with(|| {530		assert_ok!(Identity::set_identity(531			RuntimeOrigin::signed(10),532			Box::new(ten())533		));534		assert_ok!(Identity::set_subs(535			RuntimeOrigin::signed(10),536			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]537		));538		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));539		assert_eq!(Balances::free_balance(10), 100);540		assert!(Identity::super_of(20).is_none());541	});542}543544#[test]545fn killing_account_should_remove_subaccounts_and_not_refund() {546	new_test_ext().execute_with(|| {547		assert_ok!(Identity::set_identity(548			RuntimeOrigin::signed(10),549			Box::new(ten())550		));551		assert_ok!(Identity::set_subs(552			RuntimeOrigin::signed(10),553			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]554		));555		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));556		assert_eq!(Balances::free_balance(10), 80);557		assert!(Identity::super_of(20).is_none());558	});559}560561#[test]562fn cancelling_requested_judgement_should_work() {563	new_test_ext().execute_with(|| {564		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));565		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));566		assert_noop!(567			Identity::cancel_request(RuntimeOrigin::signed(10), 0),568			Error::<Test>::NoIdentity569		);570		assert_ok!(Identity::set_identity(571			RuntimeOrigin::signed(10),572			Box::new(ten())573		));574		assert_ok!(Identity::request_judgement(575			RuntimeOrigin::signed(10),576			0,577			10578		));579		assert_ok!(Identity::cancel_request(RuntimeOrigin::signed(10), 0));580		assert_eq!(Balances::free_balance(10), 90);581		assert_noop!(582			Identity::cancel_request(RuntimeOrigin::signed(10), 0),583			Error::<Test>::NotFound584		);585586		assert_ok!(Identity::provide_judgement(587			RuntimeOrigin::signed(3),588			0,589			10,590			Judgement::Reasonable,591			BlakeTwo256::hash_of(&ten())592		));593		assert_noop!(594			Identity::cancel_request(RuntimeOrigin::signed(10), 0),595			Error::<Test>::JudgementGiven596		);597	});598}599600#[test]601fn requesting_judgement_should_work() {602	new_test_ext().execute_with(|| {603		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));604		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));605		assert_ok!(Identity::set_identity(606			RuntimeOrigin::signed(10),607			Box::new(ten())608		));609		assert_noop!(610			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 9),611			Error::<Test>::FeeChanged612		);613		assert_ok!(Identity::request_judgement(614			RuntimeOrigin::signed(10),615			0,616			10617		));618		// 10 for the judgement request, 10 for the identity.619		assert_eq!(Balances::free_balance(10), 80);620621		// Re-requesting won't work as we already paid.622		assert_noop!(623			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10),624			Error::<Test>::StickyJudgement625		);626		assert_ok!(Identity::provide_judgement(627			RuntimeOrigin::signed(3),628			0,629			10,630			Judgement::Erroneous,631			BlakeTwo256::hash_of(&ten())632		));633		// Registrar got their payment now.634		assert_eq!(Balances::free_balance(3), 20);635636		// Re-requesting still won't work as it's erroneous.637		assert_noop!(638			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10),639			Error::<Test>::StickyJudgement640		);641642		// Requesting from a second registrar still works.643		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 4));644		assert_ok!(Identity::request_judgement(645			RuntimeOrigin::signed(10),646			1,647			10648		));649650		// Re-requesting after the judgement has been reduced works.651		assert_ok!(Identity::provide_judgement(652			RuntimeOrigin::signed(3),653			0,654			10,655			Judgement::OutOfDate,656			BlakeTwo256::hash_of(&ten())657		));658		assert_ok!(Identity::request_judgement(659			RuntimeOrigin::signed(10),660			0,661			10662		));663	});664}665666#[test]667fn provide_judgement_should_return_judgement_payment_failed_error() {668	new_test_ext().execute_with(|| {669		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));670		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));671		assert_ok!(Identity::set_identity(672			RuntimeOrigin::signed(10),673			Box::new(ten())674		));675		assert_ok!(Identity::request_judgement(676			RuntimeOrigin::signed(10),677			0,678			10679		));680		// 10 for the judgement request, 10 for the identity.681		assert_eq!(Balances::free_balance(10), 80);682683		// This forces judgement payment failed error684		Balances::make_free_balance_be(&3, 0);685		assert_noop!(686			Identity::provide_judgement(687				RuntimeOrigin::signed(3),688				0,689				10,690				Judgement::Erroneous,691				BlakeTwo256::hash_of(&ten())692			),693			Error::<Test>::JudgementPaymentFailed694		);695	});696}697698#[test]699fn field_deposit_should_work() {700	new_test_ext().execute_with(|| {701		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));702		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));703		assert_ok!(Identity::set_identity(704			RuntimeOrigin::signed(10),705			Box::new(IdentityInfo {706				additional: vec![707					(708						Data::Raw(b"number".to_vec().try_into().unwrap()),709						Data::Raw(10u32.encode().try_into().unwrap())710					),711					(712						Data::Raw(b"text".to_vec().try_into().unwrap()),713						Data::Raw(b"10".to_vec().try_into().unwrap())714					),715				]716				.try_into()717				.unwrap(),718				..Default::default()719			})720		));721		assert_eq!(Balances::free_balance(10), 70);722	});723}724725#[test]726fn setting_account_id_should_work() {727	new_test_ext().execute_with(|| {728		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));729		// account 4 cannot change the first registrar's identity since it's owned by 3.730		assert_noop!(731			Identity::set_account_id(RuntimeOrigin::signed(4), 0, 3),732			Error::<Test>::InvalidIndex733		);734		// account 3 can, because that's the registrar's current account.735		assert_ok!(Identity::set_account_id(RuntimeOrigin::signed(3), 0, 4));736		// account 4 can now, because that's their new ID.737		assert_ok!(Identity::set_account_id(RuntimeOrigin::signed(4), 0, 3));738	});739}740741#[test]742fn test_has_identity() {743	new_test_ext().execute_with(|| {744		assert_ok!(Identity::set_identity(745			RuntimeOrigin::signed(10),746			Box::new(ten())747		));748		assert!(Identity::has_identity(&10, IdentityField::Display as u64));749		assert!(Identity::has_identity(&10, IdentityField::Legal as u64));750		assert!(Identity::has_identity(751			&10,752			IdentityField::Display as u64 | IdentityField::Legal as u64753		));754		assert!(!Identity::has_identity(755			&10,756			IdentityField::Display as u64 | IdentityField::Legal as u64 | IdentityField::Web as u64757		));758	});759}