test

test/unit/packages/core/services/g_service_test.dart

@@ -0,0 +1,122 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:rasadyar_core/core.dart';
+
+class MockHiveBox extends Mock implements Box {}
+
+void main() {
+  group('GService Tests', () {
+    late GService gService;
+    late MockHiveBox mockBox;
+
+    setUp(() {
+      mockBox = MockHiveBox();
+      gService = GService();
+
+      // Setup Hive mock
+      when(() => mockBox.get(any())).thenReturn(null);
+      when(() => mockBox.put(any(), any())).thenAnswer((_) async {});
+      when(() => mockBox.delete(any())).thenAnswer((_) async {});
+      when(() => mockBox.clear()).thenAnswer((_) async {});
+    });
+
+    tearDown(() {
+      Get.reset();
+    });
+
+    test('should initialize correctly', () async {
+      // Act
+      await gService.init();
+
+      // Assert
+      expect(gService, isA<GService>());
+    });
+
+    test('should check first time correctly when true', () {
+      // Arrange
+      when(() => mockBox.get('isFirstTime')).thenReturn(true);
+
+      // Act
+      final result = gService.isFirstTime();
+
+      // Assert
+      expect(result, isTrue);
+    });
+
+    test('should check first time correctly when false', () {
+      // Arrange
+      when(() => mockBox.get('isFirstTime')).thenReturn(false);
+
+      // Act
+      final result = gService.isFirstTime();
+
+      // Assert
+      expect(result, isFalse);
+    });
+
+    test('should return true for first time when no value stored', () {
+      // Arrange
+      when(() => mockBox.get('isFirstTime')).thenReturn(null);
+
+      // Act
+      final result = gService.isFirstTime();
+
+      // Assert
+      expect(result, isTrue);
+    });
+
+    test('should set is not first time', () async {
+      // Act
+      await gService.setIsNotFirstTime();
+
+      // Assert - Method should complete without error
+      expect(() => gService.setIsNotFirstTime(), returnsNormally);
+    });
+
+    test('should save and retrieve target page', () {
+      // Arrange
+      const testPage = '/test-page';
+      when(() => mockBox.get('targetPage')).thenReturn(testPage);
+
+      // Act
+      gService.saveTargetPage(testPage);
+      final retrievedPage = gService.getTargetPage();
+
+      // Assert
+      expect(retrievedPage, equals(testPage));
+    });
+
+    test('should handle null target page', () {
+      // Arrange
+      when(() => mockBox.get('targetPage')).thenReturn(null);
+
+      // Act
+      final retrievedPage = gService.getTargetPage();
+
+      // Assert
+      expect(retrievedPage, isNull);
+    });
+
+    test('should clear target page', () {
+      // Act
+      gService.clearTargetPage();
+
+      // Assert
+      expect(() => gService.clearTargetPage(), returnsNormally);
+    });
+
+    test('should save and retrieve user preferences', () {
+      // Arrange
+      const testPreference = 'dark_mode';
+      when(() => mockBox.get('userPreference')).thenReturn(testPreference);
+
+      // Act
+      gService.saveUserPreference(testPreference);
+      final retrievedPreference = gService.getUserPreference();
+
+      // Assert
+      expect(retrievedPreference, equals(testPreference));
+    });
+  });
+}

test/unit/packages/core/services/token_storage_service_test.dart

@@ -0,0 +1,104 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:rasadyar_core/core.dart';
+
+class MockHiveBox extends Mock implements Box {}
+
+void main() {
+  group('TokenStorageService Tests', () {
+    late TokenStorageService tokenStorageService;
+    late MockHiveBox mockBox;
+
+    setUp(() {
+      mockBox = MockHiveBox();
+      tokenStorageService = TokenStorageService();
+
+      // Setup Hive mock
+      when(() => mockBox.get(any())).thenReturn(null);
+      when(() => mockBox.put(any(), any())).thenAnswer((_) async {});
+      when(() => mockBox.delete(any())).thenAnswer((_) async {});
+      when(() => mockBox.clear()).thenAnswer((_) async {});
+    });
+
+    tearDown(() {
+      Get.reset();
+    });
+
+    test('should initialize correctly', () async {
+      // Act
+      await tokenStorageService.init();
+
+      // Assert
+      expect(tokenStorageService, isA<TokenStorageService>());
+    });
+
+    test('should save and retrieve access token', () {
+      // Arrange
+      const testToken = 'test_access_token';
+      when(() => mockBox.get('accessToken')).thenReturn(testToken);
+
+      // Act
+      tokenStorageService.saveAccessToken(testToken);
+      final retrievedToken = tokenStorageService.getAccessToken();
+
+      // Assert
+      expect(retrievedToken, equals(testToken));
+    });
+
+    test('should save and retrieve refresh token', () {
+      // Arrange
+      const testToken = 'test_refresh_token';
+      when(() => mockBox.get('refreshToken')).thenReturn(testToken);
+
+      // Act
+      tokenStorageService.saveRefreshToken(testToken);
+      final retrievedToken = tokenStorageService.getRefreshToken();
+
+      // Assert
+      expect(retrievedToken, equals(testToken));
+    });
+
+    test('should clear all tokens', () {
+      // Act
+      tokenStorageService.clearTokens();
+
+      // Assert
+      expect(tokenStorageService.getAccessToken(), isNull);
+      expect(tokenStorageService.getRefreshToken(), isNull);
+    });
+
+    test('should check if user is authenticated', () {
+      // Arrange
+      when(() => mockBox.get('accessToken')).thenReturn('valid_token');
+
+      // Act
+      final isAuthenticated = tokenStorageService.isAuthenticated();
+
+      // Assert
+      expect(isAuthenticated, isTrue);
+    });
+
+    test('should return false when not authenticated', () {
+      // Arrange
+      when(() => mockBox.get('accessToken')).thenReturn(null);
+
+      // Act
+      final isAuthenticated = tokenStorageService.isAuthenticated();
+
+      // Assert
+      expect(isAuthenticated, isFalse);
+    });
+
+    test('should handle empty token strings', () {
+      // Arrange
+      when(() => mockBox.get('accessToken')).thenReturn('');
+
+      // Act
+      final isAuthenticated = tokenStorageService.isAuthenticated();
+
+      // Assert
+      expect(isAuthenticated, isFalse);
+    });
+  });
+}