forked from eatvio/eatvio_app
941 lines
37 KiB
Dart
941 lines
37 KiB
Dart
import 'package:dio/dio.dart';
|
||
import 'package:eatvio_app/features/chat/repositories/chat_repository.dart';
|
||
import 'package:eatvio_app/features/diary/entities/diary_future_diet_day_entity.dart';
|
||
import 'package:eatvio_app/features/diary/models/diary_day_model.dart';
|
||
import 'package:eatvio_app/features/diary/models/nutrition_model.dart';
|
||
import 'package:eatvio_app/features/diary/presentation/bloc/diary_cubit.dart';
|
||
import 'package:eatvio_app/features/diary/presentation/bloc/diary_state.dart';
|
||
import 'package:eatvio_app/features/diary/repositories/diary_repository.dart';
|
||
import 'package:eatvio_app/features/diets/repositories/diet_repository.dart';
|
||
import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
|
||
import 'package:eatvio_app/features/glossary/models/glossary_model.dart';
|
||
import 'package:eatvio_app/features/glossary/repositories/glossary_repository.dart';
|
||
import 'package:eatvio_app/features/profile/repositories/profile_repository.dart';
|
||
import 'package:eatvio_app/features/settings/models/profile_settings_model.dart';
|
||
import 'package:eatvio_app/features/settings/repositories/service_repository.dart';
|
||
import 'package:flutter_test/flutter_test.dart';
|
||
import 'package:mockito/annotations.dart';
|
||
import 'package:mockito/mockito.dart';
|
||
import 'diary_cubit_test.mocks.dart';
|
||
|
||
@GenerateNiceMocks([
|
||
MockSpec<DiaryRepository>(),
|
||
MockSpec<GlossaryRepository>(),
|
||
MockSpec<ProfileRepository>(),
|
||
MockSpec<DietRepository>(),
|
||
MockSpec<ChatRepository>(),
|
||
MockSpec<SettingsRepository>(),
|
||
])
|
||
void main() {
|
||
group('DiaryCubit', () {
|
||
DiaryCubit? diaryCubit;
|
||
late MockDiaryRepository mockDiaryRepository;
|
||
late MockGlossaryRepository mockGlossaryRepository;
|
||
late MockProfileRepository mockProfileRepository;
|
||
late MockDietRepository mockDietRepository;
|
||
late MockChatRepository mockChatRepository;
|
||
late MockSettingsRepository mockSettingsRepository;
|
||
|
||
const testDiaryDay = DiaryDayModel(
|
||
id: 1,
|
||
date: '2024-01-15',
|
||
closed: 0,
|
||
comment: '',
|
||
typeOfDiary: TypeOfDiaryModel(
|
||
hasChosenDiet: false,
|
||
hasChosenPlan: false,
|
||
diaryState: null,
|
||
),
|
||
meals: [],
|
||
chosenPlanId: null,
|
||
dayOfChosenDiet: null,
|
||
diet: null,
|
||
);
|
||
|
||
const testNutrition = NutritionDataModel(
|
||
dailyNutritionIntake: NutritionModel(
|
||
energy: 2000.0,
|
||
proteins: 150.0,
|
||
fats: 80.0,
|
||
carbohydrates: 250.0,
|
||
),
|
||
dailyNutritionRecommendation: NutritionModel(
|
||
energy: 2200.0,
|
||
proteins: 160.0,
|
||
fats: 90.0,
|
||
carbohydrates: 270.0,
|
||
),
|
||
);
|
||
|
||
setUp(() {
|
||
mockDiaryRepository = MockDiaryRepository();
|
||
mockGlossaryRepository = MockGlossaryRepository();
|
||
mockProfileRepository = MockProfileRepository();
|
||
mockDietRepository = MockDietRepository();
|
||
mockChatRepository = MockChatRepository();
|
||
mockSettingsRepository = MockSettingsRepository();
|
||
});
|
||
|
||
tearDown(() async {
|
||
if (diaryCubit != null && !diaryCubit!.isClosed) {
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
diaryCubit!.close();
|
||
diaryCubit = null;
|
||
}
|
||
});
|
||
|
||
test('начальное состояние - loading', () {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
expect(diaryCubit!.state, const DiaryState.loading());
|
||
});
|
||
|
||
test('setSelectedDay - успешно меняет выбранный день', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.createDiaryDay(day: anyNamed('day')))
|
||
.thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
final result = await diaryCubit!.setSelectedDay(DateTime(2024, 1, 15));
|
||
|
||
expect(result, true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
expect(diaryCubit!.state, isA<DiaryStateLoaded>());
|
||
});
|
||
|
||
test('fetchDiaryV2 - загружает дневник по ID', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.getDiaryDay(any))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
final result = await diaryCubit!.fetchDiaryV2(needLoading: true, diaryId: 1);
|
||
|
||
expect(result, true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
expect(diaryCubit!.state, isA<DiaryStateLoaded>());
|
||
});
|
||
|
||
test('fetchDiaryV2 - обрабатывает ошибку 422 при создании дня', () async {
|
||
when(mockDiaryRepository.createDiaryDay(day: anyNamed('day')))
|
||
.thenThrow(DioException(
|
||
requestOptions: RequestOptions(path: ''),
|
||
response: Response(
|
||
requestOptions: RequestOptions(path: ''),
|
||
statusCode: 422,
|
||
),
|
||
));
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
final result = await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
|
||
expect(result, true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
expect(diaryCubit!.state, isA<DiaryStateLoaded>());
|
||
});
|
||
|
||
test('setSelectedMeal - меняет выбранный прием пищи', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.createDiaryDay(day: anyNamed('day')))
|
||
.thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
diaryCubit!.setSelectedMeal(2);
|
||
|
||
expect(diaryCubit!.selectedMeal, 2);
|
||
expect(diaryCubit!.state, isA<DiaryStateLoaded>());
|
||
});
|
||
|
||
test('setDiaryForDietOnly - устанавливает дневник только для диеты', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
const diet = Diet(
|
||
id: 1,
|
||
slug: 'test-diet',
|
||
name: 'Test Diet',
|
||
image: '',
|
||
duration: 7,
|
||
state: DietState.active,
|
||
type: DietType(),
|
||
details: '',
|
||
dailySchedule: {
|
||
1: {
|
||
1: {
|
||
1: DailySchedule(
|
||
name: 'Яблоко',
|
||
portion: Portion.grams,
|
||
quantity: 1,
|
||
),
|
||
},
|
||
},
|
||
},
|
||
author: Author(
|
||
authorSlug: 'test',
|
||
authorName: 'Test',
|
||
authorProfileIcon: '',
|
||
authorIsMe: false,
|
||
),
|
||
totalLikes: 0,
|
||
totalViews: 0,
|
||
totalComments: 0,
|
||
wasLikedByMe: false,
|
||
isFavorite: false,
|
||
dailyNutrition: [],
|
||
);
|
||
|
||
when(mockDietRepository.getDiet(1))
|
||
.thenAnswer((_) async => diet);
|
||
|
||
final result = await diaryCubit!.setDiaryForDietOnly(
|
||
const DiaryFutureDietDayEntity(
|
||
date: '2024-01-15',
|
||
typeOfDiary: TypeOfDiaryModel(
|
||
hasChosenDiet: true,
|
||
hasChosenPlan: false,
|
||
diaryState: null,
|
||
),
|
||
meals: [],
|
||
dayOfChosenDiet: 1,
|
||
diet: DiaryDietModel(id: 1, duration: 7, name: 'Test Diet'),
|
||
),
|
||
);
|
||
|
||
expect(result, true);
|
||
expect(diaryCubit!.state, isA<DiaryStateLoadedTomorrowWithDiet>());
|
||
});
|
||
|
||
test('setDiaryForDietOnly - возвращает false если нет выбранной диеты', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
final result = await diaryCubit!.setDiaryForDietOnly(
|
||
const DiaryFutureDietDayEntity(
|
||
date: '2024-01-15',
|
||
typeOfDiary: TypeOfDiaryModel(
|
||
hasChosenDiet: false,
|
||
hasChosenPlan: false,
|
||
diaryState: null,
|
||
),
|
||
meals: [],
|
||
dayOfChosenDiet: null,
|
||
diet: null,
|
||
),
|
||
);
|
||
|
||
expect(result, false);
|
||
});
|
||
|
||
test('finishDiaryDay - завершает день дневника', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.finishDiaryDay(
|
||
diaryId: anyNamed('diaryId'),
|
||
wakeUp: anyNamed('wakeUp'),
|
||
retire: anyNamed('retire'),
|
||
comment: anyNamed('comment'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.finishDiaryDay(
|
||
diaryId: 1,
|
||
wakeUp: '07:00',
|
||
retire: '23:00',
|
||
);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
});
|
||
|
||
test('addProductToMeal - добавляет продукт в прием пищи', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.addPortionToMeal(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
productName: anyNamed('productName'),
|
||
portion: anyNamed('portion'),
|
||
quantity: anyNamed('quantity'),
|
||
productNutritionalValueId: anyNamed('productNutritionalValueId'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.addProductToMeal(
|
||
diaryId: 1,
|
||
mealId: 1,
|
||
productName: 'Яблоко',
|
||
portion: '100г',
|
||
quantity: 2,
|
||
);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
});
|
||
|
||
test('markEaten - отмечает продукт как съеденный', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.markEaten(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
portionId: anyNamed('portionId'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.markEaten(diaryId: 1, mealId: 1, portionId: 5);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
});
|
||
|
||
test('getGlossaryListByQuery - получает список глоссариев по запросу', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockGlossaryRepository.getGlossaryListByQuery(any))
|
||
.thenAnswer((_) async => [
|
||
const GlossaryModel(
|
||
id: 1,
|
||
name: 'Яблоко',
|
||
grInPortion: 100,
|
||
energyOn100Gr: 52.0,
|
||
proteinsOn100Gr: 0.3,
|
||
fatsOn100Gr: 0.2,
|
||
carbohydratesOn100Gr: 14.0,
|
||
energyOnPortion: 52.0,
|
||
proteinsOnPortion: 0.3,
|
||
fatsOnPortion: 0.2,
|
||
carbohydratesOnPortion: 14.0,
|
||
),
|
||
]);
|
||
|
||
final result = await diaryCubit!.getGlossaryListByQuery('яблоко');
|
||
|
||
expect(result, isA<List<GlossaryModel>>());
|
||
expect(result.length, 1);
|
||
expect(result.first.name, 'Яблоко');
|
||
});
|
||
|
||
test('fillSatiety - заполняет сытость', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.fillSatiety(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
satiety: anyNamed('satiety'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.fillSatiety(diaryId: 1, satiety: 5);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
});
|
||
|
||
test('fillMood - заполняет настроение', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.fillMood(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
mood: anyNamed('mood'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.fillMood(diaryId: 1, mood: 4);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
});
|
||
|
||
test('fillComment - заполняет комментарий', () {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
diaryCubit!.fillComment('Хороший день');
|
||
expect(diaryCubit!.comment, 'Хороший день');
|
||
});
|
||
|
||
test('updateCurrentDiary - обновляет текущий дневник', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.updateCurrentDiary();
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day'))).called(1);
|
||
});
|
||
|
||
test('updateCurrentDiary - обрабатывает ошибку', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenThrow(Exception('Ошибка'));
|
||
|
||
await diaryCubit!.updateCurrentDiary();
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
});
|
||
|
||
test('getNutrition - получает данные о питании', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
|
||
final result = await diaryCubit!.getNutrition(1);
|
||
|
||
expect(result, testNutrition);
|
||
verify(mockDiaryRepository.getNutritionData(1)).called(1);
|
||
});
|
||
|
||
test('updateProductInMeal - обновляет продукт в приеме пищи', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.updateProductInMeal(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
portionId: anyNamed('portionId'),
|
||
productName: anyNamed('productName'),
|
||
portion: anyNamed('portion'),
|
||
quantity: anyNamed('quantity'),
|
||
productNutritionalValueId: anyNamed('productNutritionalValueId'),
|
||
portionState: anyNamed('portionState'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.updateProductInMeal(
|
||
diaryId: 1,
|
||
mealId: 1,
|
||
portionId: 5,
|
||
productName: 'Яблоко',
|
||
portion: '150г',
|
||
quantity: 3,
|
||
portionState: PortionState.eaten,
|
||
);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.updateProductInMeal(
|
||
diaryId: 1,
|
||
mealId: 1,
|
||
portionId: 5,
|
||
productName: 'Яблоко',
|
||
portion: '150г',
|
||
quantity: 3,
|
||
productNutritionalValueId: anyNamed('productNutritionalValueId'),
|
||
portionState: PortionState.eaten,
|
||
)).called(1);
|
||
});
|
||
|
||
test('unmarkEaten - снимает отметку о съеденном', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.unmarkEaten(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
portionId: anyNamed('portionId'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.unmarkEaten(diaryId: 1, mealId: 1, portionId: 5);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.unmarkEaten(diaryId: 1, mealId: 1, portionId: 5)).called(1);
|
||
});
|
||
|
||
test('restore - восстанавливает продукт', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.restore(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
portionId: anyNamed('portionId'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.restore(diaryId: 1, mealId: 1, portionId: 5);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.restore(diaryId: 1, mealId: 1, portionId: 5)).called(1);
|
||
});
|
||
|
||
test('deleteProductFromMeal - удаляет продукт из приема пищи', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.deleteProductFromMeal(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
portionId: anyNamed('portionId'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.deleteProductFromMeal(diaryId: 1, mealId: 1, portionId: 5);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.deleteProductFromMeal(diaryId: 1, mealId: 1, portionId: 5)).called(1);
|
||
});
|
||
|
||
test('sendProductToModeration - отправляет продукт на модерацию', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
const moderationModel = GlossaryModerationModel(
|
||
glossary: GlossaryModel(
|
||
id: 1,
|
||
name: 'Новый продукт',
|
||
grInPortion: 100,
|
||
energyOn100Gr: 100.0,
|
||
proteinsOn100Gr: 10.0,
|
||
fatsOn100Gr: 5.0,
|
||
carbohydratesOn100Gr: 15.0,
|
||
energyOnPortion: 100.0,
|
||
proteinsOnPortion: 10.0,
|
||
fatsOnPortion: 5.0,
|
||
carbohydratesOnPortion: 15.0,
|
||
),
|
||
);
|
||
when(mockDiaryRepository.sendProductToModeration(
|
||
name: anyNamed('name'),
|
||
energy: anyNamed('energy'),
|
||
proteins: anyNamed('proteins'),
|
||
fats: anyNamed('fats'),
|
||
carbohydrates: anyNamed('carbohydrates'),
|
||
)).thenAnswer((_) async => moderationModel);
|
||
|
||
final result = await diaryCubit!.sendProductToModeration(
|
||
name: 'Новый продукт',
|
||
energy: 100.0,
|
||
proteins: 10.0,
|
||
fats: 5.0,
|
||
carbohydrates: 15.0,
|
||
);
|
||
|
||
expect(result, moderationModel);
|
||
verify(mockDiaryRepository.sendProductToModeration(
|
||
name: 'Новый продукт',
|
||
energy: 100.0,
|
||
proteins: 10.0,
|
||
fats: 5.0,
|
||
carbohydrates: 15.0,
|
||
)).called(1);
|
||
});
|
||
|
||
test('sendProductToModeration - возвращает null при ошибке', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.sendProductToModeration(
|
||
name: anyNamed('name'),
|
||
energy: anyNamed('energy'),
|
||
proteins: anyNamed('proteins'),
|
||
fats: anyNamed('fats'),
|
||
carbohydrates: anyNamed('carbohydrates'),
|
||
)).thenThrow(Exception('Ошибка'));
|
||
|
||
final result = await diaryCubit!.sendProductToModeration(
|
||
name: 'Новый продукт',
|
||
energy: 100.0,
|
||
proteins: 10.0,
|
||
fats: 5.0,
|
||
carbohydrates: 15.0,
|
||
);
|
||
|
||
expect(result, isNull);
|
||
});
|
||
|
||
test('fillTime - заполняет время приема пищи', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.fillTime(
|
||
diaryId: anyNamed('diaryId'),
|
||
mealId: anyNamed('mealId'),
|
||
time: anyNamed('time'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.fillTime(diaryId: 1, time: '12:00');
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.fillTime(diaryId: 1, mealId: 1, time: '12:00')).called(1);
|
||
});
|
||
|
||
test('fillWakeup - заполняет время пробуждения', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.fillWakeup(
|
||
diaryId: anyNamed('diaryId'),
|
||
time: anyNamed('time'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.fillWakeup(diaryId: 1, time: '07:00');
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.fillWakeup(diaryId: 1, time: '07:00')).called(1);
|
||
});
|
||
|
||
test('fillRetire - заполняет время отхода ко сну', () async {
|
||
diaryCubit = DiaryCubit(
|
||
diaryRepository: mockDiaryRepository,
|
||
glossaryRepository: mockGlossaryRepository,
|
||
profileRepository: mockProfileRepository,
|
||
dietRepository: mockDietRepository,
|
||
chatRepository: mockChatRepository,
|
||
settingsRepository: mockSettingsRepository,
|
||
);
|
||
when(mockDiaryRepository.fillRetire(
|
||
diaryId: anyNamed('diaryId'),
|
||
time: anyNamed('time'),
|
||
)).thenAnswer((_) async => Future.value());
|
||
when(mockDiaryRepository.getDiaryDayV2(day: anyNamed('day')))
|
||
.thenAnswer((_) async => testDiaryDay);
|
||
when(mockDiaryRepository.getNutritionData(any))
|
||
.thenAnswer((_) async => testNutrition);
|
||
when(mockSettingsRepository.getProfileSettings())
|
||
.thenAnswer((_) async => const ProfileSettingsModel(
|
||
isMoodFillable: true,
|
||
isBedtimeFillable: true,
|
||
isPublicProfile: true,
|
||
newUpdatesNotifications: null,
|
||
diaryReminderNotifications: null,
|
||
));
|
||
|
||
await diaryCubit!.fetchDiaryV2(needLoading: true);
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
await diaryCubit!.fillRetire(diaryId: 1, time: '23:00');
|
||
await Future.delayed(const Duration(milliseconds: 100));
|
||
verify(mockDiaryRepository.fillRetire(diaryId: 1, time: '23:00')).called(1);
|
||
});
|
||
});
|
||
}
|