feat: db tests

2 files changed, 256 insertions, 9 deletions

diff --git a/src/db.rs b/src/db.rs
index 22bbdd1..4b07f91 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -261,11 +261,16 @@ impl ToSql for LogFilter {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashSet;
+    use std::{collections::HashSet, str::FromStr};
 
+    use chrono::NaiveDateTime;
     use test_log::test;
 
-    use crate::task::{Category, Task};
+    use crate::{
+        db::{LogFilter, TaskFilter},
+        task::{Category, Task},
+        Log,
+    };
 
     use super::Db;
 
@@ -327,7 +332,58 @@ mod tests {
     // TODO: task orderings: by day, by week, by what's most urgent.
 
     #[test]
-    fn filter_tasks() {}
+    fn filter_tasks() {
+        let db = Db::create_connect_memory().unwrap();
+
+        let piano = Task::new(
+            "piano".to_string(),
+            None,
+            Some("practice piano".to_string()),
+            Some(HashSet::from([Category::new("music".to_string())])),
+        );
+
+        db.create_task(&piano).unwrap();
+
+        let mut german = Task::new(
+            "german".to_string(),
+            None,
+            Some("study german".to_string()),
+            Some(HashSet::from([Category::new("study".to_string())])),
+        );
+        german.archived = true;
+
+        db.create_task(&german).unwrap();
+
+        let math = Task::new(
+            "math".to_string(),
+            None,
+            Some("study mathematics".to_string()),
+            Some(HashSet::from([Category::new("study".to_string())])),
+        );
+
+        db.create_task(&math).unwrap();
+
+        assert_eq!(
+            vec![piano],
+            db.read_tasks(vec![TaskFilter::Category("music".to_string())])
+                .unwrap()
+        );
+
+        assert_eq!(
+            vec![german.clone()],
+            db.read_tasks(vec![
+                TaskFilter::Category("study".to_string()),
+                TaskFilter::Archived(true)
+            ])
+            .unwrap()
+        );
+
+        assert_eq!(
+            vec![german, math],
+            db.read_tasks(vec![TaskFilter::Category("study".to_string())])
+                .unwrap()
+        );
+    }
 
     #[test]
     fn update_task() {
@@ -369,17 +425,208 @@ mod tests {
     }
 
     #[test]
-    fn delete_task() {}
+    fn delete_task() {
+        let db = Db::create_connect_memory().unwrap();
+
+        let piano = Task::new(
+            "piano".to_string(),
+            None,
+            Some("practice piano".to_string()),
+            Some(HashSet::from([Category::new("music".to_string())])),
+        );
+
+        db.create_task(&piano).unwrap();
+
+        let german = Task::new(
+            "german".to_string(),
+            None,
+            Some("study german".to_string()),
+            None,
+        );
+
+        db.create_task(&german).unwrap();
+
+        assert_eq!(
+            vec![piano.clone(), german],
+            db.read_tasks(Vec::new()).unwrap()
+        );
+
+        db.delete_task("german").unwrap();
+
+        assert_eq!(vec![piano], db.read_tasks(Vec::new()).unwrap());
+    }
 
     #[test]
-    fn create_log() {}
+    fn create_log() {
+        let db = Db::create_connect_memory().unwrap();
+
+        let piano = Task::new(
+            "piano".to_string(),
+            None,
+            Some("practice piano".to_string()),
+            Some(HashSet::from([Category::new("music".to_string())])),
+        );
+
+        db.create_task(&piano).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:16:00").unwrap();
+        let log = Log::new(timestamp);
+
+        db.create_log("piano", &log).unwrap();
+    }
 
     #[test]
-    fn read_logs() {}
+    fn read_logs() {
+        let db = Db::create_connect_memory().unwrap();
+
+        let piano = Task::new(
+            "piano".to_string(),
+            None,
+            Some("practice piano".to_string()),
+            Some(HashSet::from([Category::new("music".to_string())])),
+        );
+
+        db.create_task(&piano).unwrap();
+
+        let german = Task::new(
+            "german".to_string(),
+            None,
+            Some("study german".to_string()),
+            None,
+        );
+
+        db.create_task(&german).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:16:00").unwrap();
+        let piano_log = Log::new(timestamp);
+
+        db.create_log("piano", &piano_log).unwrap();
+
+        assert_eq!(vec![piano_log], db.read_logs(vec![]).unwrap());
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:18:00").unwrap();
+        let piano_log_2 = Log::new(timestamp);
+
+        db.create_log("piano", &piano_log_2).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:17:00").unwrap();
+        let german_log = Log::new(timestamp);
+
+        db.create_log("german", &german_log).unwrap();
+
+        assert_eq!(
+            vec![piano_log, piano_log_2, german_log],
+            db.read_logs(vec![]).unwrap()
+        );
+    }
 
     #[test]
-    fn filter_logs() {}
+    fn filter_logs() {
+        let db = Db::create_connect_memory().unwrap();
+
+        let piano = Task::new(
+            "piano".to_string(),
+            None,
+            Some("practice piano".to_string()),
+            Some(HashSet::from([Category::new("music".to_string())])),
+        );
+
+        db.create_task(&piano).unwrap();
+
+        let german = Task::new(
+            "german".to_string(),
+            None,
+            Some("study german".to_string()),
+            None,
+        );
+
+        db.create_task(&german).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:16:00").unwrap();
+        let piano_log = Log::new(timestamp);
+
+        db.create_log("piano", &piano_log).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:18:00").unwrap();
+        let piano_log_2 = Log::new(timestamp);
+
+        db.create_log("piano", &piano_log_2).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:17:00").unwrap();
+        let german_log = Log::new(timestamp);
+
+        db.create_log("german", &german_log).unwrap();
+
+        assert_eq!(
+            vec![piano_log, piano_log_2],
+            db.read_logs(vec![LogFilter::Task("piano".to_string())])
+                .unwrap()
+        );
+
+        // NEXT: remember to stage the log eq derive
+        assert_eq!(
+            vec![piano_log],
+            db.read_logs(vec![
+                LogFilter::Task("piano".to_string()),
+                LogFilter::Before(NaiveDateTime::from_str("2025-06-05T16:16:30").unwrap())
+            ])
+            .unwrap()
+        );
+
+        assert_eq!(
+            vec![piano_log_2],
+            db.read_logs(vec![
+                LogFilter::Task("piano".to_string()),
+                LogFilter::After(NaiveDateTime::from_str("2025-06-05T16:16:30").unwrap())
+            ])
+            .unwrap()
+        );
+    }
 
     #[test]
-    fn delete_log() {}
+    fn delete_log() {
+        let db = Db::create_connect_memory().unwrap();
+
+        let piano = Task::new(
+            "piano".to_string(),
+            None,
+            Some("practice piano".to_string()),
+            Some(HashSet::from([Category::new("music".to_string())])),
+        );
+
+        db.create_task(&piano).unwrap();
+
+        let german = Task::new(
+            "german".to_string(),
+            None,
+            Some("study german".to_string()),
+            None,
+        );
+
+        db.create_task(&german).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:16:00").unwrap();
+        let piano_log = Log::new(timestamp);
+
+        db.create_log("piano", &piano_log).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:18:00").unwrap();
+        let piano_log_2 = Log::new(timestamp);
+
+        db.create_log("piano", &piano_log_2).unwrap();
+
+        let timestamp = NaiveDateTime::from_str("2025-06-05T16:17:00").unwrap();
+        let german_log = Log::new(timestamp);
+
+        db.create_log("german", &german_log).unwrap();
+
+        assert_eq!(
+            vec![piano_log, piano_log_2, german_log],
+            db.read_logs(vec![]).unwrap()
+        );
+
+        db.delete_log(&piano_log_2).unwrap();
+
+        assert_eq!(vec![piano_log, german_log], db.read_logs(vec![]).unwrap());
+    }
 }
diff --git a/src/task.rs b/src/task.rs
index ce2e7e6..cf07a5f 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -93,7 +93,7 @@ impl Category {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Log {
     pub(crate) id: Uuid,
     pub(crate) timestamp: NaiveDateTime,