Some more

types/src/task.rs

@@ -188,4 +188,43 @@ mod tests {
         assert_eq!(task.status, TaskStatus::Pending);
         assert!(task.result.is_none());
     }
+
+    #[test]
+    fn test_task_default_values() {
+        let task = Task::default();
+        assert_eq!(task.status, TaskStatus::Pending);
+        assert!(task.result.is_none());
+        assert!(task.logs.is_empty());
+        assert!(task.started_at.is_none());
+        assert!(task.completed_at.is_none());
+    }
+
+    #[test]
+    fn test_task_serialization_roundtrip() {
+        let original = Task::new(Uuid::new_v4(), "Test task".to_string());
+        let serialized = serde_json::to_string(&original).unwrap();
+        let deserialized: Task = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(original.id, deserialized.id);
+        assert_eq!(original.todo_id, deserialized.todo_id);
+        assert_eq!(original.description, deserialized.description);
+        assert_eq!(original.status, deserialized.status);
+    }
+
+    #[test]
+    fn test_task_fail() {
+        let mut task = Task::default();
+        task.status = TaskStatus::Running;
+        assert!(task.fail("error message".to_string()).is_ok());
+        assert_eq!(task.status, TaskStatus::Failed);
+        assert!(task.result.is_some());
+    }
+
+    #[test]
+    fn test_task_invalid_transition() {
+        let mut task = Task::default();
+        // Cannot complete a pending task directly
+        let result = TaskResult::Success("done".to_string());
+        assert!(task.complete(result).is_err());
+    }
 }

types/src/todo.rs

@@ -260,4 +260,61 @@ mod tests {
             Err(ValidationError::InvalidStatusTransition { .. })
         ));
     }
+
+    #[test]
+    fn test_todo_default_values() {
+        let todo = ToDo::default();
+        assert_eq!(todo.status, ToDoStatus::Pending);
+        assert_eq!(todo.priority, DEFAULT_PRIORITY);
+        assert!(todo.depends_on.is_empty());
+        assert!(!todo.id.is_nil());
+    }
+
+    #[test]
+    fn test_todo_serialization_roundtrip() {
+        let original = ToDo::new(
+            "Test Title".to_string(),
+            "Test Description".to_string(),
+            Uuid::new_v4(),
+        );
+
+        let serialized = serde_json::to_string(&original).unwrap();
+        let deserialized: ToDo = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(original.id, deserialized.id);
+        assert_eq!(original.title, deserialized.title);
+        assert_eq!(original.description, deserialized.description);
+        assert_eq!(original.status, deserialized.status);
+        assert_eq!(original.priority, deserialized.priority);
+    }
+
+    #[test]
+    fn test_todo_update_title() {
+        let mut todo = ToDo::default();
+        let result = todo.update(Some("New Title".to_string()), None, None);
+        assert!(result.is_ok());
+        assert_eq!(todo.title, "New Title");
+    }
+
+    #[test]
+    fn test_todo_update_empty_title() {
+        let mut todo = ToDo::default();
+        let result = todo.update(Some("".to_string()), None, None);
+        assert!(matches!(result, Err(ValidationError::EmptyTitle)));
+    }
+
+    #[test]
+    fn test_todo_update_priority() {
+        let mut todo = ToDo::default();
+        let result = todo.update(None, None, Some(50));
+        assert!(result.is_ok());
+        assert_eq!(todo.priority, 50);
+    }
+
+    #[test]
+    fn test_todo_update_invalid_priority() {
+        let mut todo = ToDo::default();
+        let result = todo.update(None, None, Some(0));
+        assert!(matches!(result, Err(ValidationError::InvalidPriority)));
+    }
 }