fix more test

pallets/automation-time/src/tests.rs

@@ -920,11 +920,14 @@ fn trigger_tasks_handles_missed_slots() {
 #[test]
 fn trigger_tasks_limits_missed_slots() {
 	new_test_ext(START_BLOCK_TIME).execute_with(|| {
+        let call: <Test as frame_system::Config>::RuntimeCall = frame_system::Call::remark_with_event { remark: vec![50], }.into();
+
 		let missing_task_id0 = add_task_to_task_queue(
 			ALICE,
 			vec![40],
 			vec![SCHEDULED_TIME],
-			Action::Notify { message: vec![40] },
+			//Action::Notify { message: vec![40] },
+            Action::DynamicDispatch { encoded_call: call.encode() },
 		);
 		assert_eq!(AutomationTime::get_missed_queue().len(), 0);
 		Timestamp::set_timestamp((SCHEDULED_TIME - 25200) * 1_000);
@@ -943,6 +946,11 @@ fn trigger_tasks_limits_missed_slots() {
 		LastTimeSlot::<Test>::put((SCHEDULED_TIME - 25200, SCHEDULED_TIME - 25200));
 		System::reset_events();
 
+
+        // this is same call we mock in create_event_tasks
+		//AutomationTime::trigger_tasks(Weight::from_ref_time(200_000 + call.get_dispatch_info().weight.ref_time() as u128));
+        // the 200_000_000 number make it big enough so we attempt to run those tasks to generate
+        // missing event for test
 		AutomationTime::trigger_tasks(Weight::from_ref_time(200_000));
 
 		if let Some((updated_last_time_slot, updated_last_missed_slot)) =
@@ -953,7 +961,12 @@ fn trigger_tasks_limits_missed_slots() {
 			assert_eq!(
 				events(),
 				[
-					RuntimeEvent::AutomationTime(crate::Event::Notify { message: vec![50] }),
+					//RuntimeEvent::AutomationTime(crate::Event::Notify { message: vec![50] }),
+                    RuntimeEvent::System(frame_system::pallet::Event::Remarked {
+                        sender: AccountId32::new(ALICE),
+                        hash: BlakeTwo256::hash(&vec![50]),
+                    }),
+
 					RuntimeEvent::AutomationTime(crate::Event::TaskMissed {
 						who: AccountId32::new(ALICE),
 						task_id: missing_task_id0,

pallets/automation-time/src/types.rs

@@ -223,6 +223,8 @@ impl<AccountId: Ord, Balance: Ord, CurrencyId: Ord> PartialEq
 
 impl<AccountId: Ord, Balance: Ord, CurrencyId: Ord> Eq for Task<AccountId, Balance, CurrencyId> {}
 
+use sp_runtime::print;
+
 impl<AccountId: Clone, Balance, CurrencyId> Task<AccountId, Balance, CurrencyId> {
 	pub fn new(
 		owner_id: AccountId,
@@ -241,7 +243,6 @@ impl<AccountId: Clone, Balance, CurrencyId> Task<AccountId, Balance, CurrencyId>
 	) -> Result<Self, DispatchError> {
         let call: <T as frame_system::Config>::RuntimeCall = frame_system::Call::remark_with_event { remark: message }.into();
         let action = Action::DynamicDispatch { encoded_call: call.encode() };
-
 		let schedule = Schedule::new_fixed_schedule::<T>(execution_times)?;
 		Ok(Self::new(owner_id, provided_id, schedule, action))
 	}
@@ -354,8 +355,6 @@ impl<AccountId, TaskId> ScheduledTasks<AccountId, TaskId> {
 		AccountId: Clone,
 	{
 		let action_weight = task.action.execution_weight::<T>()?;
-
-
 		let weight =
 			self.weight.checked_add(action_weight as u128).ok_or(Error::<T>::TimeSlotFull)?;
 		// A hard limit on tasks/slot prevents unforseen performance consequences
@@ -449,8 +448,13 @@ mod tests {
 				scheduled_tasks
 					.try_push::<Test, BalanceOf<Test>>(task_id, &task)
 					.expect("slot is not full");
+
 				assert_eq!(scheduled_tasks.tasks, vec![(task.owner_id, task_id)]);
-				assert_eq!(scheduled_tasks.weight, 20_000);
+
+                // this is same call we mock in create_event_tasks
+                let call: <Test as frame_system::Config>::RuntimeCall = frame_system::Call::remark_with_event { remark: vec![0] }.into();
+                // weight will be equal = weight of the dynamic dispatch + the call itself
+				assert_eq!(scheduled_tasks.weight, 20_000 + call.get_dispatch_info().weight.ref_time() as u128);
 			})
 		}
 	}