feat(consultant): Issue-420 + Tests

test/features/consultant/become_consultant/presentation/bloc/register_consultant_cubit_test.dart

@@ -0,0 +1,130 @@
+import 'package:eatvio_app/features/consultant/become_consultant/models/consultant_cert_photo_model.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/models/consultant_profile_model.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/models/consultation_request_model.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/presentation/bloc/register_consultant_cubit/register_consultant_cubit.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/repositories/consultant_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+
+import '../../../../../fixtures/fixture_reader.dart';
+
+class MockConsultantRepository extends Mock implements ConsultantRepository {}
+
+void main() {
+  setUpAll(() {
+    registerFallbackValue(const ConsultantProfileModel());
+    registerFallbackValue('');
+    registerFallbackValue(false);
+    registerFallbackValue(0);
+  });
+
+  group('RegisterConsultantCubit', () {
+    late MockConsultantRepository repository;
+    late RegisterConsultantCubit cubit;
+    late ConsultationRequestModel requestModel;
+    late List<ConsultantCertPhotoModel> certPhotosFromFixture;
+    late ConsultantProfileModel consultantProfile;
+
+    setUp(() {
+      repository = MockConsultantRepository();
+      cubit = RegisterConsultantCubit(consultantRepository: repository);
+      requestModel = ConsultationRequestModel.fromJson(FixtureReader.readAsMap('consultant/consultation_request.json'));
+      certPhotosFromFixture = FixtureReader.readAsList(
+        'consultant/consultant_cert_photos.json',
+      ).map((item) => ConsultantCertPhotoModel.fromJson(item as Map<String, dynamic>)).toList();
+      consultantProfile = ConsultantProfileModel.fromJson(FixtureReader.readAsMap('consultant/consultant_profile_request.json'));
+    });
+
+    tearDown(() async {
+      await cubit.close();
+    });
+
+    test('initial state has loading=true and default consultant model', () {
+      expect(cubit.state.loading, isTrue);
+      expect(cubit.state.consultant.hasMedicalEducation, isTrue);
+      expect(cubit.state.acceptOffer, isFalse);
+      expect(cubit.state.requestModel, isNull);
+    });
+
+    test('getMyRequestStatus hydrates state with backend data and visible certificates only', () async {
+      when(() => repository.getMyRequestStatus(any<String>())).thenAnswer((_) async => requestModel);
+      when(() => repository.getConsultantCertPhotos()).thenAnswer((_) async => certPhotosFromFixture);
+
+      await cubit.getMyRequestStatus('my-consultant-slug');
+
+      final state = cubit.state;
+      expect(state.loading, isFalse);
+      expect(state.requestModel, equals(requestModel));
+      expect(state.consultant.certificates, isNotNull);
+      expect(state.consultant.certificates, hasLength(2));
+      expect(state.consultant.certificates!.first.title, 'Нутрициология PRO');
+      expect(state.consultant.socialLinks?.instaLink, isNull, reason: 'empty links are sanitized');
+      expect(state.consultant.socialLinks?.vkLink, 'https://vk.com/consultant');
+      expect(state.certPhotos, hasLength(2));
+      expect(state.certPhotos.map((e) => e.id), containsAll(<int>[101, 103]));
+      verify(() => repository.getMyRequestStatus('my-consultant-slug')).called(1);
+      verify(() => repository.getConsultantCertPhotos()).called(1);
+    });
+
+    test('disableLoading stops spinner and loads visible cert photos', () async {
+      when(() => repository.getConsultantCertPhotos()).thenAnswer((_) async => certPhotosFromFixture);
+
+      await cubit.disableLoading();
+
+      expect(cubit.state.loading, isFalse);
+      expect(cubit.state.certPhotos, hasLength(2));
+      verify(() => repository.getConsultantCertPhotos()).called(1);
+    });
+
+    test('updateConsultantProfileModel replaces consultant data and offer flag', () {
+      cubit.updateConsultantProfileModel(consultantProfile, true);
+
+      expect(cubit.state.consultant, consultantProfile);
+      expect(cubit.state.acceptOffer, isTrue);
+      expect(cubit.state.loading, isFalse);
+    });
+
+    test('registerConsultant forwards payload with update=false by default', () async {
+      when(
+        () => repository.registerConsultant(
+          consultant: any<ConsultantProfileModel>(named: 'consultant'),
+          update: any<bool>(named: 'update'),
+        ),
+      ).thenAnswer((_) async {});
+
+      await cubit.registerConsultant();
+
+      verify(() => repository.registerConsultant(consultant: cubit.state.consultant, update: false)).called(1);
+    });
+
+    test('registerConsultant sends update=true after getMyRequestStatus call', () async {
+      when(() => repository.getMyRequestStatus(any<String>())).thenAnswer((_) async => requestModel);
+      when(() => repository.getConsultantCertPhotos()).thenAnswer((_) async => certPhotosFromFixture);
+      when(
+        () => repository.registerConsultant(
+          consultant: any<ConsultantProfileModel>(named: 'consultant'),
+          update: any<bool>(named: 'update'),
+        ),
+      ).thenAnswer((_) async {});
+
+      await cubit.getMyRequestStatus('my-consultant-slug');
+      await cubit.registerConsultant();
+
+      verify(() => repository.registerConsultant(consultant: cubit.state.consultant, update: true)).called(1);
+    });
+
+    test('removeCertPhoto hides cert locally after repository call', () async {
+      when(() => repository.getMyRequestStatus(any<String>())).thenAnswer((_) async => requestModel);
+      when(() => repository.getConsultantCertPhotos()).thenAnswer((_) async => certPhotosFromFixture);
+      when(() => repository.hideConsultantCertPhoto(any<int>())).thenAnswer((_) async {});
+
+      await cubit.getMyRequestStatus('my-consultant-slug');
+      expect(cubit.state.certPhotos, hasLength(2));
+
+      await cubit.removeCertPhoto(101);
+
+      verify(() => repository.hideConsultantCertPhoto(101)).called(1);
+      expect(cubit.state.certPhotos.any((photo) => photo.id == 101), isFalse);
+    });
+  });
+}

test/features/consultant/become_consultant/repositories/consultant_repository_test.dart

@@ -0,0 +1,129 @@
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:dio/dio.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/models/consultant_cert_photo_model.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/models/consultant_profile_model.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/models/consultation_request_model.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/repositories/consultant_repository.dart';
+import 'package:eatvio_app/features/consultant/become_consultant/services/consultant_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+
+import '../../../../fixtures/fixture_reader.dart';
+
+class MockConsultantService extends Mock implements ConsultantService {}
+
+class MockFile extends Mock implements File {}
+
+void main() {
+  setUpAll(() {
+    registerFallbackValue(const ConsultantProfileModel());
+    registerFallbackValue(<MultipartFile>[]);
+    registerFallbackValue(<String, dynamic>{});
+    registerFallbackValue('');
+    registerFallbackValue(false);
+    registerFallbackValue(0);
+  });
+
+  group('ConsultantRepository', () {
+    late ConsultantRepository repository;
+    late MockConsultantService mockService;
+    late ConsultantProfileModel consultantProfile;
+    late ConsultationRequestModel consultationRequest;
+    late List<ConsultantCertPhotoModel> certPhotos;
+
+    setUp(() {
+      mockService = MockConsultantService();
+      repository = ConsultantRepository(consultantService: mockService);
+      consultantProfile = ConsultantProfileModel.fromJson(FixtureReader.readAsMap('consultant/consultant_profile_request.json'));
+      consultationRequest = ConsultationRequestModel.fromJson(FixtureReader.readAsMap('consultant/consultation_request.json'));
+      certPhotos = FixtureReader.readAsList('consultant/consultant_cert_photos.json')
+          .map((item) => ConsultantCertPhotoModel.fromJson(item as Map<String, dynamic>))
+          .toList();
+    });
+
+    test('registerConsultant delegates to consultantRegistration when update=false', () async {
+      when(() => mockService.consultantRegistration(consultantModel: any<ConsultantProfileModel>(named: 'consultantModel'))).thenAnswer((_) async {});
+
+      await repository.registerConsultant(consultant: consultantProfile);
+
+      verify(() => mockService.consultantRegistration(consultantModel: consultantProfile)).called(1);
+      verifyNever(() => mockService.consultantUpdate(consultantModel: any<ConsultantProfileModel>(named: 'consultantModel')));
+    });
+
+    test('registerConsultant delegates to consultantUpdate when update=true', () async {
+      when(() => mockService.consultantUpdate(consultantModel: any<ConsultantProfileModel>(named: 'consultantModel'))).thenAnswer((_) async {});
+
+      await repository.registerConsultant(consultant: consultantProfile, update: true);
+
+      verify(() => mockService.consultantUpdate(consultantModel: consultantProfile)).called(1);
+      verifyNever(() => mockService.consultantRegistration(consultantModel: any<ConsultantProfileModel>(named: 'consultantModel')));
+    });
+
+    test('getConsultantRequestStatus returns request from service', () async {
+      when(() => mockService.getConsultantRequestStatus(slug: any<String>(named: 'slug'))).thenAnswer((_) async => consultationRequest);
+
+      final result = await repository.getConsultantRequestStatus('user-slug');
+
+      expect(result, equals(consultationRequest));
+      verify(() => mockService.getConsultantRequestStatus(slug: 'user-slug')).called(1);
+    });
+
+    test('getMyRequestStatus returns request from service', () async {
+      when(() => mockService.getMyRequestStatus(slug: any<String>(named: 'slug'))).thenAnswer((_) async => consultationRequest);
+
+      final result = await repository.getMyRequestStatus('my-slug');
+
+      expect(result, equals(consultationRequest));
+      verify(() => mockService.getMyRequestStatus(slug: 'my-slug')).called(1);
+    });
+
+    test('getConsultantCertPhotos returns photos from service', () async {
+      when(() => mockService.getConsultantCertPhotos()).thenAnswer((_) async => certPhotos);
+
+      final result = await repository.getConsultantCertPhotos();
+
+      expect(result, certPhotos);
+      verify(() => mockService.getConsultantCertPhotos()).called(1);
+    });
+
+    test('storeConsultantCertPhotos returns empty list when no files provided', () async {
+      final result = await repository.storeConsultantCertPhotos(files: []);
+
+      expect(result, isEmpty);
+      verifyNever(() => mockService.storeConsultantCertPhotos(photos: any<List<MultipartFile>>(named: 'photos')));
+    });
+
+    test('storeConsultantCertPhotos uploads prepared files and returns response', () async {
+      final mockFile = MockFile();
+      when(() => mockFile.readAsBytes()).thenAnswer((_) async => Uint8List.fromList([1, 2, 3]));
+      when(() => mockFile.path).thenReturn('/tmp/certificate.png');
+      when(() => mockService.storeConsultantCertPhotos(photos: any<List<MultipartFile>>(named: 'photos'))).thenAnswer((_) async => certPhotos);
+
+      final result = await repository.storeConsultantCertPhotos(files: [mockFile]);
+
+      expect(result, certPhotos);
+      final capturedArgument = verify(() => mockService.storeConsultantCertPhotos(photos: captureAny<List<MultipartFile>>(named: 'photos'))).captured.single as List<MultipartFile>;
+      expect(capturedArgument, hasLength(1));
+      expect(capturedArgument.first.filename, 'certificate.png');
+    });
+
+    test('hideConsultantCertPhoto sends payload to service', () async {
+      when(() => mockService.hideConsultantCertPhoto(payload: any<Map<String, dynamic>>(named: 'payload'))).thenAnswer((_) async {});
+
+      await repository.hideConsultantCertPhoto(42);
+
+      verify(() => mockService.hideConsultantCertPhoto(payload: {'cert_photo_id': 42})).called(1);
+    });
+
+    test('unHideConsultantCertPhoto sends payload to service', () async {
+      when(() => mockService.unHideConsultantCertPhoto(payload: any<Map<String, dynamic>>(named: 'payload'))).thenAnswer((_) async {});
+
+      await repository.unHideConsultantCertPhoto(7);
+
+      verify(() => mockService.unHideConsultantCertPhoto(payload: {'cert_photo_id': 7})).called(1);
+    });
+  });
+}
+

test/features/create_diet/basic_widget_test.dart

@@ -1,12 +1,17 @@
 import 'dart:io';
 
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/locator_service.dart';
 import 'package:eatvio_app/core/theme/theme_helper.dart';
 import 'package:eatvio_app/features/create_diet/presentation/cubit/create_diet_cubit.dart';
 import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
 import 'package:flutter_image_compress/flutter_image_compress.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:image/image.dart' as img;
 
 import '../../fixtures/doubles/create_diet_doubles.dart';
 import '../../fixtures/fixture_reader.dart';
@@ -19,7 +24,11 @@ void main() {
     late CreateDietCubit createDietCubit;
     late Map<String, dynamic> dietFixture;
 
-    setUp(() {
+    setUp(() async {
+      // Initialize AppConfig for tests to enable compression bypass
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
       dietFixture = FixtureReader.readAsMap('create_diet/create_diet_request.json');
       createDietRepository = FixtureCreateDietRepository();
       profileRepository = FixtureProfileRepository();
@@ -485,26 +494,12 @@ void main() {
 
     testWidgets('should send correct request when creating diet', (WidgetTester tester) async {
       // Arrange
-      // Create a minimal valid JPEG file (1x1 pixel)
-      final jpegHeader = [
-        0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01,
-        0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43,
-        0x00, 0x08, 0x06, 0x06, 0x07, 0x06, 0x05, 0x08, 0x07, 0x07, 0x07, 0x09,
-        0x09, 0x08, 0x0A, 0x0C, 0x14, 0x0D, 0x0C, 0x0B, 0x0B, 0x0C, 0x19, 0x12,
-        0x13, 0x0F, 0x14, 0x1D, 0x1A, 0x1F, 0x1E, 0x1D, 0x1A, 0x1C, 0x1C, 0x20,
-        0x24, 0x2E, 0x27, 0x20, 0x22, 0x2C, 0x23, 0x1C, 0x1C, 0x28, 0x37, 0x29,
-        0x2C, 0x30, 0x31, 0x34, 0x34, 0x34, 0x1F, 0x27, 0x39, 0x3D, 0x38, 0x32,
-        0x3C, 0x2E, 0x33, 0x34, 0x32, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x01,
-        0x00, 0x01, 0x01, 0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
-        0xFF, 0xC4, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xFF, 0xC4,
-        0x00, 0x14, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x0C,
-        0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00, 0x3F, 0xFF,
-        0xD9
-      ];
-      final tempFile = File('${Directory.systemTemp.path}/test_image.jpg');
-      await tempFile.writeAsBytes(jpegHeader);
+      // Create a valid JPEG file using image package (100x100 pixel image)
+      final testImage = img.Image(width: 100, height: 100);
+      img.fill(testImage, color: img.ColorRgb8(128, 128, 128));
+      final jpegBytes = img.encodeJpg(testImage, quality: 85);
+      final tempFile = File('${Directory.systemTemp.path}/test_image_${DateTime.now().millisecondsSinceEpoch}.jpg');
+      await tempFile.writeAsBytes(jpegBytes);
       final xFile = XFile(tempFile.path);
       
       createDietCubit.setName(dietFixture['name'] as String);
@@ -537,8 +532,11 @@ void main() {
       createDietCubit.setImage(xFile, imageUrl: null);
       
       // Act
-      final result = await createDietCubit.createDiet();
-      await tester.pumpAndSettle();
+      final result = await createDietCubit.createDiet().timeout(
+        const Duration(seconds: 10),
+      );
+      await tester.pump(); // Allow state changes to propagate
+      await tester.pump(); // Additional pump for any delayed updates
 
       // Assert
       expect(result, isNull); // Should return null on success
@@ -550,10 +548,16 @@ void main() {
       expect(request['state'], dietFixture['state']);
       expect(request['types'], dietFixture['types']);
       
-      // Cleanup
+      // Cleanup - remove original and compressed files
       if (await tempFile.exists()) {
         await tempFile.delete();
       }
+      // ImageCompressUtility creates compressed file with _compressed suffix
+      final filePathWithoutExtension = tempFile.path.replaceAll(RegExp(r'\.(jpg|jpeg)$', caseSensitive: false), '');
+      final compressedFile = File('${filePathWithoutExtension}_compressed.jpg');
+      if (await compressedFile.exists()) {
+        await compressedFile.delete();
+      }
     });
   });
 }