test: added test for root files under lib/models directory

Author: rohansen856

test/models/chart_test.dart

@@ -0,0 +1,30 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/chart.dart';
+
+void main() {
+  group('ChartData', () {
+    test('should create an instance with correct values', () {
+      final chartData = ChartData('2024-12-12', 100, 200);
+
+      expect(chartData.x, '2024-12-12');
+      expect(chartData.y1, 100);
+      expect(chartData.y2, 200);
+    });
+
+    test('should handle null or empty values correctly', () {
+      final chartData = ChartData('', 0, 0);
+
+      expect(chartData.x, '');
+      expect(chartData.y1, 0);
+      expect(chartData.y2, 0);
+    });
+
+    test('should handle negative values correctly', () {
+      final chartData = ChartData('2024-12-12', -100, -200);
+
+      expect(chartData.x, '2024-12-12');
+      expect(chartData.y1, -100);
+      expect(chartData.y2, -200);
+    });
+  });
+}

test/models/data_test.dart

@@ -0,0 +1,103 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/mockito.dart';
+import 'package:taskwarrior/app/models/data.dart';
+import 'package:taskwarrior/app/models/json/task.dart';
+import 'package:taskwarrior/app/services/notification_services.dart';
+import 'package:flutter/widgets.dart';
+import 'dart:io';
+
+class MockNotificationService extends Mock implements NotificationService {}
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  group('Data', () {
+    late Data data;
+    late Directory home;
+    late MockNotificationService mockNotificationService;
+
+    setUp(() {
+      WidgetsFlutterBinding.ensureInitialized();
+      home = Directory.systemTemp.createTempSync();
+      data = Data(home);
+      mockNotificationService = MockNotificationService();
+
+      when(mockNotificationService.initiliazeNotification())
+          .thenAnswer((_) async {});
+    });
+
+    test('should update tasks with status "waiting" or "until" correctly',
+        () async {
+      final task1 = Task((b) => b
+        ..uuid = '1'
+        ..status = 'pending'
+        ..wait = DateTime.now().toUtc().subtract(const Duration(days: 1))
+        ..description = 'Test Task'
+        ..entry = DateTime.now().toUtc());
+      final task2 = Task((b) => b
+        ..uuid = '2'
+        ..status = 'deleted'
+        ..until = DateTime.now().toUtc().subtract(const Duration(days: 1))
+        ..description = 'Test Task'
+        ..entry = DateTime.now().toUtc());
+
+      final updatedTasks = data.pendingData();
+      expect(
+          updatedTasks.any(
+              (task) => task.uuid == task1.uuid && task.status == task1.status),
+          isFalse);
+      expect(
+          updatedTasks.any(
+              (task) => task.uuid == task2.uuid && task.status == task2.status),
+          isFalse);
+    });
+
+    test('should correctly return pending data', () {
+      final task = Task((b) => b
+        ..uuid = '1'
+        ..status = 'pending'
+        ..description = 'Test Task'
+        ..entry = DateTime.now().toUtc());
+
+      data.updateWaitOrUntil([task]);
+      final tasks = data.pendingData();
+      expect(tasks.any((t) => t.uuid == '1' && t.description == 'Test Task'),
+          isFalse);
+    });
+
+    test('should correctly return completed data', () {
+      final task = Task((b) => b
+        ..uuid = '1'
+        ..status = 'completed'
+        ..description = 'Test Task'
+        ..entry = DateTime.now().toUtc());
+
+      data.updateWaitOrUntil([task]);
+      final tasks = data.completedData();
+      expect(tasks.any((t) => t.uuid == '1' && t.description == 'Test Task'),
+          isFalse);
+    });
+
+    test('should correctly return waiting data', () {
+      final task = Task((b) => b
+        ..uuid = '1'
+        ..status = 'waiting'
+        ..description = 'Test Task'
+        ..entry = DateTime.now().toUtc());
+
+      data.updateWaitOrUntil([task]);
+      final tasks = data.waitingData();
+      expect(tasks.any((t) => t.uuid == '1' && t.description == 'Test Task'),
+          isFalse);
+    });
+
+    test('should correctly export data', () {
+      final exportedData = data.export();
+      expect(exportedData, isNotNull);
+    });
+
+    tearDown(() {
+      home.deleteSync(recursive: true);
+    });
+  });
+}

test/models/filters_test.dart

@@ -0,0 +1,104 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/filters.dart';
+import 'package:taskwarrior/app/services/tag_filter.dart';
+
+void main() {
+  group('Filters', () {
+    late Filters filters;
+    late bool pendingFilter;
+    late bool waitingFilter;
+    late String projectFilter;
+    late bool tagUnion;
+    late Map<String, TagFilterMetadata> tags;
+
+    setUp(() {
+      pendingFilter = false;
+      waitingFilter = false;
+      projectFilter = 'TestProject';
+      tagUnion = false;
+      tags = {
+        'tag1': const TagFilterMetadata(display: 'Tag 1', selected: false),
+        'tag2': const TagFilterMetadata(display: 'Tag 2', selected: true),
+      };
+
+      filters = Filters(
+        pendingFilter: pendingFilter,
+        waitingFilter: waitingFilter,
+        togglePendingFilter: () {
+          pendingFilter = !pendingFilter;
+        },
+        toggleWaitingFilter: () {
+          waitingFilter = !waitingFilter;
+        },
+        tagFilters: TagFilters(
+          tagUnion: tagUnion,
+          toggleTagUnion: () {
+            tagUnion = !tagUnion;
+          },
+          tags: tags,
+          toggleTagFilter: (String tag) {
+            tags[tag] = TagFilterMetadata(
+              display: tags[tag]!.display,
+              selected: !tags[tag]!.selected,
+            );
+          },
+        ),
+        projects: [],
+        projectFilter: projectFilter,
+        toggleProjectFilter: (String project) {
+          projectFilter = project;
+        },
+      );
+    });
+
+    test('should correctly initialize with given parameters', () {
+      expect(filters.pendingFilter, pendingFilter);
+      expect(filters.waitingFilter, waitingFilter);
+      expect(filters.projectFilter, projectFilter);
+      expect(filters.tagFilters.tagUnion, tagUnion);
+      expect(filters.tagFilters.tags, tags);
+    });
+
+    test('should correctly toggle pending filter', () {
+      filters.togglePendingFilter();
+      expect(pendingFilter, isTrue);
+
+      filters.togglePendingFilter();
+      expect(pendingFilter, isFalse);
+    });
+
+    test('should correctly toggle waiting filter', () {
+      filters.toggleWaitingFilter();
+      expect(waitingFilter, isTrue);
+
+      filters.toggleWaitingFilter();
+      expect(waitingFilter, isFalse);
+    });
+
+    test('should correctly toggle project filter', () {
+      const newProject = 'NewProject';
+      filters.toggleProjectFilter(newProject);
+      expect(projectFilter, newProject);
+
+      const anotherProject = 'AnotherProject';
+      filters.toggleProjectFilter(anotherProject);
+      expect(projectFilter, anotherProject);
+    });
+
+    test('should correctly toggle tag union', () {
+      filters.tagFilters.toggleTagUnion();
+      expect(tagUnion, isTrue);
+
+      filters.tagFilters.toggleTagUnion();
+      expect(tagUnion, isFalse);
+    });
+
+    test('should correctly toggle tag filter', () {
+      filters.tagFilters.toggleTagFilter('tag1');
+      expect(tags['tag1']!.selected, isTrue);
+
+      filters.tagFilters.toggleTagFilter('tag1');
+      expect(tags['tag1']!.selected, isFalse);
+    });
+  });
+}

test/models/onboarding_model_test.dart

@@ -0,0 +1,25 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/onboarding_model.dart';
+
+void main() {
+  group('OnboardingModel', () {
+    late OnboardingModel model;
+
+    setUp(() {
+      model = OnboardingModel(
+        title: 'Welcome',
+        image: 'assets/images/welcome.png',
+        desc: 'Welcome to the app!',
+        colors: Colors.blue,
+      );
+    });
+
+    test('should correctly initialize with given parameters', () {
+      expect(model.title, 'Welcome');
+      expect(model.image, 'assets/images/welcome.png');
+      expect(model.desc, 'Welcome to the app!');
+      expect(model.colors, Colors.blue);
+    });
+  });
+}

test/models/size_config_model_test.dart

@@ -0,0 +1,35 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/size_config_model.dart';
+
+void main() {
+  group('SizeConfig', () {
+    late SizeConfig sizeConfig;
+
+    setUp(() {
+      sizeConfig = SizeConfig();
+    });
+
+    testWidgets('should initialize screen dimensions correctly',
+        (WidgetTester tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Builder(
+            builder: (BuildContext context) {
+              sizeConfig.init(context);
+              return Container();
+            },
+          ),
+        ),
+      );
+
+      final mediaQueryData =
+          MediaQuery.of(tester.element(find.byType(Container)));
+
+      expect(sizeConfig.screenW, mediaQueryData.size.width);
+      expect(sizeConfig.screenH, mediaQueryData.size.height);
+      expect(sizeConfig.blockH, mediaQueryData.size.width / 100);
+      expect(sizeConfig.blockV, mediaQueryData.size.height / 100);
+    });
+  });
+}

test/models/storage_test.dart

@@ -0,0 +1,61 @@
+import 'dart:io';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/models/data.dart';
+import 'package:taskwarrior/app/models/storage.dart';
+import 'package:taskwarrior/app/models/storage/tabs.dart';
+import 'package:taskwarrior/app/utils/home_path/impl/gui_pem_file_paths.dart';
+import 'package:taskwarrior/app/utils/home_path/impl/home.dart';
+import 'package:taskwarrior/app/utils/home_path/impl/taskrc.dart';
+import 'package:taskwarrior/app/utils/taskfunctions/query.dart';
+
+void main() {
+  group('Storage', () {
+    late Directory profile;
+    late Storage storage;
+
+    setUp(() {
+      profile = Directory.systemTemp.createTempSync();
+      storage = Storage(profile);
+    });
+
+    tearDown(() {
+      profile.deleteSync(recursive: true);
+    });
+
+    test('should correctly initialize with given directory', () {
+      expect(storage.profile, profile);
+    });
+
+    test('should correctly initialize Data with profile directory', () {
+      expect(storage.data, isA<Data>());
+      expect(storage.profile, profile);
+    });
+
+    test('should correctly initialize GUIPemFiles with profile directory', () {
+      expect(storage.guiPemFiles, isA<GUIPemFiles>());
+      expect(storage.profile, profile);
+    });
+
+    test('should correctly initialize Home with profile directory', () {
+      expect(storage.home, isA<Home>());
+      expect(storage.home.home, profile);
+      expect(
+          storage.home.pemFilePaths?.key, storage.guiPemFiles.pemFilePaths.key);
+    });
+
+    test('should correctly initialize Query with profile directory', () {
+      expect(storage.query, isA<Query>());
+      expect(storage.profile, profile);
+    });
+
+    test('should correctly initialize Tabs with profile directory', () {
+      expect(storage.tabs, isA<Tabs>());
+      expect(storage.tabs.profile, profile);
+    });
+
+    test('should correctly initialize Taskrc with profile directory', () {
+      expect(storage.taskrc, isA<Taskrc>());
+      expect(storage.profile, profile);
+    });
+  });
+}