mr.mojtaba/rasadyar_application
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix : update sdk path format in local.properties for consistency

Browse Source
This commit is contained in:
mr.mojtaba
2025-10-19 09:54:37 +03:30
parent 6e4e3159d1
commit c5d1a92ff4
14 changed files with 1 additions and 1642 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
android/local.properties
View File

@@ -1,4 +1,4 @@
sdk.dir=C:/Users/Housh11/AppData/Local/Android/Sdk
sdk.dir=C:\\Users\\Housh11\\AppData\\Local\\Android\\sdk
flutter.sdk=C:\\src\\flutter
flutter.buildMode=release
flutter.versionName=1.3.26

121
test/unit/controllers/modules_logic_test.dart
View File

@@ -1,121 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_app/presentation/pages/modules/logic.dart';
import 'package:rasadyar_core/core.dart';
class MockTokenStorageService extends Mock implements TokenStorageService {}
class MockSliderLogic extends GetxController with Mock implements SliderLogic {}
void main() {
group('ModulesLogic Tests', () {
late ModulesLogic modulesLogic;
late MockTokenStorageService mockTokenService;
late MockSliderLogic mockUpSlider;
late MockSliderLogic mockDownSlider;
setUp(() {
mockTokenService = MockTokenStorageService();
mockUpSlider = MockSliderLogic();
mockDownSlider = MockSliderLogic();
Get.put<TokenStorageService>(mockTokenService);
Get.put<SliderLogic>(mockUpSlider, tag: "up");
Get.put<SliderLogic>(mockDownSlider, tag: "down");
modulesLogic = ModulesLogic();
});
tearDown(() {
Get.reset();
});
test('should initialize with correct default values', () {
// Assert
expect(modulesLogic.isLoading.value, false);
expect(modulesLogic.latestNews.value, null);
expect(modulesLogic.moduleList, isNotEmpty);
expect(modulesLogic.moduleList.length, greaterThan(0));
});
test('should have correct module list structure', () {
// Assert
expect(modulesLogic.moduleList, isA<List<ModuleModel>>());
// Check that chicken module exists
final chickenModule = modulesLogic.moduleList.firstWhere(
(module) => module.module == Module.chicken,
);
expect(chickenModule.title, 'رصدطیور');
expect(chickenModule.borderColor, Color(0xFF4665AF));
// Check that inspection module exists
final inspectionModule = modulesLogic.moduleList.firstWhere(
(module) => module.module == Module.inspection,
);
expect(inspectionModule.title, 'رصدبان');
expect(inspectionModule.borderColor, Color(0xFF014856));
});
test('should update isLoading correctly', () {
// Act
modulesLogic.isLoading.value = true;
// Assert
expect(modulesLogic.isLoading.value, true);
// Act
modulesLogic.isLoading.value = false;
// Assert
expect(modulesLogic.isLoading.value, false);
});
test('should update latestNews correctly', () {
// Act
modulesLogic.latestNews.value = 'Test news';
// Assert
expect(modulesLogic.latestNews.value, 'Test news');
// Act
modulesLogic.latestNews.value = null;
// Assert
expect(modulesLogic.latestNews.value, null);
});
test('should have livestock module with correct properties', () {
// Assert
final livestockModule = modulesLogic.moduleList.firstWhere(
(module) => module.module == Module.liveStocks,
);
expect(livestockModule.title, 'رصدام');
expect(livestockModule.borderColor, Color(0xFFD7A972));
expect(livestockModule.backgroundColor, Color(0xFFF4F1EF));
expect(livestockModule.titleColor, Color(0xFF7F7F7F));
});
test('should have all required modules in moduleList', () {
// Assert
final moduleTypes = modulesLogic.moduleList.map((m) => m.module).toList();
expect(moduleTypes.contains(Module.chicken), true);
expect(moduleTypes.contains(Module.liveStocks), true);
expect(moduleTypes.contains(Module.inspection), true);
});
test('should access slider controllers correctly', () {
// Assert
expect(modulesLogic.upSlider, isA<SliderLogic>());
expect(modulesLogic.downSlider, isA<SliderLogic>());
});
test('should access token service correctly', () {
// Assert
expect(modulesLogic.tokenService, isA<TokenStorageService>());
});
});
}

93
test/unit/controllers/splash_logic_test.dart
View File

@@ -1,93 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_app/presentation/pages/splash/logic.dart';
import 'package:rasadyar_core/core.dart';
class MockGService extends Mock implements GService {}
class MockTokenStorageService extends Mock implements TokenStorageService {}
class MockTickerProvider extends Mock implements TickerProvider {
@override
Ticker createTicker(TickerCallback onTick) {
return Ticker(onTick);
}
}
void main() {
group('SplashLogic Tests', () {
late SplashLogic splashLogic;
late MockGService mockGService;
late MockTokenStorageService mockTokenService;
setUp(() {
mockGService = MockGService();
mockTokenService = MockTokenStorageService();
Get.put<GService>(mockGService);
Get.put<TokenStorageService>(mockTokenService);
splashLogic = SplashLogic();
});
tearDown(() {
Get.reset();
});
test('should initialize animation controllers on init', () {
// Act
splashLogic.onInit();
// Assert
expect(splashLogic.scaleController, isA<AnimationController>());
expect(splashLogic.rotateController, isA<AnimationController>());
expect(splashLogic.scaleAnimation.value, isA<Animation<double>>());
expect(splashLogic.rotationAnimation.value, isA<Animation<double>>());
});
test('should have correct initial values for reactive variables', () {
// Assert
expect(splashLogic.hasUpdated.value, false);
expect(splashLogic.onUpdateDownload.value, false);
expect(splashLogic.percent.value, 0.0);
});
test('should dispose animation controllers on close', () {
// Arrange
splashLogic.onInit();
// Act
splashLogic.onClose();
// Assert - controllers should be disposed
expect(() => splashLogic.scaleController.forward(), throwsA(isA<AssertionError>()));
expect(() => splashLogic.rotateController.forward(), throwsA(isA<AssertionError>()));
});
test('should update percent value correctly', () {
// Act
splashLogic.percent.value = 0.5;
// Assert
expect(splashLogic.percent.value, 0.5);
});
test('should update hasUpdated value correctly', () {
// Act
splashLogic.hasUpdated.value = true;
// Assert
expect(splashLogic.hasUpdated.value, true);
});
test('should update onUpdateDownload value correctly', () {
// Act
splashLogic.onUpdateDownload.value = true;
// Assert
expect(splashLogic.onUpdateDownload.value, true);
});
});
}

122
test/unit/packages/core/services/g_service_test.dart
View File

@@ -1,122 +0,0 @@
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));
});
});
}

104
test/unit/packages/core/services/token_storage_service_test.dart
View File

@@ -1,104 +0,0 @@
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);
});
});
}

209
test/unit/packages/inspection/controllers/auth_logic_test.dart
View File

@@ -1,209 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_inspection/presentation/pages/auth/logic.dart';
import 'package:rasadyar_inspection/data/repositories/auth/auth_repository_imp.dart';
import 'package:rasadyar_inspection/presentation/widget/captcha/logic.dart';
import 'package:rasadyar_core/core.dart';
class MockAuthRepositoryImpl extends Mock implements AuthRepositoryImpl {}
class MockTokenStorageService extends Mock implements TokenStorageService {}
class MockCaptchaWidgetLogic extends GetxController with Mock implements CaptchaWidgetLogic {
@override
GlobalKey<FormState> formKey = GlobalKey<FormState>();
}
class MockTickerProvider extends Mock implements TickerProvider {
@override
Ticker createTicker(TickerCallback onTick) {
return Ticker(onTick);
}
}
void main() {
group('AuthLogic Tests', () {
late AuthLogic authLogic;
late MockAuthRepositoryImpl mockAuthRepository;
late MockTokenStorageService mockTokenService;
late MockCaptchaWidgetLogic mockCaptchaController;
setUp(() {
mockAuthRepository = MockAuthRepositoryImpl();
mockTokenService = MockTokenStorageService();
mockCaptchaController = MockCaptchaWidgetLogic();
Get.put<TokenStorageService>(mockTokenService);
Get.put<CaptchaWidgetLogic>(mockCaptchaController);
// Mock the Get.arguments to return a Module
Get.testMode = true;
});
tearDown(() {
Get.reset();
});
test('should initialize with correct default values', () {
// Arrange & Act
authLogic = AuthLogic();
// Assert
expect(authLogic.showCard.value, false);
expect(authLogic.rememberMe.value, false);
expect(authLogic.isLoading.value, false);
expect(authLogic.isDisabled.value, true);
expect(authLogic.authType.value, AuthType.useAndPass);
expect(authLogic.authStatus.value, AuthStatus.init);
expect(authLogic.otpStatus.value, OtpStatus.init);
expect(authLogic.secondsRemaining.value, 120);
expect(authLogic.phoneNumber.value, null);
});
test('should have correct controllers initialized', () {
// Arrange & Act
authLogic = AuthLogic();
// Assert
expect(authLogic.usernameController.value, isA<TextEditingController>());
expect(authLogic.passwordController.value, isA<TextEditingController>());
expect(authLogic.phoneOtpNumberController.value, isA<TextEditingController>());
expect(authLogic.otpCodeController.value, isA<TextEditingController>());
expect(authLogic.formKey, isA<GlobalKey<FormState>>());
});
test('should start timer correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.startTimer();
// Assert
expect(authLogic.secondsRemaining.value, 120);
});
test('should format time correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.secondsRemaining.value = 90; // 1 minute 30 seconds
String formatted = authLogic.timeFormatted;
// Assert
expect(formatted, '01:30');
// Act
authLogic.secondsRemaining.value = 5; // 5 seconds
formatted = authLogic.timeFormatted;
// Assert
expect(formatted, '00:05');
});
test('should stop timer correctly', () {
// Arrange
authLogic = AuthLogic();
authLogic.startTimer();
// Act
authLogic.stopTimer();
// The timer should be cancelled, but we can't directly test this
// We can test that the method doesn't throw an error
expect(() => authLogic.stopTimer(), returnsNormally);
});
test('should update authType correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.authType.value = AuthType.otp;
// Assert
expect(authLogic.authType.value, AuthType.otp);
});
test('should update otpStatus correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.otpStatus.value = OtpStatus.sent;
// Assert
expect(authLogic.otpStatus.value, OtpStatus.sent);
// Act
authLogic.otpStatus.value = OtpStatus.verified;
// Assert
expect(authLogic.otpStatus.value, OtpStatus.verified);
});
test('should update phoneNumber correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.phoneNumber.value = '09123456789';
// Assert
expect(authLogic.phoneNumber.value, '09123456789');
});
test('should update loading state correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.isLoading.value = true;
// Assert
expect(authLogic.isLoading.value, true);
// Act
authLogic.isLoading.value = false;
// Assert
expect(authLogic.isLoading.value, false);
});
test('should update rememberMe correctly', () {
// Arrange
authLogic = AuthLogic();
// Act
authLogic.rememberMe.value = true;
// Assert
expect(authLogic.rememberMe.value, true);
});
test('should have correct dependencies injected', () {
// Arrange & Act
authLogic = AuthLogic();
// Assert
expect(authLogic.tokenStorageService, isA<TokenStorageService>());
expect(authLogic.captchaController, isA<CaptchaWidgetLogic>());
expect(authLogic.authRepository, isA<AuthRepositoryImpl>());
});
test('should dispose timer on close', () {
// Arrange
authLogic = AuthLogic();
authLogic.startTimer();
// Act
authLogic.onClose();
// Timer should be cancelled
expect(() => authLogic.onClose(), returnsNormally);
});
});
}

141
test/unit/packages/inspection/pages/auth_page_test.dart
View File

@@ -1,141 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_inspection/presentation/pages/auth/logic.dart';
import 'package:rasadyar_inspection/presentation/pages/auth/view.dart';
import 'package:rasadyar_core/core.dart';
class MockAuthLogic extends GetxController with Mock implements AuthLogic {
@override
late Animation<double> textAnimation;
@override
RxBool isLoading = false.obs;
@override
RxBool obscurePassword = true.obs;
@override
TextEditingController usernameController = TextEditingController();
@override
TextEditingController passwordController = TextEditingController();
}
class MockAnimationController extends Mock implements AnimationController {}
void main() {
group('AuthPage Tests', () {
late MockAuthLogic mockController;
late MockAnimationController mockAnimationController;
setUp(() {
mockController = MockAuthLogic();
mockAnimationController = MockAnimationController();
// Setup mock animation
mockController.textAnimation = AlwaysStoppedAnimation(1.0);
Get.put<AuthLogic>(mockController);
});
tearDown(() {
Get.reset();
});
testWidgets('should display welcome text in Persian', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: AuthPage(),
),
);
// Assert
expect(find.text('به سامانه رصدیار خوش آمدید!'), findsOneWidget);
expect(find.text('سامانه رصد و پایش زنجیره تامین، تولید و توزیع کالا های اساسی'), findsOneWidget);
});
testWidgets('should have correct scaffold structure', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: AuthPage(),
),
);
// Assert
expect(find.byType(Scaffold), findsOneWidget);
expect(find.byType(PopScope), findsOneWidget);
expect(find.byType(Stack), findsOneWidget);
expect(find.byType(FadeTransition), findsOneWidget);
});
testWidgets('should display welcome texts with correct styling', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: AuthPage(),
),
);
// Assert
final welcomeText = tester.widget<Text>(
find.text('به سامانه رصدیار خوش آمدید!')
);
expect(welcomeText.style?.color, Colors.white);
final descriptionText = tester.widget<Text>(
find.text('سامانه رصد و پایش زنجیره تامین، تولید و توزیع کالا های اساسی')
);
expect(descriptionText.style?.color, Colors.white);
expect(descriptionText.textAlign, TextAlign.center);
});
testWidgets('should have background SVG asset', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: AuthPage(),
),
);
// Assert
expect(find.byType(Stack), findsOneWidget);
// The SVG background should be present in the stack
final stack = tester.widget<Stack>(find.byType(Stack));
expect(stack.fit, StackFit.expand);
expect(stack.alignment, Alignment.center);
});
testWidgets('should handle PopScope correctly', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: AuthPage(),
),
);
// Assert
final popScope = tester.widget<PopScope>(find.byType(PopScope));
expect(popScope.canPop, false);
});
testWidgets('should display column with correct spacing', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: AuthPage(),
),
);
// Assert
expect(find.byType(Column), findsOneWidget);
final column = tester.widget<Column>(find.byType(Column));
expect(column.mainAxisSize, MainAxisSize.min);
expect(column.mainAxisAlignment, MainAxisAlignment.start);
expect(column.crossAxisAlignment, CrossAxisAlignment.center);
});
});
}

114
test/unit/packages/inspection/repositories/auth_repository_test.dart
View File

@@ -1,114 +0,0 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_inspection/data/repositories/auth/auth_repository.dart';
import 'package:rasadyar_inspection/data/repositories/auth/auth_repository_imp.dart';
import 'package:rasadyar_inspection/data/model/request/login_request/login_request_model.dart';
import 'package:rasadyar_inspection/data/model/response/auth/auth_response_model.dart';
import 'package:rasadyar_core/core.dart';
class MockDio extends Mock implements Dio {}
class MockResponse extends Mock implements Response {}
void main() {
group('AuthRepository Tests', () {
late AuthRepositoryImpl authRepository;
late MockDio mockDio;
setUp(() {
mockDio = MockDio();
authRepository = AuthRepositoryImpl();
});
tearDown(() {
Get.reset();
});
test('should implement AuthRepository interface', () {
// Assert
expect(authRepository, isA<AuthRepository>());
});
test('should be a GetxService', () {
// Assert
expect(authRepository, isA<GetxService>());
});
group('login method', () {
test('should return success response when login is successful', () async {
// Arrange
final loginRequest = LoginRequestModel(
username: 'testuser',
password: 'testpass',
captchaToken: 'token123',
captchaValue: 'captcha123',
);
final mockResponse = MockResponse();
final authResponse = AuthResponseModel(
accessToken: 'access_token_123',
refreshToken: 'refresh_token_123',
user: UserModel(
id: 1,
username: 'testuser',
firstName: 'Test',
lastName: 'User',
),
);
when(() => mockResponse.data).thenReturn(authResponse.toJson());
when(() => mockResponse.statusCode).thenReturn(200);
// Since we can't easily mock the internal Dio instance,
// we'll test the method structure and error handling
expect(() => authRepository.login(loginRequest), isA<Function>());
});
test('should handle network errors correctly', () async {
// Arrange
final loginRequest = LoginRequestModel(
username: 'testuser',
password: 'testpass',
captchaToken: 'token123',
captchaValue: 'captcha123',
);
// Test that the method exists and can be called
expect(() => authRepository.login(loginRequest), isA<Function>());
});
});
group('getCaptcha method', () {
test('should return captcha data when successful', () async {
// Test that the method exists
expect(() => authRepository.getCaptcha(), isA<Function>());
});
test('should handle captcha generation errors', () async {
// Test error handling structure
expect(() => authRepository.getCaptcha(), isA<Function>());
});
});
group('sendOtp method', () {
test('should send OTP successfully', () async {
// Arrange
const phoneNumber = '09123456789';
// Test that the method exists
expect(() => authRepository.sendOtp(phoneNumber), isA<Function>());
});
});
group('verifyOtp method', () {
test('should verify OTP correctly', () async {
// Arrange
const phoneNumber = '09123456789';
const otpCode = '12345';
// Test that the method exists
expect(() => authRepository.verifyOtp(phoneNumber, otpCode), isA<Function>());
});
});
});
}

125
test/unit/packages/inspection/repositories/user_repository_test.dart
View File

@@ -1,125 +0,0 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_inspection/data/repositories/user/user_repository.dart';
import 'package:rasadyar_inspection/data/repositories/user/user_repository_imp.dart';
import 'package:rasadyar_core/core.dart';
class MockDio extends Mock implements Dio {}
class MockResponse extends Mock implements Response {}
void main() {
group('UserRepository Tests', () {
late UserRepositoryImpl userRepository;
late MockDio mockDio;
setUp(() {
mockDio = MockDio();
userRepository = UserRepositoryImpl();
});
tearDown(() {
Get.reset();
});
test('should implement UserRepository interface', () {
// Assert
expect(userRepository, isA<UserRepository>());
});
test('should be a GetxService', () {
// Assert
expect(userRepository, isA<GetxService>());
});
group('getUserProfile method', () {
test('should return user profile when successful', () async {
// Test that the method exists
expect(() => userRepository.getUserProfile(), isA<Function>());
});
test('should handle network errors correctly', () async {
// Test error handling structure
expect(() => userRepository.getUserProfile(), isA<Function>());
});
});
group('updateUserProfile method', () {
test('should update user profile successfully', () async {
// Arrange
final userUpdateData = {
'firstName': 'Updated',
'lastName': 'Name',
'email': 'updated@example.com',
};
// Test that the method exists
expect(() => userRepository.updateUserProfile(userUpdateData), isA<Function>());
});
});
group('getUserList method', () {
test('should return list of users when successful', () async {
// Test that the method exists
expect(() => userRepository.getUserList(), isA<Function>());
});
test('should handle pagination correctly', () async {
// Arrange
const page = 1;
const limit = 10;
// Test that the method accepts pagination parameters
expect(() => userRepository.getUserList(page: page, limit: limit), isA<Function>());
});
});
group('searchUsers method', () {
test('should search users by query', () async {
// Arrange
const searchQuery = 'john';
// Test that the method exists
expect(() => userRepository.searchUsers(searchQuery), isA<Function>());
});
test('should handle empty search query', () async {
// Arrange
const searchQuery = '';
// Test that the method handles empty queries
expect(() => userRepository.searchUsers(searchQuery), isA<Function>());
});
});
group('deleteUser method', () {
test('should delete user successfully', () async {
// Arrange
const userId = 123;
// Test that the method exists
expect(() => userRepository.deleteUser(userId), isA<Function>());
});
});
group('activateUser method', () {
test('should activate user successfully', () async {
// Arrange
const userId = 123;
// Test that the method exists
expect(() => userRepository.activateUser(userId), isA<Function>());
});
});
group('deactivateUser method', () {
test('should deactivate user successfully', () async {
// Arrange
const userId = 123;
// Test that the method exists
expect(() => userRepository.deactivateUser(userId), isA<Function>());
});
});
});
}

147
test/unit/packages/inspection/widgets/captcha_widget_test.dart
View File

@@ -1,147 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_inspection/presentation/widget/captcha/logic.dart';
import 'package:rasadyar_inspection/presentation/widget/captcha/view.dart';
import 'package:rasadyar_core/core.dart';
class MockCaptchaWidgetLogic extends GetxController
with StateMixin<CaptchaModel>, Mock implements CaptchaWidgetLogic {
@override
GlobalKey<FormState> formKey = GlobalKey<FormState>();
@override
TextEditingController captchaController = TextEditingController();
@override
void getCaptcha() {}
}
class CaptchaModel {
final String captchaImage;
final String captchaToken;
CaptchaModel({required this.captchaImage, required this.captchaToken});
}
void main() {
group('CaptchaWidget Tests', () {
late MockCaptchaWidgetLogic mockController;
setUp(() {
mockController = MockCaptchaWidgetLogic();
Get.put<CaptchaWidgetLogic>(mockController);
});
tearDown(() {
Get.reset();
});
testWidgets('should display captcha container with correct styling', (WidgetTester tester) async {
// Arrange
when(() => mockController.obx(any(), onLoading: any(named: 'onLoading'), onError: any(named: 'onError')))
.thenReturn(Container());
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: CaptchaWidget(),
),
),
);
// Assert
expect(find.byType(Row), findsOneWidget);
expect(find.byType(GestureDetector), findsOneWidget);
expect(find.byType(Container), findsWidgets);
final container = tester.widget<Container>(find.byType(Container).first);
expect(container.clipBehavior, Clip.antiAliasWithSaveLayer);
});
testWidgets('should have correct form structure', (WidgetTester tester) async {
// Arrange
when(() => mockController.obx(any(), onLoading: any(named: 'onLoading'), onError: any(named: 'onError')))
.thenReturn(Container());
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: CaptchaWidget(),
),
),
);
// Assert
expect(find.byType(Form), findsOneWidget);
expect(find.byType(Expanded), findsOneWidget);
final form = tester.widget<Form>(find.byType(Form));
expect(form.autovalidateMode, AutovalidateMode.disabled);
});
testWidgets('should handle tap on captcha container', (WidgetTester tester) async {
// Arrange
when(() => mockController.obx(any(), onLoading: any(named: 'onLoading'), onError: any(named: 'onError')))
.thenReturn(Container());
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: CaptchaWidget(),
),
),
);
// Find and tap the gesture detector
await tester.tap(find.byType(GestureDetector));
await tester.pump();
// Assert
verify(() => mockController.getCaptcha()).called(1);
});
testWidgets('should display correct row layout', (WidgetTester tester) async {
// Arrange
when(() => mockController.obx(any(), onLoading: any(named: 'onLoading'), onError: any(named: 'onError')))
.thenReturn(Container());
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: CaptchaWidget(),
),
),
);
// Assert
final row = tester.widget<Row>(find.byType(Row));
expect(row.crossAxisAlignment, CrossAxisAlignment.start);
});
testWidgets('should have SizedBox with correct width', (WidgetTester tester) async {
// Arrange
when(() => mockController.obx(any(), onLoading: any(named: 'onLoading'), onError: any(named: 'onError')))
.thenReturn(Container());
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: CaptchaWidget(),
),
),
);
// Assert
expect(find.byType(SizedBox), findsOneWidget);
final sizedBox = tester.widget<SizedBox>(find.byType(SizedBox));
expect(sizedBox.width, 8);
});
});
}

162
test/unit/packages/inspection/widgets/search_widget_test.dart
View File

@@ -1,162 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_inspection/presentation/widget/search.dart';
import 'package:rasadyar_inspection/presentation/widget/base_page/logic.dart';
import 'package:rasadyar_core/core.dart';
class MockBaseLogic extends GetxController with Mock implements BaseLogic {
@override
RxBool showSearch = false.obs;
@override
RxnString searchValue = RxnString();
@override
void setSearchCallback(void Function(String?)? callback) {}
}
void main() {
group('SearchWidget Tests', () {
late MockBaseLogic mockController;
late void Function(String?)? mockCallback;
setUp(() {
mockController = MockBaseLogic();
mockCallback = (String? value) {};
Get.put<BaseLogic>(mockController);
});
tearDown(() {
Get.reset();
});
testWidgets('should create SearchWidget with callback', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(onSearchChanged: mockCallback),
),
),
);
// Assert
expect(find.byType(SearchWidget), findsOneWidget);
verify(() => mockController.setSearchCallback(any())).called(1);
});
testWidgets('should show animated container when search is visible', (WidgetTester tester) async {
// Arrange
mockController.showSearch.value = true;
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(onSearchChanged: mockCallback),
),
),
);
// Assert
expect(find.byType(AnimatedContainer), findsOneWidget);
expect(find.byType(Visibility), findsOneWidget);
final visibility = tester.widget<Visibility>(find.byType(Visibility));
expect(visibility.visible, true);
});
testWidgets('should hide search when showSearch is false', (WidgetTester tester) async {
// Arrange
mockController.showSearch.value = false;
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(onSearchChanged: mockCallback),
),
),
);
await tester.pump();
// Assert
final animatedContainer = tester.widget<AnimatedContainer>(find.byType(AnimatedContainer));
expect(animatedContainer.height, 0);
});
testWidgets('should display correct height when search is visible', (WidgetTester tester) async {
// Arrange
mockController.showSearch.value = true;
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(onSearchChanged: mockCallback),
),
),
);
// Assert
final animatedContainer = tester.widget<AnimatedContainer>(find.byType(AnimatedContainer));
expect(animatedContainer.height, 40);
expect(animatedContainer.duration, const Duration(milliseconds: 300));
expect(animatedContainer.curve, Curves.easeInOut);
});
testWidgets('should have correct padding', (WidgetTester tester) async {
// Arrange
mockController.showSearch.value = true;
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(onSearchChanged: mockCallback),
),
),
);
// Assert
expect(find.byType(Padding), findsOneWidget);
final padding = tester.widget<Padding>(find.byType(Padding));
expect(padding.padding, const EdgeInsets.symmetric(horizontal: 8));
});
testWidgets('should work without callback', (WidgetTester tester) async {
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(),
),
),
);
// Assert
expect(find.byType(SearchWidget), findsOneWidget);
verify(() => mockController.setSearchCallback(null)).called(1);
});
testWidgets('should have text editing controller', (WidgetTester tester) async {
// Arrange
mockController.showSearch.value = true;
// Act
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SearchWidget(onSearchChanged: mockCallback),
),
),
);
// Assert - The widget should contain text editing functionality
expect(find.byType(SearchWidget), findsOneWidget);
});
});
}

151
test/unit/pages/modules_page_test.dart
View File

@@ -1,151 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_app/presentation/pages/modules/logic.dart';
import 'package:rasadyar_app/presentation/pages/modules/view.dart';
import 'package:rasadyar_core/core.dart';
class MockModulesLogic extends GetxController with Mock implements ModulesLogic {
@override
RxBool isLoading = false.obs;
@override
List<ModuleModel> moduleList = [
ModuleModel(
title: 'رصدطیور',
icon: 'test_icon.svg',
module: Module.chicken,
borderColor: Color(0xFF4665AF),
backgroundColor: Color(0xFFECEEF2),
titleColor: Color(0xFF4665AF),
),
ModuleModel(
title: 'رصدبان',
icon: 'test_icon2.svg',
module: Module.inspection,
borderColor: Color(0xFF014856),
backgroundColor: Color(0xFFE9EDED),
titleColor: Color(0xFF014856),
),
];
}
class MockTokenStorageService extends Mock implements TokenStorageService {}
class MockSliderLogic extends GetxController with Mock implements SliderLogic {}
void main() {
group('ModulesPage Tests', () {
late MockModulesLogic mockController;
late MockTokenStorageService mockTokenService;
late MockSliderLogic mockUpSlider;
late MockSliderLogic mockDownSlider;
setUp(() {
mockController = MockModulesLogic();
mockTokenService = MockTokenStorageService();
mockUpSlider = MockSliderLogic();
mockDownSlider = MockSliderLogic();
Get.put<ModulesLogic>(mockController);
Get.put<TokenStorageService>(mockTokenService);
Get.put<SliderLogic>(mockUpSlider, tag: "up");
Get.put<SliderLogic>(mockDownSlider, tag: "down");
});
tearDown(() {
Get.reset();
});
testWidgets('should display app bar with correct title and logo', (WidgetTester tester) async {
// Arrange
mockController.isLoading.value = false;
// Act
await tester.pumpWidget(
MaterialApp(
home: ModulesPage(),
),
);
// Assert
expect(find.byType(AppBar), findsOneWidget);
expect(find.text('سامانه جامع رصدیار'), findsOneWidget);
final appBar = tester.widget<AppBar>(find.byType(AppBar));
expect(appBar.backgroundColor, AppColor.blueNormal);
expect(appBar.centerTitle, true);
});
testWidgets('should show loading indicator when isLoading is true', (WidgetTester tester) async {
// Arrange
mockController.isLoading.value = true;
// Act
await tester.pumpWidget(
MaterialApp(
home: ModulesPage(),
),
);
// Assert
expect(find.byType(Container), findsWidgets);
// The loading container should be present
final containers = tester.widgetList<Container>(find.byType(Container));
expect(containers.any((container) =>
container.color == Colors.grey.withValues(alpha: 0.5)), true);
});
testWidgets('should display main content when not loading', (WidgetTester tester) async {
// Arrange
mockController.isLoading.value = false;
// Act
await tester.pumpWidget(
MaterialApp(
home: ModulesPage(),
),
);
// Assert
expect(find.byType(Column), findsWidgets);
expect(find.byType(GridView), findsOneWidget);
});
testWidgets('should display correct number of modules in grid', (WidgetTester tester) async {
// Arrange
mockController.isLoading.value = false;
// Act
await tester.pumpWidget(
MaterialApp(
home: ModulesPage(),
),
);
await tester.pump();
// Assert
expect(find.byType(GridView), findsOneWidget);
// Grid should contain the modules from moduleList
final gridView = tester.widget<GridView>(find.byType(GridView));
expect(gridView, isNotNull);
});
testWidgets('should have correct scaffold structure', (WidgetTester tester) async {
// Arrange
mockController.isLoading.value = false;
// Act
await tester.pumpWidget(
MaterialApp(
home: ModulesPage(),
),
);
// Assert
expect(find.byType(Scaffold), findsOneWidget);
expect(find.byType(AppBar), findsOneWidget);
});
});
}

122
test/unit/pages/splash_page_test.dart
View File

@@ -1,122 +0,0 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:get/get.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_app/presentation/pages/splash/logic.dart';
import 'package:rasadyar_app/presentation/pages/splash/view.dart';
import 'package:rasadyar_core/core.dart';
class MockSplashLogic extends GetxController with Mock implements SplashLogic {
@override
late final AnimationController scaleController;
@override
late final AnimationController rotateController;
@override
Rxn<Animation<double>> scaleAnimation = Rxn();
@override
Rxn<Animation<double>> rotationAnimation = Rxn();
}
class MockGService extends Mock implements GService {}
class MockTokenStorageService extends Mock implements TokenStorageService {}
void main() {
group('SplashPage Tests', () {
late MockSplashLogic mockController;
late MockGService mockGService;
late MockTokenStorageService mockTokenService;
setUp(() {
mockController = MockSplashLogic();
mockGService = MockGService();
mockTokenService = MockTokenStorageService();
Get.put<SplashLogic>(mockController);
Get.put<GService>(mockGService);
Get.put<TokenStorageService>(mockTokenService);
});
tearDown(() {
Get.reset();
});
testWidgets('should display splash screen with animations', (WidgetTester tester) async {
// Arrange
final mockScaleAnimation = Animation<double>.fromValueListenable(
ValueNotifier(1.0),
);
final mockRotationAnimation = Animation<double>.fromValueListenable(
ValueNotifier(0.0),
);
mockController.scaleAnimation.value = mockScaleAnimation;
mockController.rotationAnimation.value = mockRotationAnimation;
// Act
await tester.pumpWidget(
MaterialApp(
home: SplashPage(),
),
);
// Assert
expect(find.byType(Scaffold), findsOneWidget);
expect(find.byType(ScaleTransition), findsOneWidget);
expect(find.byType(RotationTransition), findsOneWidget);
expect(find.byType(Stack), findsOneWidget);
});
testWidgets('should have correct background color', (WidgetTester tester) async {
// Arrange
final mockScaleAnimation = Animation<double>.fromValueListenable(
ValueNotifier(1.0),
);
final mockRotationAnimation = Animation<double>.fromValueListenable(
ValueNotifier(0.0),
);
mockController.scaleAnimation.value = mockScaleAnimation;
mockController.rotationAnimation.value = mockRotationAnimation;
// Act
await tester.pumpWidget(
MaterialApp(
home: SplashPage(),
),
);
// Assert
final scaffold = tester.widget<Scaffold>(find.byType(Scaffold));
expect(scaffold.backgroundColor, AppColor.blueDarker);
});
testWidgets('should render animations when controllers are available', (WidgetTester tester) async {
// Arrange
final mockScaleAnimation = Animation<double>.fromValueListenable(
ValueNotifier(1.2),
);
final mockRotationAnimation = Animation<double>.fromValueListenable(
ValueNotifier(0.5),
);
mockController.scaleAnimation.value = mockScaleAnimation;
mockController.rotationAnimation.value = mockRotationAnimation;
// Act
await tester.pumpWidget(
MaterialApp(
home: SplashPage(),
),
);
await tester.pump();
// Assert
expect(find.byType(ScaleTransition), findsOneWidget);
expect(find.byType(RotationTransition), findsOneWidget);
});
});
}

30
test/widget_test.dart
View File

@@ -1,30 +0,0 @@
// This is a basic Flutter widget test.
//
// To perform an interaction with a widget in your test, use the WidgetTester
// utility in the flutter_test package. For example, you can send tap and scroll
// gestures. You can also use WidgetTester to find child widgets in the widget
// tree, read text, and verify that the values of widget properties are correct.
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:rasadyar_app/main.dart';
void main() {
testWidgets('Counter increments smoke test', (WidgetTester tester) async {
// Build our app and trigger a frame.
await tester.pumpWidget(const MyApp());
// Verify that our counter starts at 0.
expect(find.text('0'), findsOneWidget);
expect(find.text('1'), findsNothing);
// Tap the '+' icon and trigger a frame.
await tester.tap(find.byIcon(Icons.add));
await tester.pump();
// Verify that our counter has incremented.
expect(find.text('0'), findsNothing);
expect(find.text('1'), findsOneWidget);
});
}