Merge pull request #404 from rohansen856/utils_test

Utils test

Author: Pavel401

pubspec.yaml

@@ -63,6 +63,7 @@ dependencies:
   tutorial_coach_mark: ^1.2.11
   url_launcher: ^6.1.14
   uuid: ^4.2.2
+  built_collection: ^5.1.1
 
 dev_dependencies:
   build_runner: null

test/utils/app_settings/app_settings_test.dart

@@ -0,0 +1,39 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:taskwarrior/app/utils/app_settings/app_settings.dart';
+import 'package:taskwarrior/app/utils/language/supported_language.dart';
+
+void main() {
+  group('AppSettings', () {
+    setUp(() async {
+      SharedPreferences.setMockInitialValues({});
+      await AppSettings.init();
+    });
+
+    test('should initialize settings correctly', () async {
+      expect(AppSettings.isDarkMode, true);
+      expect(AppSettings.selectedLanguage, SupportedLanguage.english);
+    });
+
+    test('should save settings correctly', () async {
+      await AppSettings.saveSettings(false, SupportedLanguage.english);
+      expect(AppSettings.isDarkMode, true);
+      expect(AppSettings.selectedLanguage, SupportedLanguage.english);
+    });
+  });
+
+  group('SelectedTheme', () {
+    setUp(() async {
+      SharedPreferences.setMockInitialValues({});
+      await SelectedTheme.init();
+    });
+
+    test('should save and retrieve theme mode correctly', () async {
+      await SelectedTheme.saveMode(false);
+      expect(SelectedTheme.getMode(), false);
+
+      await SelectedTheme.saveMode(true);
+      expect(SelectedTheme.getMode(), true);
+    });
+  });
+}

test/utils/app_settings/save_tour_status_test.dart

@@ -0,0 +1,61 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:taskwarrior/app/utils/app_settings/app_settings.dart';
+
+void main() {
+  group('SaveTourStatus', () {
+    setUp(() async {
+      SharedPreferences.setMockInitialValues({});
+      await SaveTourStatus.init();
+    });
+
+    test('should save and retrieve reports tour status correctly', () async {
+      await SaveTourStatus.saveReportsTourStatus(true);
+      expect(await SaveTourStatus.getReportsTourStatus(), true);
+
+      await SaveTourStatus.saveReportsTourStatus(false);
+      expect(await SaveTourStatus.getReportsTourStatus(), false);
+    });
+
+    test('should save and retrieve in-app tour status correctly', () async {
+      await SaveTourStatus.saveInAppTourStatus(true);
+      expect(await SaveTourStatus.getInAppTourStatus(), true);
+
+      await SaveTourStatus.saveInAppTourStatus(false);
+      expect(await SaveTourStatus.getInAppTourStatus(), false);
+    });
+
+    test('should save and retrieve filter tour status correctly', () async {
+      await SaveTourStatus.saveFilterTourStatus(true);
+      expect(await SaveTourStatus.getFilterTourStatus(), true);
+
+      await SaveTourStatus.saveFilterTourStatus(false);
+      expect(await SaveTourStatus.getFilterTourStatus(), false);
+    });
+
+    test('should save and retrieve profile tour status correctly', () async {
+      await SaveTourStatus.saveProfileTourStatus(true);
+      expect(await SaveTourStatus.getProfileTourStatus(), true);
+
+      await SaveTourStatus.saveProfileTourStatus(false);
+      expect(await SaveTourStatus.getProfileTourStatus(), false);
+    });
+
+    test('should save and retrieve details tour status correctly', () async {
+      await SaveTourStatus.saveDetailsTourStatus(true);
+      expect(await SaveTourStatus.getDetailsTourStatus(), true);
+
+      await SaveTourStatus.saveDetailsTourStatus(false);
+      expect(await SaveTourStatus.getDetailsTourStatus(), false);
+    });
+
+    test('should save and retrieve manage task server tour status correctly',
+        () async {
+      await SaveTourStatus.saveManageTaskServerTourStatus(true);
+      expect(await SaveTourStatus.getManageTaskServerTourStatus(), true);
+
+      await SaveTourStatus.saveManageTaskServerTourStatus(false);
+      expect(await SaveTourStatus.getManageTaskServerTourStatus(), false);
+    });
+  });
+}

test/utils/app_settings/selected_language_test.dart

@@ -0,0 +1,21 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:taskwarrior/app/utils/app_settings/app_settings.dart';
+import 'package:taskwarrior/app/utils/language/supported_language.dart';
+
+void main() {
+  group('SelectedLanguage', () {
+    setUp(() async {
+      SharedPreferences.setMockInitialValues({});
+      await SelectedLanguage.init();
+    });
+
+    test('should save and retrieve selected language correctly', () async {
+      await SelectedLanguage.saveSelectedLanguage(SupportedLanguage.spanish);
+      expect(SelectedLanguage.getSelectedLanguage(), SupportedLanguage.spanish);
+
+      await SelectedLanguage.saveSelectedLanguage(SupportedLanguage.english);
+      expect(SelectedLanguage.getSelectedLanguage(), SupportedLanguage.english);
+    });
+  });
+}

test/utils/app_settings/selected_theme_test.dart

@@ -0,0 +1,20 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:taskwarrior/app/utils/app_settings/app_settings.dart';
+
+void main() {
+  group('SelectedTheme', () {
+    setUp(() async {
+      SharedPreferences.setMockInitialValues({});
+      await SelectedTheme.init();
+    });
+
+    test('should save and retrieve theme mode correctly', () async {
+      await SelectedTheme.saveMode(false);
+      expect(SelectedTheme.getMode(), false);
+
+      await SelectedTheme.saveMode(true);
+      expect(SelectedTheme.getMode(), true);
+    });
+  });
+}

test/utils/constants/onboarding_screen_content_test.dart

@@ -0,0 +1,26 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/utils/constants/onboarding_screen_content.dart';
+
+void main() {
+  group('Onboarding Screen Content', () {
+    test('should contain three onboarding items', () {
+      expect(contents.length, 3);
+    });
+
+    test('should have valid content for each onboarding item', () {
+      for (var content in contents) {
+        expect(content.title.isNotEmpty, true);
+        expect(content.image.isNotEmpty, true);
+        expect(content.colors, isA<Color>());
+        expect(content.desc.isNotEmpty, true);
+      }
+    });
+
+    test('should match the expected titles', () {
+      expect(contents[0].title, "Welcome to Taskwarrior");
+      expect(contents[1].title, "Powerful Reporting");
+      expect(contents[2].title, "Sync Across Devices");
+    });
+  });
+}

test/utils/constants/pallette_test.dart

@@ -0,0 +1,24 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:taskwarrior/app/utils/constants/palette.dart';
+import 'package:flutter/material.dart';
+
+void main() {
+  group('Palette', () {
+    test('kToDark should be a MaterialColor', () {
+      expect(Palette.kToDark, isA<MaterialColor>());
+    });
+
+    test('kToDark should contain the correct color values', () {
+      expect(Palette.kToDark[50], const Color(0xff1e1e1e));
+      expect(Palette.kToDark[100], const Color(0xff1a1a1a));
+      expect(Palette.kToDark[200], const Color(0xff171717));
+      expect(Palette.kToDark[300], const Color(0xff141414));
+      expect(Palette.kToDark[400], const Color(0xff111111));
+      expect(Palette.kToDark[500], const Color(0xff0d0d0d));
+      expect(Palette.kToDark[600], const Color(0xff0a0a0a));
+      expect(Palette.kToDark[700], const Color(0xff070707));
+      expect(Palette.kToDark[800], const Color(0xff030303));
+      expect(Palette.kToDark[900], const Color(0xff000000));
+    });
+  });
+}

test/utils/constants/permissions_test.dart

@@ -0,0 +1,15 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:taskwarrior/app/utils/constants/permissions.dart';
+
+void main() {
+  group('Permissions', () {
+    test('should contain the correct permissions', () {
+      expect(permissions, [
+        Permission.notification,
+        Permission.storage,
+        Permission.manageExternalStorage,
+      ]);
+    });
+  });
+}

test/utils/constants/taskwarrior_colors_test.dart

@@ -0,0 +1,47 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter/material.dart';
+import 'package:taskwarrior/app/utils/constants/palette.dart';
+import 'package:taskwarrior/app/utils/constants/taskwarrior_colors.dart';
+
+void main() {
+  group('TaskWarriorColors', () {
+    test('should contain the correct normal colors', () {
+      expect(TaskWarriorColors.red, Colors.red);
+      expect(TaskWarriorColors.green, Colors.green);
+      expect(TaskWarriorColors.yellow, Colors.yellow);
+      expect(TaskWarriorColors.white, Colors.white);
+      expect(TaskWarriorColors.black, Colors.black);
+      expect(TaskWarriorColors.grey, Colors.grey);
+      expect(TaskWarriorColors.lightGrey, Colors.grey[600]);
+      expect(TaskWarriorColors.purple, Colors.purple);
+      expect(TaskWarriorColors.borderColor, Colors.grey.shade300);
+      expect(TaskWarriorColors.deepPurpleAccent, Colors.deepPurpleAccent);
+      expect(TaskWarriorColors.deepPurple, Colors.deepPurple);
+    });
+
+    test('should contain the correct dark theme colors', () {
+      expect(
+          TaskWarriorColors.kprimaryBackgroundColor, Palette.kToDark.shade200);
+      expect(TaskWarriorColors.ksecondaryBackgroundColor,
+          const Color.fromARGB(255, 48, 46, 46));
+      expect(TaskWarriorColors.kprimaryTextColor, Colors.white);
+      expect(TaskWarriorColors.ksecondaryTextColor, Colors.white);
+      expect(
+          TaskWarriorColors.kprimaryDisabledTextColor, const Color(0xff595f6b));
+      expect(TaskWarriorColors.kdialogBackGroundColor,
+          const Color.fromARGB(255, 25, 25, 25));
+    });
+
+    test('should contain the correct light theme colors', () {
+      expect(TaskWarriorColors.kLightPrimaryBackgroundColor, Colors.white);
+      expect(TaskWarriorColors.kLightSecondaryBackgroundColor,
+          const Color.fromARGB(255, 220, 216, 216));
+      expect(TaskWarriorColors.kLightPrimaryTextColor, Colors.black);
+      expect(TaskWarriorColors.kLightSecondaryTextColor,
+          const Color.fromARGB(255, 48, 46, 46));
+      expect(TaskWarriorColors.kLightPrimaryDisabledTextColor,
+          const Color(0xffACACAB));
+      expect(TaskWarriorColors.kLightDialogBackGroundColor, Colors.white);
+    });
+  });
+}

test/utils/constants/taskwarrior_fonts_test.dart

@@ -0,0 +1,26 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter/material.dart';
+import 'package:taskwarrior/app/utils/constants/taskwarrior_fonts.dart';
+
+void main() {
+  group('TaskWarriorFonts', () {
+    test('should contain the correct font weights', () {
+      expect(TaskWarriorFonts.thin, FontWeight.w100);
+      expect(TaskWarriorFonts.extraLight, FontWeight.w200);
+      expect(TaskWarriorFonts.light, FontWeight.w300);
+      expect(TaskWarriorFonts.regular, FontWeight.w400);
+      expect(TaskWarriorFonts.medium, FontWeight.w500);
+      expect(TaskWarriorFonts.semiBold, FontWeight.w600);
+      expect(TaskWarriorFonts.bold, FontWeight.w700);
+      expect(TaskWarriorFonts.extraBold, FontWeight.w800);
+      expect(TaskWarriorFonts.black, FontWeight.w900);
+    });
+
+    test('should contain the correct font sizes', () {
+      expect(TaskWarriorFonts.fontSizeSmall, 12.0);
+      expect(TaskWarriorFonts.fontSizeMedium, 16.0);
+      expect(TaskWarriorFonts.fontSizeLarge, 20.0);
+      expect(TaskWarriorFonts.fontSizeExtraLarge, 24.0);
+    });
+  });
+}