Refactor, Add tests

Author: Tackx

README.md

@@ -61,14 +61,14 @@ The built binary & installers will be created in `src-tauri/target/release`.
 
 ## TODO
 
-- LICENCE
 - Try building for MacOS via GHA pipeline provided by tauri
-- Mention in readme the location of `tasks.json`, `settings.json` and `alarm.mp3`
 - Calendar units for recurrence
 - GUI paging
 
 ## Future Releases
 
+- Update paging so that all generated instances are not held in memory and do not grow with each new page
+  - Only hold the current page and check if it's needed to regenerate upon every request for a page of tasks
 - MacOS release
   - Fix title bar (<https://v2.tauri.app/learn/window-customization/#creating-a-custom-titlebar>)
 - Clean up the app data directory when uninstalling (maybe make it optional with a checkbox?)

src-tauri/Cargo.lock

@@ -30,6 +30,9 @@ features = [
     "v4",
 ]
 
+[dev-dependencies]
+tempfile = "3.10"
+
 [profile.dev]
 incremental = true # Compile your binary in smaller steps.
 

src-tauri/Cargo.toml

@@ -39,12 +39,6 @@ fn setup_config(dir_path: &PathBuf) -> (PathBuf, Settings) {
     let task_path = dir_path.join(TASK_FILE_NAME);
     let settings_path = dir_path.join(SETTINGS_FILE_NAME);
 
-    // Path relative to the location of the executable
-    // let exe_dir = std::env::current_exe()
-    //     .unwrap()
-    //     .parent()
-    //     .unwrap()
-    //     .to_path_buf();
     let resources_dir = dir_path.join("resources");
 
     if !resources_dir.exists() {
@@ -110,10 +104,10 @@ pub fn update_settings(settings: Settings) -> Result<(), Box<dyn Error>> {
 pub fn init(data_dir_path: PathBuf) {
     let (data_path, settings) = setup_config(&data_dir_path);
 
-    CONFIG
-        .set(Mutex::new(Config {
+    CONFIG.get_or_init(|| {
+        Mutex::new(Config {
             data_path,
             settings,
-        }))
-        .expect("Config already initialized");
+        })
+    });
 }

src-tauri/src/config.rs

@@ -61,8 +61,8 @@ fn setup_tray(app: &mut App) {
                 }
             }
             _ => {
-                #[cfg(debug_assertions)]
-                println!("unhandled event {event:?}");
+                // #[cfg(debug_assertions)]
+                // println!("unhandled event {event:?}");
             }
         })
         .build(app)
@@ -179,7 +179,7 @@ pub fn run() {
                             if !next.0.window_spawned {
                                 #[cfg(debug_assertions)]
                                 println!("Reminding task!!!: {:?}", next.0.timestamp);
-                                
+
                                 window_counter += 1;
 
                                 next.0.window_spawned = true;

src-tauri/src/lib.rs

@@ -118,12 +118,12 @@ impl TaskReminder {
     /// Calculates task instances from definitions on demand.
     /// Generates enough instances to provide the requested page.
     ///
-    /// E.g., for page 0 with `PAGE_SIZE=30`, up to 30 instances are generated. For page 2 with the same `PAGE_SIZE`, up to 90 instances are returned.
+    /// E.g., for page 0 with `PAGE_SIZE=30`, up to 30 instances per definition are generated. For page 2 with the same `PAGE_SIZE`, up to 90 instances per definition are generated.
     pub fn generate_task_instances(&mut self, page: i32) {
         #[cfg(debug_assertions)]
         println!("Beginning to recalculate new instances");
-        
-        let definitions = self.task_definitions.clone();
+
+        let definitions = &self.task_definitions;
 
         // If any tasks already have a window spawned, the state must be kept and set accordingly on the new set of instances
         let mut window_spawned_map: HashMap<(Uuid, DateTime<Utc>), bool> = HashMap::new();
@@ -195,14 +195,17 @@ impl TaskReminder {
         });
 
         instances.sort_by_key(|i| i.timestamp);
-        instances.iter_mut().take(PAGE_SIZE as usize).for_each(|i| {
-            if window_spawned_map.contains_key(&(i.definition_id, i.timestamp)) {
-                i.window_spawned = *window_spawned_map
-                    .get(&(i.definition_id, i.timestamp))
-                    .unwrap_or(&false);
-            };
-            self.push_task_instance(i.clone());
-        });
+        instances
+            .iter_mut()
+            .take(instances_required as usize)
+            .for_each(|i| {
+                if window_spawned_map.contains_key(&(i.definition_id, i.timestamp)) {
+                    i.window_spawned = *window_spawned_map
+                        .get(&(i.definition_id, i.timestamp))
+                        .unwrap_or(&false);
+                };
+                self.push_task_instance(i.clone());
+            });
 
         self.calculated_instances = self.task_instances.len();
 
@@ -296,3 +299,193 @@ impl TaskReminder {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use super::*;
+    use chrono::TimeZone;
+    use tempfile::tempdir;
+
+    fn sample_task_definition() -> TaskDefinition {
+        TaskDefinition {
+            id: Uuid::new_v4(),
+            name: "Sample Task".to_string(),
+            desc: Some("Sample Description".to_string()),
+            start: Utc.with_ymd_and_hms(2025, 1, 1, 12, 0, 0).unwrap(),
+            recurrence: Some(Recurrence::Recurring {
+                last_recurrence: None,
+                minutes: 60,
+                exceptions: None,
+            }),
+        }
+    }
+
+    #[test]
+    fn test_push_and_get_task_definition() {
+        let mut reminder = TaskReminder {
+            task_definitions: vec![],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        let def = sample_task_definition();
+        let id = def.id;
+        reminder.push_task_definition(def.clone());
+
+        assert_eq!(
+            reminder.get_task_definition(id).unwrap().name,
+            "Sample Task"
+        );
+    }
+
+    #[test]
+    fn test_generate_single_instance() {
+        let mut reminder = TaskReminder {
+            task_definitions: vec![sample_task_definition()],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        reminder.generate_task_instances(0);
+        let tasks = reminder.get_tasks(0);
+
+        assert!(!tasks.is_empty());
+        assert_eq!(tasks[0].name, "Sample Task");
+    }
+
+    #[test]
+    fn test_mark_task_completed_updates_last_recurrence() {
+        let temp_dir = tempdir().expect("Failed to create temp dir");
+        let test_data_path: PathBuf = temp_dir.path().join("tasks.json");
+
+        config::init(test_data_path.clone());
+
+        let mut reminder = TaskReminder {
+            task_definitions: vec![sample_task_definition()],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        reminder.generate_task_instances(0);
+        let task = reminder.get_next_task().unwrap().clone();
+        reminder.mark_task_completed(task.clone()).unwrap();
+
+        let updated_def = reminder.get_task_definition(task.definition_id).unwrap();
+        if let Some(Recurrence::Recurring {
+            last_recurrence, ..
+        }) = &updated_def.recurrence
+        {
+            assert_eq!(*last_recurrence, Some(task.timestamp));
+        } else {
+            panic!("Expected recurring task");
+        }
+    }
+
+    #[test]
+    fn test_delete_task_definition() {
+        let temp_dir = tempdir().expect("Failed to create temp dir");
+        let test_data_path: PathBuf = temp_dir.path().join("tasks.json");
+
+        config::init(test_data_path.clone());
+
+        let mut reminder = TaskReminder {
+            task_definitions: vec![sample_task_definition()],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        let id = reminder.task_definitions[0].id;
+        reminder.delete_task_definition(id).unwrap();
+
+        assert!(reminder.get_task_definition(id).is_none());
+    }
+
+    #[test]
+    fn test_non_recurring_task_generates_single_instance() {
+        let mut reminder = TaskReminder {
+            task_definitions: vec![TaskDefinition {
+                id: Uuid::new_v4(),
+                name: "One-time Task".to_string(),
+                desc: None,
+                start: Utc.with_ymd_and_hms(2025, 1, 1, 9, 0, 0).unwrap(),
+                recurrence: Some(Recurrence::None),
+            }],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        reminder.generate_task_instances(0);
+        let tasks = reminder.get_tasks(0);
+
+        assert_eq!(tasks.len(), 1);
+        assert_eq!(tasks[0].name, "One-time Task");
+    }
+
+    #[test]
+    fn test_task_with_exception_does_not_generate_that_instance() {
+        let start = Utc.with_ymd_and_hms(2025, 1, 1, 10, 0, 0).unwrap();
+        let exception_time = start + Duration::minutes(60);
+
+        let mut reminder = TaskReminder {
+            task_definitions: vec![TaskDefinition {
+                id: Uuid::new_v4(),
+                name: "With Exception".to_string(),
+                desc: None,
+                start,
+                recurrence: Some(Recurrence::Recurring {
+                    last_recurrence: None,
+                    minutes: 60,
+                    exceptions: Some(vec![exception_time]),
+                }),
+            }],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        reminder.generate_task_instances(0);
+        let tasks = reminder.get_tasks(0);
+
+        // Ensure that the exception timestamp is not in the generated list
+        for task in tasks {
+            assert_ne!(task.timestamp, exception_time);
+        }
+    }
+
+    #[test]
+    fn test_pagination_limits_task_output() {
+        let def = TaskDefinition {
+            id: Uuid::new_v4(),
+            name: "Paged Task".to_string(),
+            desc: None,
+            start: Utc.with_ymd_and_hms(2025, 1, 1, 8, 0, 0).unwrap(),
+            recurrence: Some(Recurrence::Recurring {
+                last_recurrence: None,
+                minutes: 5, // small interval to fill multiple pages quickly
+                exceptions: None,
+            }),
+        };
+
+        let mut reminder = TaskReminder {
+            task_definitions: vec![def],
+            task_instances: BinaryHeap::new(),
+            calculated_instances: 0,
+        };
+
+        // Generate page 0
+        let page_0 = reminder.get_tasks(0);
+        assert_eq!(page_0.len(), PAGE_SIZE as usize);
+
+        // Generate page 1
+        let page_1 = reminder.get_tasks(1);
+        assert_eq!(page_1.len(), PAGE_SIZE as usize);
+
+        // Ensure no duplicates between pages
+        let timestamps_page_0: Vec<_> = page_0.iter().map(|t| t.timestamp).collect();
+        let timestamps_page_1: Vec<_> = page_1.iter().map(|t| t.timestamp).collect();
+        assert!(timestamps_page_0
+            .iter()
+            .all(|ts| !timestamps_page_1.contains(ts)));
+    }
+}