Preimage registrar and Scheduler integration (#10356)

* initial idea * more * fix compile * add clear and request logic * improve some docs * Add and implement trait * continuing to improve * refcount type * infallible system preimage upload * fmt * fix requests * Make it simple * Make it simple * Formatting * Initial draft * request when scheduled * Docs * Scheduler good * Scheduler good * Scheduler tests working * Add new files * Missing stuff * Repotting, add weights. * Add some tests to preimage pallet * More tests * Fix benchmarks * preimage benchmarks * All preimage benchmarks * Tidy cargo * Update weights.rs * Allow hash provision in benchmarks * Initial work on new benchmarks for Scheduler * Tests working, refactor looks good * Tests for new Scheduler functionality * Use real weight, make tests work with runtimes without Preimage * Rename * Update benchmarks * Formatting * Formatting * Fix weird formatting * Update frame/preimage/src/lib.rs * Fix try-runtime build * Fixes * Fixes * Update frame/support/src/traits/tokens/currency.rs Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> * Update frame/support/src/traits/tokens/currency/reservable.rs Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> * Update frame/support/src/traits/tokens/imbalance.rs Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> * Update frame/preimage/src/mock.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Update frame/scheduler/src/lib.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Update frame/preimage/src/lib.rs * Fixes * Fixes * Formatting * Fixes * Fixes * cargo run --quiet --release --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark --chain=dev --steps=50 --repeat=20 --pallet=pallet_scheduler --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/scheduler/src/weights.rs --template=./.maintain/frame-weight-template.hbs * cargo run --quiet --release --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark --chain=dev --steps=50 --repeat=20 --pallet=pallet_preimage --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/preimage/src/weights.rs --template=./.maintain/frame-weight-template.hbs Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com> Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> Co-authored-by: Parity Bot <admin@parity.io>
2026-04-26 20:27:58 +00:00 · 2021-12-11 15:55:23 +01:00
parent f6f58f95e1
commit 5e50e0bc2c
24 changed files with 3592 additions and 1287 deletions
@@ -0,0 +1,901 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # Scheduler tests.
+
+use super::*;
+use crate::mock::{logger, new_test_ext, root, run_to_block, Call, LoggerCall, Scheduler, Test, *};
+use frame_support::{
+	assert_err, assert_noop, assert_ok,
+	traits::{Contains, OnInitialize, PreimageProvider},
+	Hashable,
+};
+use sp_runtime::traits::Hash;
+use substrate_test_utils::assert_eq_uvec;
+
+#[test]
+fn basic_scheduling_works() {
+	new_test_ext().execute_with(|| {
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.into()));
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn scheduling_with_preimages_works() {
+	new_test_ext().execute_with(|| {
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
+		let hashed = MaybeHashed::Hash(hash.clone());
+		assert_ok!(Preimage::note_preimage(Origin::signed(0), call.encode()));
+		assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), hashed));
+		assert!(Preimage::preimage_requested(&hash));
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		run_to_block(4);
+		assert!(!Preimage::have_preimage(&hash));
+		assert!(!Preimage::preimage_requested(&hash));
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn scheduling_with_preimage_postpones_correctly() {
+	new_test_ext().execute_with(|| {
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
+		let hashed = MaybeHashed::Hash(hash.clone());
+
+		assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), hashed));
+		assert!(Preimage::preimage_requested(&hash));
+
+		run_to_block(4);
+		// #4 empty due to no preimage
+		assert!(logger::log().is_empty());
+
+		// Register preimage.
+		assert_ok!(Preimage::note_preimage(Origin::signed(0), call.encode()));
+
+		run_to_block(5);
+		// #5 empty since postponement is 2 blocks.
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		// #6 is good.
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		assert!(!Preimage::have_preimage(&hash));
+		assert!(!Preimage::preimage_requested(&hash));
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn schedule_after_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(2);
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6
+		assert_ok!(Scheduler::do_schedule(DispatchTime::After(3), None, 127, root(), call.into()));
+		run_to_block(5);
+		assert!(logger::log().is_empty());
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn schedule_after_zero_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(2);
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_ok!(Scheduler::do_schedule(DispatchTime::After(0), None, 127, root(), call.into()));
+		// Will trigger on the next block.
+		run_to_block(3);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn periodic_scheduling_works() {
+	new_test_ext().execute_with(|| {
+		// at #4, every 3 blocks, 3 times.
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			Some((3, 3)),
+			127,
+			root(),
+			Call::Logger(logger::Call::log { i: 42, weight: 1000 }).into()
+		));
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(7);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
+		run_to_block(9);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
+		run_to_block(10);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn reschedule_works() {
+	new_test_ext().execute_with(|| {
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_eq!(
+			Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call.into()).unwrap(),
+			(4, 0)
+		);
+
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		assert_eq!(Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(), (6, 0));
+
+		assert_noop!(
+			Scheduler::do_reschedule((6, 0), DispatchTime::At(6)),
+			Error::<Test>::RescheduleNoChange
+		);
+
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn reschedule_named_works() {
+	new_test_ext().execute_with(|| {
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_eq!(
+			Scheduler::do_schedule_named(
+				1u32.encode(),
+				DispatchTime::At(4),
+				None,
+				127,
+				root(),
+				call.into(),
+			)
+			.unwrap(),
+			(4, 0)
+		);
+
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		assert_eq!(
+			Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(),
+			(6, 0)
+		);
+
+		assert_noop!(
+			Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)),
+			Error::<Test>::RescheduleNoChange
+		);
+
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn reschedule_named_perodic_works() {
+	new_test_ext().execute_with(|| {
+		let call = Call::Logger(LoggerCall::log { i: 42, weight: 1000 });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_eq!(
+			Scheduler::do_schedule_named(
+				1u32.encode(),
+				DispatchTime::At(4),
+				Some((3, 3)),
+				127,
+				root(),
+				call.into(),
+			)
+			.unwrap(),
+			(4, 0)
+		);
+
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		assert_eq!(
+			Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(5)).unwrap(),
+			(5, 0)
+		);
+		assert_eq!(
+			Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(),
+			(6, 0)
+		);
+
+		run_to_block(5);
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		assert_eq!(
+			Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(10)).unwrap(),
+			(10, 0)
+		);
+
+		run_to_block(9);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(10);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
+
+		run_to_block(13);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn cancel_named_scheduling_works_with_normal_cancel() {
+	new_test_ext().execute_with(|| {
+		// at #4.
+		Scheduler::do_schedule_named(
+			1u32.encode(),
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+		)
+		.unwrap();
+		let i = Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into(),
+		)
+		.unwrap();
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));
+		assert_ok!(Scheduler::do_cancel(None, i));
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+	});
+}
+
+#[test]
+fn cancel_named_periodic_scheduling_works() {
+	new_test_ext().execute_with(|| {
+		// at #4, every 3 blocks, 3 times.
+		Scheduler::do_schedule_named(
+			1u32.encode(),
+			DispatchTime::At(4),
+			Some((3, 3)),
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into(),
+		)
+		.unwrap();
+		// same id results in error.
+		assert!(Scheduler::do_schedule_named(
+			1u32.encode(),
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+		)
+		.is_err());
+		// different id is ok.
+		Scheduler::do_schedule_named(
+			2u32.encode(),
+			DispatchTime::At(8),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+		)
+		.unwrap();
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(6);
+		assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
+	});
+}
+
+#[test]
+fn scheduler_respects_weight_limits() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: MaximumSchedulerWeight::get() / 2 })
+				.into(),
+		));
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: MaximumSchedulerWeight::get() / 2 })
+				.into(),
+		));
+		// 69 and 42 do not fit together
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(5);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
+	});
+}
+
+#[test]
+fn scheduler_respects_hard_deadlines_more() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			0,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: MaximumSchedulerWeight::get() / 2 })
+				.into(),
+		));
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			0,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: MaximumSchedulerWeight::get() / 2 })
+				.into(),
+		));
+		// With base weights, 69 and 42 should not fit together, but do because of hard
+		// deadlines
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
+	});
+}
+
+#[test]
+fn scheduler_respects_priority_ordering() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			1,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: MaximumSchedulerWeight::get() / 2 })
+				.into(),
+		));
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			0,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: MaximumSchedulerWeight::get() / 2 })
+				.into(),
+		));
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn scheduler_respects_priority_ordering_with_soft_deadlines() {
+	new_test_ext().execute_with(|| {
+		let max_weight = MaximumSchedulerWeight::get() - <() as WeightInfo>::on_initialize(0);
+		let item_weight =
+			<() as WeightInfo>::on_initialize(1) - <() as WeightInfo>::on_initialize(0);
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			255,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: max_weight / 2 - item_weight }).into(),
+		));
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: max_weight / 2 - item_weight }).into(),
+		));
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			126,
+			root(),
+			Call::Logger(LoggerCall::log { i: 2600, weight: max_weight / 2 - item_weight + 1 })
+				.into(),
+		));
+
+		// 2600 does not fit with 69 or 42, but has higher priority, so will go through
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 2600u32)]);
+		// 69 and 42 fit together
+		run_to_block(5);
+		assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn on_initialize_weight_is_correct() {
+	new_test_ext().execute_with(|| {
+		let base_weight = <() as WeightInfo>::on_initialize(0);
+		let call_weight = MaximumSchedulerWeight::get() / 4;
+
+		// Named
+		assert_ok!(Scheduler::do_schedule_named(
+			1u32.encode(),
+			DispatchTime::At(3),
+			None,
+			255,
+			root(),
+			Call::Logger(LoggerCall::log { i: 3, weight: call_weight + 1 }).into(),
+		));
+		// Anon Periodic
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(2),
+			Some((1000, 3)),
+			128,
+			root(),
+			Call::Logger(LoggerCall::log { i: 42, weight: call_weight + 2 }).into(),
+		));
+		// Anon
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(2),
+			None,
+			127,
+			root(),
+			Call::Logger(LoggerCall::log { i: 69, weight: call_weight + 3 }).into(),
+		));
+		// Named Periodic
+		assert_ok!(Scheduler::do_schedule_named(
+			2u32.encode(),
+			DispatchTime::At(1),
+			Some((1000, 3)),
+			126,
+			root(),
+			Call::Logger(LoggerCall::log { i: 2600, weight: call_weight + 4 }).into(),
+		));
+
+		// Will include the named periodic only
+		let actual_weight = Scheduler::on_initialize(1);
+		assert_eq!(
+			actual_weight,
+			base_weight +
+				call_weight + 4 + <() as MarginalWeightInfo>::item(true, true, Some(false))
+		);
+		assert_eq!(logger::log(), vec![(root(), 2600u32)]);
+
+		// Will include anon and anon periodic
+		let actual_weight = Scheduler::on_initialize(2);
+		assert_eq!(
+			actual_weight,
+			base_weight +
+				call_weight + 2 + <() as MarginalWeightInfo>::item(false, false, Some(false)) +
+				call_weight + 3 + <() as MarginalWeightInfo>::item(true, false, Some(false))
+		);
+		assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);
+
+		// Will include named only
+		let actual_weight = Scheduler::on_initialize(3);
+		assert_eq!(
+			actual_weight,
+			base_weight +
+				call_weight + 1 + <() as MarginalWeightInfo>::item(false, true, Some(false))
+		);
+		assert_eq!(
+			logger::log(),
+			vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32), (root(), 3u32)]
+		);
+
+		// Will contain none
+		let actual_weight = Scheduler::on_initialize(4);
+		assert_eq!(actual_weight, base_weight);
+	});
+}
+
+#[test]
+fn root_calls_works() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into());
+		let call2 = Box::new(Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into());
+		assert_ok!(Scheduler::schedule_named(Origin::root(), 1u32.encode(), 4, None, 127, call,));
+		assert_ok!(Scheduler::schedule(Origin::root(), 4, None, 127, call2));
+		run_to_block(3);
+		// Scheduled calls are in the agenda.
+		assert_eq!(Agenda::<Test>::get(4).len(), 2);
+		assert!(logger::log().is_empty());
+		assert_ok!(Scheduler::cancel_named(Origin::root(), 1u32.encode()));
+		assert_ok!(Scheduler::cancel(Origin::root(), 4, 1));
+		// Scheduled calls are made NONE, so should not effect state
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+	});
+}
+
+#[test]
+fn fails_to_schedule_task_in_the_past() {
+	new_test_ext().execute_with(|| {
+		run_to_block(3);
+
+		let call1 = Box::new(Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into());
+		let call2 = Box::new(Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into());
+		let call3 = Box::new(Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into());
+
+		assert_err!(
+			Scheduler::schedule_named(Origin::root(), 1u32.encode(), 2, None, 127, call1),
+			Error::<Test>::TargetBlockNumberInPast,
+		);
+
+		assert_err!(
+			Scheduler::schedule(Origin::root(), 2, None, 127, call2),
+			Error::<Test>::TargetBlockNumberInPast,
+		);
+
+		assert_err!(
+			Scheduler::schedule(Origin::root(), 3, None, 127, call3),
+			Error::<Test>::TargetBlockNumberInPast,
+		);
+	});
+}
+
+#[test]
+fn should_use_orign() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into());
+		let call2 = Box::new(Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into());
+		assert_ok!(Scheduler::schedule_named(
+			system::RawOrigin::Signed(1).into(),
+			1u32.encode(),
+			4,
+			None,
+			127,
+			call,
+		));
+		assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2,));
+		run_to_block(3);
+		// Scheduled calls are in the agenda.
+		assert_eq!(Agenda::<Test>::get(4).len(), 2);
+		assert!(logger::log().is_empty());
+		assert_ok!(Scheduler::cancel_named(system::RawOrigin::Signed(1).into(), 1u32.encode()));
+		assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));
+		// Scheduled calls are made NONE, so should not effect state
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+	});
+}
+
+#[test]
+fn should_check_orign() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into());
+		let call2 = Box::new(Call::Logger(LoggerCall::log { i: 42, weight: 1000 }).into());
+		assert_noop!(
+			Scheduler::schedule_named(
+				system::RawOrigin::Signed(2).into(),
+				1u32.encode(),
+				4,
+				None,
+				127,
+				call
+			),
+			BadOrigin
+		);
+		assert_noop!(
+			Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2),
+			BadOrigin
+		);
+	});
+}
+
+#[test]
+fn should_check_orign_for_cancel() {
+	new_test_ext().execute_with(|| {
+		let call =
+			Box::new(Call::Logger(LoggerCall::log_without_filter { i: 69, weight: 1000 }).into());
+		let call2 =
+			Box::new(Call::Logger(LoggerCall::log_without_filter { i: 42, weight: 1000 }).into());
+		assert_ok!(Scheduler::schedule_named(
+			system::RawOrigin::Signed(1).into(),
+			1u32.encode(),
+			4,
+			None,
+			127,
+			call,
+		));
+		assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2,));
+		run_to_block(3);
+		// Scheduled calls are in the agenda.
+		assert_eq!(Agenda::<Test>::get(4).len(), 2);
+		assert!(logger::log().is_empty());
+		assert_noop!(
+			Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()),
+			BadOrigin
+		);
+		assert_noop!(Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1), BadOrigin);
+		assert_noop!(
+			Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()),
+			BadOrigin
+		);
+		assert_noop!(Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1), BadOrigin);
+		run_to_block(5);
+		assert_eq!(
+			logger::log(),
+			vec![
+				(system::RawOrigin::Signed(1).into(), 69u32),
+				(system::RawOrigin::Signed(1).into(), 42u32)
+			]
+		);
+	});
+}
+
+#[test]
+fn migration_to_v3_works() {
+	new_test_ext().execute_with(|| {
+		for i in 0..3u64 {
+			let k = i.twox_64_concat();
+			let old = vec![
+				Some(ScheduledV1 {
+					maybe_id: None,
+					priority: i as u8 + 10,
+					call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }),
+					maybe_periodic: None,
+				}),
+				None,
+				Some(ScheduledV1 {
+					maybe_id: Some(b"test".to_vec()),
+					priority: 123,
+					call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }),
+					maybe_periodic: Some((456u64, 10)),
+				}),
+			];
+			frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
+		}
+
+		assert_eq!(StorageVersion::<Test>::get(), Releases::V1);
+
+		assert!(Scheduler::migrate_v1_to_v3());
+
+		assert_eq_uvec!(
+			Agenda::<Test>::iter().collect::<Vec<_>>(),
+			vec![
+				(
+					0,
+					vec![
+						Some(ScheduledV3Of::<Test> {
+							maybe_id: None,
+							priority: 10,
+							call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+							maybe_periodic: None,
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledV3Of::<Test> {
+							maybe_id: Some(b"test".to_vec()),
+							priority: 123,
+							call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				),
+				(
+					1,
+					vec![
+						Some(ScheduledV3Of::<Test> {
+							maybe_id: None,
+							priority: 11,
+							call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+							maybe_periodic: None,
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledV3Of::<Test> {
+							maybe_id: Some(b"test".to_vec()),
+							priority: 123,
+							call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				),
+				(
+					2,
+					vec![
+						Some(ScheduledV3Of::<Test> {
+							maybe_id: None,
+							priority: 12,
+							call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+							maybe_periodic: None,
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledV3Of::<Test> {
+							maybe_id: Some(b"test".to_vec()),
+							priority: 123,
+							call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				)
+			]
+		);
+
+		assert_eq!(StorageVersion::<Test>::get(), Releases::V3);
+	});
+}
+
+#[test]
+fn test_migrate_origin() {
+	new_test_ext().execute_with(|| {
+		for i in 0..3u64 {
+			let k = i.twox_64_concat();
+			let old: Vec<Option<Scheduled<CallOrHashOf<Test>, u64, u32, u64>>> = vec![
+				Some(Scheduled {
+					maybe_id: None,
+					priority: i as u8 + 10,
+					call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+					origin: 3u32,
+					maybe_periodic: None,
+					_phantom: Default::default(),
+				}),
+				None,
+				Some(Scheduled {
+					maybe_id: Some(b"test".to_vec()),
+					priority: 123,
+					origin: 2u32,
+					call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+					maybe_periodic: Some((456u64, 10)),
+					_phantom: Default::default(),
+				}),
+			];
+			frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
+		}
+
+		impl Into<OriginCaller> for u32 {
+			fn into(self) -> OriginCaller {
+				match self {
+					3u32 => system::RawOrigin::Root.into(),
+					2u32 => system::RawOrigin::None.into(),
+					_ => unreachable!("test make no use of it"),
+				}
+			}
+		}
+
+		Scheduler::migrate_origin::<u32>();
+
+		assert_eq_uvec!(
+			Agenda::<Test>::iter().collect::<Vec<_>>(),
+			vec![
+				(
+					0,
+					vec![
+						Some(ScheduledV2::<CallOrHashOf<Test>, u64, OriginCaller, u64> {
+							maybe_id: None,
+							priority: 10,
+							call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+							maybe_periodic: None,
+							origin: system::RawOrigin::Root.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledV2 {
+							maybe_id: Some(b"test".to_vec()),
+							priority: 123,
+							call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: system::RawOrigin::None.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				),
+				(
+					1,
+					vec![
+						Some(ScheduledV2 {
+							maybe_id: None,
+							priority: 11,
+							call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+							maybe_periodic: None,
+							origin: system::RawOrigin::Root.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledV2 {
+							maybe_id: Some(b"test".to_vec()),
+							priority: 123,
+							call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: system::RawOrigin::None.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				),
+				(
+					2,
+					vec![
+						Some(ScheduledV2 {
+							maybe_id: None,
+							priority: 12,
+							call: Call::Logger(LoggerCall::log { i: 96, weight: 100 }).into(),
+							maybe_periodic: None,
+							origin: system::RawOrigin::Root.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledV2 {
+							maybe_id: Some(b"test".to_vec()),
+							priority: 123,
+							call: Call::Logger(LoggerCall::log { i: 69, weight: 1000 }).into(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: system::RawOrigin::None.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				)
+			]
+		);
+	});
+}