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

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 frame_support::{38	assert_noop, assert_ok, ord_parameter_types, parameter_types,39	traits::{ConstU32, ConstU64, EitherOfDiverse},40	BoundedVec,41};42use frame_system::{EnsureRoot, EnsureSignedBy};43use parity_scale_codec::{Decode, Encode};44use sp_core::H256;45use sp_runtime::{46	traits::{BadOrigin, BlakeTwo256, IdentityLookup},47	BuildStorage,48};4950use super::*;51use crate as pallet_identity;5253type Block = frame_system::mocking::MockBlockU32<Test>;5455frame_support::construct_runtime!(56	pub enum Test {57		System: frame_system,58		Balances: pallet_balances,59		Identity: pallet_identity,60	}61);6263parameter_types! {64	pub BlockWeights: frame_system::limits::BlockWeights =65		frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::from_parts(1024, 0));66}67impl frame_system::Config for Test {68	type BaseCallFilter = frame_support::traits::Everything;69	type Block = Block;70	type BlockWeights = ();71	type BlockLength = ();72	type RuntimeOrigin = RuntimeOrigin;73	type Nonce = u64;74	type Hash = H256;75	type RuntimeCall = RuntimeCall;76	type Hashing = BlakeTwo256;77	type AccountId = u64;78	type Lookup = IdentityLookup<Self::AccountId>;79	type RuntimeEvent = RuntimeEvent;80	type BlockHashCount = ConstU32<250>;81	type DbWeight = ();82	type Version = ();83	type PalletInfo = PalletInfo;84	type AccountData = pallet_balances::AccountData<u64>;85	type OnNewAccount = ();86	type OnKilledAccount = ();87	type SystemWeightInfo = ();88	type SS58Prefix = ();89	type OnSetCode = ();90	type MaxConsumers = ConstU32<16>;91}9293impl pallet_balances::Config for Test {94	type Balance = u64;95	type RuntimeEvent = RuntimeEvent;96	type DustRemoval = ();97	type ExistentialDeposit = ConstU64<1>;98	type AccountStore = System;99	type MaxLocks = ();100	type MaxReserves = ();101	type ReserveIdentifier = [u8; 8];102	type WeightInfo = ();103	type RuntimeHoldReason = RuntimeHoldReason;104	type RuntimeFreezeReason = RuntimeFreezeReason;105	type FreezeIdentifier = ();106	type MaxHolds = ();107	type MaxFreezes = ();108}109110parameter_types! {111	pub const MaxAdditionalFields: u32 = 2;112	pub const MaxRegistrars: u32 = 20;113}114115ord_parameter_types! {116	pub const One: u64 = 1;117	pub const Two: u64 = 2;118}119type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<One, u64>>;120type EnsureTwoOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<Two, u64>>;121impl pallet_identity::Config for Test {122	type RuntimeEvent = RuntimeEvent;123	type Currency = Balances;124	type Slashed = ();125	type BasicDeposit = ConstU64<10>;126	type FieldDeposit = ConstU64<10>;127	type SubAccountDeposit = ConstU64<10>;128	type MaxSubAccounts = ConstU32<2>;129	type MaxAdditionalFields = MaxAdditionalFields;130	type MaxRegistrars = MaxRegistrars;131	type RegistrarOrigin = EnsureOneOrRoot;132	type ForceOrigin = EnsureTwoOrRoot;133	type WeightInfo = ();134}135136pub fn new_test_ext() -> sp_io::TestExternalities {137	let mut t = <frame_system::GenesisConfig<Test>>::default()138		.build_storage()139		.unwrap();140	pallet_balances::GenesisConfig::<Test> {141		balances: vec![(1, 10), (2, 10), (3, 10), (10, 100), (20, 100), (30, 100)],142	}143	.assimilate_storage(&mut t)144	.unwrap();145	t.into()146}147148fn ten() -> IdentityInfo<MaxAdditionalFields> {149	IdentityInfo {150		display: Data::Raw(b"ten".to_vec().try_into().unwrap()),151		legal: Data::Raw(b"The Right Ordinal Ten, Esq.".to_vec().try_into().unwrap()),152		..Default::default()153	}154}155156fn twenty() -> IdentityInfo<MaxAdditionalFields> {157	IdentityInfo {158		display: Data::Raw(b"twenty".to_vec().try_into().unwrap()),159		legal: Data::Raw(160			b"The Right Ordinal Twenty, Esq."161				.to_vec()162				.try_into()163				.unwrap(),164		),165		..Default::default()166	}167}168169#[test]170fn editing_subaccounts_should_work() {171	new_test_ext().execute_with(|| {172		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());173174		assert_noop!(175			Identity::add_sub(RuntimeOrigin::signed(10), 20, data(1)),176			Error::<Test>::NoIdentity177		);178179		assert_ok!(Identity::set_identity(180			RuntimeOrigin::signed(10),181			Box::new(ten())182		));183184		// first sub account185		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));186		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(1))));187		assert_eq!(Balances::free_balance(10), 80);188189		// second sub account190		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 2, data(2)));191		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(1))));192		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));193		assert_eq!(Balances::free_balance(10), 70);194195		// third sub account is too many196		assert_noop!(197			Identity::add_sub(RuntimeOrigin::signed(10), 3, data(3)),198			Error::<Test>::TooManySubAccounts199		);200201		// rename first sub account202		assert_ok!(Identity::rename_sub(RuntimeOrigin::signed(10), 1, data(11)));203		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(11))));204		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));205		assert_eq!(Balances::free_balance(10), 70);206207		// remove first sub account208		assert_ok!(Identity::remove_sub(RuntimeOrigin::signed(10), 1));209		assert_eq!(SuperOf::<Test>::get(1), None);210		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));211		assert_eq!(Balances::free_balance(10), 80);212213		// add third sub account214		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 3, data(3)));215		assert_eq!(SuperOf::<Test>::get(1), None);216		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));217		assert_eq!(SuperOf::<Test>::get(3), Some((10, data(3))));218		assert_eq!(Balances::free_balance(10), 70);219	});220}221222#[test]223fn resolving_subaccount_ownership_works() {224	new_test_ext().execute_with(|| {225		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());226227		assert_ok!(Identity::set_identity(228			RuntimeOrigin::signed(10),229			Box::new(ten())230		));231		assert_ok!(Identity::set_identity(232			RuntimeOrigin::signed(20),233			Box::new(twenty())234		));235236		// 10 claims 1 as a subaccount237		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));238		assert_eq!(Balances::free_balance(1), 10);239		assert_eq!(Balances::free_balance(10), 80);240		assert_eq!(Balances::reserved_balance(10), 20);241		// 20 cannot claim 1 now242		assert_noop!(243			Identity::add_sub(RuntimeOrigin::signed(20), 1, data(1)),244			Error::<Test>::AlreadyClaimed245		);246		// 1 wants to be with 20 so it quits from 10247		assert_ok!(Identity::quit_sub(RuntimeOrigin::signed(1)));248		// 1 gets the 10 that 10 paid.249		assert_eq!(Balances::free_balance(1), 20);250		assert_eq!(Balances::free_balance(10), 80);251		assert_eq!(Balances::reserved_balance(10), 10);252		// 20 can claim 1 now253		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(20), 1, data(1)));254	});255}256257#[test]258fn trailing_zeros_decodes_into_default_data() {259	let encoded = Data::Raw(b"Hello".to_vec().try_into().unwrap()).encode();260	assert!(<(Data, Data)>::decode(&mut &encoded[..]).is_err());261	let input = &mut &encoded[..];262	let (a, b) = <(Data, Data)>::decode(&mut AppendZerosInput::new(input)).unwrap();263	assert_eq!(a, Data::Raw(b"Hello".to_vec().try_into().unwrap()));264	assert_eq!(b, Data::None);265}266267#[test]268fn adding_registrar_should_work() {269	new_test_ext().execute_with(|| {270		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));271		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));272		let fields = IdentityFields(IdentityField::Display | IdentityField::Legal);273		assert_ok!(Identity::set_fields(RuntimeOrigin::signed(3), 0, fields));274		assert_eq!(275			Identity::registrars(),276			vec![Some(RegistrarInfo {277				account: 3,278				fee: 10,279				fields280			})]281		);282	});283}284285#[test]286fn amount_of_registrars_is_limited() {287	new_test_ext().execute_with(|| {288		for i in 1..MaxRegistrars::get() + 1 {289			assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), i as u64));290		}291		let last_registrar = MaxRegistrars::get() as u64 + 1;292		assert_noop!(293			Identity::add_registrar(RuntimeOrigin::signed(1), last_registrar),294			Error::<Test>::TooManyRegistrars295		);296	});297}298299#[test]300fn registration_should_work() {301	new_test_ext().execute_with(|| {302		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));303		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));304		let mut three_fields = ten();305		three_fields306			.additional307			.try_push(Default::default())308			.unwrap();309		three_fields310			.additional311			.try_push(Default::default())312			.unwrap();313		assert!(three_fields314			.additional315			.try_push(Default::default())316			.is_err());317		assert_ok!(Identity::set_identity(318			RuntimeOrigin::signed(10),319			Box::new(ten())320		));321		assert_eq!(Identity::identity(10).unwrap().info, ten());322		assert_eq!(Balances::free_balance(10), 90);323		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));324		assert_eq!(Balances::free_balance(10), 100);325		assert_noop!(326			Identity::clear_identity(RuntimeOrigin::signed(10)),327			Error::<Test>::NotNamed328		);329	});330}331332#[test]333fn uninvited_judgement_should_work() {334	new_test_ext().execute_with(|| {335		assert_noop!(336			Identity::provide_judgement(337				RuntimeOrigin::signed(3),338				0,339				10,340				Judgement::Reasonable,341				H256::random()342			),343			Error::<Test>::InvalidIndex344		);345346		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));347		assert_noop!(348			Identity::provide_judgement(349				RuntimeOrigin::signed(3),350				0,351				10,352				Judgement::Reasonable,353				H256::random()354			),355			Error::<Test>::InvalidTarget356		);357358		assert_ok!(Identity::set_identity(359			RuntimeOrigin::signed(10),360			Box::new(ten())361		));362		assert_noop!(363			Identity::provide_judgement(364				RuntimeOrigin::signed(3),365				0,366				10,367				Judgement::Reasonable,368				H256::random()369			),370			Error::<Test>::JudgementForDifferentIdentity371		);372373		let identity_hash = BlakeTwo256::hash_of(&ten());374375		assert_noop!(376			Identity::provide_judgement(377				RuntimeOrigin::signed(10),378				0,379				10,380				Judgement::Reasonable,381				identity_hash382			),383			Error::<Test>::InvalidIndex384		);385		assert_noop!(386			Identity::provide_judgement(387				RuntimeOrigin::signed(3),388				0,389				10,390				Judgement::FeePaid(1),391				identity_hash392			),393			Error::<Test>::InvalidJudgement394		);395396		assert_ok!(Identity::provide_judgement(397			RuntimeOrigin::signed(3),398			0,399			10,400			Judgement::Reasonable,401			identity_hash402		));403		assert_eq!(404			Identity::identity(10).unwrap().judgements,405			vec![(0, Judgement::Reasonable)]406		);407	});408}409410#[test]411fn clearing_judgement_should_work() {412	new_test_ext().execute_with(|| {413		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));414		assert_ok!(Identity::set_identity(415			RuntimeOrigin::signed(10),416			Box::new(ten())417		));418		assert_ok!(Identity::provide_judgement(419			RuntimeOrigin::signed(3),420			0,421			10,422			Judgement::Reasonable,423			BlakeTwo256::hash_of(&ten())424		));425		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));426		assert_eq!(Identity::identity(10), None);427	});428}429430#[test]431fn killing_slashing_should_work() {432	new_test_ext().execute_with(|| {433		assert_ok!(Identity::set_identity(434			RuntimeOrigin::signed(10),435			Box::new(ten())436		));437		assert_noop!(438			Identity::kill_identity(RuntimeOrigin::signed(1), 10),439			BadOrigin440		);441		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));442		assert_eq!(Identity::identity(10), None);443		assert_eq!(Balances::free_balance(10), 90);444		assert_noop!(445			Identity::kill_identity(RuntimeOrigin::signed(2), 10),446			Error::<Test>::NotNamed447		);448	});449}450451#[test]452fn setting_subaccounts_should_work() {453	new_test_ext().execute_with(|| {454		let mut subs = vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))];455		assert_noop!(456			Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()),457			Error::<Test>::NotFound458		);459460		assert_ok!(Identity::set_identity(461			RuntimeOrigin::signed(10),462			Box::new(ten())463		));464		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));465		assert_eq!(Balances::free_balance(10), 80);466		assert_eq!(Identity::subs_of(10), (10, vec![20].try_into().unwrap()));467		assert_eq!(468			Identity::super_of(20),469			Some((10, Data::Raw(vec![40; 1].try_into().unwrap())))470		);471472		// push another item and re-set it.473		subs.push((30, Data::Raw(vec![50; 1].try_into().unwrap())));474		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));475		assert_eq!(Balances::free_balance(10), 70);476		assert_eq!(477			Identity::subs_of(10),478			(20, vec![20, 30].try_into().unwrap())479		);480		assert_eq!(481			Identity::super_of(20),482			Some((10, Data::Raw(vec![40; 1].try_into().unwrap())))483		);484		assert_eq!(485			Identity::super_of(30),486			Some((10, Data::Raw(vec![50; 1].try_into().unwrap())))487		);488489		// switch out one of the items and re-set.490		subs[0] = (40, Data::Raw(vec![60; 1].try_into().unwrap()));491		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));492		assert_eq!(Balances::free_balance(10), 70); // no change in the balance493		assert_eq!(494			Identity::subs_of(10),495			(20, vec![40, 30].try_into().unwrap())496		);497		assert_eq!(Identity::super_of(20), None);498		assert_eq!(499			Identity::super_of(30),500			Some((10, Data::Raw(vec![50; 1].try_into().unwrap())))501		);502		assert_eq!(503			Identity::super_of(40),504			Some((10, Data::Raw(vec![60; 1].try_into().unwrap())))505		);506507		// clear508		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), vec![]));509		assert_eq!(Balances::free_balance(10), 90);510		assert_eq!(Identity::subs_of(10), (0, BoundedVec::default()));511		assert_eq!(Identity::super_of(30), None);512		assert_eq!(Identity::super_of(40), None);513514		subs.push((20, Data::Raw(vec![40; 1].try_into().unwrap())));515		assert_noop!(516			Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()),517			Error::<Test>::TooManySubAccounts518		);519	});520}521522#[test]523fn clearing_account_should_remove_subaccounts_and_refund() {524	new_test_ext().execute_with(|| {525		assert_ok!(Identity::set_identity(526			RuntimeOrigin::signed(10),527			Box::new(ten())528		));529		assert_ok!(Identity::set_subs(530			RuntimeOrigin::signed(10),531			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]532		));533		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));534		assert_eq!(Balances::free_balance(10), 100);535		assert!(Identity::super_of(20).is_none());536	});537}538539#[test]540fn killing_account_should_remove_subaccounts_and_not_refund() {541	new_test_ext().execute_with(|| {542		assert_ok!(Identity::set_identity(543			RuntimeOrigin::signed(10),544			Box::new(ten())545		));546		assert_ok!(Identity::set_subs(547			RuntimeOrigin::signed(10),548			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]549		));550		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));551		assert_eq!(Balances::free_balance(10), 80);552		assert!(Identity::super_of(20).is_none());553	});554}555556#[test]557fn cancelling_requested_judgement_should_work() {558	new_test_ext().execute_with(|| {559		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));560		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));561		assert_noop!(562			Identity::cancel_request(RuntimeOrigin::signed(10), 0),563			Error::<Test>::NoIdentity564		);565		assert_ok!(Identity::set_identity(566			RuntimeOrigin::signed(10),567			Box::new(ten())568		));569		assert_ok!(Identity::request_judgement(570			RuntimeOrigin::signed(10),571			0,572			10573		));574		assert_ok!(Identity::cancel_request(RuntimeOrigin::signed(10), 0));575		assert_eq!(Balances::free_balance(10), 90);576		assert_noop!(577			Identity::cancel_request(RuntimeOrigin::signed(10), 0),578			Error::<Test>::NotFound579		);580581		assert_ok!(Identity::provide_judgement(582			RuntimeOrigin::signed(3),583			0,584			10,585			Judgement::Reasonable,586			BlakeTwo256::hash_of(&ten())587		));588		assert_noop!(589			Identity::cancel_request(RuntimeOrigin::signed(10), 0),590			Error::<Test>::JudgementGiven591		);592	});593}594595#[test]596fn requesting_judgement_should_work() {597	new_test_ext().execute_with(|| {598		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));599		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));600		assert_ok!(Identity::set_identity(601			RuntimeOrigin::signed(10),602			Box::new(ten())603		));604		assert_noop!(605			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 9),606			Error::<Test>::FeeChanged607		);608		assert_ok!(Identity::request_judgement(609			RuntimeOrigin::signed(10),610			0,611			10612		));613		// 10 for the judgement request, 10 for the identity.614		assert_eq!(Balances::free_balance(10), 80);615616		// Re-requesting won't work as we already paid.617		assert_noop!(618			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10),619			Error::<Test>::StickyJudgement620		);621		assert_ok!(Identity::provide_judgement(622			RuntimeOrigin::signed(3),623			0,624			10,625			Judgement::Erroneous,626			BlakeTwo256::hash_of(&ten())627		));628		// Registrar got their payment now.629		assert_eq!(Balances::free_balance(3), 20);630631		// Re-requesting still won't work as it's erroneous.632		assert_noop!(633			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10),634			Error::<Test>::StickyJudgement635		);636637		// Requesting from a second registrar still works.638		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 4));639		assert_ok!(Identity::request_judgement(640			RuntimeOrigin::signed(10),641			1,642			10643		));644645		// Re-requesting after the judgement has been reduced works.646		assert_ok!(Identity::provide_judgement(647			RuntimeOrigin::signed(3),648			0,649			10,650			Judgement::OutOfDate,651			BlakeTwo256::hash_of(&ten())652		));653		assert_ok!(Identity::request_judgement(654			RuntimeOrigin::signed(10),655			0,656			10657		));658	});659}660661#[test]662fn provide_judgement_should_return_judgement_payment_failed_error() {663	new_test_ext().execute_with(|| {664		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));665		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));666		assert_ok!(Identity::set_identity(667			RuntimeOrigin::signed(10),668			Box::new(ten())669		));670		assert_ok!(Identity::request_judgement(671			RuntimeOrigin::signed(10),672			0,673			10674		));675		// 10 for the judgement request, 10 for the identity.676		assert_eq!(Balances::free_balance(10), 80);677678		// This forces judgement payment failed error679		Balances::make_free_balance_be(&3, 0);680		assert_noop!(681			Identity::provide_judgement(682				RuntimeOrigin::signed(3),683				0,684				10,685				Judgement::Erroneous,686				BlakeTwo256::hash_of(&ten())687			),688			Error::<Test>::JudgementPaymentFailed689		);690	});691}692693#[test]694fn field_deposit_should_work() {695	new_test_ext().execute_with(|| {696		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));697		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));698		assert_ok!(Identity::set_identity(699			RuntimeOrigin::signed(10),700			Box::new(IdentityInfo {701				additional: vec![702					(703						Data::Raw(b"number".to_vec().try_into().unwrap()),704						Data::Raw(10u32.encode().try_into().unwrap())705					),706					(707						Data::Raw(b"text".to_vec().try_into().unwrap()),708						Data::Raw(b"10".to_vec().try_into().unwrap())709					),710				]711				.try_into()712				.unwrap(),713				..Default::default()714			})715		));716		assert_eq!(Balances::free_balance(10), 70);717	});718}719720#[test]721fn setting_account_id_should_work() {722	new_test_ext().execute_with(|| {723		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));724		// account 4 cannot change the first registrar's identity since it's owned by 3.725		assert_noop!(726			Identity::set_account_id(RuntimeOrigin::signed(4), 0, 3),727			Error::<Test>::InvalidIndex728		);729		// account 3 can, because that's the registrar's current account.730		assert_ok!(Identity::set_account_id(RuntimeOrigin::signed(3), 0, 4));731		// account 4 can now, because that's their new ID.732		assert_ok!(Identity::set_account_id(RuntimeOrigin::signed(4), 0, 3));733	});734}735736#[test]737fn test_has_identity() {738	new_test_ext().execute_with(|| {739		assert_ok!(Identity::set_identity(740			RuntimeOrigin::signed(10),741			Box::new(ten())742		));743		assert!(Identity::has_identity(&10, IdentityField::Display as u64));744		assert!(Identity::has_identity(&10, IdentityField::Legal as u64));745		assert!(Identity::has_identity(746			&10,747			IdentityField::Display as u64 | IdentityField::Legal as u64748		));749		assert!(!Identity::has_identity(750			&10,751			IdentityField::Display as u64 | IdentityField::Legal as u64 | IdentityField::Web as u64752		));753	});754}