Make CI happy again

Author: snawaz

magicblock-committor-service/src/tasks/mod.rs

@@ -119,7 +119,9 @@ pub struct CommitTask {
 impl CommitTask {
     // Accounts larger than COMMIT_STATE_SIZE_THRESHOLD, use CommitDiff to
     // reduce instruction size. Below this, commit is sent as CommitState.
-    const COMMIT_STATE_SIZE_THRESHOLD: usize = 200;
+    // Chose 256 as thresold seems good enough as it could hold 8 u32 fields
+    // or 4 u64 fields.
+    const COMMIT_STATE_SIZE_THRESHOLD: usize = 256;
 
     pub async fn new(
         commit_id: u64,
@@ -416,25 +418,29 @@ mod serialization_safety_test {
     };
 
     // Test all ArgsTask variants
-    #[test]
-    fn test_args_task_instruction_serialization() {
+    #[tokio::test]
+    async fn test_args_task_instruction_serialization() {
         let validator = Pubkey::new_unique();
 
         // Test Commit variant
-        let commit_task: ArgsTask = ArgsTaskType::Commit(CommitTask::new(
-            123,
-            true,
-            CommittedAccount {
-                pubkey: Pubkey::new_unique(),
-                account: Account {
-                    lamports: 1000,
-                    data: vec![1, 2, 3],
-                    owner: Pubkey::new_unique(),
-                    executable: false,
-                    rent_epoch: 0,
+        let commit_task: ArgsTask = ArgsTaskType::Commit(
+            CommitTask::new(
+                123,
+                true,
+                CommittedAccount {
+                    pubkey: Pubkey::new_unique(),
+                    account: Account {
+                        lamports: 1000,
+                        data: vec![1, 2, 3],
+                        owner: Pubkey::new_unique(),
+                        executable: false,
+                        rent_epoch: 0,
+                    },
                 },
-            },
-        ))
+                AccountFetcher::new(),
+            )
+            .await,
+        )
         .into();
         assert_serializable(&commit_task.instruction(&validator));
 

magicblock-committor-service/src/tasks/task_strategist.rs

@@ -250,6 +250,7 @@ pub type TaskStrategistResult<T, E = TaskStrategistError> = Result<T, E>;
 
 #[cfg(test)]
 mod tests {
+    use futures_util::future::join_all;
     use magicblock_program::magic_scheduled_base_intent::{
         BaseAction, CommittedAccount, ProgramArgs,
     };
@@ -259,25 +260,35 @@ mod tests {
     use super::*;
     use crate::{
         persist::IntentPersisterImpl,
-        tasks::{BaseActionTask, CommitTask, TaskStrategy, UndelegateTask},
+        tasks::{
+            AccountFetcher, BaseActionTask, CommitTask, TaskStrategy,
+            UndelegateTask,
+        },
     };
 
     // Helper to create a simple commit task
-    fn create_test_commit_task(commit_id: u64, data_size: usize) -> ArgsTask {
-        ArgsTask::new(ArgsTaskType::Commit(CommitTask::new(
-            commit_id,
-            false,
-            CommittedAccount {
-                pubkey: Pubkey::new_unique(),
-                account: Account {
-                    lamports: 1000,
-                    data: vec![1; data_size],
-                    owner: system_program::id(),
-                    executable: false,
-                    rent_epoch: 0,
+    async fn create_test_commit_task(
+        commit_id: u64,
+        data_size: usize,
+    ) -> ArgsTask {
+        ArgsTask::new(ArgsTaskType::Commit(
+            CommitTask::new(
+                commit_id,
+                false,
+                CommittedAccount {
+                    pubkey: Pubkey::new_unique(),
+                    account: Account {
+                        lamports: 1000,
+                        data: vec![1; data_size],
+                        owner: system_program::id(),
+                        executable: false,
+                        rent_epoch: 0,
+                    },
                 },
-            },
-        )))
+                AccountFetcher::new(),
+            )
+            .await,
+        ))
     }
 
     // Helper to create a Base action task
@@ -312,10 +323,10 @@ mod tests {
         }))
     }
 
-    #[test]
-    fn test_build_strategy_with_single_small_task() {
+    #[tokio::test]
+    async fn test_build_strategy_with_single_small_task() {
         let validator = Pubkey::new_unique();
-        let task = create_test_commit_task(1, 100);
+        let task = create_test_commit_task(1, 100).await;
         let tasks = vec![Box::new(task) as Box<dyn BaseTask>];
 
         let strategy = TaskStrategist::build_strategy(
@@ -329,11 +340,11 @@ mod tests {
         assert!(strategy.lookup_tables_keys.is_empty());
     }
 
-    #[test]
-    fn test_build_strategy_optimizes_to_buffer_when_needed() {
+    #[tokio::test]
+    async fn test_build_strategy_optimizes_to_buffer_when_needed() {
         let validator = Pubkey::new_unique();
 
-        let task = create_test_commit_task(1, 1000); // Large task
+        let task = create_test_commit_task(1, 1000).await; // Large task
         let tasks = vec![Box::new(task) as Box<dyn BaseTask>];
 
         let strategy = TaskStrategist::build_strategy(
@@ -350,11 +361,11 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn test_build_strategy_optimizes_to_buffer_u16_exceeded() {
+    #[tokio::test]
+    async fn test_build_strategy_optimizes_to_buffer_u16_exceeded() {
         let validator = Pubkey::new_unique();
 
-        let task = create_test_commit_task(1, 66_000); // Large task
+        let task = create_test_commit_task(1, 66_000).await; // Large task
         let tasks = vec![Box::new(task) as Box<dyn BaseTask>];
 
         let strategy = TaskStrategist::build_strategy(
@@ -371,19 +382,18 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn test_build_strategy_creates_multiple_buffers() {
+    #[tokio::test]
+    async fn test_build_strategy_creates_multiple_buffers() {
         // TODO: ALSO MAX NUM WITH PURE BUFFER commits, no alts
         const NUM_COMMITS: u64 = 3;
 
         let validator = Pubkey::new_unique();
 
-        let tasks = (0..NUM_COMMITS)
-            .map(|i| {
-                let task = create_test_commit_task(i, 500); // Large task
-                Box::new(task) as Box<dyn BaseTask>
-            })
-            .collect();
+        let tasks = join_all((0..NUM_COMMITS).map(|i| async move {
+            let task = create_test_commit_task(i, 500).await; // Large task
+            Box::new(task) as Box<dyn BaseTask>
+        }))
+        .await;
 
         let strategy = TaskStrategist::build_strategy(
             tasks,
@@ -398,20 +408,19 @@ mod tests {
         assert!(strategy.lookup_tables_keys.is_empty());
     }
 
-    #[test]
-    fn test_build_strategy_with_lookup_tables_when_needed() {
+    #[tokio::test]
+    async fn test_build_strategy_with_lookup_tables_when_needed() {
         // Also max number of committed accounts fit with ALTs!
         const NUM_COMMITS: u64 = 22;
 
         let validator = Pubkey::new_unique();
 
-        let tasks = (0..NUM_COMMITS)
-            .map(|i| {
-                // Large task
-                let task = create_test_commit_task(i, 10000);
-                Box::new(task) as Box<dyn BaseTask>
-            })
-            .collect();
+        let tasks = join_all((0..NUM_COMMITS).map(|i| async move {
+            // Large task
+            let task = create_test_commit_task(i, 10000).await;
+            Box::new(task) as Box<dyn BaseTask>
+        }))
+        .await;
 
         let strategy = TaskStrategist::build_strategy(
             tasks,
@@ -426,19 +435,18 @@ mod tests {
         assert!(!strategy.lookup_tables_keys.is_empty());
     }
 
-    #[test]
-    fn test_build_strategy_fails_when_cant_fit() {
+    #[tokio::test]
+    async fn test_build_strategy_fails_when_cant_fit() {
         const NUM_COMMITS: u64 = 23;
 
         let validator = Pubkey::new_unique();
 
-        let tasks = (0..NUM_COMMITS)
-            .map(|i| {
-                // Large task
-                let task = create_test_commit_task(i, 1000);
-                Box::new(task) as Box<dyn BaseTask>
-            })
-            .collect();
+        let tasks = join_all((0..NUM_COMMITS).map(|i| async move {
+            // Large task
+            let task = create_test_commit_task(i, 1000).await;
+            Box::new(task) as Box<dyn BaseTask>
+        }))
+        .await;
 
         let result = TaskStrategist::build_strategy(
             tasks,
@@ -448,12 +456,15 @@ mod tests {
         assert!(matches!(result, Err(TaskStrategistError::FailedToFitError)));
     }
 
-    #[test]
-    fn test_optimize_strategy_prioritizes_largest_tasks() {
+    #[tokio::test]
+    async fn test_optimize_strategy_prioritizes_largest_tasks() {
         let mut tasks = [
-            Box::new(create_test_commit_task(1, 100)) as Box<dyn BaseTask>,
-            Box::new(create_test_commit_task(2, 1000)) as Box<dyn BaseTask>, // Larger task
-            Box::new(create_test_commit_task(3, 1000)) as Box<dyn BaseTask>, // Larger task
+            Box::new(create_test_commit_task(1, 100).await)
+                as Box<dyn BaseTask>,
+            Box::new(create_test_commit_task(2, 1000).await)
+                as Box<dyn BaseTask>, // Larger task
+            Box::new(create_test_commit_task(3, 1000).await)
+                as Box<dyn BaseTask>, // Larger task
         ];
 
         let _ = TaskStrategist::optimize_strategy(&mut tasks);
@@ -462,11 +473,12 @@ mod tests {
         assert!(matches!(tasks[1].strategy(), TaskStrategy::Buffer));
     }
 
-    #[test]
-    fn test_mixed_task_types_with_optimization() {
+    #[tokio::test]
+    async fn test_mixed_task_types_with_optimization() {
         let validator = Pubkey::new_unique();
         let tasks = vec![
-            Box::new(create_test_commit_task(1, 1000)) as Box<dyn BaseTask>,
+            Box::new(create_test_commit_task(1, 1000).await)
+                as Box<dyn BaseTask>,
             Box::new(create_test_finalize_task()) as Box<dyn BaseTask>,
             Box::new(create_test_base_action_task(500)) as Box<dyn BaseTask>,
             Box::new(create_test_undelegate_task()) as Box<dyn BaseTask>,