difftreelog
CORE-36 Enable/Disable Transfers + Unit tests fix
in: master
8 files changed
Cargo.lockdiffbeforeafterboth5847 "sp-std",5847 "sp-std",5848]5848]58495850[[package]]5851name = "pallet-scheduler"5852version = "3.0.0"5853dependencies = [5854 "frame-benchmarking",5855 "frame-support",5856 "frame-system",5857 "log",5858 "parity-scale-codec 2.1.3",5859 "serde",5860 "sp-core",5861 "sp-io",5862 "sp-runtime",5863 "sp-std",5864 "substrate-test-utils",5865 "up-sponsorship",5866]586758495868[[package]]5850[[package]]5869name = "pallet-scheduler"5851name = "pallet-scheduler"5880 "sp-std",5862 "sp-std",5881]5863]58645865[[package]]5866name = "pallet-scheduler"5867version = "3.0.0"5868dependencies = [5869 "frame-benchmarking",5870 "frame-support",5871 "frame-system",5872 "log",5873 "parity-scale-codec 2.1.3",5874 "serde",5875 "sp-core",5876 "sp-io",5877 "sp-runtime",5878 "sp-std",5879 "substrate-test-utils",5880 "up-sponsorship",5881]588258825883[[package]]5883[[package]]5884name = "pallet-session"5884name = "pallet-session"node/cli/src/chain_spec.rsdiffbeforeafterboth196 const_on_chain_schema: vec![],196 const_on_chain_schema: vec![],197 variable_on_chain_schema: vec![],197 variable_on_chain_schema: vec![],198 limits: CollectionLimits::default(),198 limits: CollectionLimits::default(),199 transfers_enabled: true,199 },200 },200 )],201 )],201 nft_item_id: vec![],202 nft_item_id: vec![],pallets/inflation/src/tests.rsdiffbeforeafterboth31 type ExistentialDeposit = ExistentialDeposit;31 type ExistentialDeposit = ExistentialDeposit;32 type WeightInfo = ();32 type WeightInfo = ();33 type MaxLocks = MaxLocks;33 type MaxLocks = MaxLocks;34 type MaxReserves = ();35 type ReserveIdentifier = ();34}36}353736frame_support::construct_runtime!(38frame_support::construct_runtime!(pallets/nft/src/lib.rsdiffbeforeafterboth175 BadCreateRefungibleCall,175 BadCreateRefungibleCall,176 /// Gas limit exceeded176 /// Gas limit exceeded177 OutOfGas,177 OutOfGas,178 /// Collection settings not allowing items transferring179 TransferNotAllowed,178 }180 }179}181}180182533 variable_on_chain_schema: Vec::new(),535 variable_on_chain_schema: Vec::new(),534 const_on_chain_schema: Vec::new(),536 const_on_chain_schema: Vec::new(),535 limits,537 limits,538 transfers_enabled: true,536 };539 };537540538 // Add new collection to map541 // Add new collection to map922 Ok(())925 Ok(())923 }926 }927928 // TODO! transaction weight929930 /// Set transfers_enabled value for particular collection931 ///932 /// # Permissions933 ///934 /// * Collection Owner.935 ///936 /// # Arguments937 ///938 /// * collection_id: ID of the collection.939 ///940 /// * value: New flag value.941 #[weight = <T as Config>::WeightInfo::burn_item()]942 #[transactional]943 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {944945 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);946 let mut target_collection = Self::get_collection(collection_id)?;947948 Self::check_owner_permissions(&target_collection, sender.as_sub())?;949 950 target_collection.transfers_enabled = value;951 Self::save_collection(target_collection);952953 Ok(())954 }924955925 /// Destroys a concrete instance of NFT.956 /// Destroys a concrete instance of NFT.926 ///957 ///1575 Error::<T>::AccountTokenLimitExceeded1606 Error::<T>::AccountTokenLimitExceeded1576 );1607 );16081609 // preliminary transfer check1610 ensure!(1611 collection.transfers_enabled,1612 Error::<T>::TransferNotAllowed1613 );157716141578 Ok(())1615 Ok(())1579 }1616 }pallets/nft/src/mock.rsdiffbeforeafterboth74 type ExistentialDeposit = ExistentialDeposit;74 type ExistentialDeposit = ExistentialDeposit;75 type WeightInfo = ();75 type WeightInfo = ();76 type MaxLocks = MaxLocks;76 type MaxLocks = MaxLocks;77 type MaxReserves = ();78 type ReserveIdentifier = [u8; 8];77}79}788079parameter_types! {81parameter_types! {100type Timestamp = pallet_timestamp::Pallet<Test>;102type Timestamp = pallet_timestamp::Pallet<Test>;101type Randomness = pallet_randomness_collective_flip::Pallet<Test>;103type Randomness = pallet_randomness_collective_flip::Pallet<Test>;102104103parameter_types! {105// parameter_types! {104 pub const TombstoneDeposit: u64 = 1;106// pub const TombstoneDeposit: u64 = 1;105 pub const DepositPerContract: u64 = 1;107// pub const DepositPerContract: u64 = 1;106 pub const DepositPerStorageByte: u64 = 1;108// pub const DepositPerStorageByte: u64 = 1;107 pub const DepositPerStorageItem: u64 = 1;109// pub const DepositPerStorageItem: u64 = 1;108 pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * 24 * 60 * 10);110// pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * 24 * 60 * 10);109 pub const SurchargeReward: u64 = 1;111// pub const SurchargeReward: u64 = 1;110 pub const SignedClaimHandicap: u32 = 2;112// pub const SignedClaimHandicap: u32 = 2;111 pub DeletionWeightLimit: u64 = u64::MAX;//Perbill::from_percent(10);113// pub DeletionWeightLimit: u64 = u64::MAX;//Perbill::from_percent(10);112 pub DeletionQueueDepth: u32 = 10;114// pub DeletionQueueDepth: u32 = 10;113 pub Schedule: pallet_contracts::Schedule<Test> = Default::default();115// pub Schedule: pallet_contracts::Schedule<Test> = Default::default();114}116// }115117116impl pallet_contracts::Config for Test {118// impl pallet_contracts::Config for Test {117 type Time = Timestamp;119// type Time = Timestamp;118 type Randomness = Randomness;120// type Randomness = Randomness;119 type Currency = pallet_balances::Pallet<Test>;121// type Currency = pallet_balances::Pallet<Test>;120 type Event = ();122// type Event = ();121 type RentPayment = ();123// type RentPayment = ();122 type SignedClaimHandicap = SignedClaimHandicap;124// type SignedClaimHandicap = SignedClaimHandicap;123 type TombstoneDeposit = TombstoneDeposit;125// type TombstoneDeposit = TombstoneDeposit;124 type DepositPerContract = DepositPerContract;126// type DepositPerContract = DepositPerContract;125 type DepositPerStorageByte = DepositPerStorageByte;127// type DepositPerStorageByte = DepositPerStorageByte;126 type DepositPerStorageItem = DepositPerStorageItem;128// type DepositPerStorageItem = DepositPerStorageItem;127 type RentFraction = RentFraction;129// type RentFraction = RentFraction;128 type SurchargeReward = SurchargeReward;130// type SurchargeReward = SurchargeReward;129 type DeletionWeightLimit = DeletionWeightLimit;131// type DeletionWeightLimit = DeletionWeightLimit;130 type DeletionQueueDepth = DeletionQueueDepth;132// type DeletionQueueDepth = DeletionQueueDepth;131 type ChainExtension = ();133// type ChainExtension = ();132 type WeightPrice = ();134// type WeightPrice = ();133 type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;135// type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;134 type Schedule = Schedule;136// type Schedule = Schedule;135 type CallStack = [pallet_contracts::Frame<Self>; 31];137// type CallStack = [pallet_contracts::Frame<Self>; 31];136}138// }137139138parameter_types! {140parameter_types! {139 pub const CollectionCreationPrice: u32 = 0;141 pub const CollectionCreationPrice: u32 = 0;pallets/nft/src/tests.rsdiffbeforeafterboth2352 });2352 });2353}2353}23542355#[test]2356fn collection_transfer_flag_works() {2357 new_test_ext().execute_with(|| {2358 default_limits();23592360 let origin1 = Origin::signed(1);23612362 let collection_id = create_test_collection(&CollectionMode::NFT, 1);2363 assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, 1, true));23642365 let data = default_nft_data();2366 create_test_item(collection_id, &data.into());2367 assert_eq!(TemplateModule::balance_count(1, 1), 1);2368 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);23692370 let origin1 = Origin::signed(1);23712372 // default scenario2373 assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1000));2374 assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(2));2375 assert_eq!(TemplateModule::balance_count(1, 1), 0);2376 assert_eq!(TemplateModule::balance_count(1, 2), 1);23772378 assert_eq!(TemplateModule::address_tokens(1, 2), [1]);2379 });2380}23812382#[test]2383fn collection_transfer_flag_works_neg() {2384 new_test_ext().execute_with(|| {2385 default_limits();23862387 let origin1 = Origin::signed(1);23882389 let collection_id = create_test_collection(&CollectionMode::NFT, 1);2390 assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, 1, false));23912392 let data = default_nft_data();2393 create_test_item(collection_id, &data.into());2394 assert_eq!(TemplateModule::balance_count(1, 1), 1);2395 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);23962397 let origin1 = Origin::signed(1);23982399 // default scenario2400 assert_noop!(2401 TemplateModule::transfer(origin1, account(2), 1, 1, 1000),2402 Error::<Test>::TransferNotAllowed2403 );2404 assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(1));2405 assert_eq!(TemplateModule::balance_count(1, 1), 1);2406 assert_eq!(TemplateModule::balance_count(1, 2), 0);24072408 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);2409 });2410}23542411pallets/scheduler/src/lib.rsdiffbeforeafterboth948 system::RawOrigin::Root.into()948 system::RawOrigin::Root.into()949 }949 }950951 #[test]952 fn basic_scheduling_works() {953 new_test_ext().execute_with(|| {954 let call = Call::Logger(logger::Call::log(42, 1000));955 assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(956 &call957 ));958 assert_ok!(Scheduler::do_schedule(959 DispatchTime::At(4),960 None,961 127,962 root(),963 call964 ));965 run_to_block(3);966 assert!(logger::log().is_empty());967 run_to_block(4);968 assert_eq!(logger::log(), vec![(root(), 42u32)]);969 run_to_block(100);970 assert_eq!(logger::log(), vec![(root(), 42u32)]);971 });972 }973974 #[test]975 fn schedule_after_works() {976 new_test_ext().execute_with(|| {977 run_to_block(2);978 let call = Call::Logger(logger::Call::log(42, 1000));979 assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(980 &call981 ));982 // This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6983 assert_ok!(Scheduler::do_schedule(984 DispatchTime::After(3),985 None,986 127,987 root(),988 call989 ));990 run_to_block(5);991 assert!(logger::log().is_empty());992 run_to_block(6);993 assert_eq!(logger::log(), vec![(root(), 42u32)]);994 run_to_block(100);995 assert_eq!(logger::log(), vec![(root(), 42u32)]);996 });997 }998999 #[test]1000 fn schedule_after_zero_works() {1001 new_test_ext().execute_with(|| {1002 run_to_block(2);1003 let call = Call::Logger(logger::Call::log(42, 1000));1004 assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(1005 &call1006 ));1007 assert_ok!(Scheduler::do_schedule(1008 DispatchTime::After(0),1009 None,1010 127,1011 root(),1012 call1013 ));1014 // Will trigger on the next block.1015 run_to_block(3);1016 assert_eq!(logger::log(), vec![(root(), 42u32)]);1017 run_to_block(100);1018 assert_eq!(logger::log(), vec![(root(), 42u32)]);1019 });1020 }10211022 #[test]1023 fn periodic_scheduling_works() {1024 new_test_ext().execute_with(|| {1025 // at #4, every 3 blocks, 3 times.1026 assert_ok!(Scheduler::do_schedule(1027 DispatchTime::At(4),1028 Some((3, 3)),1029 127,1030 root(),1031 Call::Logger(logger::Call::log(42, 1000))1032 ));1033 run_to_block(3);1034 assert!(logger::log().is_empty());1035 run_to_block(4);1036 assert_eq!(logger::log(), vec![(root(), 42u32)]);1037 run_to_block(6);1038 assert_eq!(logger::log(), vec![(root(), 42u32)]);1039 run_to_block(7);1040 assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);1041 run_to_block(9);1042 assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);1043 run_to_block(10);1044 assert_eq!(1045 logger::log(),1046 vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]1047 );1048 run_to_block(100);1049 assert_eq!(1050 logger::log(),1051 vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]1052 );1053 });1054 }10551056 #[test]1057 fn reschedule_works() {1058 new_test_ext().execute_with(|| {1059 let call = Call::Logger(logger::Call::log(42, 1000));1060 assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(1061 &call1062 ));1063 assert_eq!(1064 Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call).unwrap(),1065 (4, 0)1066 );10671068 run_to_block(3);1069 assert!(logger::log().is_empty());10701071 assert_eq!(1072 Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(),1073 (6, 0)1074 );10751076 assert_noop!(1077 Scheduler::do_reschedule((6, 0), DispatchTime::At(6)),1078 Error::<Test>::RescheduleNoChange1079 );10801081 run_to_block(4);1082 assert!(logger::log().is_empty());10831084 run_to_block(6);1085 assert_eq!(logger::log(), vec![(root(), 42u32)]);10861087 run_to_block(100);1088 assert_eq!(logger::log(), vec![(root(), 42u32)]);1089 });1090 }10911092 #[test]1093 fn reschedule_named_works() {1094 new_test_ext().execute_with(|| {1095 let call = Call::Logger(logger::Call::log(42, 1000));1096 assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(1097 &call1098 ));1099 assert_eq!(1100 Scheduler::do_schedule_named(1101 1u32.encode(),1102 DispatchTime::At(4),1103 None,1104 127,1105 root(),1106 call1107 )1108 .unwrap(),1109 (4, 0)1110 );11111112 run_to_block(3);1113 assert!(logger::log().is_empty());11141115 assert_eq!(1116 Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(),1117 (6, 0)1118 );11191120 assert_noop!(1121 Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)),1122 Error::<Test>::RescheduleNoChange1123 );11241125 run_to_block(4);1126 assert!(logger::log().is_empty());11271128 run_to_block(6);1129 assert_eq!(logger::log(), vec![(root(), 42u32)]);11301131 run_to_block(100);1132 assert_eq!(logger::log(), vec![(root(), 42u32)]);1133 });1134 }11351136 #[test]1137 fn reschedule_named_perodic_works() {1138 new_test_ext().execute_with(|| {1139 let call = Call::Logger(logger::Call::log(42, 1000));1140 assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(1141 &call1142 ));1143 assert_eq!(1144 Scheduler::do_schedule_named(1145 1u32.encode(),1146 DispatchTime::At(4),1147 Some((3, 3)),1148 127,1149 root(),1150 call1151 )1152 .unwrap(),1153 (4, 0)1154 );11551156 run_to_block(3);1157 assert!(logger::log().is_empty());11581159 assert_eq!(1160 Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(5)).unwrap(),1161 (5, 0)1162 );1163 assert_eq!(1164 Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(),1165 (6, 0)1166 );11671168 run_to_block(5);1169 assert!(logger::log().is_empty());11701171 run_to_block(6);1172 assert_eq!(logger::log(), vec![(root(), 42u32)]);11731174 assert_eq!(1175 Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(10)).unwrap(),1176 (10, 0)1177 );11781179 run_to_block(9);1180 assert_eq!(logger::log(), vec![(root(), 42u32)]);11811182 run_to_block(10);1183 assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);11841185 run_to_block(13);1186 assert_eq!(1187 logger::log(),1188 vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]1189 );11901191 run_to_block(100);1192 assert_eq!(1193 logger::log(),1194 vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]1195 );1196 });1197 }11981199 #[test]1200 fn cancel_named_scheduling_works_with_normal_cancel() {1201 new_test_ext().execute_with(|| {1202 // at #4.1203 Scheduler::do_schedule_named(1204 1u32.encode(),1205 DispatchTime::At(4),1206 None,1207 127,1208 root(),1209 Call::Logger(logger::Call::log(69, 1000)),1210 )1211 .unwrap();1212 let i = Scheduler::do_schedule(1213 DispatchTime::At(4),1214 None,1215 127,1216 root(),1217 Call::Logger(logger::Call::log(42, 1000)),1218 )1219 .unwrap();1220 run_to_block(3);1221 assert!(logger::log().is_empty());1222 assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1223 assert_ok!(Scheduler::do_cancel(None, i));1224 run_to_block(100);1225 assert!(logger::log().is_empty());1226 });1227 }12281229 #[test]1230 fn cancel_named_periodic_scheduling_works() {1231 new_test_ext().execute_with(|| {1232 // at #4, every 3 blocks, 3 times.1233 Scheduler::do_schedule_named(1234 1u32.encode(),1235 DispatchTime::At(4),1236 Some((3, 3)),1237 127,1238 root(),1239 Call::Logger(logger::Call::log(42, 1000)),1240 )1241 .unwrap();1242 // same id results in error.1243 assert!(Scheduler::do_schedule_named(1244 1u32.encode(),1245 DispatchTime::At(4),1246 None,1247 127,1248 root(),1249 Call::Logger(logger::Call::log(69, 1000))1250 )1251 .is_err());1252 // different id is ok.1253 Scheduler::do_schedule_named(1254 2u32.encode(),1255 DispatchTime::At(8),1256 None,1257 127,1258 root(),1259 Call::Logger(logger::Call::log(69, 1000)),1260 )1261 .unwrap();1262 run_to_block(3);1263 assert!(logger::log().is_empty());1264 run_to_block(4);1265 assert_eq!(logger::log(), vec![(root(), 42u32)]);1266 run_to_block(6);1267 assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1268 run_to_block(100);1269 assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1270 });1271 }12721273 #[test]1274 fn scheduler_respects_weight_limits() {1275 new_test_ext().execute_with(|| {1276 assert_ok!(Scheduler::do_schedule(1277 DispatchTime::At(4),1278 None,1279 127,1280 root(),1281 Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1282 ));1283 assert_ok!(Scheduler::do_schedule(1284 DispatchTime::At(4),1285 None,1286 127,1287 root(),1288 Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1289 ));1290 // 69 and 42 do not fit together1291 run_to_block(4);1292 assert_eq!(logger::log(), vec![(root(), 42u32)]);1293 run_to_block(5);1294 assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1295 });1296 }12971298 #[test]1299 fn scheduler_respects_hard_deadlines_more() {1300 new_test_ext().execute_with(|| {1301 assert_ok!(Scheduler::do_schedule(1302 DispatchTime::At(4),1303 None,1304 0,1305 root(),1306 Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1307 ));1308 assert_ok!(Scheduler::do_schedule(1309 DispatchTime::At(4),1310 None,1311 0,1312 root(),1313 Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1314 ));1315 // With base weights, 69 and 42 should not fit together, but do because of hard deadlines1316 run_to_block(4);1317 assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1318 });1319 }13201321 #[test]1322 fn scheduler_respects_priority_ordering() {1323 new_test_ext().execute_with(|| {1324 assert_ok!(Scheduler::do_schedule(1325 DispatchTime::At(4),1326 None,1327 1,1328 root(),1329 Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1330 ));1331 assert_ok!(Scheduler::do_schedule(1332 DispatchTime::At(4),1333 None,1334 0,1335 root(),1336 Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1337 ));1338 run_to_block(4);1339 assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);1340 });1341 }13421343 #[test]1344 fn scheduler_respects_priority_ordering_with_soft_deadlines() {1345 new_test_ext().execute_with(|| {1346 assert_ok!(Scheduler::do_schedule(1347 DispatchTime::At(4),1348 None,1349 255,1350 root(),1351 Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1352 ));1353 assert_ok!(Scheduler::do_schedule(1354 DispatchTime::At(4),1355 None,1356 127,1357 root(),1358 Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1359 ));1360 assert_ok!(Scheduler::do_schedule(1361 DispatchTime::At(4),1362 None,1363 126,1364 root(),1365 Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))1366 ));13671368 // 2600 does not fit with 69 or 42, but has higher priority, so will go through1369 run_to_block(4);1370 assert_eq!(logger::log(), vec![(root(), 2600u32)]);1371 // 69 and 42 fit together1372 run_to_block(5);1373 assert_eq!(1374 logger::log(),1375 vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]1376 );1377 });1378 }13791380 #[test]1381 fn on_initialize_weight_is_correct() {1382 new_test_ext().execute_with(|| {1383 let base_weight: Weight =1384 <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);1385 let base_multiplier = 0;1386 let named_multiplier = <Test as frame_system::Config>::DbWeight::get().writes(1);1387 let periodic_multiplier =1388 <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 1);13891390 // Named1391 assert_ok!(Scheduler::do_schedule_named(1392 1u32.encode(),1393 DispatchTime::At(1),1394 None,1395 255,1396 root(),1397 Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))1398 ));1399 // Anon Periodic1400 assert_ok!(Scheduler::do_schedule(1401 DispatchTime::At(1),1402 Some((1000, 3)),1403 128,1404 root(),1405 Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1406 ));1407 // Anon1408 assert_ok!(Scheduler::do_schedule(1409 DispatchTime::At(1),1410 None,1411 127,1412 root(),1413 Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1414 ));1415 // Named Periodic1416 assert_ok!(Scheduler::do_schedule_named(1417 2u32.encode(),1418 DispatchTime::At(1),1419 Some((1000, 3)),1420 126,1421 root(),1422 Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))1423 ));14241425 // Will include the named periodic only1426 let actual_weight = Scheduler::on_initialize(1);1427 let call_weight = MaximumSchedulerWeight::get() / 2;1428 assert_eq!(1429 actual_weight,1430 call_weight1431 + base_weight + base_multiplier1432 + named_multiplier + periodic_multiplier1433 );1434 assert_eq!(logger::log(), vec![(root(), 2600u32)]);14351436 // Will include anon and anon periodic1437 let actual_weight = Scheduler::on_initialize(2);1438 let call_weight = MaximumSchedulerWeight::get() / 2 + MaximumSchedulerWeight::get() / 3;1439 assert_eq!(1440 actual_weight,1441 call_weight + base_weight + base_multiplier * 2 + periodic_multiplier1442 );1443 assert_eq!(1444 logger::log(),1445 vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]1446 );14471448 // Will include named only1449 let actual_weight = Scheduler::on_initialize(3);1450 let call_weight = MaximumSchedulerWeight::get() / 3;1451 assert_eq!(1452 actual_weight,1453 call_weight + base_weight + base_multiplier + named_multiplier1454 );1455 assert_eq!(1456 logger::log(),1457 vec![1458 (root(), 2600u32),1459 (root(), 69u32),1460 (root(), 42u32),1461 (root(), 3u32)1462 ]1463 );14641465 // Will contain none1466 let actual_weight = Scheduler::on_initialize(4);1467 assert_eq!(actual_weight, 0);1468 });1469 }14701471 #[test]1472 fn root_calls_works() {1473 new_test_ext().execute_with(|| {1474 let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1475 let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1476 assert_ok!(Scheduler::schedule_named(1477 Origin::root(),1478 1u32.encode(),1479 4,1480 None,1481 127,1482 call1483 ));1484 assert_ok!(Scheduler::schedule(Origin::root(), 4, None, 127, call2));1485 run_to_block(3);1486 // Scheduled calls are in the agenda.1487 assert_eq!(Agenda::<Test>::get(4).len(), 2);1488 assert!(logger::log().is_empty());1489 assert_ok!(Scheduler::cancel_named(Origin::root(), 1u32.encode()));1490 assert_ok!(Scheduler::cancel(Origin::root(), 4, 1));1491 // Scheduled calls are made NONE, so should not effect state1492 run_to_block(100);1493 assert!(logger::log().is_empty());1494 });1495 }14961497 #[test]1498 fn fails_to_schedule_task_in_the_past() {1499 new_test_ext().execute_with(|| {1500 run_to_block(3);15011502 let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1503 let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));15041505 assert_err!(1506 Scheduler::schedule_named(Origin::root(), 1u32.encode(), 2, None, 127, call),1507 Error::<Test>::TargetBlockNumberInPast,1508 );15091510 assert_err!(1511 Scheduler::schedule(Origin::root(), 2, None, 127, call2.clone()),1512 Error::<Test>::TargetBlockNumberInPast,1513 );15141515 assert_err!(1516 Scheduler::schedule(Origin::root(), 3, None, 127, call2),1517 Error::<Test>::TargetBlockNumberInPast,1518 );1519 });1520 }15211522 #[test]1523 fn should_use_orign() {1524 new_test_ext().execute_with(|| {1525 let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1526 let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1527 assert_ok!(Scheduler::schedule_named(1528 system::RawOrigin::Signed(1).into(),1529 1u32.encode(),1530 4,1531 None,1532 127,1533 call1534 ));1535 assert_ok!(Scheduler::schedule(1536 system::RawOrigin::Signed(1).into(),1537 4,1538 None,1539 127,1540 call21541 ));1542 run_to_block(3);1543 // Scheduled calls are in the agenda.1544 assert_eq!(Agenda::<Test>::get(4).len(), 2);1545 assert!(logger::log().is_empty());1546 assert_ok!(Scheduler::cancel_named(1547 system::RawOrigin::Signed(1).into(),1548 1u32.encode()1549 ));1550 assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));1551 // Scheduled calls are made NONE, so should not effect state1552 run_to_block(100);1553 assert!(logger::log().is_empty());1554 });1555 }15561557 #[test]1558 fn should_check_orign() {1559 new_test_ext().execute_with(|| {1560 let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1561 let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1562 assert_noop!(1563 Scheduler::schedule_named(1564 system::RawOrigin::Signed(2).into(),1565 1u32.encode(),1566 4,1567 None,1568 127,1569 call1570 ),1571 BadOrigin1572 );1573 assert_noop!(1574 Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2),1575 BadOrigin1576 );1577 });1578 }15791580 #[test]1581 fn should_check_orign_for_cancel() {1582 new_test_ext().execute_with(|| {1583 let call = Box::new(Call::Logger(logger::Call::log_without_filter(69, 1000)));1584 let call2 = Box::new(Call::Logger(logger::Call::log_without_filter(42, 1000)));1585 assert_ok!(Scheduler::schedule_named(1586 system::RawOrigin::Signed(1).into(),1587 1u32.encode(),1588 4,1589 None,1590 127,1591 call1592 ));1593 assert_ok!(Scheduler::schedule(1594 system::RawOrigin::Signed(1).into(),1595 4,1596 None,1597 127,1598 call21599 ));1600 run_to_block(3);1601 // Scheduled calls are in the agenda.1602 assert_eq!(Agenda::<Test>::get(4).len(), 2);1603 assert!(logger::log().is_empty());1604 assert_noop!(1605 Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()),1606 BadOrigin1607 );1608 assert_noop!(1609 Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1),1610 BadOrigin1611 );1612 assert_noop!(1613 Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()),1614 BadOrigin1615 );1616 assert_noop!(1617 Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1),1618 BadOrigin1619 );1620 run_to_block(5);1621 assert_eq!(1622 logger::log(),1623 vec![1624 (system::RawOrigin::Signed(1).into(), 69u32),1625 (system::RawOrigin::Signed(1).into(), 42u32)1626 ]1627 );1628 });1629 }16301631 #[test]1632 fn migration_to_v2_works() {1633 new_test_ext().execute_with(|| {1634 for i in 0..3u64 {1635 let k = i.twox_64_concat();1636 let old = vec![1637 Some(ScheduledV1 {1638 maybe_id: None,1639 priority: i as u8 + 10,1640 call: Call::Logger(logger::Call::log(96, 100)),1641 maybe_periodic: None,1642 }),1643 None,1644 Some(ScheduledV1 {1645 maybe_id: Some(b"test".to_vec()),1646 priority: 123,1647 call: Call::Logger(logger::Call::log(69, 1000)),1648 maybe_periodic: Some((456u64, 10)),1649 }),1650 ];1651 frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);1652 }16531654 assert_eq!(StorageVersion::get(), Releases::V1);16551656 assert!(Scheduler::migrate_v1_to_t2());16571658 assert_eq_uvec!(1659 Agenda::<Test>::iter().collect::<Vec<_>>(),1660 vec![1661 (1662 0,1663 vec![1664 Some(ScheduledV2 {1665 maybe_id: None,1666 priority: 10,1667 call: Call::Logger(logger::Call::log(96, 100)),1668 maybe_periodic: None,1669 origin: root(),1670 _phantom: PhantomData::<u64>::default(),1671 }),1672 None,1673 Some(ScheduledV2 {1674 maybe_id: Some(b"test".to_vec()),1675 priority: 123,1676 call: Call::Logger(logger::Call::log(69, 1000)),1677 maybe_periodic: Some((456u64, 10)),1678 origin: root(),1679 _phantom: PhantomData::<u64>::default(),1680 }),1681 ]1682 ),1683 (1684 1,1685 vec![1686 Some(ScheduledV2 {1687 maybe_id: None,1688 priority: 11,1689 call: Call::Logger(logger::Call::log(96, 100)),1690 maybe_periodic: None,1691 origin: root(),1692 _phantom: PhantomData::<u64>::default(),1693 }),1694 None,1695 Some(ScheduledV2 {1696 maybe_id: Some(b"test".to_vec()),1697 priority: 123,1698 call: Call::Logger(logger::Call::log(69, 1000)),1699 maybe_periodic: Some((456u64, 10)),1700 origin: root(),1701 _phantom: PhantomData::<u64>::default(),1702 }),1703 ]1704 ),1705 (1706 2,1707 vec![1708 Some(ScheduledV2 {1709 maybe_id: None,1710 priority: 12,1711 call: Call::Logger(logger::Call::log(96, 100)),1712 maybe_periodic: None,1713 origin: root(),1714 _phantom: PhantomData::<u64>::default(),1715 }),1716 None,1717 Some(ScheduledV2 {1718 maybe_id: Some(b"test".to_vec()),1719 priority: 123,1720 call: Call::Logger(logger::Call::log(69, 1000)),1721 maybe_periodic: Some((456u64, 10)),1722 origin: root(),1723 _phantom: PhantomData::<u64>::default(),1724 }),1725 ]1726 )1727 ]1728 );17291730 assert_eq!(StorageVersion::get(), Releases::V2);1731 });1732 }17331734 #[test]1735 fn test_migrate_origin() {1736 new_test_ext().execute_with(|| {1737 for i in 0..3u64 {1738 let k = i.twox_64_concat();1739 let old: Vec<Option<Scheduled<_, _, u32, u64>>> = vec![1740 Some(Scheduled {1741 maybe_id: None,1742 priority: i as u8 + 10,1743 call: Call::Logger(logger::Call::log(96, 100)),1744 origin: 3u32,1745 maybe_periodic: None,1746 _phantom: Default::default(),1747 }),1748 None,1749 Some(Scheduled {1750 maybe_id: Some(b"test".to_vec()),1751 priority: 123,1752 origin: 2u32,1753 call: Call::Logger(logger::Call::log(69, 1000)),1754 maybe_periodic: Some((456u64, 10)),1755 _phantom: Default::default(),1756 }),1757 ];1758 frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);1759 }17601761 impl From<u32> for OriginCaller {1762 fn from(value: u32) -> Self {1763 match value {1764 3 => system::RawOrigin::Root.into(),1765 2 => system::RawOrigin::None.into(),1766 _ => unimplemented!(),1767 }1768 }1769 }17701771 Scheduler::migrate_origin::<u32>();17721773 assert_eq_uvec!(1774 Agenda::<Test>::iter().collect::<Vec<_>>(),1775 vec![1776 (1777 0,1778 vec![1779 Some(ScheduledV2::<_, _, OriginCaller, u64> {1780 maybe_id: None,1781 priority: 10,1782 call: Call::Logger(logger::Call::log(96, 100)),1783 maybe_periodic: None,1784 origin: system::RawOrigin::Root.into(),1785 _phantom: PhantomData::<u64>::default(),1786 }),1787 None,1788 Some(ScheduledV2 {1789 maybe_id: Some(b"test".to_vec()),1790 priority: 123,1791 call: Call::Logger(logger::Call::log(69, 1000)),1792 maybe_periodic: Some((456u64, 10)),1793 origin: system::RawOrigin::None.into(),1794 _phantom: PhantomData::<u64>::default(),1795 }),1796 ]1797 ),1798 (1799 1,1800 vec![1801 Some(ScheduledV2 {1802 maybe_id: None,1803 priority: 11,1804 call: Call::Logger(logger::Call::log(96, 100)),1805 maybe_periodic: None,1806 origin: system::RawOrigin::Root.into(),1807 _phantom: PhantomData::<u64>::default(),1808 }),1809 None,1810 Some(ScheduledV2 {1811 maybe_id: Some(b"test".to_vec()),1812 priority: 123,1813 call: Call::Logger(logger::Call::log(69, 1000)),1814 maybe_periodic: Some((456u64, 10)),1815 origin: system::RawOrigin::None.into(),1816 _phantom: PhantomData::<u64>::default(),1817 }),1818 ]1819 ),1820 (1821 2,1822 vec![1823 Some(ScheduledV2 {1824 maybe_id: None,1825 priority: 12,1826 call: Call::Logger(logger::Call::log(96, 100)),1827 maybe_periodic: None,1828 origin: system::RawOrigin::Root.into(),1829 _phantom: PhantomData::<u64>::default(),1830 }),1831 None,1832 Some(ScheduledV2 {1833 maybe_id: Some(b"test".to_vec()),1834 priority: 123,1835 call: Call::Logger(logger::Call::log(69, 1000)),1836 maybe_periodic: Some((456u64, 10)),1837 origin: system::RawOrigin::None.into(),1838 _phantom: PhantomData::<u64>::default(),1839 }),1840 ]1841 )1842 ]1843 );1844 });1845 }1846}950}1847951primitives/nft/src/lib.rsdiffbeforeafterboth144 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions144 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions145 pub variable_on_chain_schema: Vec<u8>, //145 pub variable_on_chain_schema: Vec<u8>, //146 pub const_on_chain_schema: Vec<u8>, //146 pub const_on_chain_schema: Vec<u8>, //147 pub transfers_enabled: bool,147}148}148149149#[derive(Encode, Decode, Debug, Clone, PartialEq)]150#[derive(Encode, Decode, Debug, Clone, PartialEq)]