test: added test for all files under utils/taskfunctions

Author: rohansen856

test/utils/taskfunctions/comparator_test.dart

@@ -0,0 +1,109 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/json/task.dart';
+import 'package:taskwarrior/app/utils/taskfunctions/comparator.dart';
+
+void main() {
+  group('compareTasks', () {
+    Task createTask(
+        {DateTime? entry,
+        DateTime? modified,
+        DateTime? start,
+        DateTime? due,
+        String? priority,
+        String? project,
+        List<String>? tags}) {
+      return Task((b) => b
+        ..uuid = '1'
+        ..description = 'Task'
+        ..entry = entry ?? DateTime.now()
+        ..modified = modified
+        ..start = start
+        ..due = due
+        ..priority = priority
+        ..project = project
+        ..status = 'pending');
+    }
+
+    test('should compare tasks by Created date', () {
+      final task1 = createTask(entry: DateTime(2022, 1, 1));
+      final task2 = createTask(entry: DateTime(2023, 1, 1));
+
+      final comparator = compareTasks('Created');
+      expect(comparator(task1, task2), lessThan(0));
+      expect(comparator(task2, task1), greaterThan(0));
+    });
+
+    test('should compare tasks by Modified date', () {
+      final task1 = createTask(modified: DateTime(2022, 1, 1));
+      final task2 = createTask(modified: DateTime(2023, 1, 1));
+
+      final comparator = compareTasks('Modified');
+      expect(comparator(task1, task2), lessThan(0));
+      expect(comparator(task2, task1), greaterThan(0));
+      expect(comparator(task1, task1), equals(0));
+    });
+
+    test('should compare tasks by Start Time', () {
+      final task1 = createTask(start: DateTime(2022, 1, 1));
+      final task2 = createTask(start: DateTime(2023, 1, 1));
+
+      final comparator = compareTasks('Start Time');
+      expect(comparator(task1, task2), lessThan(0));
+      expect(comparator(task2, task1), greaterThan(0));
+    });
+
+    test('should compare tasks by Due till', () {
+      final task1 = createTask(due: DateTime(2022, 1, 1));
+      final task2 = createTask(due: DateTime(2023, 1, 1));
+
+      final comparator = compareTasks('Due till');
+      expect(comparator(task1, task2), lessThan(0));
+      expect(comparator(task2, task1), greaterThan(0));
+    });
+
+    test('should compare tasks by Priority', () {
+      final task1 = createTask(priority: 'H');
+      final task2 = createTask(priority: 'L');
+
+      final comparator = compareTasks('Priority');
+      expect(comparator(task1, task2), greaterThan(0));
+      expect(comparator(task2, task1), lessThan(0));
+    });
+
+    test('should compare tasks by Project', () {
+      final task1 = createTask(project: 'ProjectA');
+      final task2 = createTask(project: 'ProjectB');
+
+      final comparator = compareTasks('Project');
+      expect(comparator(task1, task2), lessThan(0));
+      expect(comparator(task2, task1), greaterThan(0));
+    });
+
+    test('should compare tasks by Tags', () {
+      final task1 = createTask(tags: ['Tag1', 'Tag2']);
+      final task2 = createTask(tags: ['Tag1', 'Tag3']);
+
+      final comparator = compareTasks('Tags');
+      expect(comparator(task1, task2), 0);
+    });
+
+    test('should compare tasks by Urgency', () {
+      final task1 = createTask();
+      final task2 = createTask();
+
+      // Define urgency function to compare tasks
+      int urgency(Task task) => task.entry.microsecondsSinceEpoch;
+
+      final comparator = compareTasks('Urgency');
+      expect(comparator(task1, task2), equals(0));
+    });
+
+    test('should return 1 for unknown column', () {
+      final task1 = createTask();
+      final task2 = createTask();
+
+      final comparator = compareTasks('Unknown');
+      expect(comparator(task1, task2), equals(1));
+    });
+  });
+}

test/utils/taskfunctions/datetime_differences_test.dart

@@ -0,0 +1,71 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/utils/taskfunctions/datetime_differences.dart';
+
+void main() {
+  group('DateTime Differences', () {
+    test('age function should return correct string for years', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(days: 2 * 365));
+      expect(age(dt), '2y ');
+    });
+
+    test('age function should return correct string for months', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(days: 2 * 30));
+      expect(age(dt), '2mo ');
+    });
+
+    test('age function should return correct string for weeks', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(days: 2 * 7));
+      expect(age(dt), '2w ');
+    });
+
+    test('age function should return correct string for days', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(days: 2)); // 2 days
+      expect(age(dt), '2d ');
+    });
+
+    test('age function should return correct string for hours', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(hours: 2)); // 2 hours
+      expect(age(dt), '2h ');
+    });
+
+    test('age function should return correct string for minutes', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(minutes: 2)); // 2 minutes
+      expect(age(dt), '2min ');
+    });
+
+    test('age function should return correct string for seconds', () {
+      final now = DateTime.now();
+      final dt = now.subtract(const Duration(seconds: 2)); // 2 seconds
+      expect(age(dt), '2s ');
+    });
+
+    test('when function should return correct string for future dates', () {
+      final now = DateTime.now();
+      final dt = now.add(const Duration(days: 2)); // 2 days from now
+      expect(when(dt), '1d ');
+    });
+
+    test(
+        'difference function should return correct string for various durations',
+        () {
+      expect(difference(const Duration(days: 2 * 365)), '2y ');
+      expect(difference(const Duration(days: 2 * 30)), '2mo ');
+      expect(difference(const Duration(days: 2 * 7)), '2w ');
+      expect(difference(const Duration(days: 2)), '2d ');
+      expect(difference(const Duration(hours: 2)), '2h ');
+      expect(difference(const Duration(minutes: 2)), '2min ');
+      expect(difference(const Duration(seconds: 2)), '2s ');
+
+      expect(difference(const Duration(days: -2)), '2d ago ');
+      expect(difference(const Duration(hours: -2)), '2h ago ');
+      expect(difference(const Duration(minutes: -2)), '2min ago ');
+      expect(difference(const Duration(seconds: -2)), '2s ago ');
+    });
+  });
+}

test/utils/taskfunctions/draft_test.dart

@@ -0,0 +1,42 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/models.dart';
+import 'package:taskwarrior/app/utils/taskfunctions/draft.dart';
+
+void main() {
+  group('Draft', () {
+    late Task originalTask;
+    late Draft draft;
+
+    setUp(() {
+      originalTask = Task((b) => b
+        ..uuid = '1'
+        ..description = 'Original Task'
+        ..status = 'pending'
+        ..entry = DateTime.now());
+      draft = Draft(originalTask);
+    });
+
+    test('should initialize with original task', () {
+      expect(draft.original, originalTask);
+      expect(draft.draft, originalTask);
+    });
+
+    test('should update draft with new values', () {
+      draft.set('description', 'Updated Task');
+      expect(draft.draft.description, 'Updated Task');
+    });
+
+    test('should set start and end dates based on status', () {
+      final now = DateTime.now();
+
+      draft.set('status', 'completed');
+      expect(draft.draft.status, 'completed');
+      expect(draft.draft.start, originalTask.start);
+      expect(draft.draft.end?.isAfter(now), isTrue);
+
+      draft.set('status', 'pending');
+      expect(draft.draft.status, 'pending');
+      expect(draft.draft.end, isNull);
+    });
+  });
+}

test/utils/taskfunctions/modify_test.dart

@@ -0,0 +1,47 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/models.dart';
+import 'package:taskwarrior/app/utils/taskfunctions/modify.dart';
+
+void main() {
+  group('Modify', () {
+    late Task originalTask;
+    late Modify modify;
+    late Task Function(String) getTask;
+    late void Function(Task) mergeTask;
+    late String uuid;
+
+    setUp(() {
+      uuid = '1';
+      originalTask = Task((b) => b
+        ..uuid = uuid
+        ..description = 'Original Task'
+        ..status = 'pending'
+        ..entry = DateTime.now());
+
+      getTask = (String id) => originalTask;
+      mergeTask = (Task task) {
+        originalTask = task;
+      };
+
+      modify = Modify(getTask: getTask, mergeTask: mergeTask, uuid: uuid);
+    });
+
+    test('should initialize with original task', () {
+      expect(modify.draft, originalTask);
+    });
+
+    test('should update draft with new values', () {
+      modify.set('description', 'Updated Task');
+      expect(modify.draft.description, 'Updated Task');
+    });
+
+    test('should save changes correctly', () {
+      final now = DateTime.now();
+      modify.set('description', 'Updated Task');
+      modify.save(modified: () => now);
+
+      expect(modify.draft.description, 'Updated Task');
+      expect(modify.draft.modified, now);
+    });
+  });
+}

test/utils/taskfunctions/patch_test.dart

@@ -0,0 +1,81 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/models.dart';
+import 'package:taskwarrior/app/utils/taskfunctions/patch.dart';
+import 'package:built_collection/built_collection.dart';
+
+void main() {
+  group('patch', () {
+    late Task originalTask;
+
+    setUp(() {
+      originalTask = Task((b) => b
+        ..uuid = '1'
+        ..description = 'Original Task'
+        ..status = 'pending'
+        ..entry = DateTime.now()
+        ..tags = ListBuilder<String>(['tag1', 'tag2']));
+    });
+
+    test('should update description', () {
+      final updatedTask = patch(originalTask, {'description': 'Updated Task'});
+      expect(updatedTask.description, 'Updated Task');
+    });
+
+    test('should update status', () {
+      final updatedTask = patch(originalTask, {'status': 'completed'});
+      expect(updatedTask.status, 'completed');
+    });
+
+    test('should update start date', () {
+      final newStart = DateTime.now().add(const Duration(days: 1));
+      final updatedTask = patch(originalTask, {'start': newStart});
+      expect(updatedTask.start, newStart);
+    });
+
+    test('should update end date', () {
+      final newEnd = DateTime.now().add(const Duration(days: 1));
+      final updatedTask = patch(originalTask, {'end': newEnd});
+      expect(updatedTask.end, newEnd);
+    });
+
+    test('should update due date', () {
+      final newDue = DateTime.now().add(const Duration(days: 1));
+      final updatedTask = patch(originalTask, {'due': newDue});
+      expect(updatedTask.due, newDue);
+    });
+
+    test('should update wait date', () {
+      final newWait = DateTime.now().add(const Duration(days: 1));
+      final updatedTask = patch(originalTask, {'wait': newWait});
+      expect(updatedTask.wait, newWait);
+    });
+
+    test('should update until date', () {
+      final newUntil = DateTime.now().add(const Duration(days: 1));
+      final updatedTask = patch(originalTask, {'until': newUntil});
+      expect(updatedTask.until, newUntil);
+    });
+
+    test('should update modified date', () {
+      final newModified = DateTime.now().add(const Duration(days: 1));
+      final updatedTask = patch(originalTask, {'modified': newModified});
+      expect(updatedTask.modified, newModified);
+    });
+
+    test('should update priority', () {
+      final updatedTask = patch(originalTask, {'priority': 'H'});
+      expect(updatedTask.priority, 'H');
+    });
+
+    test('should update project', () {
+      final updatedTask = patch(originalTask, {'project': 'New Project'});
+      expect(updatedTask.project, 'New Project');
+    });
+
+    test('should update tags', () {
+      final newTags = ListBuilder<String>(['tag3', 'tag4']);
+      final updatedTask = patch(originalTask, {'tags': newTags});
+      expect(updatedTask.tags?.rebuild((b) => b).toList(), ['tag3', 'tag4']);
+    });
+  });
+}