added widget and unit tests for plans, diets, recipes

Reviewed-on: eatvio/eatvio_app#792

Makefile

@@ -7,4 +7,7 @@ run-analyse:
 run-checks: run-analyse run-tests
 
 build-generated-files:
-	dart run build_runner build --delete-conflicting-outputs
+	dart run build_runner build --delete-conflicting-outputs
+
+clean-coverage:
+	@./scripts/remove_generated_from_coverage.sh

ios/Runner.xcodeproj/project.pbxproj

@@ -388,7 +388,7 @@
 				CODE_SIGN_ENTITLEMENTS = Runner/Runner.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Distribution: ITVIO, OOO (VL68C36HYS)";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 81;
+				CURRENT_PROJECT_VERSION = 83;
 				DEVELOPMENT_TEAM = VL68C36HYS;
 				ENABLE_BITCODE = NO;
 				FRAMEWORK_SEARCH_PATHS = (
@@ -406,7 +406,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Flutter",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.3.3;
 				PRODUCT_BUNDLE_IDENTIFIER = com.eatvioapp.app;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "match AppStore com.eatvioapp.app 1747050044";
@@ -539,7 +539,7 @@
 				CODE_SIGN_ENTITLEMENTS = Runner/Runner.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Distribution: ITVIO, OOO (VL68C36HYS)";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 81;
+				CURRENT_PROJECT_VERSION = 83;
 				DEVELOPMENT_TEAM = VL68C36HYS;
 				ENABLE_BITCODE = NO;
 				FRAMEWORK_SEARCH_PATHS = (
@@ -557,7 +557,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Flutter",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.3.3;
 				PRODUCT_BUNDLE_IDENTIFIER = com.eatvioapp.app;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "match AppStore com.eatvioapp.app 1747050044";
@@ -578,7 +578,7 @@
 				CODE_SIGN_ENTITLEMENTS = Runner/Runner.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Distribution: ITVIO, OOO (VL68C36HYS)";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 81;
+				CURRENT_PROJECT_VERSION = 83;
 				DEVELOPMENT_TEAM = VL68C36HYS;
 				ENABLE_BITCODE = NO;
 				FRAMEWORK_SEARCH_PATHS = (
@@ -596,7 +596,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Flutter",
 				);
-				MARKETING_VERSION = 1.3.4;
+				MARKETING_VERSION = 1.3.3;
 				PRODUCT_BUNDLE_IDENTIFIER = com.eatvioapp.app;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "match AppStore com.eatvioapp.app 1747050044";

lib/features/chat/presentation/pages/chat_screen.dart

@@ -135,12 +135,12 @@ class _ChatScreenState extends State<ChatScreen> {
     } else if (!amIConsultant &&
         (chosenPlan.chosenPlanState == ChosenPlanStateEnum.stateStartDateHasBeenSet || chosenPlan.chosenPlanState == ChosenPlanStateEnum.statePendingPayment)) {
       bannerType = BannerType.payment;
-    } else if (chosenOption?.hasPersonalDiet == true && amIConsultant) {
-      bannerType = BannerType.setPersonalDiet;
     } else if (chosenPlan.chosenPlanState == ChosenPlanStateEnum.stateDone && amIConsultant) {
       bannerType = BannerType.collectCharge;
     } else if (chosenPlan.chosenPlanState == ChosenPlanStateEnum.stateLastDayFinished && !amIConsultant) {
       bannerType = BannerType.finishPlan;
+    } else if (chosenOption?.hasPersonalDiet == true && amIConsultant && chosenPlan.chosenPlanState != ChosenPlanStateEnum.stateDone) {
+      bannerType = BannerType.setPersonalDiet;
     }
 
     return Scaffold(

lib/features/diets/presentation/widgets/author_card.dart

@@ -29,7 +29,7 @@ class AuthorCard extends StatelessWidget {
         child: Stack(
           children: [
             Padding(
-              padding: const EdgeInsets.only(left: 16, top: 16, bottom: 24),
+              padding: const EdgeInsets.only(left: 16, top: 16, bottom: 24, right: 16),
               child: Column(
                 children: [
                   ListTile(
@@ -68,20 +68,23 @@ class AuthorCard extends StatelessWidget {
                         if (author.authorPlaceInRating != null)
                           InfoBouble(
                             radius: 12,
-                            backgroundColor: appTheme.whiteA700,
+                            backgroundColor: appTheme.cardBackground,
                             children: [
                               Text('${author.authorPlaceInRating}-й в рейтинге', style: TextStyles.textMMediumAuto.copyWith(color: appTheme.blueA400)),
                             ],
                           ),
                       ] else
-                        GestureDetector(
-                          onTap: () {
-                            GoRouter.of(context).pushNamed(UserDetailsScreen.name, extra: customerProfile!.slug);
-                          },
-                          child: InfoBouble(
-                            radius: 12,
-                            backgroundColor: appTheme.whiteA700,
-                            children: [Text('Анкета пользователя', style: TextStyles.textMMediumAuto.copyWith(color: appTheme.blueA400))],
+                        Expanded(
+                          child: GestureDetector(
+                            onTap: () {
+                              GoRouter.of(context).pushNamed(UserDetailsScreen.name, extra: customerProfile!.slug);
+                            },
+                            child: InfoBouble(
+                              radius: 12,
+                              backgroundColor: appTheme.cardBackground,
+                              mainAxisAlignment: MainAxisAlignment.center,
+                              children: [Text('Анкета пользователя', style: TextStyles.textMMediumAuto.copyWith(color: appTheme.blueA400))],
+                            ),
                           ),
                         ),
                     ],

lib/features/diets/presentation/widgets/info_bouble.dart

@@ -2,20 +2,25 @@ import 'package:eatvio_app/core/theme/theme_helper.dart';
 import 'package:flutter/material.dart';
 
 class InfoBouble extends StatelessWidget {
-  const InfoBouble({super.key, required this.children, this.backgroundColor, this.radius = 100, this.padding});
+  const InfoBouble({
+    super.key,
+    required this.children,
+    this.backgroundColor,
+    this.radius = 100,
+    this.padding,
+    this.mainAxisAlignment = MainAxisAlignment.start,
+  });
   final List<Widget> children;
   final Color? backgroundColor;
   final double radius;
   final EdgeInsetsGeometry? padding;
+  final MainAxisAlignment mainAxisAlignment;
   @override
   Widget build(BuildContext context) {
     return Container(
       padding: padding ?? const EdgeInsets.symmetric(horizontal: 12, vertical: 8.5),
-      decoration: BoxDecoration(
-        color: backgroundColor ?? appTheme.gray50,
-        borderRadius: BorderRadius.circular(radius),
-      ),
-      child: Row(mainAxisSize: MainAxisSize.min, children: children),
+      decoration: BoxDecoration(color: backgroundColor ?? appTheme.gray50, borderRadius: BorderRadius.circular(radius)),
+      child: Row(mainAxisSize: MainAxisSize.min, mainAxisAlignment: mainAxisAlignment, children: children),
     );
   }
 }

lib/features/notifications/models/notification_model.dart

@@ -316,7 +316,7 @@ class ChosenPlanFinishedToConsultantNotification implements BaseNotificationMode
       type: type,
       planName: json['plan_name'],
       customerName: json['client_name'],
-      planId: json['plan_id'],
+      planId: json['chosen_plan_id'],
       isRead: isRead ?? false,
       createdAt: parseDate(createdAt ?? json['created_at'] ?? DateTime.now().toIso8601String()),
     );
@@ -1695,6 +1695,35 @@ class DiaryReminderForUsersNotification implements BaseNotificationModel {
   }
 }
 
+class PersonalDietIsDefinedToCustomerNotification implements BaseNotificationModel {
+  @override
+  final NotificationType type;
+  @override
+  final bool isRead;
+  @override
+  final DateTime createdAt;
+  final String dietName;
+  final int dietId;
+
+  PersonalDietIsDefinedToCustomerNotification({
+    required this.type,
+    required this.isRead,
+    required this.createdAt,
+    required this.dietName,
+    required this.dietId,
+  });
+
+  factory PersonalDietIsDefinedToCustomerNotification.fromJson(Map<String, dynamic> json, NotificationType type, {bool? isRead, String? createdAt}) {
+    return PersonalDietIsDefinedToCustomerNotification(
+      type: type,
+      isRead: isRead ?? false,
+      createdAt: parseDate(createdAt ?? json['created_at'] ?? DateTime.now().toIso8601String()),
+      dietName: json['diet_name'] ?? '',
+      dietId: json['diet_id'],
+    );
+  }
+}
+
 enum NotificationType {
   // Diet related
   dietCancelled,
@@ -1726,6 +1755,7 @@ enum NotificationType {
   userDailyReportCompleted,
   chosenPlanFinishedToConsultant,
   stayOnTrackToCustomer,
+  personalDietIsDefinedToCustomer,
 
   // Comments
   entityCommented,
@@ -1834,6 +1864,7 @@ enum NotificationType {
     'chosen-plan-finished-to-consultant' => NotificationType.chosenPlanFinishedToConsultant,
     'stay-on-track-to-customer' => NotificationType.stayOnTrackToCustomer,
     'diary-reminder-for-users' => NotificationType.diaryReminderForUsers,
+    'personal-diet-is-defined-to-customer' => NotificationType.personalDietIsDefinedToCustomer,
 
     // Legacy mapping
     'App\\Notifications\\Plan\\PlanSubscriptionStartedToAuthor' => NotificationType.planSubscriptionStartedToAuthor,

lib/features/notifications/presentation/notifications_cubit/notifications_cubit.dart

@@ -261,6 +261,12 @@ class NotificationsCubit extends Cubit<NotificationsState> {
           createdAt: createdAt,
         ),
         NotificationType.diaryReminderForUsers => DiaryReminderForUsersNotification.fromJson(notificationJson, type, isRead: isRead, createdAt: createdAt),
+        NotificationType.personalDietIsDefinedToCustomer => PersonalDietIsDefinedToCustomerNotification.fromJson(
+          notificationJson,
+          type,
+          isRead: isRead,
+          createdAt: createdAt,
+        ),
         NotificationType.unknown => UnknownNotification(type: type),
       };
     } catch (e) {

lib/features/notifications/presentation/widgets/notification_widget.dart

@@ -1,3 +1,4 @@
+import 'package:eatvio_app/core/routing/route_constants.dart';
 import 'package:eatvio_app/core/theme/custom_text_style.dart';
 import 'package:eatvio_app/core/theme/theme_helper.dart';
 import 'package:eatvio_app/core/utils/date_time_utils.dart';
@@ -113,7 +114,11 @@ class NotificationWidget extends StatelessWidget {
         notification: notification as ProductStatusUpdatedForAuthorNotification,
       ),
       DiaryReminderForUsersNotification() => _DiaryReminderForUsersWidget(notification: notification as DiaryReminderForUsersNotification),
+      PersonalDietIsDefinedToCustomerNotification() => _PersonalDietIsDefinedToCustomerWidget(
+        notification: notification as PersonalDietIsDefinedToCustomerNotification,
+      ),
       UnknownNotification() => _UnknownNotificationWidget(notification: notification as UnknownNotification),
+      // TODO: Handle this case.
     };
   }
 }
@@ -364,34 +369,38 @@ class _ChosenPlanFinishedToConsultantWidget extends StatelessWidget {
 
 // CardSettingsScreen
 class _BaseNotificationWidget extends StatelessWidget {
-  const _BaseNotificationWidget({required this.notificationsText, required this.isRead, required this.createdAt});
+  const _BaseNotificationWidget({required this.notificationsText, required this.isRead, required this.createdAt, this.onTap});
   final String notificationsText;
   final bool isRead;
   final DateTime createdAt;
+  final void Function()? onTap;
   @override
   Widget build(BuildContext context) {
-    return Column(
-      crossAxisAlignment: CrossAxisAlignment.start,
-      children: [
-        Row(
-          children: [
-            Expanded(
-              child: Text(notificationsText, style: TextStyles.textMMedium.copyWith(color: appTheme.black)),
-            ),
-            if (!isRead)
-              Container(
-                decoration: BoxDecoration(color: appTheme.blueA400, shape: BoxShape.circle),
-                width: 8,
-                height: 8,
+    return GestureDetector(
+      onTap: onTap,
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              Expanded(
+                child: Text(notificationsText, style: TextStyles.textMMedium.copyWith(color: appTheme.black)),
               ),
-          ],
-        ),
-        const SizedBox(height: 4),
-        Text(
-          '${createdAt.day} ${_getMonthName(createdAt.month)} ${createdAt.hour.toString().padLeft(2, '0')}:${createdAt.minute.toString().padLeft(2, '0')}',
-          style: TextStyles.textSMedium.copyWith(color: appTheme.gray600),
-        ),
-      ],
+              if (!isRead)
+                Container(
+                  decoration: BoxDecoration(color: appTheme.blueA400, shape: BoxShape.circle),
+                  width: 8,
+                  height: 8,
+                ),
+            ],
+          ),
+          const SizedBox(height: 4),
+          Text(
+            '${createdAt.day} ${_getMonthName(createdAt.month)} ${createdAt.hour.toString().padLeft(2, '0')}:${createdAt.minute.toString().padLeft(2, '0')}',
+            style: TextStyles.textSMedium.copyWith(color: appTheme.gray600),
+          ),
+        ],
+      ),
     );
   }
 
@@ -1053,3 +1062,17 @@ class _DiaryReminderForUsersWidget extends StatelessWidget {
     return _BaseNotificationWidget(isRead: notification.isRead, notificationsText: 'Напоминание о заполнении дневника', createdAt: notification.createdAt);
   }
 }
+
+class _PersonalDietIsDefinedToCustomerWidget extends StatelessWidget {
+  const _PersonalDietIsDefinedToCustomerWidget({required this.notification});
+  final PersonalDietIsDefinedToCustomerNotification notification;
+  @override
+  Widget build(BuildContext context) {
+    return _BaseNotificationWidget(
+      isRead: notification.isRead,
+      onTap: () => GoRouter.of(context).push(RouteConstants.aboutDietScreen, extra: {'id': notification.dietId, 'navigateToComments': false}),
+      notificationsText: 'Персональная диета "${notification.dietName}" установлена',
+      createdAt: notification.createdAt,
+    );
+  }
+}

lib/features/notifications/service/notifications_service.dart

@@ -407,6 +407,12 @@ class NotificationsService {
                 isRead: readDate != null,
                 createdAt: createdAt,
               ),
+              NotificationType.personalDietIsDefinedToCustomer => PersonalDietIsDefinedToCustomerNotification.fromJson(
+                notificationJson['data'],
+                type,
+                isRead: readDate != null,
+                createdAt: createdAt,
+              ),
               NotificationType.unknown => UnknownNotification(type: type, createdAt: parseDate(createdAt)),
             };
           } catch (e) {

lib/features/order_info/presentation/widgets/payment_banner.dart

@@ -11,11 +11,7 @@ import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:go_router/go_router.dart';
 
 class PaymentBanner extends StatefulWidget {
-  const PaymentBanner({
-    super.key,
-    required this.successfulPayment,
-    
-  });
+  const PaymentBanner({super.key, required this.successfulPayment});
   final bool successfulPayment;
 
   @override
@@ -29,8 +25,9 @@ class _PaymentBannerState extends State<PaymentBanner> {
     final s = S.of(context);
     final size = MediaQuery.sizeOf(context);
     return MainBackgroundBouble(
-        padding: const EdgeInsets.symmetric(vertical: 16),
-        child: Stack(children: [
+      padding: const EdgeInsets.symmetric(vertical: 16),
+      child: Stack(
+        children: [
           Positioned(
             left: 0,
             top: 0,
@@ -38,8 +35,9 @@ class _PaymentBannerState extends State<PaymentBanner> {
             child: Container(
               width: 4,
               decoration: BoxDecoration(
-                  color: widget.successfulPayment ? appTheme.blueA400 : appTheme.strongRed,
-                  borderRadius: const BorderRadius.only(topRight: Radius.circular(20), bottomRight: Radius.circular(20))),
+                color: widget.successfulPayment ? appTheme.blueA400 : appTheme.strongRed,
+                borderRadius: const BorderRadius.only(topRight: Radius.circular(20), bottomRight: Radius.circular(20)),
+              ),
             ),
           ),
           Padding(
@@ -50,78 +48,65 @@ class _PaymentBannerState extends State<PaymentBanner> {
                   ? [
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
-                          s.cunsutation_was_paid_successfully,
-                          style: TextStyles.textLSemibold.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 8,
+                        child: Text(s.cunsutation_was_paid_successfully, style: TextStyles.textLSemibold.copyWith(color: appTheme.black)),
                       ),
+                      const SizedBox(height: 8),
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
-                          s.wait_for_start_day,
-                          style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 16,
+                        child: Text(s.wait_for_start_day, style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black)),
                       ),
+                      const SizedBox(height: 16),
                       isLoading
                           ? const Center(child: Loader())
                           : CustomOutlinedButton(
                               text: s.go_to_diary,
                               height: 52,
                               buttonTextStyle: TextStyles.textMSemibold.copyWith(color: appTheme.whiteA700),
-                              buttonStyle:
-                                  ButtonStyle(side: const WidgetStatePropertyAll(BorderSide.none), backgroundColor: WidgetStatePropertyAll(appTheme.blueA400)),
+                              buttonStyle: ButtonStyle(
+                                side: const WidgetStatePropertyAll(BorderSide.none),
+                                backgroundColor: WidgetStatePropertyAll(appTheme.blueA400),
+                              ),
                               onPressed: () async {
                                 GoRouter.of(context).pushReplacement('/diary-screen');
                               },
                             ),
+                      const SizedBox(height: 10),
                       isLoading
                           ? const Center(child: Loader())
                           : CustomOutlinedButton(
                               text: s.back_to_chat,
                               height: 52,
                               buttonTextStyle: TextStyles.textMSemibold.copyWith(color: appTheme.whiteA700),
-                              buttonStyle:
-                                  ButtonStyle(side: const WidgetStatePropertyAll(BorderSide.none), backgroundColor: WidgetStatePropertyAll(appTheme.blueA400)),
+                              buttonStyle: ButtonStyle(
+                                side: const WidgetStatePropertyAll(BorderSide.none),
+                                backgroundColor: WidgetStatePropertyAll(appTheme.blueA400),
+                              ),
                               onPressed: () {
                                 GoRouter.of(context).pop();
                               },
-                            )
+                            ),
                     ]
                   : [
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
-                          s.smth_went_wrong_payment_failed,
-                          style: TextStyles.textLSemibold.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 8,
+                        child: Text(s.smth_went_wrong_payment_failed, style: TextStyles.textLSemibold.copyWith(color: appTheme.black)),
                       ),
+                      const SizedBox(height: 8),
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
-                          s.try_again_2,
-                          style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 16,
+                        child: Text(s.try_again_2, style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black)),
                       ),
+                      const SizedBox(height: 16),
                       isLoading
                           ? const Center(child: Loader())
                           : CustomOutlinedButton(
                               text: s.pay,
                               height: 52,
                               buttonTextStyle: TextStyles.textMSemibold.copyWith(color: appTheme.whiteA700),
-                              buttonStyle:
-                                  ButtonStyle(side: const WidgetStatePropertyAll(BorderSide.none), backgroundColor: WidgetStatePropertyAll(appTheme.blueA400)),
+                              buttonStyle: ButtonStyle(
+                                side: const WidgetStatePropertyAll(BorderSide.none),
+                                backgroundColor: WidgetStatePropertyAll(appTheme.blueA400),
+                              ),
                               onPressed: () async {
                                 final planId = context.read<OrderInfoCubit>().state.chosenPlan?.id;
                                 setState(() {
@@ -133,16 +118,15 @@ class _PaymentBannerState extends State<PaymentBanner> {
                                 });
                                 if (paymentLink != null && planId != null) {
                                   if (!context.mounted) return;
-                                  GoRouter.of(context).pushReplacement(
-                                    PaymentScreen.path,
-                                    extra: {'url': paymentLink, 'planId': planId},
-                                  );
+                                  GoRouter.of(context).pushReplacement(PaymentScreen.path, extra: {'url': paymentLink, 'planId': planId});
                                 }
                               },
-                            )
+                            ),
                     ],
             ),
-          )
-        ]));
+          ),
+        ],
+      ),
+    );
   }
 }

lib/features/user_details/presentation/user_details_screen.dart

@@ -49,8 +49,7 @@ class _UserDetailsContentState extends State<UserDetailsContent> {
   final List<String> chipsIntervalList = ['1', '3', '6', '12', 'all'];
 
   List<WeightModel> weightPoints = [];
-  List<CircumferenceModel> circumferencePoints = [];
-  int _selectedChipIndex = 0;
+  List<CircumferenceModel> circumferencePoints = [];  int _selectedChipIndex = 0;
   int _selectedIntervalChipIndex = 0;
   bool isMoreOptionsVisible = false;
   @override

pubspec.yaml

@@ -1,6 +1,6 @@
 name: eatvio_app
 description: A new Flutter project.
-version: 1.3.4+83
+version: 1.3.3+83
 publish_to: 'none'
 
 environment:
@@ -86,6 +86,7 @@ dev_dependencies:
   json_serializable: ^6.10.0
   retrofit_generator: ^10.0.2
   mockito: ^5.5.0
+  network_image_mock: ^2.1.1
 
   flutter_test:
     sdk: flutter

scripts/remove_generated_from_coverage.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Script to remove generated files from coverage/lcov.info
+# Generated files include: .g.dart, .freezed.dart, .mocks.dart
+#
+# Usage:
+#   ./scripts/remove_generated_from_coverage.sh
+#
+# This script:
+#   1. Creates a backup of the original coverage file
+#   2. Removes all entries for generated files (.g.dart, .freezed.dart, .mocks.dart)
+#   3. Saves the cleaned file back to coverage/lcov.info
+
+set -e  # Exit on error
+
+COVERAGE_FILE="coverage/lcov.info"
+BACKUP_FILE="coverage/lcov.info.backup"
+
+# Get the script directory and project root
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+cd "$PROJECT_ROOT"
+
+# Check if coverage file exists
+if [ ! -f "$COVERAGE_FILE" ]; then
+    echo "Error: $COVERAGE_FILE not found"
+    echo "Please run 'flutter test --coverage' first to generate the coverage file"
+    exit 1
+fi
+
+# Create backup
+cp "$COVERAGE_FILE" "$BACKUP_FILE"
+echo "Backup created: $BACKUP_FILE"
+
+# Remove entries for generated files
+# This uses awk to process the lcov.info file
+# It skips entries that start with SF: and contain .g.dart, .freezed.dart, or .mocks.dart
+
+awk '
+BEGIN {
+    skip_entry = 0
+}
+/^SF:/ {
+    # Check if this is a generated file
+    # Matches: .g.dart, .freezed.dart, .mocks.dart
+    if ($0 ~ /\.(g|freezed|mocks)\.dart$/) {
+        skip_entry = 1
+    } else {
+        skip_entry = 0
+    }
+}
+{
+    if (!skip_entry) {
+        print
+    }
+}
+/^end_of_record$/ {
+    skip_entry = 0
+}
+' "$BACKUP_FILE" > "$COVERAGE_FILE.tmp"
+
+# Replace original file with cleaned version
+mv "$COVERAGE_FILE.tmp" "$COVERAGE_FILE"
+
+# Count removed entries
+REMOVED=$(grep -c "^SF:.*\.\(g\|freezed\|mocks\)\.dart$" "$BACKUP_FILE" 2>/dev/null || echo "0")
+echo "Removed $REMOVED generated file entries from coverage/lcov.info"
+echo "Cleaned file saved to: $COVERAGE_FILE"
+echo ""
+echo "To restore the original file, run:"
+echo "  cp $BACKUP_FILE $COVERAGE_FILE"
+

test/features/diets/presentation/cubit/diets_cubit_test.dart

@@ -0,0 +1,194 @@
+import 'package:easy_debounce/easy_debounce.dart';
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/diets/models/diet_likes_model.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/feed/presentation/bloc/diets_cubit/diets_cubit.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'diets_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>(), MockSpec<DietRepository>()])
+void main() {
+  group('DietsCubit', () {
+    DietsCubit? dietsCubit;
+    late MockFeedRepository mockFeedRepository;
+    late MockDietRepository mockDietRepository;
+
+    const testDiet = Diet(
+      id: 1,
+      slug: 'test-diet',
+      name: 'Test Diet',
+      image: 'https://someurl.com/img.jpg',
+      duration: 30,
+      state: DietState.active,
+      type: DietType(light: false, veg: false, carb: false, meat: false),
+      details: 'Test diet description',
+      dailySchedule: {},
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      wasLikedByMe: false,
+      isFavorite: false,
+      dailyNutrition: [],
+    );
+
+    const testDietsPagination = DietsPagination(
+      data: [testDiet],
+      links: Links(first: '', last: '', prev: null, next: null),
+      meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+    );
+
+    setUp(() {
+      mockFeedRepository = MockFeedRepository();
+      mockDietRepository = MockDietRepository();
+    });
+
+    tearDown(() async {
+      EasyDebounce.cancel('loadDiets');
+      EasyDebounce.cancel('like_diet');
+      EasyDebounce.cancel('add_or_remove_diet_from_favorite');
+      if (dietsCubit != null && !dietsCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        dietsCubit!.close();
+        dietsCubit = null;
+      }
+    });
+
+    test('начальное состояние - initial state', () {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+      expect(dietsCubit!.state.dietsList, isEmpty);
+      expect(dietsCubit!.state.isLoading, true);
+      expect(dietsCubit!.state.errorMessage, null);
+      expect(dietsCubit!.state.filterState.durationIndex, 0);
+      expect(dietsCubit!.state.filterState.sortingIndex, 0);
+      expect(dietsCubit!.state.filterState.typeIndex, 0);
+    });
+
+    test('loadDiets - загружает диеты успешно', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      when(mockFeedRepository.getDiets(query: null, types: null, duration: null, sorting: null)).thenAnswer((_) async => testDietsPagination);
+
+      await dietsCubit!.loadDiets();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(dietsCubit!.state.dietsList.length, 1);
+      expect(dietsCubit!.state.dietsList.first.name, 'Test Diet');
+      expect(dietsCubit!.state.errorMessage, null);
+    });
+
+    test('loadDiets - обрабатывает ошибку', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      when(mockFeedRepository.getDiets(query: null, types: null, duration: null, sorting: null)).thenThrow(Exception('Network error'));
+
+      await dietsCubit!.loadDiets();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(dietsCubit!.state.errorMessage, isNotNull);
+      expect(dietsCubit!.state.isLoading, false);
+    });
+
+    test('changeTypeFilter - меняет фильтр типа', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      dietsCubit!.changeTypeFilter(1);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(dietsCubit!.state.filterState.typeIndex, 1);
+      
+      // Wait for debounce to complete
+      await Future.delayed(const Duration(milliseconds: 1100));
+    });
+
+    test('changeDurationFilter - меняет фильтр длительности', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      dietsCubit!.changeDurationFilter(1);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(dietsCubit!.state.filterState.durationIndex, 1);
+      
+      // Wait for debounce to complete
+      await Future.delayed(const Duration(milliseconds: 1100));
+    });
+
+    test('changeSortingType - меняет тип сортировки', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      dietsCubit!.changeSortingType(1);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(dietsCubit!.state.filterState.sortingIndex, 1);
+      
+      // Wait for debounce to complete
+      await Future.delayed(const Duration(milliseconds: 1100));
+    });
+
+    test('likeDiet - лайкает диету', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      when(mockFeedRepository.getDiets(query: null, types: null, duration: null, sorting: null)).thenAnswer((_) async => testDietsPagination);
+
+      await dietsCubit!.loadDiets();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockDietRepository.likeDiet(1)).thenAnswer((_) async => const DietLikesModel(totalLikes: 2, isLiked: true));
+
+      dietsCubit!.likeDiet(1, 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(dietsCubit!.state.dietsList[0].wasLikedByMe, true);
+      expect(dietsCubit!.state.dietsList[0].totalLikes, 2);
+    });
+
+    test('addDietToFavorite - добавляет диету в избранное', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      when(mockFeedRepository.getDiets(query: null, types: null, duration: null, sorting: null)).thenAnswer((_) async => testDietsPagination);
+
+      await dietsCubit!.loadDiets();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockDietRepository.addToFavorite(1)).thenAnswer((_) async => testDiet.copyWith(isFavorite: true));
+
+      dietsCubit!.addDietToFavorite(1, 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(dietsCubit!.state.dietsList[0].isFavorite, true);
+    });
+
+    test('removeDietFromFavorite - удаляет диету из избранного', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      when(
+        mockFeedRepository.getDiets(query: null, types: null, duration: null, sorting: null),
+      ).thenAnswer((_) async => testDietsPagination.copyWith(data: [testDiet.copyWith(isFavorite: true)]));
+
+      await dietsCubit!.loadDiets();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockDietRepository.removeFromFavorite(1)).thenAnswer((_) async => testDiet.copyWith(isFavorite: false));
+
+      dietsCubit!.removeDietFromFavorite(1, 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(dietsCubit!.state.dietsList[0].isFavorite, false);
+    });
+
+    test('deleteDiet - удаляет диету', () async {
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      when(mockDietRepository.deleteDiet(1)).thenAnswer((_) async => Future.value());
+
+      final result = await dietsCubit!.deleteDiet(1);
+
+      expect(result, true);
+      verify(mockDietRepository.deleteDiet(1)).called(1);
+    });
+  });
+}

test/features/diets/presentation/widgets/basic_widget_test.dart

@@ -0,0 +1,244 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.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/feed/presentation/bloc/diets_cubit/diets_cubit.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/diets_cubit/diets_state.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/diets.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/diets_widget.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:network_image_mock/network_image_mock.dart';
+import 'package:visibility_detector/visibility_detector.dart';
+
+import 'basic_widget_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>(), MockSpec<DietRepository>()])
+void main() {
+  group('Diets Basic Widget Tests', () {
+    late MockFeedRepository mockFeedRepository;
+    late MockDietRepository mockDietRepository;
+    late DietsCubit dietsCubit;
+
+    const testDiet = Diet(
+      id: 1,
+      slug: 'test-diet',
+      name: 'Test Diet',
+      image: 'test-image.jpg',
+      duration: 30,
+      state: DietState.active,
+      type: DietType(light: false, veg: false, carb: false, meat: false),
+      details: 'Test diet description',
+      dailySchedule: {},
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      wasLikedByMe: false,
+      isFavorite: false,
+      dailyNutrition: [],
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockFeedRepository = MockFeedRepository();
+      mockDietRepository = MockDietRepository();
+      dietsCubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+      VisibilityDetectorController.instance.updateInterval = Duration.zero;
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!dietsCubit.isClosed) {
+        dietsCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<DietsCubit>(
+        create: (context) => dietsCubit,
+        child: Portal(
+          child: wrapInScaffold
+              ? Scaffold(body: SingleChildScrollView(child: child))
+              : SizedBox(width: 800, height: 1200, child: SingleChildScrollView(child: child)),
+        ),
+      );
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: widget,
+      );
+    }
+
+    Widget createDietsTestWidget(Widget child) {
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: Portal(
+          child: Scaffold(
+            body: BlocProvider<DietsCubit>(
+              create: (context) => dietsCubit,
+              child: LayoutBuilder(
+                builder: (context, constraints) => SizedBox(
+                  width: constraints.maxWidth > 0 ? constraints.maxWidth : 800,
+                  height: constraints.maxHeight > 0 ? constraints.maxHeight : 600,
+                  child: child,
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+    }
+
+    testWidgets('should create DietsCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = DietsCubit(feedRepository: mockFeedRepository, dietsRepository: mockDietRepository);
+
+      // Assert
+      expect(cubit, isA<DietsCubit>());
+      expect(cubit.state.dietsList, isEmpty);
+
+      cubit.close();
+    });
+
+    testWidgets('should display DietsWidget with diet name', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        dietsCubit.emit(DietsState.initial().copyWith(dietsList: [testDiet], isLoading: false));
+        const widget = DietsWidget(diet: testDiet, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.text('Test Diet'), findsOneWidget);
+        expect(find.byType(DietsWidget), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display DietsWidget with description when details are present', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        dietsCubit.emit(DietsState.initial().copyWith(dietsList: [testDiet], isLoading: false));
+        const widget = DietsWidget(diet: testDiet, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.text('Test Diet'), findsOneWidget);
+        expect(find.byType(DietsWidget), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display DietsWidget structure correctly', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        dietsCubit.emit(DietsState.initial().copyWith(dietsList: [testDiet], isLoading: false));
+        const widget = DietsWidget(diet: testDiet, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(DietsWidget), findsOneWidget);
+        expect(find.text('Test Diet'), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display Diets widget with loading state', (WidgetTester tester) async {
+      // Arrange
+      dietsCubit.emit(DietsState.initial());
+      final widget = Diets(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createDietsTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(find.byType(Diets), findsOneWidget);
+    });
+
+    testWidgets('should display Diets widget with loaded state', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        dietsCubit.emit(DietsState.initial().copyWith(dietsList: [testDiet], isLoading: false));
+        final widget = Diets(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createDietsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(Diets), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display Diets widget with error state', (WidgetTester tester) async {
+      // Arrange
+      dietsCubit.emit(DietsState.initial().copyWith(isLoading: false, errorMessage: 'Error message'));
+      final widget = Diets(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createDietsTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(find.byType(Diets), findsOneWidget);
+    });
+
+    testWidgets('should display Diets widget with multiple diets', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        final testDiet2 = testDiet.copyWith(id: 2, name: 'Test Diet 2');
+        dietsCubit.emit(DietsState.initial().copyWith(dietsList: [testDiet, testDiet2], isLoading: false));
+        final widget = Diets(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createDietsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(Diets), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+  });
+}

test/features/diets/presentation/widgets/widgets_test.dart

@@ -0,0 +1,242 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/features/diets/presentation/widgets/author_card.dart';
+import 'package:eatvio_app/features/diets/presentation/widgets/expandable_text.dart';
+import 'package:eatvio_app/features/diets/presentation/widgets/info_bouble.dart';
+import 'package:eatvio_app/features/diets/presentation/widgets/type_badges.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:network_image_mock/network_image_mock.dart';
+
+void main() {
+  group('Diets Widgets Tests', () {
+    setUp(() async {
+      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'));
+    });
+
+    Widget createTestWidget(Widget child) {
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: Portal(
+          child: Scaffold(body: SingleChildScrollView(child: child)),
+        ),
+      );
+    }
+
+    group('InfoBouble', () {
+      testWidgets('should display InfoBouble with children', (WidgetTester tester) async {
+        // Arrange
+        const widget = InfoBouble(children: [Text('Test Text')]);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(InfoBouble), findsOneWidget);
+        expect(find.text('Test Text'), findsOneWidget);
+      });
+
+      testWidgets('should display InfoBouble with multiple children', (WidgetTester tester) async {
+        // Arrange
+        const widget = InfoBouble(children: [Text('First'), Text('Second')]);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(InfoBouble), findsOneWidget);
+        expect(find.text('First'), findsOneWidget);
+        expect(find.text('Second'), findsOneWidget);
+      });
+
+      testWidgets('should display InfoBouble with custom radius', (WidgetTester tester) async {
+        // Arrange
+        const widget = InfoBouble(radius: 20, children: [Text('Test')]);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(InfoBouble), findsOneWidget);
+        expect(find.text('Test'), findsOneWidget);
+      });
+    });
+
+    group('ExpandableText', () {
+      testWidgets('should display ExpandableText with short text', (WidgetTester tester) async {
+        // Arrange
+        const widget = ExpandableText(text: 'Short text', maxLines: 5);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(ExpandableText), findsOneWidget);
+        expect(find.text('Short text'), findsOneWidget);
+      });
+
+      testWidgets('should display ExpandableText with long text', (WidgetTester tester) async {
+        // Arrange
+        const longText =
+            'This is a very long text that should be truncated and show an expand button when it exceeds the maximum number of lines specified in the widget. This text should be long enough to trigger the expand functionality.';
+        const widget = ExpandableText(text: longText, maxLines: 3);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 200));
+
+        // Assert
+        expect(find.byType(ExpandableText), findsOneWidget);
+      });
+
+      testWidgets('should toggle expansion when expand button is tapped', (WidgetTester tester) async {
+        // Arrange
+        const longText =
+            'This is a very long text that should be truncated and show an expand button when it exceeds the maximum number of lines specified in the widget. This text should be long enough to trigger the expand functionality.';
+        const widget = ExpandableText(text: longText, maxLines: 3);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 200));
+
+        // Try to find and tap expand button if it exists
+        final expandButtons = find.text('Развернуть');
+        if (expandButtons.evaluate().isNotEmpty) {
+          await tester.tap(expandButtons);
+          await tester.pump();
+          await tester.pump(const Duration(milliseconds: 200));
+        }
+
+        // Assert
+        expect(find.byType(ExpandableText), findsOneWidget);
+      });
+    });
+
+    group('AuthorCard', () {
+      testWidgets('should display AuthorCard with author information', (WidgetTester tester) async {
+        await mockNetworkImagesFor(() async {
+          // Arrange
+          const author = Author(authorSlug: 'test-author', authorName: 'Test Author', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false);
+          const widget = AuthorCard(author: author, title: 'Автор');
+
+          // Act
+          await tester.pumpWidget(createTestWidget(widget));
+          await tester.pump();
+          await tester.pump(const Duration(milliseconds: 100));
+
+          // Assert
+          expect(find.byType(AuthorCard), findsOneWidget);
+          expect(find.text('Test Author'), findsOneWidget);
+          expect(find.text('Автор'), findsOneWidget);
+        });
+        await tester.pump(const Duration(milliseconds: 600));
+      });
+
+      testWidgets('should display AuthorCard with rating when available', (WidgetTester tester) async {
+        await mockNetworkImagesFor(() async {
+          // Arrange
+          const author = Author(
+            authorSlug: 'test-author',
+            authorName: 'Test Author',
+            authorProfileIcon: 'https://example.com/icon.jpg',
+            authorIsMe: false,
+            authorPlaceInRating: 5,
+          );
+          const widget = AuthorCard(author: author, title: 'Автор');
+
+          // Act
+          await tester.pumpWidget(createTestWidget(widget));
+          await tester.pump();
+          await tester.pump(const Duration(milliseconds: 100));
+
+          // Assert
+          expect(find.byType(AuthorCard), findsOneWidget);
+          expect(find.text('Test Author'), findsOneWidget);
+        });
+        await tester.pump(const Duration(milliseconds: 600));
+      });
+    });
+
+    group('TypeBadges', () {
+      testWidgets('should display TypeBadges with diet type', (WidgetTester tester) async {
+        // Arrange
+        const dietType = DietType(light: true, veg: false, carb: false, meat: false);
+        const widget = TypeBadges(type: dietType, disableDescriptionOfTypes: false);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(TypeBadges), findsOneWidget);
+      });
+
+      testWidgets('should display TypeBadges with plan type', (WidgetTester tester) async {
+        // Arrange
+        const planType = PlanType(fit: true, slim: false, behavior: false, wellness: false);
+        const widget = TypeBadges(planType: planType, disableDescriptionOfTypes: false);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(TypeBadges), findsOneWidget);
+      });
+
+      testWidgets('should display TypeBadges with multiple types', (WidgetTester tester) async {
+        // Arrange
+        const dietType = DietType(light: true, veg: true, carb: false, meat: false);
+        const widget = TypeBadges(type: dietType, disableDescriptionOfTypes: false);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(TypeBadges), findsOneWidget);
+      });
+
+      testWidgets('should not show overlay when disableDescriptionOfTypes is true', (WidgetTester tester) async {
+        // Arrange
+        const dietType = DietType(light: true, veg: false, carb: false, meat: false);
+        const widget = TypeBadges(type: dietType, disableDescriptionOfTypes: true);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(TypeBadges), findsOneWidget);
+      });
+    });
+  });
+}

test/features/diets/repositories/diet_repository_test.dart

@@ -0,0 +1,207 @@
+import 'package:eatvio_app/features/diets/models/diet_likes_model.dart';
+import 'package:eatvio_app/features/diets/repositories/diet_repository.dart';
+import 'package:eatvio_app/features/diets/services/diet_service.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'diet_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<DietService>()])
+void main() {
+  group('DietRepository', () {
+    late DietRepository dietRepository;
+    late MockDietService mockDietService;
+
+    setUp(() {
+      mockDietService = MockDietService();
+      dietRepository = DietRepository(dietsService: mockDietService);
+    });
+
+    test('likeDiet returns DietLikesModel', () async {
+      const id = 1;
+      const expected = DietLikesModel(totalLikes: 10, isLiked: true);
+
+      when(mockDietService.likeDiet(id: id)).thenAnswer((_) async => expected);
+
+      final result = await dietRepository.likeDiet(id);
+
+      expect(result, isA<DietLikesModel>());
+      expect(result.totalLikes, 10);
+      expect(result.isLiked, true);
+      verify(mockDietService.likeDiet(id: id)).called(1);
+    });
+
+    test('getDiet returns Diet by id', () async {
+      const id = 1;
+      const expected = Diet(
+        id: id,
+        slug: 'test-diet',
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: false,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.getDiet(id: id)).thenAnswer((_) async => expected);
+
+      final result = await dietRepository.getDiet(id);
+
+      expect(result, isA<Diet>());
+      expect(result.id, id);
+      expect(result.name, 'Test Diet');
+      verify(mockDietService.getDiet(id: id)).called(1);
+    });
+
+    test('getDietBySlug returns Diet by slug', () async {
+      const slug = 'test-diet-slug';
+      const expected = Diet(
+        id: 1,
+        slug: slug,
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: false,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.getDietBySlug(slug: slug)).thenAnswer((_) async => expected);
+
+      final result = await dietRepository.getDietBySlug(slug);
+
+      expect(result, isA<Diet>());
+      expect(result.slug, slug);
+      verify(mockDietService.getDietBySlug(slug: slug)).called(1);
+    });
+
+    test('addToFavorite returns Diet', () async {
+      const id = 1;
+      const expected = Diet(
+        id: id,
+        slug: 'test-diet',
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: true,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.addToFavorite(id: id)).thenAnswer((_) async => expected);
+
+      final result = await dietRepository.addToFavorite(id);
+
+      expect(result, isA<Diet>());
+      expect(result.isFavorite, true);
+      verify(mockDietService.addToFavorite(id: id)).called(1);
+    });
+
+    test('removeFromFavorite returns Diet', () async {
+      const id = 1;
+      const expected = Diet(
+        id: id,
+        slug: 'test-diet',
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: false,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.removeFromFavorite(id: id)).thenAnswer((_) async => expected);
+
+      final result = await dietRepository.removeFromFavorite(id);
+
+      expect(result, isA<Diet>());
+      expect(result.isFavorite, false);
+      verify(mockDietService.removeFromFavorite(id: id)).called(1);
+    });
+
+    test('startDiet starts diet with date', () async {
+      const id = 1;
+      const date = '2024-01-01';
+
+      when(mockDietService.startDiet(id: id, body: {'date': date})).thenAnswer((_) async => Future.value());
+
+      await dietRepository.startDiet(id, date);
+
+      verify(mockDietService.startDiet(id: id, body: {'date': date})).called(1);
+    });
+
+    test('cancelDiet cancels diet by id', () async {
+      const id = 1;
+
+      when(mockDietService.cancelDiet(id: id)).thenAnswer((_) async => Future.value());
+
+      await dietRepository.cancelDiet(id);
+
+      verify(mockDietService.cancelDiet(id: id)).called(1);
+    });
+
+    test('deleteDiet deletes diet by id', () async {
+      const id = 1;
+
+      when(mockDietService.deleteDiet(id: id)).thenAnswer((_) async => Future.value());
+
+      await dietRepository.deleteDiet(id);
+
+      verify(mockDietService.deleteDiet(id: id)).called(1);
+    });
+
+    test('likeDiet rethrows exception on error', () async {
+      const id = 1;
+
+      when(mockDietService.likeDiet(id: id)).thenThrow(Exception('Network error'));
+
+      expect(() => dietRepository.likeDiet(id), throwsException);
+      verify(mockDietService.likeDiet(id: id)).called(1);
+    });
+
+    test('getDiet rethrows exception on error', () async {
+      const id = 1;
+
+      when(mockDietService.getDiet(id: id)).thenThrow(Exception('Network error'));
+
+      expect(() => dietRepository.getDiet(id), throwsException);
+      verify(mockDietService.getDiet(id: id)).called(1);
+    });
+  });
+}
+

test/features/diets/services/diet_service_test.dart

@@ -0,0 +1,203 @@
+import 'package:eatvio_app/features/diets/models/diet_likes_model.dart';
+import 'package:eatvio_app/features/diets/services/diet_service.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'diet_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<DietService>()])
+void main() {
+  group('DietService', () {
+    late MockDietService mockDietService;
+
+    setUp(() {
+      mockDietService = MockDietService();
+    });
+
+    test('likeDiet returns DietLikesModel', () async {
+      const id = 1;
+      const expected = DietLikesModel(totalLikes: 10, isLiked: true);
+
+      when(mockDietService.likeDiet(id: id)).thenAnswer((_) async => expected);
+
+      final result = await mockDietService.likeDiet(id: id);
+
+      expect(result, isA<DietLikesModel>());
+      expect(result.totalLikes, 10);
+      expect(result.isLiked, true);
+      verify(mockDietService.likeDiet(id: id)).called(1);
+    });
+
+    test('likeDiet returns DietLikesModel with different values', () async {
+      const id = 2;
+      const expected = DietLikesModel(totalLikes: 5, isLiked: false);
+
+      when(mockDietService.likeDiet(id: id)).thenAnswer((_) async => expected);
+
+      final result = await mockDietService.likeDiet(id: id);
+
+      expect(result, isA<DietLikesModel>());
+      expect(result.totalLikes, 5);
+      expect(result.isLiked, false);
+      verify(mockDietService.likeDiet(id: id)).called(1);
+    });
+
+    test('addToFavorite returns Diet', () async {
+      const id = 1;
+      const expected = Diet(
+        id: id,
+        slug: 'test-diet',
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: true,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.addToFavorite(id: id)).thenAnswer((_) async => expected);
+
+      final result = await mockDietService.addToFavorite(id: id);
+
+      expect(result, isA<Diet>());
+      expect(result.id, id);
+      expect(result.isFavorite, true);
+      verify(mockDietService.addToFavorite(id: id)).called(1);
+    });
+
+    test('removeFromFavorite returns Diet', () async {
+      const id = 1;
+      const expected = Diet(
+        id: id,
+        slug: 'test-diet',
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: false,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.removeFromFavorite(id: id)).thenAnswer((_) async => expected);
+
+      final result = await mockDietService.removeFromFavorite(id: id);
+
+      expect(result, isA<Diet>());
+      expect(result.id, id);
+      expect(result.isFavorite, false);
+      verify(mockDietService.removeFromFavorite(id: id)).called(1);
+    });
+
+    test('getDiet returns Diet by id', () async {
+      const id = 1;
+      const expected = Diet(
+        id: id,
+        slug: 'test-diet',
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: false,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.getDiet(id: id)).thenAnswer((_) async => expected);
+
+      final result = await mockDietService.getDiet(id: id);
+
+      expect(result, isA<Diet>());
+      expect(result.id, id);
+      expect(result.name, 'Test Diet');
+      verify(mockDietService.getDiet(id: id)).called(1);
+    });
+
+    test('getDietBySlug returns Diet by slug', () async {
+      const slug = 'test-diet-slug';
+      const expected = Diet(
+        id: 1,
+        slug: slug,
+        name: 'Test Diet',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: DietState.active,
+        type: DietType(light: true, veg: false, carb: false, meat: false),
+        details: 'Test diet description',
+        dailySchedule: {},
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        wasLikedByMe: false,
+        isFavorite: false,
+        dailyNutrition: [],
+      );
+
+      when(mockDietService.getDietBySlug(slug: slug)).thenAnswer((_) async => expected);
+
+      final result = await mockDietService.getDietBySlug(slug: slug);
+
+      expect(result, isA<Diet>());
+      expect(result.slug, slug);
+      verify(mockDietService.getDietBySlug(slug: slug)).called(1);
+    });
+
+    test('startDiet starts diet with date', () async {
+      const id = 1;
+      const date = '2024-01-01';
+      final body = {'date': date};
+
+      when(mockDietService.startDiet(id: id, body: body)).thenAnswer((_) async => Future.value());
+
+      await mockDietService.startDiet(id: id, body: body);
+
+      verify(mockDietService.startDiet(id: id, body: body)).called(1);
+    });
+
+    test('cancelDiet cancels diet by id', () async {
+      const id = 1;
+
+      when(mockDietService.cancelDiet(id: id)).thenAnswer((_) async => Future.value());
+
+      await mockDietService.cancelDiet(id: id);
+
+      verify(mockDietService.cancelDiet(id: id)).called(1);
+    });
+
+    test('deleteDiet deletes diet by id', () async {
+      const id = 1;
+
+      when(mockDietService.deleteDiet(id: id)).thenAnswer((_) async => Future.value());
+
+      await mockDietService.deleteDiet(id: id);
+
+      verify(mockDietService.deleteDiet(id: id)).called(1);
+    });
+  });
+}
+

test/features/feed/presentation/bloc/feed_cubit_test.dart

@@ -0,0 +1,404 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_settings_model.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/feed_cubit/feed_cubit.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/feed_cubit/feed_state.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'feed_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>()])
+void main() {
+  group('FeedCubit', () {
+    FeedCubit? feedCubit;
+    late MockFeedRepository mockFeedRepository;
+
+    final testBlogPost = FeedBlogPostModel(
+      id: 1,
+      title: 'Test Post',
+      description: 'Test description',
+      image: 'https://example.com/image.jpg',
+      state: 'published',
+      author: const Author(authorSlug: 'author-1', authorName: 'Author Name', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false),
+      videoUrl: 'https://example.com/video.mp4',
+      createdAt: DateTime(2024, 1, 15),
+      updatedAt: DateTime(2024, 1, 15),
+      totalLikes: 10,
+      totalViews: 100,
+      totalComments: 5,
+      wasLikedByMe: false,
+    );
+
+    final testBlogPost2 = FeedBlogPostModel(
+      id: 2,
+      title: 'Test Post 2',
+      description: 'Test description 2',
+      image: 'https://example.com/image2.jpg',
+      state: 'published',
+      author: const Author(authorSlug: 'author-2', authorName: 'Author Name 2', authorProfileIcon: 'https://example.com/icon2.jpg', authorIsMe: false),
+      videoUrl: 'https://example.com/video2.mp4',
+      createdAt: DateTime(2024, 1, 16),
+      updatedAt: DateTime(2024, 1, 16),
+      totalLikes: 20,
+      totalViews: 200,
+      totalComments: 10,
+      wasLikedByMe: true,
+    );
+
+    setUp(() {
+      mockFeedRepository = MockFeedRepository();
+    });
+
+    tearDown(() async {
+      if (feedCubit != null && !feedCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        feedCubit!.close();
+        feedCubit = null;
+      }
+    });
+
+    test('начальное состояние - loading', () {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      expect(feedCubit!.state, const FeedState.loading());
+    });
+
+    test('loadFeedBlogPostList - успешно загружает список постов', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final expectedSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => expectedSettings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateLoaded>());
+      final loadedState = feedCubit!.state as FeedStateLoaded;
+      expect(loadedState.feedBlogPostList.length, 1);
+      expect(loadedState.feedBlogPostList.first.id, 1);
+      expect(loadedState.isLoading, false);
+      expect(feedCubit!.lastPage, 3);
+      verify(mockFeedRepository.getFeedBlogPosts(query: null)).called(1);
+    });
+
+    test('loadFeedBlogPostList - загружает список постов с query', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const query = 'test query';
+      final expectedSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost, testBlogPost2],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 2, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: query)).thenAnswer((_) async => expectedSettings);
+
+      await feedCubit!.loadFeedBlogPostList(query: query);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateLoaded>());
+      final loadedState = feedCubit!.state as FeedStateLoaded;
+      expect(loadedState.feedBlogPostList.length, 2);
+      verify(mockFeedRepository.getFeedBlogPosts(query: query)).called(1);
+    });
+
+    test('loadFeedBlogPostList - обрабатывает ошибку', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final exception = Exception('Network error');
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenThrow(exception);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateError>());
+      final errorState = feedCubit!.state as FeedStateError;
+      expect(errorState.errorMessage, contains('Exception: Network error'));
+    });
+
+    test('loadNextPage - загружает следующую страницу', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final firstPageSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      final secondPageSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost2],
+        meta: const Meta(currentPage: 2, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => firstPageSettings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockFeedRepository.getFeedBlogPosts(page: 2, query: null)).thenAnswer((_) async => secondPageSettings);
+
+      await feedCubit!.loadNextPage();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateLoaded>());
+      final loadedState = feedCubit!.state as FeedStateLoaded;
+      expect(loadedState.feedBlogPostList.length, 2);
+      expect(feedCubit!.currentPage, 2);
+      expect(loadedState.isLoading, false);
+      verify(mockFeedRepository.getFeedBlogPosts(page: 2, query: null)).called(1);
+    });
+
+    test('loadNextPage - не загружает если уже на последней странице', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final settings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => settings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      await feedCubit!.loadNextPage();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      verifyNever(mockFeedRepository.getFeedBlogPosts(page: 2, query: anyNamed('query')));
+    });
+
+    test('loadNextPage - не загружает если уже загружается', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final settings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => settings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      feedCubit!.isLoading = true;
+
+      await feedCubit!.loadNextPage();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      verifyNever(mockFeedRepository.getFeedBlogPosts(page: 2, query: anyNamed('query')));
+    });
+
+    test('loadNextPage - обрабатывает ошибку при загрузке следующей страницы', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final firstPageSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => firstPageSettings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      final exception = Exception('Network error');
+      when(mockFeedRepository.getFeedBlogPosts(page: 2, query: null)).thenThrow(exception);
+
+      await feedCubit!.loadNextPage();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateError>());
+      final errorState = feedCubit!.state as FeedStateError;
+      expect(errorState.errorMessage, contains('Exception: Network error'));
+    });
+
+    test('loadNextPage - сохраняет query при загрузке следующей страницы', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const query = 'test query';
+      final firstPageSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      final secondPageSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost2],
+        meta: const Meta(currentPage: 2, lastPage: 3, total: 3, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: query)).thenAnswer((_) async => firstPageSettings);
+
+      await feedCubit!.loadFeedBlogPostList(query: query);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockFeedRepository.getFeedBlogPosts(page: 2, query: query)).thenAnswer((_) async => secondPageSettings);
+
+      await feedCubit!.loadNextPage();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      verify(mockFeedRepository.getFeedBlogPosts(page: 2, query: query)).called(1);
+    });
+
+    test('updateFeedBlogPostList - обновляет лайк поста', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final settings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => settings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      feedCubit!.updateFeedBlogPostList(testBlogPost, true);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateLoaded>());
+      final loadedState = feedCubit!.state as FeedStateLoaded;
+      expect(loadedState.feedBlogPostList.first.wasLikedByMe, true);
+      expect(loadedState.feedBlogPostList.first.totalLikes, 11);
+    });
+
+    test('updateFeedBlogPostList - убирает лайк поста', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final settings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost2],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => settings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      feedCubit!.updateFeedBlogPostList(testBlogPost2, false);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, isA<FeedStateLoaded>());
+      final loadedState = feedCubit!.state as FeedStateLoaded;
+      expect(loadedState.feedBlogPostList.first.wasLikedByMe, false);
+      expect(loadedState.feedBlogPostList.first.totalLikes, 19);
+    });
+
+    test('updateFeedBlogPostList - не обновляет если пост не найден', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final settings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => settings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      final nonExistentPost = testBlogPost.copyWith(id: 999);
+      final initialState = feedCubit!.state;
+      feedCubit!.updateFeedBlogPostList(nonExistentPost, true);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, initialState);
+    });
+
+    test('updateFeedBlogPostList - не обновляет если state не loaded', () {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      feedCubit!.updateFeedBlogPostList(testBlogPost, true);
+      expect(feedCubit!.state, const FeedState.loading());
+    });
+
+    test('updateFeedBlogPostList - не обновляет если post null', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      final settings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [testBlogPost],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer((_) async => settings);
+
+      await feedCubit!.loadFeedBlogPostList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      final initialState = feedCubit!.state;
+      feedCubit!.updateFeedBlogPostList(null, true);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(feedCubit!.state, initialState);
+    });
+
+    test('likePost - лайкает пост', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const postId = 1;
+
+      when(mockFeedRepository.likeBlogPost(id: postId)).thenAnswer((_) async => Future.value());
+
+      await feedCubit!.likePost(postId);
+
+      verify(mockFeedRepository.likeBlogPost(id: postId)).called(1);
+    });
+
+    test('likePost - обрабатывает ошибку без выбрасывания', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const postId = 1;
+      final exception = Exception('Network error');
+
+      when(mockFeedRepository.likeBlogPost(id: postId)).thenThrow(exception);
+
+      await feedCubit!.likePost(postId);
+
+      verify(mockFeedRepository.likeBlogPost(id: postId)).called(1);
+    });
+
+    test('unlikedPost - убирает лайк с поста', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const postId = 1;
+
+      when(mockFeedRepository.unlikedBlogPost(id: postId)).thenAnswer((_) async => Future.value());
+
+      await feedCubit!.unlikedPost(postId);
+
+      verify(mockFeedRepository.unlikedBlogPost(id: postId)).called(1);
+    });
+
+    test('viewPost - отправляет просмотр поста', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const postId = 1;
+
+      when(mockFeedRepository.viewPost(postId)).thenAnswer((_) async => Future.value());
+
+      await feedCubit!.viewPost(postId);
+
+      verify(mockFeedRepository.viewPost(postId)).called(1);
+    });
+
+    test('viewRecipe - отправляет просмотр рецепта', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const slug = 'recipe-1';
+
+      when(mockFeedRepository.viewRecipe(slug)).thenAnswer((_) async => Future.value());
+
+      await feedCubit!.viewRecipe(slug);
+
+      verify(mockFeedRepository.viewRecipe(slug)).called(1);
+    });
+
+    test('viewDiet - отправляет просмотр диеты', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const dietId = 2;
+
+      when(mockFeedRepository.viewDiet(dietId)).thenAnswer((_) async => Future.value());
+
+      await feedCubit!.viewDiet(dietId);
+
+      verify(mockFeedRepository.viewDiet(dietId)).called(1);
+    });
+
+    test('viewPlan - отправляет просмотр плана', () async {
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      const slug = 'plan-1';
+
+      when(mockFeedRepository.viewPlan(slug)).thenAnswer((_) async => Future.value());
+
+      await feedCubit!.viewPlan(slug);
+
+      verify(mockFeedRepository.viewPlan(slug)).called(1);
+    });
+  });
+}

test/features/feed/presentation/widgets/basic_widget_test.dart

@@ -0,0 +1,533 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/core/routing/route_constants.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_settings_model.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/feed_cubit/feed_cubit.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/feed_cubit/feed_state.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/blog_posts.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/chip_group.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:go_router/go_router.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:network_image_mock/network_image_mock.dart';
+import 'package:visibility_detector/visibility_detector.dart';
+
+import 'basic_widget_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>()])
+void main() {
+  group('Feed Basic Widget Tests', () {
+    late MockFeedRepository mockFeedRepository;
+    late FeedCubit feedCubit;
+    VisibilityDetectorController.instance.updateInterval = Duration.zero;
+
+    final testBlogPost = FeedBlogPostModel(
+      id: 1,
+      title: 'Test Post',
+      description: 'Test description',
+      image: '', // Empty - CachedNetworkImage will show errorWidget (SizedBox.shrink)
+      state: 'published',
+      author: const Author(authorSlug: 'author-1', authorName: 'Author Name', authorProfileIcon: '', authorIsMe: false),
+      videoUrl: '',
+      createdAt: DateTime(2024, 1, 15),
+      updatedAt: DateTime(2024, 1, 15),
+      totalLikes: 10,
+      totalViews: 100,
+      totalComments: 5,
+      wasLikedByMe: false,
+    );
+
+    final testBlogPost2 = FeedBlogPostModel(
+      id: 2,
+      title: 'Test Post 2',
+      description: 'Test description 2',
+      image: '', // Empty - CachedNetworkImage will show errorWidget (SizedBox.shrink)
+      state: 'published',
+      author: const Author(authorSlug: 'author-2', authorName: 'Author Name 2', authorProfileIcon: '', authorIsMe: false),
+      videoUrl: '',
+      createdAt: DateTime(2024, 1, 16),
+      updatedAt: DateTime(2024, 1, 16),
+      totalLikes: 20,
+      totalViews: 200,
+      totalComments: 10,
+      wasLikedByMe: true,
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockFeedRepository = MockFeedRepository();
+      feedCubit = FeedCubit(feedRepository: mockFeedRepository);
+      // Register AppConfig with proper baseUrl for image URL construction
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!feedCubit.isClosed) {
+        feedCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<FeedCubit>(
+        create: (context) => feedCubit,
+        child: wrapInScaffold ? Scaffold(body: SingleChildScrollView(child: child)) : SizedBox(width: 800, height: 600, child: child),
+      );
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: widget,
+      );
+    }
+
+    Widget createBlogPostsTestWidget(Widget child) {
+      // Create a minimal GoRouter for tests
+      final router = GoRouter(
+        initialLocation: '/',
+        routes: [
+          GoRoute(
+            path: '/',
+            builder: (context, state) => BlocProvider<FeedCubit>(
+              create: (context) => feedCubit,
+              child: Scaffold(
+                body: LayoutBuilder(
+                  builder: (context, constraints) => SizedBox(
+                    width: constraints.maxWidth > 0 ? constraints.maxWidth : 800,
+                    height: constraints.maxHeight > 0 ? constraints.maxHeight : 600,
+                    child: child,
+                  ),
+                ),
+              ),
+            ),
+          ),
+          GoRoute(
+            path: RouteConstants.blogPostScreen,
+            name: 'blogPostScreen',
+            builder: (context, state) => Scaffold(
+              appBar: AppBar(title: const Text('Blog Post')),
+              body: Center(child: Text('Blog Post ${state.extra ?? ''}')),
+            ),
+          ),
+        ],
+      );
+
+      return MaterialApp.router(
+        theme: ThemeHelper().themeData(),
+        routerConfig: router,
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+      );
+    }
+
+    testWidgets('should create FeedCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = FeedCubit(feedRepository: mockFeedRepository);
+
+      // Assert
+      expect(cubit, isA<FeedCubit>());
+      expect(cubit.state, const FeedState.loading());
+
+      cubit.close();
+    });
+
+    testWidgets('should display ChipGroup with all chips', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Все', 'Рецепты', 'Диеты', 'Планы питания', 'Консультанты'];
+      int selectedIndex = 0;
+      final widget = ChipGroup(
+        selectedChipIndex: selectedIndex,
+        chipsLabelList: chipsLabelList,
+        setSelectedChipIndex: (index) {
+          selectedIndex = index;
+        },
+      );
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.text('Все'), findsOneWidget);
+      expect(find.text('Рецепты'), findsOneWidget);
+      expect(find.text('Диеты'), findsOneWidget);
+      expect(find.text('Планы питания'), findsOneWidget);
+      expect(find.text('Консультанты'), findsOneWidget);
+    });
+
+    testWidgets('should handle chip selection in ChipGroup', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Все', 'Рецепты', 'Диеты'];
+      int selectedIndex = 0;
+      final widget = ChipGroup(
+        selectedChipIndex: selectedIndex,
+        chipsLabelList: chipsLabelList,
+        setSelectedChipIndex: (index) {
+          selectedIndex = index;
+        },
+      );
+
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Act
+      await tester.tap(find.text('Рецепты'));
+      await tester.pump();
+
+      // Assert
+      expect(selectedIndex, 1);
+    });
+
+    testWidgets('should display ChipGroup with custom labels', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Tab 1', 'Tab 2', 'Tab 3'];
+      final widget = ChipGroup(selectedChipIndex: 0, chipsLabelList: chipsLabelList, setSelectedChipIndex: (index) {});
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.text('Tab 1'), findsOneWidget);
+      expect(find.text('Tab 2'), findsOneWidget);
+      expect(find.text('Tab 3'), findsOneWidget);
+    });
+
+    testWidgets('should display BlogPosts widget with loading state', (WidgetTester tester) async {
+      // Arrange
+      feedCubit.emit(const FeedState.loading());
+
+      final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      final router = GoRouter(
+        initialLocation: '/',
+        routes: [
+          GoRoute(
+            path: '/',
+            builder: (context, state) => BlocProvider<FeedCubit>(create: (context) => feedCubit, child: widget),
+          ),
+        ],
+      );
+
+      await tester.pumpWidget(
+        MaterialApp.router(
+          theme: ThemeHelper().themeData(),
+          routerConfig: router,
+          localizationsDelegates: const [
+            S.delegate,
+            GlobalMaterialLocalizations.delegate,
+            GlobalWidgetsLocalizations.delegate,
+            GlobalCupertinoLocalizations.delegate,
+          ],
+          supportedLocales: const [Locale('ru')],
+        ),
+      );
+      await tester.pump();
+
+      // Assert
+      expect(feedCubit.state, isA<FeedStateLoading>());
+      expect(find.byType(BlogPosts), findsOneWidget);
+    });
+
+    testWidgets('should display BlogPosts widget with loaded state', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: [testBlogPost, testBlogPost2], isLoading: false));
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        // Pump frames to allow widgets to render
+        // Note: VisibilityDetector creates a 500ms timer, but we don't need to wait for it
+        // to complete to verify the widget structure
+        await tester.pump();
+
+        // Assert - Verify state and widget structure
+        expect(feedCubit.state, isA<FeedStateLoaded>());
+        final loadedState = feedCubit.state as FeedStateLoaded;
+        expect(loadedState.feedBlogPostList.length, 2);
+        expect(find.byType(BlogPosts), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        // ListView should be present in loaded state
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      // Pump one more time after mockNetworkImagesFor to allow any pending timers to complete
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display BlogPosts widget with error state', (WidgetTester tester) async {
+      // Arrange
+      feedCubit.emit(const FeedState.error(errorMessage: 'Ошибка загрузки постов'));
+
+      final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createBlogPostsTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(feedCubit.state, isA<FeedStateError>());
+      final errorState = feedCubit.state as FeedStateError;
+      expect(errorState.errorMessage, 'Ошибка загрузки постов');
+      expect(find.byType(BlogPosts), findsOneWidget);
+    });
+
+    testWidgets('should display BlogPosts with empty list', (WidgetTester tester) async {
+      // Arrange
+      feedCubit.emit(const FeedState.loaded(feedBlogPostList: [], isLoading: false));
+
+      final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createBlogPostsTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(feedCubit.state, isA<FeedStateLoaded>());
+      final loadedState = feedCubit.state as FeedStateLoaded;
+      expect(loadedState.feedBlogPostList.isEmpty, true);
+      expect(find.byType(BlogPosts), findsOneWidget);
+      expect(find.byType(ListView), findsOneWidget);
+    });
+
+    testWidgets('should display BlogPosts with loading indicator when isLoading is true', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: [testBlogPost], isLoading: true));
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(feedCubit.state, isA<FeedStateLoaded>());
+        final loadedState = feedCubit.state as FeedStateLoaded;
+        expect(loadedState.isLoading, true);
+        expect(find.byType(BlogPosts), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+    });
+
+    testWidgets('should handle chip selection with multiple chips', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Все', 'Рецепты', 'Диеты', 'Планы питания', 'Консультанты'];
+      int selectedIndex = 0;
+      final widget = ChipGroup(
+        selectedChipIndex: selectedIndex,
+        chipsLabelList: chipsLabelList,
+        setSelectedChipIndex: (index) {
+          selectedIndex = index;
+        },
+      );
+
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Act
+      await tester.tap(find.text('Диеты'));
+      await tester.pump();
+
+      // Assert
+      expect(selectedIndex, 2);
+    });
+
+    testWidgets('should display ChipGroup with single chip', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Все'];
+      final widget = ChipGroup(selectedChipIndex: 0, chipsLabelList: chipsLabelList, setSelectedChipIndex: (index) {});
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.text('Все'), findsOneWidget);
+    });
+
+    testWidgets('should handle BlogPosts refresh', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: [testBlogPost], isLoading: false));
+
+        when(mockFeedRepository.getFeedBlogPosts(query: null)).thenAnswer(
+          (_) async => FeedBlogPostSettingsModel(
+            feedBlogPostList: [testBlogPost, testBlogPost2],
+            meta: const Meta(currentPage: 1, lastPage: 1, total: 2, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+          ),
+        );
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        await tester.pumpAndSettle();
+
+        // Act - Verify refresh indicator exists
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+
+        // Assert
+        expect(feedCubit.state, isA<FeedStateLoaded>());
+        expect(find.byType(ListView), findsOneWidget);
+      });
+    });
+
+    testWidgets('should display ChipGroup with correct selected chip', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Все', 'Рецепты', 'Диеты'];
+      final widget = ChipGroup(selectedChipIndex: 1, chipsLabelList: chipsLabelList, setSelectedChipIndex: (index) {});
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.text('Рецепты'), findsOneWidget);
+      expect(find.text('Все'), findsOneWidget);
+      expect(find.text('Диеты'), findsOneWidget);
+    });
+
+    testWidgets('should handle BlogPosts visibility detection', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: [testBlogPost], isLoading: false));
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(BlogPosts), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+        // Visibility detection is handled by VisibilityDetector internally
+      });
+    });
+
+    testWidgets('should display BlogPosts with multiple posts', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: [testBlogPost, testBlogPost2], isLoading: false));
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(feedCubit.state, isA<FeedStateLoaded>());
+        final loadedState = feedCubit.state as FeedStateLoaded;
+        expect(loadedState.feedBlogPostList.length, 2);
+        expect(find.byType(BlogPosts), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+    });
+
+    testWidgets('should handle ChipGroup with empty label list', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = <String>[];
+      final widget = ChipGroup(selectedChipIndex: 0, chipsLabelList: chipsLabelList, setSelectedChipIndex: (index) {});
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.byType(ChipGroup), findsOneWidget);
+    });
+
+    testWidgets('should display BlogPosts structure correctly', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: [testBlogPost], isLoading: false));
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(BlogPosts), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+        expect(feedCubit.state, isA<FeedStateLoaded>());
+      });
+    });
+
+    testWidgets('should handle chip selection callback', (WidgetTester tester) async {
+      // Arrange
+      final chipsLabelList = ['Все', 'Рецепты'];
+      int callbackIndex = -1;
+      final widget = ChipGroup(
+        selectedChipIndex: 0,
+        chipsLabelList: chipsLabelList,
+        setSelectedChipIndex: (index) {
+          callbackIndex = index;
+        },
+      );
+
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Act
+      await tester.tap(find.text('Рецепты'));
+      await tester.pump();
+
+      // Assert
+      expect(callbackIndex, 1);
+    });
+
+    testWidgets('should display BlogPosts with scrollable list', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        final posts = List.generate(10, (index) => testBlogPost.copyWith(id: index + 1));
+        feedCubit.emit(FeedState.loaded(feedBlogPostList: posts, isLoading: false));
+
+        final widget = BlogPosts(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createBlogPostsTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(BlogPosts), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+        expect(feedCubit.state, isA<FeedStateLoaded>());
+        final loadedState = feedCubit.state as FeedStateLoaded;
+        expect(loadedState.feedBlogPostList.length, 10);
+      });
+    });
+  });
+}

test/features/feed/repositories/feed_repository_test.dart

@@ -0,0 +1,609 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/comment_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_settings_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_consultant_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/view_model.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/features/feed/services/feed_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'feed_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedService>()])
+void main() {
+  group('FeedRepository', () {
+    late FeedRepository feedRepository;
+    late MockFeedService mockFeedService;
+
+    setUp(() {
+      mockFeedService = MockFeedService();
+      feedRepository = FeedRepository(feedService: mockFeedService);
+    });
+
+    test('getFeedBlogPosts - возвращает список постов блога', () async {
+      const page = 1;
+      const query = 'test query';
+      final expectedSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [
+          FeedBlogPostModel(
+            id: 1,
+            title: 'Test Post',
+            description: 'Test description',
+            image: 'https://example.com/image.jpg',
+            state: 'published',
+            author: const Author(authorSlug: 'author-1', authorName: 'Author Name', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false),
+            videoUrl: 'https://example.com/video.mp4',
+            createdAt: DateTime(2024, 1, 15),
+            updatedAt: DateTime(2024, 1, 15),
+            totalLikes: 10,
+            totalViews: 100,
+            totalComments: 5,
+            wasLikedByMe: false,
+          ),
+        ],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getBlogPostList(page: page, query: query)).thenAnswer((_) async => expectedSettings);
+
+      final result = await feedRepository.getFeedBlogPosts(query: query, page: page);
+
+      expect(result, isA<FeedBlogPostSettingsModel>());
+      expect(result.feedBlogPostList.length, 1);
+      expect(result.feedBlogPostList.first.id, 1);
+      verify(mockFeedService.getBlogPostList(page: page, query: query)).called(1);
+    });
+
+    test('getFeedBlogPosts - возвращает список постов без query', () async {
+      const page = 1;
+      const expectedSettings = FeedBlogPostSettingsModel(
+        feedBlogPostList: [],
+        meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getBlogPostList(page: page, query: null)).thenAnswer((_) async => expectedSettings);
+
+      final result = await feedRepository.getFeedBlogPosts(page: page);
+
+      expect(result, isA<FeedBlogPostSettingsModel>());
+      expect(result.feedBlogPostList.isEmpty, true);
+      verify(mockFeedService.getBlogPostList(page: page, query: null)).called(1);
+    });
+
+    test('getBlogPost - возвращает пост блога по ID', () async {
+      const id = 1;
+      final expectedPost = FeedBlogPostModel(
+        id: id,
+        title: 'Test Post',
+        description: 'Test description',
+        image: 'https://example.com/image.jpg',
+        state: 'published',
+        author: const Author(authorSlug: 'author-1', authorName: 'Author Name', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false),
+        videoUrl: 'https://example.com/video.mp4',
+        createdAt: DateTime(2024, 1, 15),
+        updatedAt: DateTime(2024, 1, 15),
+        totalLikes: 10,
+        totalViews: 100,
+        totalComments: 5,
+        wasLikedByMe: false,
+      );
+
+      when(mockFeedService.getBlogPost(postId: id)).thenAnswer((_) async => expectedPost);
+
+      final result = await feedRepository.getBlogPost(id: id);
+
+      expect(result, isA<FeedBlogPostModel>());
+      expect(result.id, id);
+      verify(mockFeedService.getBlogPost(postId: id)).called(1);
+    });
+
+    test('getRecipes - возвращает список рецептов', () async {
+      const page = 1;
+      const query = 'pasta';
+      final tags = [1, 2, 3];
+      final expectedRecipes = [
+        Recipe(
+          id: 1,
+          image: 'https://example.com/recipe.jpg',
+          state: 'published',
+          cookingTime: 30,
+          activeCookingTime: 20,
+          ingredients: [const Ingredient(name: 'Pasta', unit: 'g', portion: '200g', productId: 1)],
+          description: 'Test recipe description',
+          steps: [const Step(description: 'Step 1', image: 'https://example.com/step1.jpg')],
+          videoUrl: 'https://example.com/video.mp4',
+          createdAt: DateTime(2024, 1, 15),
+          updatedAt: DateTime(2024, 1, 15),
+          title: 'Pasta Recipe',
+          type: 'recipe',
+          slug: 'pasta-recipe',
+          commentsCount: 5,
+          wasLikedByMe: false,
+          isFavorite: false,
+          calories: 350.0,
+          servings: 4,
+          likesCount: 20,
+          viewsCount: 150,
+          tags: [const Tag(name: 'Italian')],
+          author: const Author(authorSlug: 'chef-1', authorName: 'Chef Name', authorProfileIcon: 'https://example.com/chef.jpg', authorIsMe: false),
+        ),
+      ];
+
+      final expectedPagination = RecipesPagination(recipesList: expectedRecipes);
+
+      when(mockFeedService.getRecipes(query: query, tags: tags, page: page)).thenAnswer((_) async => expectedPagination);
+
+      final result = await feedRepository.getRecipes(query: query, tags: tags, page: page);
+
+      expect(result, isA<List<Recipe>>());
+      expect(result.length, 1);
+      expect(result.first.id, 1);
+      verify(mockFeedService.getRecipes(query: query, tags: tags, page: page)).called(1);
+    });
+
+    test('getRecipes - возвращает список рецептов без query и tags', () async {
+      const page = 1;
+      final expectedRecipes = <Recipe>[];
+      final expectedPagination = RecipesPagination(recipesList: expectedRecipes);
+
+      when(mockFeedService.getRecipes(query: null, tags: null, page: page)).thenAnswer((_) async => expectedPagination);
+
+      final result = await feedRepository.getRecipes(page: page);
+
+      expect(result, isA<List<Recipe>>());
+      expect(result.isEmpty, true);
+      verify(mockFeedService.getRecipes(query: null, tags: null, page: page)).called(1);
+    });
+
+    test('getDiets - возвращает список диет', () async {
+      const page = 1;
+      const query = 'keto';
+      const types = 'keto';
+      const duration = 30;
+      const sorting = 'popular';
+      const expectedDiets = DietsPagination(
+        data: [
+          Diet(
+            id: 1,
+            slug: 'keto-diet',
+            name: 'Keto Diet',
+            image: 'https://example.com/keto.jpg',
+            duration: duration,
+            state: DietState.active,
+            type: DietType(light: false, veg: false, carb: false, meat: true),
+            details: 'Keto diet description',
+            dailySchedule: {},
+            author: Author(
+              authorSlug: 'nutritionist-1',
+              authorName: 'Nutritionist Name',
+              authorProfileIcon: 'https://example.com/nutritionist.jpg',
+              authorIsMe: false,
+            ),
+            totalLikes: 50,
+            totalViews: 500,
+            totalComments: 25,
+            wasLikedByMe: false,
+            isFavorite: false,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getDiets(page: page, query: query, types: types, duration: duration, sorting: sorting)).thenAnswer((_) async => expectedDiets);
+
+      final result = await feedRepository.getDiets(page: page, query: query, types: types, duration: duration, sorting: sorting);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 1);
+      verify(mockFeedService.getDiets(page: page, query: query, types: types, duration: duration, sorting: sorting)).called(1);
+    });
+
+    test('getDiets - возвращает список диет без параметров', () async {
+      const page = 1;
+      const expectedDiets = DietsPagination(
+        data: [],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getDiets(page: page, query: null, types: null, duration: null, sorting: null)).thenAnswer((_) async => expectedDiets);
+
+      final result = await feedRepository.getDiets(page: page);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.isEmpty, true);
+      verify(mockFeedService.getDiets(page: page, query: null, types: null, duration: null, sorting: null)).called(1);
+    });
+
+    test('getPlans - возвращает список планов', () async {
+      const page = 1;
+      const query = 'weight loss';
+      const types = 'slim';
+      const duration = 30;
+      const minPrice = 1000;
+      const maxPrice = 5000;
+      final expectedPlans = PlanPaginationModel(
+        data: [
+          PlanModel(
+            id: 1,
+            slug: 'weight-loss-plan',
+            name: 'Weight Loss Plan',
+            image: 'https://example.com/plan.jpg',
+            duration: duration,
+            state: 'active',
+            type: const PlanType(fit: false, slim: true, behavior: false, wellness: false),
+            details: 'Weight loss plan description',
+            packetsCount: 30,
+            author: const Author(
+              authorSlug: 'consultant-1',
+              authorName: 'Consultant Name',
+              authorProfileIcon: 'https://example.com/consultant.jpg',
+              authorIsMe: false,
+            ),
+            totalLikes: 100,
+            totalViews: 1000,
+            totalComments: 50,
+            isFavorite: false,
+            minPriceOfOptions: minPrice.toDouble(),
+            maxPriceOfOptions: maxPrice.toDouble(),
+            wasLikedByMe: false,
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(
+        mockFeedService.getPlans(page: page, query: query, types: types, duration: duration, minPrice: minPrice, maxPrice: maxPrice),
+      ).thenAnswer((_) async => expectedPlans);
+
+      final result = await feedRepository.getPlans(page: page, query: query, types: types, duration: duration, minPrice: minPrice, maxPrice: maxPrice);
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 1);
+      verify(mockFeedService.getPlans(page: page, query: query, types: types, duration: duration, minPrice: minPrice, maxPrice: maxPrice)).called(1);
+    });
+
+    test('getPlans - возвращает список планов без параметров', () async {
+      const page = 1;
+      const expectedPlans = PlanPaginationModel(
+        data: [],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(
+        mockFeedService.getPlans(page: page, query: null, types: null, duration: null, minPrice: null, maxPrice: null),
+      ).thenAnswer((_) async => expectedPlans);
+
+      final result = await feedRepository.getPlans(page: page);
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.isEmpty, true);
+      verify(mockFeedService.getPlans(page: page, query: null, types: null, duration: null, minPrice: null, maxPrice: null)).called(1);
+    });
+
+    test('getBlogPostComments - возвращает комментарии поста блога', () async {
+      const id = '1';
+      final expectedComments = CommentModel(
+        data: [
+          Comment(
+            id: 1,
+            authorName: 'User 1',
+            authorSlug: 'user-1',
+            authorProfileIcon: 'https://example.com/user1.jpg',
+            body: 'Great post!',
+            childrenComments: [],
+            createdAt: DateTime(2024, 1, 15),
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getBlogPostComments(id: id)).thenAnswer((_) async => expectedComments);
+
+      final result = await feedRepository.getBlogPostComments(id: id);
+
+      expect(result, isA<CommentModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 1);
+      verify(mockFeedService.getBlogPostComments(id: id)).called(1);
+    });
+
+    test('sendBlogPostComment - отправляет комментарий к посту блога', () async {
+      const id = '1';
+      const commentText = 'Nice post!';
+      const parentCommentId = 5;
+
+      when(mockFeedService.sendBlogPostComment(id: id, body: commentText, parentCommentId: parentCommentId)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.sendBlogPostComment(id: id, commentText: commentText, parentCommentId: parentCommentId);
+
+      verify(mockFeedService.sendBlogPostComment(id: id, body: commentText, parentCommentId: parentCommentId)).called(1);
+    });
+
+    test('sendBlogPostComment - отправляет комментарий без parentCommentId', () async {
+      const id = '1';
+      const commentText = 'Nice post!';
+
+      when(mockFeedService.sendBlogPostComment(id: id, body: commentText, parentCommentId: null)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.sendBlogPostComment(id: id, commentText: commentText);
+
+      verify(mockFeedService.sendBlogPostComment(id: id, body: commentText, parentCommentId: null)).called(1);
+    });
+
+    test('getDietsComments - возвращает комментарии диеты', () async {
+      const id = '5';
+      final expectedComments = CommentModel(
+        data: [
+          Comment(
+            id: 2,
+            authorName: 'User 2',
+            authorSlug: 'user-2',
+            authorProfileIcon: 'https://example.com/user2.jpg',
+            body: 'Great diet!',
+            childrenComments: [],
+            createdAt: DateTime(2024, 1, 15),
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getDietsComments(id: id)).thenAnswer((_) async => expectedComments);
+
+      final result = await feedRepository.getDietsComments(id: id);
+
+      expect(result, isA<CommentModel>());
+      expect(result.data.length, 1);
+      verify(mockFeedService.getDietsComments(id: id)).called(1);
+    });
+
+    test('sendDietsComment - отправляет комментарий к диете', () async {
+      const id = '5';
+      const commentText = 'Nice diet!';
+      const parentCommentId = 10;
+
+      when(mockFeedService.sendDietsComment(id: id, body: commentText, parentCommentId: parentCommentId)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.sendDietsComment(id: id, commentText: commentText, parentCommentId: parentCommentId);
+
+      verify(mockFeedService.sendDietsComment(id: id, body: commentText, parentCommentId: parentCommentId)).called(1);
+    });
+
+    test('getRecipesComments - возвращает комментарии рецепта', () async {
+      const id = '33';
+      final expectedComments = CommentModel(
+        data: [
+          Comment(
+            id: 3,
+            authorName: 'User 3',
+            authorSlug: 'user-3',
+            authorProfileIcon: 'https://example.com/user3.jpg',
+            body: 'Looks tasty!',
+            childrenComments: [],
+            createdAt: DateTime(2024, 1, 15),
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getRecipesComments(id: id)).thenAnswer((_) async => expectedComments);
+
+      final result = await feedRepository.getRecipesComments(id: id);
+
+      expect(result, isA<CommentModel>());
+      expect(result.data.length, 1);
+      verify(mockFeedService.getRecipesComments(id: id)).called(1);
+    });
+
+    test('sendRecipesComment - отправляет комментарий к рецепту', () async {
+      const id = '33';
+      const commentText = 'Tasty recipe!';
+      const parentCommentId = 15;
+
+      when(mockFeedService.sendRecipesComment(id: id, body: commentText, parentCommentId: parentCommentId)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.sendRecipesComment(id: id, commentText: commentText, parentCommentId: parentCommentId);
+
+      verify(mockFeedService.sendRecipesComment(id: id, body: commentText, parentCommentId: parentCommentId)).called(1);
+    });
+
+    test('getPlansComments - возвращает комментарии плана', () async {
+      const slug = 'plan-1';
+      final expectedComments = CommentModel(
+        data: [
+          Comment(
+            id: 4,
+            authorName: 'User 4',
+            authorSlug: 'user-4',
+            authorProfileIcon: 'https://example.com/user4.jpg',
+            body: 'Super plan!',
+            childrenComments: [],
+            createdAt: DateTime(2024, 1, 15),
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getPlansComments(slug: slug)).thenAnswer((_) async => expectedComments);
+
+      final result = await feedRepository.getPlansComments(slug: slug);
+
+      expect(result, isA<CommentModel>());
+      expect(result.data.length, 1);
+      verify(mockFeedService.getPlansComments(slug: slug)).called(1);
+    });
+
+    test('sendPlansComment - отправляет комментарий к плану', () async {
+      const slug = 'plan-1';
+      const commentText = 'Great plan!';
+      const parentCommentId = 20;
+
+      when(mockFeedService.sendPlansComment(slug: slug, body: commentText, parentCommentId: parentCommentId)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.sendPlansComment(slug: slug, commentText: commentText, parentCommentId: parentCommentId);
+
+      verify(mockFeedService.sendPlansComment(slug: slug, body: commentText, parentCommentId: parentCommentId)).called(1);
+    });
+
+    test('likeBlogPost - лайкает пост блога', () async {
+      const id = 1;
+
+      when(mockFeedService.likeBlogPost(id: id)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.likeBlogPost(id: id);
+
+      verify(mockFeedService.likeBlogPost(id: id)).called(1);
+    });
+
+    test('unlikedBlogPost - убирает лайк с поста блога', () async {
+      const id = 1;
+
+      when(mockFeedService.unlikedBlogPost(id: id)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.unlikedBlogPost(id: id);
+
+      verify(mockFeedService.unlikedBlogPost(id: id)).called(1);
+    });
+
+    test('getConsultants - возвращает список консультантов', () async {
+      const name = 'Anna';
+      final expectedConsultants = [
+        const FeedConsultantModel(
+          slug: 'consultant-1',
+          name: 'Anna Ivanova',
+          description: 'Test consultant description',
+          totalScores: 5,
+          photo: 'https://example.com/consultant1.jpg',
+          badges: [],
+        ),
+      ];
+
+      final expectedPagination = FeedConsultantPaginationModel(
+        data: expectedConsultants,
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getConsultants(name: name)).thenAnswer((_) async => expectedPagination);
+
+      final result = await feedRepository.getConsultants(name);
+
+      expect(result, isA<List<FeedConsultantModel>>());
+      expect(result.length, 1);
+      expect(result.first.name, 'Anna Ivanova');
+      verify(mockFeedService.getConsultants(name: name)).called(1);
+    });
+
+    test('getConsultants - возвращает список консультантов без имени', () async {
+      final expectedConsultants = <FeedConsultantModel>[];
+
+      final expectedPagination = FeedConsultantPaginationModel(
+        data: expectedConsultants,
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getConsultants(name: null)).thenAnswer((_) async => expectedPagination);
+
+      final result = await feedRepository.getConsultants();
+
+      expect(result, isA<List<FeedConsultantModel>>());
+      expect(result.isEmpty, true);
+      verify(mockFeedService.getConsultants(name: null)).called(1);
+    });
+
+    test('viewPost - отправляет просмотр поста', () async {
+      const id = 1;
+
+      when(mockFeedService.viewPost(id: id)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.viewPost(id);
+
+      verify(mockFeedService.viewPost(id: id)).called(1);
+    });
+
+    test('viewRecipe - отправляет просмотр рецепта', () async {
+      const slug = 'recipe-1';
+
+      when(mockFeedService.viewRecipe(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.viewRecipe(slug);
+
+      verify(mockFeedService.viewRecipe(slug: slug)).called(1);
+    });
+
+    test('viewDiet - отправляет просмотр диеты', () async {
+      const id = 2;
+
+      when(mockFeedService.viewDiet(id: id)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.viewDiet(id);
+
+      verify(mockFeedService.viewDiet(id: id)).called(1);
+    });
+
+    test('viewPlan - отправляет просмотр плана', () async {
+      const slug = 'plan-7';
+
+      when(mockFeedService.viewPlan(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.viewPlan(slug);
+
+      verify(mockFeedService.viewPlan(slug: slug)).called(1);
+    });
+
+    test('viewContent - отправляет просмотр контента', () async {
+      final viewModel = ViewModel(type: 'recipe', slugs: ['recipe-1']);
+
+      when(mockFeedService.viewContent(viewModel: viewModel)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.viewContent(viewModel: viewModel);
+
+      verify(mockFeedService.viewContent(viewModel: viewModel)).called(1);
+    });
+
+    test('viewContent - отправляет просмотр контента с ids', () async {
+      final viewModel = ViewModel(type: 'diet', ids: [1, 2, 3]);
+
+      when(mockFeedService.viewContent(viewModel: viewModel)).thenAnswer((_) async => Future.value());
+
+      await feedRepository.viewContent(viewModel: viewModel);
+
+      verify(mockFeedService.viewContent(viewModel: viewModel)).called(1);
+    });
+
+    test('getFeedBlogPosts - пробрасывает исключение при ошибке', () async {
+      const page = 1;
+      final exception = Exception('Network error');
+
+      when(mockFeedService.getBlogPostList(page: page, query: null)).thenThrow(exception);
+
+      expect(() => feedRepository.getFeedBlogPosts(page: page), throwsA(isA<Exception>()));
+    });
+
+    test('getBlogPost - пробрасывает исключение при ошибке', () async {
+      const id = 1;
+      final exception = Exception('Not found');
+
+      when(mockFeedService.getBlogPost(postId: id)).thenThrow(exception);
+
+      expect(() => feedRepository.getBlogPost(id: id), throwsA(isA<Exception>()));
+    });
+  });
+}

test/features/feed/services/feed_service_test.dart

@@ -0,0 +1,378 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/comment_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_blog_post_settings_model.dart';
+import 'package:eatvio_app/features/feed/models/feed_consultant_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/view_model.dart';
+import 'package:eatvio_app/features/feed/services/feed_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'feed_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedService>()])
+void main() {
+  group('FeedService', () {
+    late MockFeedService mockFeedService;
+
+    setUp(() {
+      mockFeedService = MockFeedService();
+    });
+
+    test('getBlogPostList returns settings', () async {
+      const page = 1;
+      final expected = FeedBlogPostSettingsModel(
+        feedBlogPostList: [
+          FeedBlogPostModel(
+            id: 1,
+            title: 'Post Title',
+            description: 'Test post description',
+            image: 'https://someurl.com/img.jpg',
+            state: 'published',
+            author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            videoUrl: 'https://someurl.com/video.mp4',
+            createdAt: DateTime.now(),
+            updatedAt: DateTime.now(),
+            totalLikes: 5,
+            totalViews: 10,
+            totalComments: 2,
+            wasLikedByMe: false,
+          ),
+        ],
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getBlogPostList(page: page, query: null)).thenAnswer((_) async => expected);
+
+      final result = await mockFeedService.getBlogPostList(page: page, query: null);
+
+      expect(result, isA<FeedBlogPostSettingsModel>());
+      verify(mockFeedService.getBlogPostList(page: page, query: null)).called(1);
+    });
+
+    test('getBlogPost returns post', () async {
+      const id = 10;
+      final expected = FeedBlogPostModel(
+        id: id,
+        title: 'Test',
+        description: 'Test post description',
+        image: 'https://someurl.com/img.jpg',
+        state: 'published',
+        author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        videoUrl: 'https://someurl.com/video.mp4',
+        createdAt: DateTime.now(),
+        updatedAt: DateTime.now(),
+        totalLikes: 3,
+        totalViews: 14,
+        totalComments: 1,
+        wasLikedByMe: false,
+      );
+
+      when(mockFeedService.getBlogPost(postId: id)).thenAnswer((_) async => expected);
+
+      final result = await mockFeedService.getBlogPost(postId: id);
+
+      expect(result.id, id);
+      verify(mockFeedService.getBlogPost(postId: id)).called(1);
+    });
+
+    test('getRecipes returns recipes pagination', () async {
+      final expected = RecipesPagination(
+        recipesList: [
+          Recipe(
+            id: 1,
+            image: 'https://someurl.com/img.jpg',
+            state: 'published',
+            cookingTime: 30,
+            activeCookingTime: 20,
+            ingredients: [const Ingredient(name: 'ingredient1', unit: 'unit1', portion: 'portion1', productId: 1)],
+            description: 'Test post description',
+            steps: [const Step(description: 'step1', image: 'https://someurl.com/img.jpg')],
+            videoUrl: 'https://someurl.com/video.mp4',
+            createdAt: DateTime.now(),
+            updatedAt: DateTime.now(),
+            title: 'Test',
+            type: 'recipe',
+            slug: 'test-recipe',
+            commentsCount: 1,
+            wasLikedByMe: false,
+            isFavorite: false,
+            calories: 100,
+            servings: 1,
+            likesCount: 3,
+            viewsCount: 14,
+            tags: [const Tag(name: '1')],
+            author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+          ),
+        ],
+      );
+
+      when(mockFeedService.getRecipes(page: 1, tags: [1], query: null)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getRecipes(page: 1, tags: [1], query: null);
+
+      verify(mockFeedService.getRecipes(page: 1, tags: [1], query: null)).called(1);
+    });
+
+    test('getDiets returns pagination', () async {
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 1,
+            slug: 'test-diet',
+            name: 'Test Diet',
+            image: 'https://someurl.com/img.jpg',
+            duration: 30,
+            state: DietState.active,
+            type: DietType(light: false, veg: false, carb: false, meat: false),
+            details: 'Test diet description',
+            dailySchedule: {},
+            author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 1,
+            totalViews: 1,
+            totalComments: 1,
+            wasLikedByMe: false,
+            isFavorite: false,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getDiets(page: 1, query: null)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getDiets(page: 1, query: null);
+
+      verify(mockFeedService.getDiets(page: 1, query: null)).called(1);
+    });
+
+    test('getPlans returns pagination', () async {
+      const expected = PlanPaginationModel(
+        data: [
+          PlanModel(
+            id: 1,
+            slug: 'test-plan',
+            name: 'Test Plan',
+            image: 'https://someurl.com/img.jpg',
+            duration: 30,
+            state: 'active',
+            type: PlanType(fit: false, slim: false, behavior: false, wellness: false),
+            details: '',
+            packetsCount: 1,
+            author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 1,
+            totalViews: 1,
+            totalComments: 1,
+            isFavorite: false,
+            minPriceOfOptions: 100,
+            maxPriceOfOptions: 500,
+            wasLikedByMe: false,
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getPlans(page: 1, query: null)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getPlans(page: 1, query: null);
+
+      verify(mockFeedService.getPlans(page: 1, query: null)).called(1);
+    });
+
+    test('getBlogPostComments returns comments', () async {
+      const id = "1";
+      final expected = CommentModel(
+        data: [
+          Comment(
+            id: 1,
+            authorName: 'user1',
+            authorSlug: '',
+            authorProfileIcon: '',
+            body: 'Nice',
+            childrenComments: [
+              Comment(id: 2, authorName: 'user2', authorSlug: '', authorProfileIcon: '', body: 'Great', childrenComments: [], createdAt: DateTime.now()),
+            ],
+            createdAt: DateTime.now(),
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getBlogPostComments(id: id)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getBlogPostComments(id: id);
+
+      verify(mockFeedService.getBlogPostComments(id: id)).called(1);
+    });
+
+    test('sendBlogPostComment sends comment', () async {
+      when(mockFeedService.sendBlogPostComment(id: "1", body: "Great", parentCommentId: null)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.sendBlogPostComment(id: "1", body: "Great", parentCommentId: null);
+
+      verify(mockFeedService.sendBlogPostComment(id: "1", body: "Great", parentCommentId: null)).called(1);
+    });
+
+    test('getDietsComments returns comments', () async {
+      const id = "5";
+      final expected = CommentModel(
+        data: [Comment(id: 2, authorName: 'user2', authorSlug: '', authorProfileIcon: '', body: 'Cool diet!', childrenComments: [], createdAt: DateTime.now())],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getDietsComments(id: id)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getDietsComments(id: id);
+
+      verify(mockFeedService.getDietsComments(id: id)).called(1);
+    });
+
+    test('sendDietsComment sends comment', () async {
+      when(mockFeedService.sendDietsComment(id: "5", body: "Nice diet", parentCommentId: null)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.sendDietsComment(id: "5", body: "Nice diet", parentCommentId: null);
+
+      verify(mockFeedService.sendDietsComment(id: "5", body: "Nice diet", parentCommentId: null)).called(1);
+    });
+
+    test('getPlansComments returns comments', () async {
+      const slug = "plan-1";
+      final expected = CommentModel(
+        data: [
+          Comment(id: 3, authorName: 'user3', authorSlug: '', authorProfileIcon: '', body: 'Super plan!', childrenComments: [], createdAt: DateTime.now()),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getPlansComments(slug: slug)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getPlansComments(slug: slug);
+
+      verify(mockFeedService.getPlansComments(slug: slug)).called(1);
+    });
+
+    test('sendPlansComment sends comment', () async {
+      when(mockFeedService.sendPlansComment(slug: "plan-1", body: "Ok", parentCommentId: null)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.sendPlansComment(slug: "plan-1", body: "Ok", parentCommentId: null);
+
+      verify(mockFeedService.sendPlansComment(slug: "plan-1", body: "Ok", parentCommentId: null)).called(1);
+    });
+
+    test('getRecipesComments returns comments', () async {
+      const id = "33";
+      final expected = CommentModel(
+        data: [
+          Comment(id: 4, authorName: 'user4', authorSlug: '', authorProfileIcon: '', body: 'Looks tasty!', childrenComments: [], createdAt: DateTime.now()),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getRecipesComments(id: id)).thenAnswer((_) async => expected);
+
+      await mockFeedService.getRecipesComments(id: id);
+
+      verify(mockFeedService.getRecipesComments(id: id)).called(1);
+    });
+
+    test('sendRecipesComment sends comment', () async {
+      when(mockFeedService.sendRecipesComment(id: "33", body: "Tasty", parentCommentId: null)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.sendRecipesComment(id: "33", body: "Tasty", parentCommentId: null);
+
+      verify(mockFeedService.sendRecipesComment(id: "33", body: "Tasty", parentCommentId: null)).called(1);
+    });
+
+    test('likeBlogPost works', () async {
+      when(mockFeedService.likeBlogPost(id: 1)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.likeBlogPost(id: 1);
+
+      verify(mockFeedService.likeBlogPost(id: 1)).called(1);
+    });
+
+    test('unlikedBlogPost works', () async {
+      when(mockFeedService.unlikedBlogPost(id: 1)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.unlikedBlogPost(id: 1);
+
+      verify(mockFeedService.unlikedBlogPost(id: 1)).called(1);
+    });
+
+    test('getConsultants returns consultant pagination', () async {
+      const expected = FeedConsultantPaginationModel(
+        data: [
+          FeedConsultantModel(
+            slug: 'consultant-1',
+            name: 'Anna Ivanova',
+            description: 'Test consultant description',
+            totalScores: 5,
+            photo: 'https://someurl.com/consultant1.jpg',
+            badges: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockFeedService.getConsultants(name: 'Anna')).thenAnswer((_) async => expected);
+
+      await mockFeedService.getConsultants(name: 'Anna');
+
+      verify(mockFeedService.getConsultants(name: 'Anna')).called(1);
+    });
+
+    test('viewPost works', () async {
+      when(mockFeedService.viewPost(id: 1)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.viewPost(id: 1);
+
+      verify(mockFeedService.viewPost(id: 1)).called(1);
+    });
+
+    test('viewRecipe works', () async {
+      when(mockFeedService.viewRecipe(slug: 'abc')).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.viewRecipe(slug: 'abc');
+
+      verify(mockFeedService.viewRecipe(slug: 'abc')).called(1);
+    });
+
+    test('viewDiet works', () async {
+      when(mockFeedService.viewDiet(id: 2)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.viewDiet(id: 2);
+
+      verify(mockFeedService.viewDiet(id: 2)).called(1);
+    });
+
+    test('viewPlan works', () async {
+      when(mockFeedService.viewPlan(slug: 'plan-7')).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.viewPlan(slug: 'plan-7');
+
+      verify(mockFeedService.viewPlan(slug: 'plan-7')).called(1);
+    });
+
+    test('viewContent sends view model', () async {
+      final view = ViewModel(type: 'recipe', slugs: ['recipe-1']);
+
+      when(mockFeedService.viewContent(viewModel: view)).thenAnswer((_) async => Future.value());
+
+      await mockFeedService.viewContent(viewModel: view);
+
+      verify(mockFeedService.viewContent(viewModel: view)).called(1);
+    });
+  });
+}

test/features/my_diets/presentation/cubit/my_diets_cubit_test.dart

@@ -0,0 +1,338 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/create_diet/repositories/create_diet_repository.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/my_diets/presentation/cubit/my_diets_cubit.dart';
+import 'package:eatvio_app/features/my_diets/repositories/my_diets_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'my_diets_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([
+  MockSpec<MyDietsRepository>(),
+  MockSpec<CreateDietRepository>(),
+])
+void main() {
+  group('MyDietsCubit', () {
+    MyDietsCubit? myDietsCubit;
+    late MockMyDietsRepository mockMyDietsRepository;
+    late MockCreateDietRepository mockCreateDietRepository;
+
+    const testDiet = Diet(
+      id: 1,
+      slug: 'test-diet',
+      name: 'Test Diet',
+      image: 'https://someurl.com/img.jpg',
+      duration: 30,
+      state: DietState.active,
+      type: DietType(light: false, veg: false, carb: false, meat: false),
+      details: 'Test diet description',
+      dailySchedule: {},
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      wasLikedByMe: false,
+      isFavorite: false,
+      dailyNutrition: [],
+    );
+
+    const testDietsPagination = DietsPagination(
+      data: [testDiet],
+      links: Links(first: '', last: '', prev: null, next: null),
+      meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+    );
+
+    setUp(() {
+      mockMyDietsRepository = MockMyDietsRepository();
+      mockCreateDietRepository = MockCreateDietRepository();
+    });
+
+    tearDown(() async {
+      if (myDietsCubit != null && !myDietsCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        myDietsCubit!.close();
+        myDietsCubit = null;
+      }
+    });
+
+    test('начальное состояние - empty state', () {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+      expect(myDietsCubit!.state.activeDiets, isEmpty);
+      expect(myDietsCubit!.state.draftDiets, isEmpty);
+      expect(myDietsCubit!.state.personalDiets, isEmpty);
+      expect(myDietsCubit!.state.isLoading, false);
+      expect(myDietsCubit!.state.selectedStateIndex, 0);
+    });
+
+    test('loadAllDiets - загружает все диеты', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'active',
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenAnswer((_) async => testDietsPagination);
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'drafted',
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenAnswer((_) async => testDietsPagination);
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'personal',
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenAnswer((_) async => testDietsPagination);
+
+      await myDietsCubit!.loadAllDiets();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myDietsCubit!.state.activeDiets.length, 1);
+      expect(myDietsCubit!.state.draftDiets.length, 1);
+      expect(myDietsCubit!.state.personalDiets.length, 1);
+      expect(myDietsCubit!.state.isLoading, false);
+    });
+
+    test('loadCurrentDiets - загружает активные диеты', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'active',
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenAnswer((_) async => testDietsPagination);
+
+      await myDietsCubit!.loadCurrentDiets();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myDietsCubit!.state.activeDiets.length, 1);
+    });
+
+    test('changeSelectedStateIndex - меняет выбранный индекс состояния', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      myDietsCubit!.changeSelectedStateIndex(1);
+      expect(myDietsCubit!.state.selectedStateIndex, 1);
+
+      // Wait for debounce to complete
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      myDietsCubit!.changeSelectedStateIndex(2);
+      expect(myDietsCubit!.state.selectedStateIndex, 2);
+
+      // Wait for debounce to complete before tearDown
+      await Future.delayed(const Duration(milliseconds: 1200));
+    });
+
+    test('changeTypeFilter - меняет фильтр типа для активных диет', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'active',
+        types: 'light',
+        duration: null,
+        sorting: null,
+      )).thenAnswer((_) async => testDietsPagination);
+
+      myDietsCubit!.changeTypeFilter(1);
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      expect(myDietsCubit!.state.activeFilterState.typeIndex, 1);
+    });
+
+    test('changeSortingType - меняет тип сортировки', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'active',
+        types: null,
+        duration: null,
+        sorting: 'chosen_diets_count:desc',
+      )).thenAnswer((_) async => testDietsPagination);
+
+      myDietsCubit!.changeSortingType(1);
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      expect(myDietsCubit!.state.activeFilterState.sortingIndex, 1);
+    });
+
+    test('changeDurationFilter - меняет фильтр длительности', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'active',
+        types: null,
+        duration: 7,
+        sorting: null,
+      )).thenAnswer((_) async => testDietsPagination);
+
+      myDietsCubit!.changeDurationFilter(1);
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      expect(myDietsCubit!.state.activeFilterState.durationIndex, 1);
+    });
+
+    test('deleteDiet - удаляет диету успешно', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.deleteDiet(1)).thenAnswer((_) async => Future.value());
+
+      final result = await myDietsCubit!.deleteDiet(1);
+
+      expect(result, true);
+      verify(mockMyDietsRepository.deleteDiet(1)).called(1);
+    });
+
+    test('deleteDiet - обрабатывает ошибку при удалении', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.deleteDiet(1)).thenThrow(Exception('Network error'));
+
+      final result = await myDietsCubit!.deleteDiet(1);
+
+      expect(result, false);
+      expect(myDietsCubit!.state.error, isNotNull);
+    });
+
+    test('publishDiet - публикует диету успешно', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockCreateDietRepository.updateDiet(
+        dietId: 1,
+        state: DietState.active,
+      )).thenAnswer((_) async => Future.value());
+
+      final result = await myDietsCubit!.publishDiet(1);
+
+      expect(result, true);
+      verify(mockCreateDietRepository.updateDiet(
+        dietId: 1,
+        state: DietState.active,
+      )).called(1);
+    });
+
+    test('publishDiet - обрабатывает ошибку при публикации', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockCreateDietRepository.updateDiet(
+        dietId: 1,
+        state: DietState.active,
+      )).thenThrow(Exception('Network error'));
+
+      final result = await myDietsCubit!.publishDiet(1);
+
+      expect(result, false);
+    });
+
+    test('unpublishDiet - снимает с публикации диету успешно', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockCreateDietRepository.updateDiet(
+        dietId: 1,
+        state: DietState.draft,
+      )).thenAnswer((_) async => Future.value());
+
+      final result = await myDietsCubit!.unpublishDiet(1);
+
+      expect(result, true);
+      verify(mockCreateDietRepository.updateDiet(
+        dietId: 1,
+        state: DietState.draft,
+      )).called(1);
+    });
+
+    test('unpublishDiet - обрабатывает ошибку при снятии с публикации', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockCreateDietRepository.updateDiet(
+        dietId: 1,
+        state: DietState.draft,
+      )).thenThrow(Exception('Network error'));
+
+      final result = await myDietsCubit!.unpublishDiet(1);
+
+      expect(result, false);
+    });
+
+    test('_loadActiveDiets - обрабатывает ошибку', () async {
+      myDietsCubit = MyDietsCubit(
+        myDietsRepository: mockMyDietsRepository,
+        createDietRepository: mockCreateDietRepository,
+      );
+
+      when(mockMyDietsRepository.getDiets(
+        page: 1,
+        query: null,
+        state: 'active',
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenThrow(Exception('Network error'));
+
+      await myDietsCubit!.loadCurrentDiets();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myDietsCubit!.state.activeDietsError, isNotNull);
+    });
+  });
+}
+

test/features/my_diets/presentation/widgets/basic_widget_test.dart

@@ -0,0 +1,267 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/core/widgets/animated_option_button.dart';
+import 'package:eatvio_app/core/widgets/custom_outlined_button.dart';
+import 'package:eatvio_app/features/create_diet/repositories/create_diet_repository.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/my_diets/presentation/cubit/my_diets_cubit.dart';
+import 'package:eatvio_app/features/my_diets/presentation/cubit/my_diets_state.dart';
+import 'package:eatvio_app/features/my_diets/presentation/widgets/my_diet_widget.dart';
+import 'package:eatvio_app/features/my_diets/presentation/widgets/my_diets_tab.dart';
+import 'package:eatvio_app/features/my_diets/repositories/my_diets_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+
+import 'basic_widget_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyDietsRepository>(), MockSpec<CreateDietRepository>()])
+void main() {
+  group('MyDiets Basic Widget Tests', () {
+    late MockMyDietsRepository mockMyDietsRepository;
+    late MockCreateDietRepository mockCreateDietRepository;
+    late MyDietsCubit myDietsCubit;
+
+    const testDiet = Diet(
+      id: 1,
+      slug: 'test-diet',
+      name: 'Test Diet',
+      image: 'test-image.jpg',
+      duration: 30,
+      state: DietState.active,
+      type: DietType(light: false, veg: false, carb: false, meat: false),
+      details: 'Test diet description',
+      dailySchedule: {},
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      wasLikedByMe: false,
+      isFavorite: false,
+      dailyNutrition: [],
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockMyDietsRepository = MockMyDietsRepository();
+      mockCreateDietRepository = MockCreateDietRepository();
+      myDietsCubit = MyDietsCubit(myDietsRepository: mockMyDietsRepository, createDietRepository: mockCreateDietRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!myDietsCubit.isClosed) {
+        myDietsCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<MyDietsCubit>(
+        create: (context) => myDietsCubit,
+        child: Portal(
+          child: wrapInScaffold ? Scaffold(body: SingleChildScrollView(child: child)) : SizedBox(width: 800, height: 600, child: child),
+        ),
+      );
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: widget,
+      );
+    }
+
+    testWidgets('should create MyDietsCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = MyDietsCubit(myDietsRepository: mockMyDietsRepository, createDietRepository: mockCreateDietRepository);
+
+      // Assert
+      expect(cubit, isA<MyDietsCubit>());
+      expect(cubit.state.activeDiets, isEmpty);
+
+      cubit.close();
+    });
+
+    testWidgets('should display MyDietsTab with all tabs', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      const widget = MyDietsTab();
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.byType(MyDietsTab), findsOneWidget);
+      expect(find.byType(AnimatedOptionButton), findsNWidgets(3));
+    });
+
+    testWidgets('should handle tab selection in MyDietsTab', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      const widget = MyDietsTab();
+
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Act - Find and tap the second tab
+      final tabButtons = find.byType(AnimatedOptionButton);
+      expect(tabButtons, findsNWidgets(3));
+
+      // Tap the second tab (index 1)
+      await tester.tap(tabButtons.at(1));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 1200));
+
+      // Assert
+      expect(myDietsCubit.state.selectedStateIndex, 1);
+    });
+
+    testWidgets('should display MyDietWidget with diet name', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      const widget = MyDietWidget(diet: testDiet);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.text('Test Diet'), findsOneWidget);
+      expect(find.byType(MyDietWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyDietWidget with description when details are present', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      const widget = MyDietWidget(diet: testDiet);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.text('Test Diet'), findsOneWidget);
+      expect(find.byType(MyDietWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyDietWidget buttons for active state', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      const widget = MyDietWidget(diet: testDiet);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.byType(MyDietWidget), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyDietWidget buttons for draft state', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 1));
+      const widget = MyDietWidget(diet: testDiet);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.byType(MyDietWidget), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyDietWidget buttons for personal state', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 2));
+      const widget = MyDietWidget(diet: testDiet);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.byType(MyDietWidget), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyDietsTab with correct selected tab', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 1));
+      const widget = MyDietsTab();
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.byType(MyDietsTab), findsOneWidget);
+      expect(find.byType(AnimatedOptionButton), findsNWidgets(3));
+    });
+
+    testWidgets('should handle MyDietsTab additionalOnTap callback', (WidgetTester tester) async {
+      // Arrange
+      bool callbackCalled = false;
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      final widget = MyDietsTab(
+        additionalOnTap: () {
+          callbackCalled = true;
+        },
+      );
+
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Act
+      final tabButtons = find.byType(AnimatedOptionButton);
+      await tester.tap(tabButtons.at(0));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 1200));
+
+      // Assert
+      expect(callbackCalled, true);
+    });
+
+    testWidgets('should display MyDietWidget structure correctly', (WidgetTester tester) async {
+      // Arrange
+      myDietsCubit.emit(MyDietsState(selectedStateIndex: 0));
+      const widget = MyDietWidget(diet: testDiet);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.byType(MyDietWidget), findsOneWidget);
+      expect(find.text('Test Diet'), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+  });
+}

test/features/my_diets/repositories/my_diets_repository_test.dart

@@ -0,0 +1,213 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/my_diets/repositories/my_diets_repository.dart';
+import 'package:eatvio_app/features/my_diets/services/my_diets_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'my_diets_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyDietsService>()])
+void main() {
+  group('MyDietsRepository', () {
+    late MyDietsRepository myDietsRepository;
+    late MockMyDietsService mockMyDietsService;
+
+    setUp(() {
+      mockMyDietsService = MockMyDietsService();
+      myDietsRepository = MyDietsRepository(myDietsService: mockMyDietsService);
+    });
+
+    test('getDiets returns pagination with all parameters', () async {
+      const page = 1;
+      const query = 'test diet';
+      const state = 'active';
+      const types = 'light,veg';
+      const duration = 30;
+      const sorting = 'name';
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 1,
+            slug: 'test-diet',
+            name: 'Test Diet',
+            image: 'https://someurl.com/img.jpg',
+            duration: duration,
+            state: DietState.active,
+            type: DietType(light: true, veg: false, carb: false, meat: false),
+            details: 'Test diet description',
+            dailySchedule: {},
+            author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 1,
+            totalViews: 1,
+            totalComments: 1,
+            wasLikedByMe: false,
+            isFavorite: false,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyDietsService.getDiets(
+        page: page,
+        query: query,
+        state: state,
+        types: types,
+        duration: duration,
+        sorting: sorting,
+      )).thenAnswer((_) async => expected);
+
+      final result = await myDietsRepository.getDiets(
+        page: page,
+        query: query,
+        state: state,
+        types: types,
+        duration: duration,
+        sorting: sorting,
+      );
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.name, 'Test Diet');
+      verify(mockMyDietsService.getDiets(
+        page: page,
+        query: query,
+        state: state,
+        types: types,
+        duration: duration,
+        sorting: sorting,
+      )).called(1);
+    });
+
+    test('getDiets returns pagination with default parameters', () async {
+      const expected = DietsPagination(
+        data: [],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyDietsService.getDiets(
+        page: 1,
+        query: null,
+        state: null,
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenAnswer((_) async => expected);
+
+      final result = await myDietsRepository.getDiets();
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 0);
+      verify(mockMyDietsService.getDiets(
+        page: 1,
+        query: null,
+        state: null,
+        types: null,
+        duration: null,
+        sorting: null,
+      )).called(1);
+    });
+
+    test('getDiets returns pagination with partial parameters', () async {
+      const page = 2;
+      const query = 'wellness';
+      const duration = 21;
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 2,
+            slug: 'another-diet',
+            name: 'Another Diet',
+            image: 'https://someurl.com/img2.jpg',
+            duration: duration,
+            state: DietState.draft,
+            type: DietType(light: false, veg: true, carb: false, meat: false),
+            details: '',
+            dailySchedule: {},
+            author: Author(authorSlug: 'author-slug', authorName: 'Author Name', authorProfileIcon: '', authorIsMe: true),
+            totalLikes: 5,
+            totalViews: 10,
+            totalComments: 2,
+            wasLikedByMe: true,
+            isFavorite: true,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 2, lastPage: 2, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyDietsService.getDiets(
+        page: page,
+        query: query,
+        state: null,
+        types: null,
+        duration: duration,
+        sorting: null,
+      )).thenAnswer((_) async => expected);
+
+      final result = await myDietsRepository.getDiets(
+        page: page,
+        query: query,
+        duration: duration,
+      );
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 2);
+      verify(mockMyDietsService.getDiets(
+        page: page,
+        query: query,
+        state: null,
+        types: null,
+        duration: duration,
+        sorting: null,
+      )).called(1);
+    });
+
+    test('deleteDiet deletes diet by id', () async {
+      const dietId = 1;
+
+      when(mockMyDietsService.deleteDiet(dietId: dietId)).thenAnswer((_) async => Future.value());
+
+      await myDietsRepository.deleteDiet(dietId);
+
+      verify(mockMyDietsService.deleteDiet(dietId: dietId)).called(1);
+    });
+
+    test('deleteDiet rethrows exception on error', () async {
+      const dietId = 1;
+
+      when(mockMyDietsService.deleteDiet(dietId: dietId)).thenThrow(Exception('Network error'));
+
+      expect(() => myDietsRepository.deleteDiet(dietId), throwsException);
+      verify(mockMyDietsService.deleteDiet(dietId: dietId)).called(1);
+    });
+
+    test('getDiets rethrows exception on error', () async {
+      when(mockMyDietsService.getDiets(
+        page: 1,
+        query: null,
+        state: null,
+        types: null,
+        duration: null,
+        sorting: null,
+      )).thenThrow(Exception('Network error'));
+
+      expect(() => myDietsRepository.getDiets(), throwsException);
+      verify(mockMyDietsService.getDiets(
+        page: 1,
+        query: null,
+        state: null,
+        types: null,
+        duration: null,
+        sorting: null,
+      )).called(1);
+    });
+  });
+}
+

test/features/my_diets/services/my_diets_service_test.dart

@@ -0,0 +1,220 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/my_diets/services/my_diets_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'my_diets_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyDietsService>()])
+void main() {
+  group('MyDietsService', () {
+    late MockMyDietsService mockMyDietsService;
+
+    setUp(() {
+      mockMyDietsService = MockMyDietsService();
+    });
+
+    test('getDiets returns pagination with all parameters', () async {
+      const page = 1;
+      const query = 'test diet';
+      const state = 'active';
+      const types = 'light,veg';
+      const duration = 30;
+      const sorting = 'name';
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 1,
+            slug: 'test-diet',
+            name: 'Test Diet',
+            image: 'https://someurl.com/img.jpg',
+            duration: duration,
+            state: DietState.active,
+            type: DietType(light: true, veg: false, carb: false, meat: false),
+            details: 'Test diet description',
+            dailySchedule: {},
+            author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 1,
+            totalViews: 1,
+            totalComments: 1,
+            wasLikedByMe: false,
+            isFavorite: false,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(
+        mockMyDietsService.getDiets(page: page, query: query, state: state, types: types, duration: duration, sorting: sorting),
+      ).thenAnswer((_) async => expected);
+
+      final result = await mockMyDietsService.getDiets(page: page, query: query, state: state, types: types, duration: duration, sorting: sorting);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.name, 'Test Diet');
+      verify(mockMyDietsService.getDiets(page: page, query: query, state: state, types: types, duration: duration, sorting: sorting)).called(1);
+    });
+
+    test('getDiets returns pagination with minimal parameters', () async {
+      const page = 1;
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 2,
+            slug: 'another-diet',
+            name: 'Another Diet',
+            image: 'https://someurl.com/img2.jpg',
+            duration: 14,
+            state: DietState.draft,
+            type: DietType(light: false, veg: true, carb: false, meat: false),
+            details: '',
+            dailySchedule: {},
+            author: Author(authorSlug: 'author-slug', authorName: 'Author Name', authorProfileIcon: '', authorIsMe: true),
+            totalLikes: 5,
+            totalViews: 10,
+            totalComments: 2,
+            wasLikedByMe: true,
+            isFavorite: true,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyDietsService.getDiets(page: page, query: null, state: null, types: null, duration: null, sorting: null)).thenAnswer((_) async => expected);
+
+      final result = await mockMyDietsService.getDiets(page: page, query: null, state: null, types: null, duration: null, sorting: null);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 2);
+      verify(mockMyDietsService.getDiets(page: page, query: null, state: null, types: null, duration: null, sorting: null)).called(1);
+    });
+
+    test('getDiets returns pagination with partial parameters', () async {
+      const page = 2;
+      const query = 'wellness';
+      const state = 'draft';
+      const duration = 21;
+      const expected = DietsPagination(
+        data: [],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 2, lastPage: 2, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(
+        mockMyDietsService.getDiets(page: page, query: query, state: state, types: null, duration: duration, sorting: null),
+      ).thenAnswer((_) async => expected);
+
+      final result = await mockMyDietsService.getDiets(page: page, query: query, state: state, types: null, duration: duration, sorting: null);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 0);
+      expect(result.meta.currentPage, 2);
+      verify(mockMyDietsService.getDiets(page: page, query: query, state: state, types: null, duration: duration, sorting: null)).called(1);
+    });
+
+    test('getDiets returns pagination with state filter', () async {
+      const page = 1;
+      const state = 'active';
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 3,
+            slug: 'active-diet',
+            name: 'Active Diet',
+            image: 'https://someurl.com/img3.jpg',
+            duration: 7,
+            state: DietState.active,
+            type: DietType(light: true, veg: true, carb: false, meat: false),
+            details: 'Active diet description',
+            dailySchedule: {},
+            author: Author(authorSlug: 'author-2', authorName: 'Author 2', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 10,
+            totalViews: 20,
+            totalComments: 5,
+            wasLikedByMe: false,
+            isFavorite: false,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyDietsService.getDiets(page: page, query: null, state: state, types: null, duration: null, sorting: null)).thenAnswer((_) async => expected);
+
+      final result = await mockMyDietsService.getDiets(page: page, query: null, state: state, types: null, duration: null, sorting: null);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.state, DietState.active);
+      verify(mockMyDietsService.getDiets(page: page, query: null, state: state, types: null, duration: null, sorting: null)).called(1);
+    });
+
+    test('getDiets returns pagination with sorting parameter', () async {
+      const page = 1;
+      const sorting = 'duration';
+      const expected = DietsPagination(
+        data: [
+          Diet(
+            id: 4,
+            slug: 'sorted-diet',
+            name: 'Sorted Diet',
+            image: 'https://someurl.com/img4.jpg',
+            duration: 60,
+            state: DietState.personal,
+            type: DietType(light: false, veg: false, carb: true, meat: true),
+            details: 'Sorted diet description',
+            dailySchedule: {},
+            author: Author(authorSlug: 'author-3', authorName: 'Author 3', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 15,
+            totalViews: 30,
+            totalComments: 8,
+            wasLikedByMe: true,
+            isFavorite: true,
+            dailyNutrition: [],
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyDietsService.getDiets(page: page, query: null, state: null, types: null, duration: null, sorting: sorting)).thenAnswer((_) async => expected);
+
+      final result = await mockMyDietsService.getDiets(page: page, query: null, state: null, types: null, duration: null, sorting: sorting);
+
+      expect(result, isA<DietsPagination>());
+      expect(result.data.length, 1);
+      expect(result.data.first.duration, 60);
+      verify(mockMyDietsService.getDiets(page: page, query: null, state: null, types: null, duration: null, sorting: sorting)).called(1);
+    });
+
+    test('deleteDiet deletes diet by id', () async {
+      const dietId = 1;
+
+      when(mockMyDietsService.deleteDiet(dietId: dietId)).thenAnswer((_) async => Future.value());
+
+      await mockMyDietsService.deleteDiet(dietId: dietId);
+
+      verify(mockMyDietsService.deleteDiet(dietId: dietId)).called(1);
+    });
+
+    test('deleteDiet deletes diet with different id', () async {
+      const dietId = 42;
+
+      when(mockMyDietsService.deleteDiet(dietId: dietId)).thenAnswer((_) async => Future.value());
+
+      await mockMyDietsService.deleteDiet(dietId: dietId);
+
+      verify(mockMyDietsService.deleteDiet(dietId: dietId)).called(1);
+    });
+  });
+}
+

test/features/my_plans/presentation/cubit/my_plans_cubit_test.dart

@@ -0,0 +1,256 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/my_plans/presentation/cubit/my_plans_cubit.dart';
+import 'package:eatvio_app/features/my_plans/repositories/my_diets_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'my_plans_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyPlansRepository>()])
+void main() {
+  group('MyPlansCubit', () {
+    MyPlansCubit? myPlansCubit;
+    late MockMyPlansRepository mockMyPlansRepository;
+
+    const testPlan = PlanModel(
+      id: 1,
+      slug: 'test-plan',
+      name: 'Test Plan',
+      image: 'https://someurl.com/img.jpg',
+      duration: 30,
+      state: 'active',
+      type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+      details: 'Test plan description',
+      packetsCount: 1,
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      isFavorite: false,
+      minPriceOfOptions: 100.0,
+      maxPriceOfOptions: 500.0,
+      wasLikedByMe: false,
+    );
+
+    const testPlansPagination = PlanPaginationModel(
+      data: [testPlan],
+      links: Links(first: '', last: '', prev: null, next: null),
+      meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null, totalMinPrice: 100, totalMaxPrice: 500),
+    );
+
+    setUp(() {
+      mockMyPlansRepository = MockMyPlansRepository();
+    });
+
+    tearDown(() async {
+      if (myPlansCubit != null && !myPlansCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        myPlansCubit!.close();
+        myPlansCubit = null;
+      }
+    });
+
+    test('начальное состояние - empty state', () {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+      expect(myPlansCubit!.state.activePlans, isEmpty);
+      expect(myPlansCubit!.state.draftPlans, isEmpty);
+      expect(myPlansCubit!.state.isLoading, false);
+      expect(myPlansCubit!.state.selectedStateIndex, 0);
+    });
+
+    test('loadAllPlans - загружает все планы', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      await myPlansCubit!.loadAllPlans();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myPlansCubit!.state.activePlans.length, 1);
+      expect(myPlansCubit!.state.draftPlans.length, 1);
+      expect(myPlansCubit!.state.isLoading, false);
+    });
+
+    test('loadPlans - загружает активные планы', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      await myPlansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myPlansCubit!.state.activePlans.length, 1);
+    });
+
+    test('changeSelectedStateIndex - меняет выбранный индекс состояния', () {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      myPlansCubit!.changeSelectedStateIndex(1);
+      expect(myPlansCubit!.state.selectedStateIndex, 1);
+
+      myPlansCubit!.changeSelectedStateIndex(0);
+      expect(myPlansCubit!.state.selectedStateIndex, 0);
+    });
+
+    test('changeTypeFilter - меняет фильтр типа для активных планов', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: 'fit',
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      myPlansCubit!.changeTypeFilter(1);
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      expect(myPlansCubit!.state.activeFilterState.typeIndex, 1);
+    });
+
+    test('changeDurationFilter - меняет фильтр длительности', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: 7,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      myPlansCubit!.changeDurationFilter(1);
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      expect(myPlansCubit!.state.activeFilterState.durationIndex, 1);
+    });
+
+    test('changePriceFilter - меняет фильтр цены', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: 100,
+        maxPrice: 500,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      myPlansCubit!.changePriceFilter(100, 500);
+      await Future.delayed(const Duration(milliseconds: 1200));
+
+      expect(myPlansCubit!.state.activeFilterState.priceFilter.$1, 100);
+      expect(myPlansCubit!.state.activeFilterState.priceFilter.$2, 500);
+    });
+
+    test('deletePlan - удаляет план успешно', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.deletePlan('test-plan-slug')).thenAnswer((_) async => Future.value());
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      final result = await myPlansCubit!.deletePlan('test-plan-slug');
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(result, true);
+      verify(mockMyPlansRepository.deletePlan('test-plan-slug')).called(1);
+    });
+
+    test('deletePlan - обрабатывает ошибку при удалении', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.deletePlan('test-plan-slug')).thenThrow(Exception('Network error'));
+
+      final result = await myPlansCubit!.deletePlan('test-plan-slug');
+
+      expect(result, false);
+      expect(myPlansCubit!.state.error, isNotNull);
+    });
+
+    test('unpublish - снимает с публикации план успешно', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.unpublish('test-plan-slug')).thenAnswer((_) async => Future.value());
+
+      final result = await myPlansCubit!.unpublish('test-plan-slug');
+
+      expect(result, true);
+      verify(mockMyPlansRepository.unpublish('test-plan-slug')).called(1);
+    });
+
+    test('unpublish - обрабатывает ошибку при снятии с публикации', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.unpublish('test-plan-slug')).thenThrow(Exception('Network error'));
+
+      final result = await myPlansCubit!.unpublish('test-plan-slug');
+
+      expect(result, false);
+    });
+
+    test('_loadActivePlans - обрабатывает ошибку', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenThrow(Exception('Network error'));
+
+      await myPlansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myPlansCubit!.state.error, isNotNull);
+    });
+
+    test('_loadActivePlans - устанавливает ценовой фильтр из мета', () async {
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      when(mockMyPlansRepository.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => testPlansPagination);
+
+      await myPlansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      expect(myPlansCubit!.state.minActivePlanPrice, 100);
+      expect(myPlansCubit!.state.maxActivePlanPrice, 500);
+    });
+  });
+}
+

test/features/my_plans/presentation/widgets/basic_widget_test.dart

@@ -0,0 +1,195 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/core/widgets/custom_outlined_button.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/my_plans/presentation/cubit/my_plans_cubit.dart';
+import 'package:eatvio_app/features/my_plans/presentation/cubit/my_plans_state.dart';
+import 'package:eatvio_app/features/my_plans/presentation/widgets/my_plan_widget.dart';
+import 'package:eatvio_app/features/my_plans/repositories/my_diets_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+
+import 'basic_widget_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyPlansRepository>()])
+void main() {
+  group('MyPlans Basic Widget Tests', () {
+    late MockMyPlansRepository mockMyPlansRepository;
+    late MyPlansCubit myPlansCubit;
+
+    const testPlan = PlanModel(
+      id: 1,
+      slug: 'test-plan',
+      name: 'Test Plan',
+      image: 'test-image.jpg',
+      duration: 30,
+      state: 'active',
+      type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+      details: 'Test plan description',
+      packetsCount: 1,
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      isFavorite: false,
+      minPriceOfOptions: 100.0,
+      maxPriceOfOptions: 500.0,
+      wasLikedByMe: false,
+      packet1Options: null,
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockMyPlansRepository = MockMyPlansRepository();
+      myPlansCubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!myPlansCubit.isClosed) {
+        myPlansCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<MyPlansCubit>(
+        create: (context) => myPlansCubit,
+        child: Portal(
+          child: wrapInScaffold ? Scaffold(body: SingleChildScrollView(child: child)) : SizedBox(width: 800, height: 600, child: child),
+        ),
+      );
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: widget,
+      );
+    }
+
+    testWidgets('should create MyPlansCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = MyPlansCubit(myPlansRepository: mockMyPlansRepository);
+
+      // Assert
+      expect(cubit, isA<MyPlansCubit>());
+      expect(cubit.state.activePlans, isEmpty);
+
+      cubit.close();
+    });
+
+    testWidgets('should display MyPlanWidget with plan name', (WidgetTester tester) async {
+      // Arrange
+      myPlansCubit.emit(MyPlansState(selectedStateIndex: 0));
+      const widget = MyPlanWidget(plan: testPlan);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.text('Test Plan'), findsOneWidget);
+      expect(find.byType(MyPlanWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyPlanWidget with description when details are present', (WidgetTester tester) async {
+      // Arrange
+      myPlansCubit.emit(MyPlansState(selectedStateIndex: 0));
+      const widget = MyPlanWidget(plan: testPlan);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.text('Test Plan'), findsOneWidget);
+      expect(find.byType(MyPlanWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyPlanWidget with price', (WidgetTester tester) async {
+      // Arrange
+      myPlansCubit.emit(MyPlansState(selectedStateIndex: 0));
+      const widget = MyPlanWidget(plan: testPlan);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.text('Test Plan'), findsOneWidget);
+      expect(find.byType(MyPlanWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyPlanWidget buttons', (WidgetTester tester) async {
+      // Arrange
+      myPlansCubit.emit(MyPlansState(selectedStateIndex: 0));
+      const widget = MyPlanWidget(plan: testPlan);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.byType(MyPlanWidget), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyPlanWidget structure correctly', (WidgetTester tester) async {
+      // Arrange
+      myPlansCubit.emit(MyPlansState(selectedStateIndex: 0));
+      const widget = MyPlanWidget(plan: testPlan);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.byType(MyPlanWidget), findsOneWidget);
+      expect(find.text('Test Plan'), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyPlanWidget with empty details', (WidgetTester tester) async {
+      // Arrange
+      myPlansCubit.emit(MyPlansState(selectedStateIndex: 0));
+      final planWithoutDetails = testPlan.copyWith(details: '');
+      final widget = MyPlanWidget(plan: planWithoutDetails);
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      // Assert
+      expect(find.text('Test Plan'), findsOneWidget);
+      expect(find.byType(MyPlanWidget), findsOneWidget);
+    });
+  });
+}
+

test/features/my_plans/repositories/my_plans_repository_test.dart

@@ -0,0 +1,236 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/my_plans/repositories/my_diets_repository.dart';
+import 'package:eatvio_app/features/my_plans/services/my_plans_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'my_plans_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyPlansService>()])
+void main() {
+  group('MyPlansRepository', () {
+    late MyPlansRepository myPlansRepository;
+    late MockMyPlansService mockMyPlansService;
+
+    setUp(() {
+      mockMyPlansService = MockMyPlansService();
+      myPlansRepository = MyPlansRepository(myPlansService: mockMyPlansService);
+    });
+
+    test('getPlans returns pagination with all parameters', () async {
+      const page = 1;
+      const query = 'test plan';
+      const types = 'fit,slim';
+      const duration = 30;
+      const minPrice = 100;
+      const maxPrice = 500;
+      final expected = PlanPaginationModel(
+        data: [
+          PlanModel(
+            id: 1,
+            slug: 'test-plan',
+            name: 'Test Plan',
+            image: 'https://someurl.com/img.jpg',
+            duration: duration,
+            state: 'active',
+            type: const PlanType(fit: true, slim: false, behavior: false, wellness: false),
+            details: 'Test plan description',
+            packetsCount: 1,
+            author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 1,
+            totalViews: 1,
+            totalComments: 1,
+            isFavorite: false,
+            minPriceOfOptions: minPrice.toDouble(),
+            maxPriceOfOptions: maxPrice.toDouble(),
+            wasLikedByMe: false,
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyPlansService.getPlans(
+        page: page,
+        query: query,
+        types: types,
+        duration: duration,
+        minPrice: minPrice,
+        maxPrice: maxPrice,
+      )).thenAnswer((_) async => expected);
+
+      final result = await myPlansRepository.getPlans(
+        page: page,
+        query: query,
+        types: types,
+        duration: duration,
+        minPrice: minPrice,
+        maxPrice: maxPrice,
+      );
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.name, 'Test Plan');
+      verify(mockMyPlansService.getPlans(
+        page: page,
+        query: query,
+        types: types,
+        duration: duration,
+        minPrice: minPrice,
+        maxPrice: maxPrice,
+      )).called(1);
+    });
+
+    test('getPlans returns pagination with default parameters', () async {
+      const expected = PlanPaginationModel(
+        data: [
+          PlanModel(
+            id: 2,
+            slug: 'another-plan',
+            name: 'Another Plan',
+            image: 'https://someurl.com/img2.jpg',
+            duration: 14,
+            state: 'draft',
+            type: PlanType(fit: false, slim: true, behavior: false, wellness: false),
+            details: '',
+            packetsCount: 2,
+            author: Author(authorSlug: 'author-slug', authorName: 'Author Name', authorProfileIcon: '', authorIsMe: true),
+            totalLikes: 5,
+            totalViews: 10,
+            totalComments: 2,
+            isFavorite: true,
+            minPriceOfOptions: 200.0,
+            maxPriceOfOptions: 600.0,
+            wasLikedByMe: true,
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyPlansService.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => expected);
+
+      final result = await myPlansRepository.getPlans();
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 2);
+      verify(mockMyPlansService.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).called(1);
+    });
+
+    test('getPlans returns pagination with partial parameters', () async {
+      const page = 2;
+      const query = 'wellness';
+      const duration = 21;
+      const expected = PlanPaginationModel(
+        data: [],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 2, lastPage: 2, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyPlansService.getPlans(
+        page: page,
+        query: query,
+        types: null,
+        duration: duration,
+        minPrice: null,
+        maxPrice: null,
+      )).thenAnswer((_) async => expected);
+
+      final result = await myPlansRepository.getPlans(
+        page: page,
+        query: query,
+        duration: duration,
+      );
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 0);
+      expect(result.meta.currentPage, 2);
+      verify(mockMyPlansService.getPlans(
+        page: page,
+        query: query,
+        types: null,
+        duration: duration,
+        minPrice: null,
+        maxPrice: null,
+      )).called(1);
+    });
+
+    test('deletePlan deletes plan by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockMyPlansService.deletePlan(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await myPlansRepository.deletePlan(slug);
+
+      verify(mockMyPlansService.deletePlan(slug: slug)).called(1);
+    });
+
+    test('unpublish unpublishes plan by slug', () async {
+      const slug = 'draft-plan-slug';
+
+      when(mockMyPlansService.unpublish(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await myPlansRepository.unpublish(slug);
+
+      verify(mockMyPlansService.unpublish(slug: slug)).called(1);
+    });
+
+    test('deletePlan rethrows exception on error', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockMyPlansService.deletePlan(slug: slug)).thenThrow(Exception('Network error'));
+
+      expect(() => myPlansRepository.deletePlan(slug), throwsException);
+      verify(mockMyPlansService.deletePlan(slug: slug)).called(1);
+    });
+
+    test('unpublish rethrows exception on error', () async {
+      const slug = 'draft-plan-slug';
+
+      when(mockMyPlansService.unpublish(slug: slug)).thenThrow(Exception('Network error'));
+
+      expect(() => myPlansRepository.unpublish(slug), throwsException);
+      verify(mockMyPlansService.unpublish(slug: slug)).called(1);
+    });
+
+    test('getPlans rethrows exception on error', () async {
+      when(mockMyPlansService.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).thenThrow(Exception('Network error'));
+
+      expect(() => myPlansRepository.getPlans(), throwsException);
+      verify(mockMyPlansService.getPlans(
+        page: 1,
+        query: null,
+        types: null,
+        duration: null,
+        minPrice: null,
+        maxPrice: null,
+      )).called(1);
+    });
+  });
+}
+

test/features/my_plans/services/my_plans_service_test.dart

@@ -0,0 +1,165 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/my_plans/services/my_plans_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'my_plans_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyPlansService>()])
+void main() {
+  group('MyPlansService', () {
+    late MockMyPlansService mockMyPlansService;
+
+    setUp(() {
+      mockMyPlansService = MockMyPlansService();
+    });
+
+    test('getPlans returns pagination with all parameters', () async {
+      const page = 1;
+      const query = 'test plan';
+      const types = 'fit,slim';
+      const duration = 30;
+      const minPrice = 100;
+      const maxPrice = 500;
+      final expected = PlanPaginationModel(
+        data: [
+          PlanModel(
+            id: 1,
+            slug: 'test-plan',
+            name: 'Test Plan',
+            image: 'https://someurl.com/img.jpg',
+            duration: duration,
+            state: 'active',
+            type: const PlanType(fit: true, slim: false, behavior: false, wellness: false),
+            details: 'Test plan description',
+            packetsCount: 1,
+            author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+            totalLikes: 1,
+            totalViews: 1,
+            totalComments: 1,
+            isFavorite: false,
+            minPriceOfOptions: minPrice.toDouble(),
+            maxPriceOfOptions: maxPrice.toDouble(),
+            wasLikedByMe: false,
+          ),
+        ],
+        links: const Links(first: '', last: '', prev: null, next: null),
+        meta: const Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(
+        mockMyPlansService.getPlans(page: page, query: query, types: types, duration: duration, minPrice: minPrice, maxPrice: maxPrice),
+      ).thenAnswer((_) async => expected);
+
+      final result = await mockMyPlansService.getPlans(page: page, query: query, types: types, duration: duration, minPrice: minPrice, maxPrice: maxPrice);
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.name, 'Test Plan');
+      verify(mockMyPlansService.getPlans(page: page, query: query, types: types, duration: duration, minPrice: minPrice, maxPrice: maxPrice)).called(1);
+    });
+
+    test('getPlans returns pagination with minimal parameters', () async {
+      const page = 1;
+      const expected = PlanPaginationModel(
+        data: [
+          PlanModel(
+            id: 2,
+            slug: 'another-plan',
+            name: 'Another Plan',
+            image: 'https://someurl.com/img2.jpg',
+            duration: 14,
+            state: 'draft',
+            type: PlanType(fit: false, slim: true, behavior: false, wellness: false),
+            details: '',
+            packetsCount: 2,
+            author: Author(authorSlug: 'author-slug', authorName: 'Author Name', authorProfileIcon: '', authorIsMe: true),
+            totalLikes: 5,
+            totalViews: 10,
+            totalComments: 2,
+            isFavorite: true,
+            minPriceOfOptions: 200.0,
+            maxPriceOfOptions: 600.0,
+            wasLikedByMe: true,
+          ),
+        ],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 1, lastPage: 1, total: 1, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(mockMyPlansService.getPlans(page: page, query: null, types: null, duration: null, minPrice: null, maxPrice: null)).thenAnswer((_) async => expected);
+
+      final result = await mockMyPlansService.getPlans(page: page, query: null, types: null, duration: null, minPrice: null, maxPrice: null);
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.id, 2);
+      verify(mockMyPlansService.getPlans(page: page, query: null, types: null, duration: null, minPrice: null, maxPrice: null)).called(1);
+    });
+
+    test('getPlans returns pagination with partial parameters', () async {
+      const page = 2;
+      const query = 'wellness';
+      const duration = 21;
+      const expected = PlanPaginationModel(
+        data: [],
+        links: Links(first: '', last: '', prev: null, next: null),
+        meta: Meta(currentPage: 2, lastPage: 2, total: 0, perPage: 10, from: null, links: [Link(url: null, label: null, active: null)], to: null),
+      );
+
+      when(
+        mockMyPlansService.getPlans(page: page, query: query, types: null, duration: duration, minPrice: null, maxPrice: null),
+      ).thenAnswer((_) async => expected);
+
+      final result = await mockMyPlansService.getPlans(page: page, query: query, types: null, duration: duration, minPrice: null, maxPrice: null);
+
+      expect(result, isA<PlanPaginationModel>());
+      expect(result.data.length, 0);
+      expect(result.meta.currentPage, 2);
+      verify(mockMyPlansService.getPlans(page: page, query: query, types: null, duration: duration, minPrice: null, maxPrice: null)).called(1);
+    });
+
+    test('deletePlan deletes plan by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockMyPlansService.deletePlan(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockMyPlansService.deletePlan(slug: slug);
+
+      verify(mockMyPlansService.deletePlan(slug: slug)).called(1);
+    });
+
+    test('deletePlan deletes plan with different slug', () async {
+      const slug = 'another-plan-slug';
+
+      when(mockMyPlansService.deletePlan(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockMyPlansService.deletePlan(slug: slug);
+
+      verify(mockMyPlansService.deletePlan(slug: slug)).called(1);
+    });
+
+    test('unpublish unpublishes plan by slug', () async {
+      const slug = 'draft-plan-slug';
+
+      when(mockMyPlansService.unpublish(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockMyPlansService.unpublish(slug: slug);
+
+      verify(mockMyPlansService.unpublish(slug: slug)).called(1);
+    });
+
+    test('unpublish unpublishes plan with different slug', () async {
+      const slug = 'published-plan-slug';
+
+      when(mockMyPlansService.unpublish(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockMyPlansService.unpublish(slug: slug);
+
+      verify(mockMyPlansService.unpublish(slug: slug)).called(1);
+    });
+  });
+}

test/features/plans/presentation/cubit/plans_cubit_test.dart

@@ -0,0 +1,181 @@
+import 'package:eatvio_app/core/models/pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/plans_cubit/plans_cubit.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/features/plans/repositories/plan_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+
+import 'plans_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>(), MockSpec<PlanRepository>()])
+void main() {
+  group('PlansCubit', () {
+    PlansCubit? plansCubit;
+    late MockFeedRepository mockFeedRepository;
+    late MockPlanRepository mockPlanRepository;
+
+    const testPlan = PlanModel(
+      id: 1,
+      slug: 'test-plan',
+      name: 'Test Plan',
+      image: 'https://someurl.com/img.jpg',
+      duration: 30,
+      state: 'active',
+      type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+      details: 'Test plan description',
+      packetsCount: 1,
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      isFavorite: false,
+      minPriceOfOptions: 100.0,
+      maxPriceOfOptions: 500.0,
+      wasLikedByMe: false,
+    );
+
+    const testPlansPagination = PlanPaginationModel(
+      data: [testPlan],
+      links: Links(first: '', last: '', prev: null, next: null),
+      meta: Meta(
+        currentPage: 1,
+        lastPage: 1,
+        total: 1,
+        perPage: 10,
+        from: null,
+        links: [Link(url: null, label: null, active: null)],
+        to: null,
+        totalMinPrice: 100,
+        totalMaxPrice: 500,
+      ),
+    );
+
+    setUp(() {
+      mockFeedRepository = MockFeedRepository();
+      mockPlanRepository = MockPlanRepository();
+    });
+
+    tearDown(() async {
+      if (plansCubit != null && !plansCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        plansCubit!.close();
+        plansCubit = null;
+      }
+    });
+
+    test('начальное состояние - initial state', () {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+      expect(plansCubit!.state.plans, isEmpty);
+      expect(plansCubit!.state.isLoading, true);
+      expect(plansCubit!.state.errorMessage, null);
+      expect(plansCubit!.state.filterState.durationIndex, 0);
+      expect(plansCubit!.state.filterState.typeIndex, 0);
+    });
+
+    test('loadPlans - загружает планы успешно', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      when(mockFeedRepository.getPlans(query: null, types: null, duration: null, minPrice: null, maxPrice: null)).thenAnswer((_) async => testPlansPagination);
+
+      await plansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(plansCubit!.state.plans.length, 1);
+      expect(plansCubit!.state.plans.first.name, 'Test Plan');
+      expect(plansCubit!.state.errorMessage, null);
+    });
+
+    test('loadPlans - обрабатывает ошибку', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      when(mockFeedRepository.getPlans(query: null, types: null, duration: null, minPrice: null, maxPrice: null)).thenThrow(Exception('Network error'));
+
+      await plansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(plansCubit!.state.errorMessage, isNotNull);
+    });
+
+    test('changeTypeFilter - меняет фильтр типа', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      plansCubit!.changeTypeFilter(1);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(plansCubit!.state.filterState.typeIndex, 1);
+    });
+
+    test('changeDurationFilter - меняет фильтр длительности', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      plansCubit!.changeDurationFilter(1);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(plansCubit!.state.filterState.durationIndex, 1);
+    });
+
+    test('changePriceFilter - меняет фильтр цены', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      plansCubit!.changePriceFilter(100, 500, disableDebounce: true);
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(plansCubit!.state.filterState.priceFilter.$1, 100);
+      expect(plansCubit!.state.filterState.priceFilter.$2, 500);
+    });
+
+    test('likePlan - лайкает план', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      when(mockFeedRepository.getPlans(query: null, types: null, duration: null, minPrice: null, maxPrice: null)).thenAnswer((_) async => testPlansPagination);
+
+      await plansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockPlanRepository.likePlan('test-plan')).thenAnswer((_) async => Future.value());
+
+      plansCubit!.likePlan('test-plan', 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(plansCubit!.state.plans[0].wasLikedByMe, true);
+      expect(plansCubit!.state.plans[0].totalLikes, 2);
+    });
+
+    test('addPlanToFavorite - добавляет план в избранное', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      when(mockFeedRepository.getPlans(query: null, types: null, duration: null, minPrice: null, maxPrice: null)).thenAnswer((_) async => testPlansPagination);
+
+      await plansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockPlanRepository.addToFavorite('test-plan')).thenAnswer((_) async => Future.value());
+
+      plansCubit!.addPlanToFavorite('test-plan', 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(plansCubit!.state.plans[0].isFavorite, true);
+    });
+
+    test('removePlanFromFavorite - удаляет план из избранного', () async {
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      when(
+        mockFeedRepository.getPlans(query: null, types: null, duration: null, minPrice: null, maxPrice: null),
+      ).thenAnswer((_) async => testPlansPagination.copyWith(data: [testPlan.copyWith(isFavorite: true)]));
+
+      await plansCubit!.loadPlans();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockPlanRepository.removeFromFavorite('test-plan')).thenAnswer((_) async => Future.value());
+
+      plansCubit!.removePlanFromFavorite('test-plan', 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(plansCubit!.state.plans[0].isFavorite, false);
+    });
+  });
+}

test/features/plans/presentation/widgets/basic_widget_test.dart

@@ -0,0 +1,246 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/plans_cubit/plans_cubit.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/plans_cubit/plans_state.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/plans.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/plan_widget.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/features/plans/repositories/plan_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:network_image_mock/network_image_mock.dart';
+import 'package:visibility_detector/visibility_detector.dart';
+
+import 'basic_widget_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>(), MockSpec<PlanRepository>()])
+void main() {
+  group('Plans Basic Widget Tests', () {
+    late MockFeedRepository mockFeedRepository;
+    late MockPlanRepository mockPlanRepository;
+    late PlansCubit plansCubit;
+
+    const testPlan = PlanModel(
+      id: 1,
+      slug: 'test-plan',
+      name: 'Test Plan',
+      image: 'test-image.jpg',
+      duration: 30,
+      state: 'active',
+      type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+      details: 'Test plan description',
+      packetsCount: 1,
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false),
+      totalLikes: 1,
+      totalViews: 1,
+      totalComments: 1,
+      isFavorite: false,
+      minPriceOfOptions: 100.0,
+      maxPriceOfOptions: 500.0,
+      wasLikedByMe: false,
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockFeedRepository = MockFeedRepository();
+      mockPlanRepository = MockPlanRepository();
+      plansCubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+      VisibilityDetectorController.instance.updateInterval = Duration.zero;
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!plansCubit.isClosed) {
+        plansCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<PlansCubit>(
+        create: (context) => plansCubit,
+        child: Portal(
+          child: wrapInScaffold
+              ? Scaffold(body: SingleChildScrollView(child: child))
+              : SizedBox(width: 800, height: 1200, child: SingleChildScrollView(child: child)),
+        ),
+      );
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: widget,
+      );
+    }
+
+    Widget createPlansTestWidget(Widget child) {
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: Portal(
+          child: Scaffold(
+            body: BlocProvider<PlansCubit>(
+              create: (context) => plansCubit,
+              child: LayoutBuilder(
+                builder: (context, constraints) => SizedBox(
+                  width: constraints.maxWidth > 0 ? constraints.maxWidth : 800,
+                  height: constraints.maxHeight > 0 ? constraints.maxHeight : 600,
+                  child: child,
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+    }
+
+    testWidgets('should create PlansCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = PlansCubit(feedRepository: mockFeedRepository, planRepository: mockPlanRepository);
+
+      // Assert
+      expect(cubit, isA<PlansCubit>());
+      expect(cubit.state.plans, isEmpty);
+
+      cubit.close();
+    });
+
+    testWidgets('should display PlanWidget with plan name', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        plansCubit.emit(PlansState.initial().copyWith(plans: [testPlan], isLoading: false));
+        const widget = PlanWidget(plan: testPlan, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.text('Test Plan'), findsOneWidget);
+        expect(find.byType(PlanWidget), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display PlanWidget with description when details are present', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        plansCubit.emit(PlansState.initial().copyWith(plans: [testPlan], isLoading: false));
+        const widget = PlanWidget(plan: testPlan, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.text('Test Plan'), findsOneWidget);
+        expect(find.byType(PlanWidget), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display PlanWidget structure correctly', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        plansCubit.emit(PlansState.initial().copyWith(plans: [testPlan], isLoading: false));
+        const widget = PlanWidget(plan: testPlan, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(PlanWidget), findsOneWidget);
+        expect(find.text('Test Plan'), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display Plans widget with loading state', (WidgetTester tester) async {
+      // Arrange
+      plansCubit.emit(PlansState.initial());
+      final widget = Plans(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createPlansTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(find.byType(Plans), findsOneWidget);
+    });
+
+    testWidgets('should display Plans widget with loaded state', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        plansCubit.emit(PlansState.initial().copyWith(plans: [testPlan], isLoading: false));
+        final widget = Plans(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createPlansTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(Plans), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display Plans widget with error state', (WidgetTester tester) async {
+      // Arrange
+      plansCubit.emit(PlansState.initial().copyWith(isLoading: false, errorMessage: 'Error message'));
+      final widget = Plans(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createPlansTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(find.byType(Plans), findsOneWidget);
+    });
+
+    testWidgets('should display Plans widget with multiple plans', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        final testPlan2 = testPlan.copyWith(id: 2, name: 'Test Plan 2');
+        plansCubit.emit(PlansState.initial().copyWith(plans: [testPlan, testPlan2], isLoading: false));
+        final widget = Plans(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createPlansTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(Plans), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+  });
+}

test/features/plans/presentation/widgets/widgets_test.dart

@@ -0,0 +1,131 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/core/widgets/animated_option_button.dart';
+import 'package:eatvio_app/features/plans/presentation/cubit/about_plan_cubit.dart';
+import 'package:eatvio_app/features/plans/presentation/cubit/about_plan_state.dart';
+import 'package:eatvio_app/features/plans/presentation/widgets/options_tab.dart';
+import 'package:eatvio_app/features/plans/repositories/plan_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+
+import 'widgets_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<PlanRepository>()])
+void main() {
+  group('Plans Widgets Tests', () {
+    late MockPlanRepository mockPlanRepository;
+    late AboutPlanCubit aboutPlanCubit;
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockPlanRepository = MockPlanRepository();
+      aboutPlanCubit = AboutPlanCubit(planRepository: mockPlanRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!aboutPlanCubit.isClosed) {
+        aboutPlanCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child) {
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: Portal(
+          child: Scaffold(body: SingleChildScrollView(child: child)),
+        ),
+      );
+    }
+
+    group('OptionsTab', () {
+      testWidgets('should display OptionsTab with three options', (WidgetTester tester) async {
+        // Arrange
+        aboutPlanCubit.emit(AboutPlanState.initial().copyWith(chosenOptionIndex: 0));
+        const widget = OptionsTab(cost: [100, 200, 300]);
+
+        // Act
+        await tester.pumpWidget(BlocProvider<AboutPlanCubit>(create: (context) => aboutPlanCubit, child: createTestWidget(widget)));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(OptionsTab), findsOneWidget);
+        expect(find.byType(AnimatedOptionButton), findsNWidgets(3));
+        expect(find.text('100₽'), findsOneWidget);
+        expect(find.text('200₽'), findsOneWidget);
+        expect(find.text('300₽'), findsOneWidget);
+      });
+
+      testWidgets('should highlight selected option', (WidgetTester tester) async {
+        // Arrange
+        aboutPlanCubit.emit(AboutPlanState.initial().copyWith(chosenOptionIndex: 1));
+        const widget = OptionsTab(cost: [100, 200, 300]);
+
+        // Act
+        await tester.pumpWidget(BlocProvider<AboutPlanCubit>(create: (context) => aboutPlanCubit, child: createTestWidget(widget)));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(OptionsTab), findsOneWidget);
+        expect(find.byType(AnimatedOptionButton), findsNWidgets(3));
+      });
+
+      testWidgets('should handle option selection', (WidgetTester tester) async {
+        // Arrange
+        aboutPlanCubit.emit(AboutPlanState.initial().copyWith(chosenOptionIndex: 0));
+        const widget = OptionsTab(cost: [100, 200, 300]);
+
+        // Act
+        await tester.pumpWidget(BlocProvider<AboutPlanCubit>(create: (context) => aboutPlanCubit, child: createTestWidget(widget)));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Tap the second option
+        final buttons = find.byType(AnimatedOptionButton);
+        expect(buttons, findsNWidgets(3));
+        await tester.tap(buttons.at(1));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(aboutPlanCubit.state.chosenOptionIndex, 1);
+      });
+
+      testWidgets('should display OptionsTab with different costs', (WidgetTester tester) async {
+        // Arrange
+        aboutPlanCubit.emit(AboutPlanState.initial().copyWith(chosenOptionIndex: 0));
+        const widget = OptionsTab(cost: [500, 1000, 1500]);
+
+        // Act
+        await tester.pumpWidget(BlocProvider<AboutPlanCubit>(create: (context) => aboutPlanCubit, child: createTestWidget(widget)));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(OptionsTab), findsOneWidget);
+        expect(find.text('500₽'), findsOneWidget);
+        expect(find.text('1000₽'), findsOneWidget);
+        expect(find.text('1500₽'), findsOneWidget);
+      });
+    });
+  });
+}

test/features/plans/repositories/plan_repository_test.dart

@@ -0,0 +1,144 @@
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/plans/enums/chosen_plan_state_enum.dart';
+import 'package:eatvio_app/features/plans/models/chosen_plan_model.dart';
+import 'package:eatvio_app/features/plans/repositories/plan_repository.dart';
+import 'package:eatvio_app/features/plans/services/plan_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+
+import 'plan_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<PlanService>()])
+void main() {
+  group('PlanRepository', () {
+    late PlanRepository planRepository;
+    late MockPlanService mockPlanService;
+
+    setUp(() {
+      mockPlanService = MockPlanService();
+      planRepository = PlanRepository(planService: mockPlanService);
+    });
+
+    test('getPlan returns PlanModel by slug', () async {
+      const slug = 'test-plan-slug';
+      const expected = PlanModel(
+        id: 1,
+        slug: slug,
+        name: 'Test Plan',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: 'active',
+        type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+        details: 'Test plan description',
+        packetsCount: 1,
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        isFavorite: false,
+        minPriceOfOptions: 100.0,
+        maxPriceOfOptions: 500.0,
+        wasLikedByMe: false,
+      );
+
+      when(mockPlanService.getPlan(slug)).thenAnswer((_) async => expected);
+
+      final result = await planRepository.getPlan(slug);
+
+      expect(result, isA<PlanModel>());
+      expect(result.slug, slug);
+      expect(result.name, 'Test Plan');
+      verify(mockPlanService.getPlan(slug)).called(1);
+    });
+
+    test('likePlan likes plan by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.likePlan(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await planRepository.likePlan(slug);
+
+      verify(mockPlanService.likePlan(slug: slug)).called(1);
+    });
+
+    test('addToFavorite adds plan to favorite by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.addToFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await planRepository.addToFavorite(slug);
+
+      verify(mockPlanService.addToFavorite(slug: slug)).called(1);
+    });
+
+    test('removeFromFavorite removes plan from favorite by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.removeFromFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await planRepository.removeFromFavorite(slug);
+
+      verify(mockPlanService.removeFromFavorite(slug: slug)).called(1);
+    });
+
+    test('chosePlan chooses plan with option', () async {
+      const slug = 'test-plan-slug';
+      final option = {'option_type': 'basic', 'start_date': '2024-01-01'};
+      final expected = ChosenPlanModel(
+        id: 1,
+        optionType: 'basic',
+        startDate: DateTime(2024, 1, 1),
+        chosenPlanState: ChosenPlanStateEnum.stateStarted,
+        chatId: 'chat-123',
+        consultantId: 1,
+        plan: const PlanModel(
+          id: 1,
+          slug: slug,
+          name: 'Test Plan',
+          image: 'https://someurl.com/img.jpg',
+          duration: 30,
+          state: 'active',
+          type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+          details: 'Test plan description',
+          packetsCount: 1,
+          author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+          totalLikes: 1,
+          totalViews: 1,
+          totalComments: 1,
+          isFavorite: false,
+          minPriceOfOptions: 100.0,
+          maxPriceOfOptions: 500.0,
+          wasLikedByMe: false,
+        ),
+      );
+
+      when(mockPlanService.chosePlan(slug: slug, option: option)).thenAnswer((_) async => expected);
+
+      final result = await planRepository.chosePlan(slug, option);
+
+      expect(result, isA<ChosenPlanModel>());
+      expect(result.plan.slug, slug);
+      verify(mockPlanService.chosePlan(slug: slug, option: option)).called(1);
+    });
+
+    test('getPlan rethrows exception on error', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.getPlan(slug)).thenThrow(Exception('Network error'));
+
+      expect(() => planRepository.getPlan(slug), throwsException);
+      verify(mockPlanService.getPlan(slug)).called(1);
+    });
+
+    test('likePlan rethrows exception on error', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.likePlan(slug: slug)).thenThrow(Exception('Network error'));
+
+      expect(() => planRepository.likePlan(slug), throwsException);
+      verify(mockPlanService.likePlan(slug: slug)).called(1);
+    });
+  });
+}

test/features/plans/services/plan_service_test.dart

@@ -0,0 +1,124 @@
+import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
+import 'package:eatvio_app/features/plans/enums/chosen_plan_state_enum.dart';
+import 'package:eatvio_app/features/plans/models/chosen_plan_model.dart';
+import 'package:eatvio_app/features/plans/services/plan_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+
+import 'plan_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<PlanService>()])
+void main() {
+  group('PlanService', () {
+    late MockPlanService mockPlanService;
+
+    setUp(() {
+      mockPlanService = MockPlanService();
+    });
+
+    test('getPlan returns PlanModel by slug', () async {
+      const slug = 'test-plan-slug';
+      const expected = PlanModel(
+        id: 1,
+        slug: slug,
+        name: 'Test Plan',
+        image: 'https://someurl.com/img.jpg',
+        duration: 30,
+        state: 'active',
+        type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+        details: 'Test plan description',
+        packetsCount: 1,
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        totalLikes: 1,
+        totalViews: 1,
+        totalComments: 1,
+        isFavorite: false,
+        minPriceOfOptions: 100.0,
+        maxPriceOfOptions: 500.0,
+        wasLikedByMe: false,
+      );
+
+      when(mockPlanService.getPlan(slug)).thenAnswer((_) async => expected);
+
+      final result = await mockPlanService.getPlan(slug);
+
+      expect(result, isA<PlanModel>());
+      expect(result.slug, slug);
+      expect(result.name, 'Test Plan');
+      verify(mockPlanService.getPlan(slug)).called(1);
+    });
+
+    test('likePlan likes plan by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.likePlan(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockPlanService.likePlan(slug: slug);
+
+      verify(mockPlanService.likePlan(slug: slug)).called(1);
+    });
+
+    test('addToFavorite adds plan to favorite by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.addToFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockPlanService.addToFavorite(slug: slug);
+
+      verify(mockPlanService.addToFavorite(slug: slug)).called(1);
+    });
+
+    test('removeFromFavorite removes plan from favorite by slug', () async {
+      const slug = 'test-plan-slug';
+
+      when(mockPlanService.removeFromFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockPlanService.removeFromFavorite(slug: slug);
+
+      verify(mockPlanService.removeFromFavorite(slug: slug)).called(1);
+    });
+
+    test('chosePlan chooses plan with option', () async {
+      const slug = 'test-plan-slug';
+      final option = {'option_type': 'basic', 'start_date': '2024-01-01'};
+      final expected = ChosenPlanModel(
+        id: 1,
+        optionType: 'basic',
+        startDate: DateTime(2024, 1, 1),
+        chosenPlanState: ChosenPlanStateEnum.stateStarted,
+        chatId: 'chat-123',
+        consultantId: 1,
+        plan: const PlanModel(
+          id: 1,
+          slug: slug,
+          name: 'Test Plan',
+          image: 'https://someurl.com/img.jpg',
+          duration: 30,
+          state: 'active',
+          type: PlanType(fit: true, slim: false, behavior: false, wellness: false),
+          details: 'Test plan description',
+          packetsCount: 1,
+          author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+          totalLikes: 1,
+          totalViews: 1,
+          totalComments: 1,
+          isFavorite: false,
+          minPriceOfOptions: 100.0,
+          maxPriceOfOptions: 500.0,
+          wasLikedByMe: false,
+        ),
+      );
+
+      when(mockPlanService.chosePlan(slug: slug, option: option)).thenAnswer((_) async => expected);
+
+      final result = await mockPlanService.chosePlan(slug: slug, option: option);
+
+      expect(result, isA<ChosenPlanModel>());
+      expect(result.plan.slug, slug);
+      verify(mockPlanService.chosePlan(slug: slug, option: option)).called(1);
+    });
+  });
+}
+

test/features/recipes/presentation/cubit/my_recipes_cubit_test.dart

@@ -0,0 +1,244 @@
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/recipe/models/my_recipe_model.dart';
+import 'package:eatvio_app/features/recipe/presentation/cubit/my_recipes_cubit/my_recieps_cubit.dart';
+import 'package:eatvio_app/features/recipe/presentation/cubit/my_recipes_cubit/my_recipes_state.dart';
+import 'package:eatvio_app/features/recipe/repositories/about_recipe_repository.dart';
+import 'package:eatvio_app/features/recipe/repositories/my_recipes_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'my_recipes_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([
+  MockSpec<MyRecipesRepository>(),
+  MockSpec<AboutRecipeRepository>(),
+])
+void main() {
+  group('MyRecipesCubit', () {
+    MyRecipesCubit? myRecipesCubit;
+    late MockMyRecipesRepository mockMyRecipesRepository;
+    late MockAboutRecipeRepository mockAboutRecipeRepository;
+
+    const testActiveRecipe = MyRecipeModel(
+      id: 1,
+      image: 'https://someurl.com/img.jpg',
+      state: 'active',
+      cookingTime: 30,
+      activeCookingTime: 20,
+      description: 'Test recipe description',
+      steps: [
+        Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1 description'),
+      ],
+      videoUrl: 'https://someurl.com/video.mp4',
+      title: 'Test Recipe',
+      slug: 'test-recipe',
+      calories: 250.0,
+      likesCount: 5,
+      viewsCount: 10,
+    );
+
+    const testArchivedRecipe = MyRecipeModel(
+      id: 2,
+      image: 'https://someurl.com/img2.jpg',
+      state: 'archived',
+      cookingTime: 45,
+      activeCookingTime: 30,
+      description: 'Archived recipe description',
+      steps: null,
+      videoUrl: null,
+      title: 'Archived Recipe',
+      slug: 'archived-recipe',
+      calories: 350.0,
+      likesCount: 8,
+      viewsCount: 15,
+    );
+
+    final testRecipe = Recipe(
+      id: 1,
+      image: 'https://someurl.com/img.jpg',
+      state: 'published',
+      cookingTime: 30,
+      activeCookingTime: 20,
+      ingredients: null,
+      description: 'Test recipe description',
+      steps: [
+        const Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1 description'),
+      ],
+      videoUrl: 'https://someurl.com/video.mp4',
+      createdAt: DateTime.now(),
+      updatedAt: DateTime.now(),
+      title: 'Test Recipe',
+      type: 'recipe',
+      slug: 'test-recipe',
+      commentsCount: 5,
+      wasLikedByMe: false,
+      isFavorite: false,
+      calories: 250.0,
+      servings: 1,
+      likesCount: 5,
+      viewsCount: 10,
+      tags: [],
+      author: const Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+    );
+
+    setUp(() {
+      mockMyRecipesRepository = MockMyRecipesRepository();
+      mockAboutRecipeRepository = MockAboutRecipeRepository();
+    });
+
+    tearDown(() async {
+      if (myRecipesCubit != null && !myRecipesCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        myRecipesCubit!.close();
+        myRecipesCubit = null;
+      }
+    });
+
+    test('начальное состояние - loading', () {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+      expect(myRecipesCubit!.state, isA<MyRecipesStateLoading>());
+    });
+
+    test('getMyRecipes - загружает активные рецепты', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenAnswer(
+        (_) async => [testActiveRecipe, testArchivedRecipe],
+      );
+
+      await myRecipesCubit!.getMyRecipes();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateLoaded>());
+      final loadedState = myRecipesCubit!.state as MyRecipesStateLoaded;
+      expect(loadedState.recipes.length, 1);
+      expect(loadedState.recipes.first.state, 'active');
+      expect(loadedState.selectedState, 'active');
+    });
+
+    test('getMyRecipes - обрабатывает ошибку', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenThrow(Exception('Network error'));
+
+      await myRecipesCubit!.getMyRecipes();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateError>());
+    });
+
+    test('setActiveState - устанавливает активное состояние', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenAnswer(
+        (_) async => [testActiveRecipe, testArchivedRecipe],
+      );
+
+      await myRecipesCubit!.setActiveState();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateLoaded>());
+      final loadedState = myRecipesCubit!.state as MyRecipesStateLoaded;
+      expect(loadedState.recipes.length, 1);
+      expect(loadedState.recipes.first.state, 'active');
+      expect(loadedState.selectedState, 'active');
+    });
+
+    test('setActiveState - обрабатывает ошибку', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenThrow(Exception('Network error'));
+
+      await myRecipesCubit!.setActiveState();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateError>());
+    });
+
+    test('setArchivedState - устанавливает архивное состояние', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenAnswer(
+        (_) async => [testActiveRecipe, testArchivedRecipe],
+      );
+
+      await myRecipesCubit!.setArchivedState();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateLoaded>());
+      final loadedState = myRecipesCubit!.state as MyRecipesStateLoaded;
+      expect(loadedState.recipes.length, 1);
+      expect(loadedState.recipes.first.state, 'archived');
+      expect(loadedState.selectedState, 'archived');
+    });
+
+    test('setArchivedState - обрабатывает ошибку', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenThrow(Exception('Network error'));
+
+      await myRecipesCubit!.setArchivedState();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateError>());
+    });
+
+    test('getRecipeById - получает рецепт по slug', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockAboutRecipeRepository.getRecipe('test-recipe')).thenAnswer((_) async => testRecipe);
+
+      final result = await myRecipesCubit!.getRecipeById('test-recipe');
+
+      expect(result, isA<Recipe>());
+      expect(result.id, 1);
+      expect(result.slug, 'test-recipe');
+      verify(mockAboutRecipeRepository.getRecipe('test-recipe')).called(1);
+    });
+
+    test('getMyRecipes - фильтрует только активные рецепты', () async {
+      myRecipesCubit = MyRecipesCubit(
+        myRecipesRepository: mockMyRecipesRepository,
+        aboutRecipeRepository: mockAboutRecipeRepository,
+      );
+
+      when(mockMyRecipesRepository.getMyRecipes()).thenAnswer(
+        (_) async => [testActiveRecipe, testArchivedRecipe, testActiveRecipe.copyWith(id: 3)],
+      );
+
+      await myRecipesCubit!.getMyRecipes();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(myRecipesCubit!.state, isA<MyRecipesStateLoaded>());
+      final loadedState = myRecipesCubit!.state as MyRecipesStateLoaded;
+      expect(loadedState.recipes.length, 2);
+      expect(loadedState.recipes.every((r) => r.state == 'active'), true);
+    });
+  });
+}
+

test/features/recipes/presentation/cubit/recipes_cubit_test.dart

@@ -0,0 +1,192 @@
+import 'package:eatvio_app/features/create_recipe/models/recipe_tag_model.dart';
+import 'package:eatvio_app/features/create_recipe/reporitories/recipe_repository.dart';
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/recipes_cubit/recipes_cubit.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/features/recipe/repositories/about_recipe_repository.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+
+import 'recipes_cubit_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>(), MockSpec<RecipeRepository>(), MockSpec<AboutRecipeRepository>()])
+void main() {
+  group('RecipesCubit', () {
+    RecipesCubit? recipesCubit;
+    late MockFeedRepository mockFeedRepository;
+    late MockRecipeRepository mockRecipeRepository;
+    late MockAboutRecipeRepository mockAboutRecipeRepository;
+
+    const testRecipe = Recipe(
+      id: 1,
+      image: 'https://someurl.com/img.jpg',
+      state: 'active',
+      cookingTime: 30,
+      activeCookingTime: 15,
+      ingredients: [],
+      description: 'Test recipe description',
+      steps: [],
+      videoUrl: null,
+      createdAt: null,
+      updatedAt: null,
+      title: 'Test Recipe',
+      type: 'main',
+      slug: 'test-recipe-slug',
+      commentsCount: 5,
+      wasLikedByMe: false,
+      isFavorite: false,
+      calories: 300.0,
+      servings: 4,
+      likesCount: 10,
+      viewsCount: 100,
+      tags: [],
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+    );
+
+    final testRecipesList = [testRecipe];
+    final testRecipeTags = [RecipeTag(id: 1, name: 'Breakfast', recipesCount: 10, createdAt: DateTime(2024, 1, 1), updatedAt: DateTime(2024, 1, 1))];
+
+    setUp(() {
+      mockFeedRepository = MockFeedRepository();
+      mockRecipeRepository = MockRecipeRepository();
+      mockAboutRecipeRepository = MockAboutRecipeRepository();
+    });
+
+    tearDown(() async {
+      if (recipesCubit != null && !recipesCubit!.isClosed) {
+        await Future.delayed(const Duration(milliseconds: 100));
+        recipesCubit!.close();
+        recipesCubit = null;
+      }
+    });
+
+    test('начальное состояние - initial state', () {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+      expect(recipesCubit!.state.recipesList, isEmpty);
+      expect(recipesCubit!.state.recipesTags, isEmpty);
+      expect(recipesCubit!.state.selectedTags, isEmpty);
+      expect(recipesCubit!.state.selectedTagsCounter, 0);
+      expect(recipesCubit!.state.isLoading, true);
+      expect(recipesCubit!.state.errorMessage, null);
+    });
+
+    test('loadRecipesList - загружает рецепты успешно', () async {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      when(mockFeedRepository.getRecipes(query: null, tags: [])).thenAnswer((_) async => testRecipesList);
+
+      when(mockRecipeRepository.getRecipesTags()).thenAnswer((_) async => testRecipeTags);
+
+      await recipesCubit!.loadRecipesList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(recipesCubit!.state.recipesList.length, 1);
+      expect(recipesCubit!.state.recipesList.first.title, 'Test Recipe');
+      expect(recipesCubit!.state.recipesTags.length, 1);
+      expect(recipesCubit!.state.errorMessage, null);
+    });
+
+    test('loadRecipesList - обрабатывает ошибку', () async {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      when(mockFeedRepository.getRecipes(query: null, tags: [])).thenThrow(Exception('Network error'));
+
+      await recipesCubit!.loadRecipesList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      expect(recipesCubit!.state.errorMessage, isNotNull);
+      expect(recipesCubit!.state.isLoading, false);
+    });
+
+    test('updateTags - добавляет тег', () {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      final tag = RecipeTag(id: 1, name: 'Breakfast', recipesCount: 10, createdAt: DateTime(2024, 1, 1), updatedAt: DateTime(2024, 1, 1));
+
+      recipesCubit!.updateTags(tag);
+
+      expect(recipesCubit!.state.selectedTags.contains(1), true);
+      expect(recipesCubit!.state.selectedTagsCounter, 1);
+    });
+
+    test('updateTags - удаляет тег', () {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      final tag = RecipeTag(id: 1, name: 'Breakfast', recipesCount: 10, createdAt: DateTime(2024, 1, 1), updatedAt: DateTime(2024, 1, 1));
+
+      recipesCubit!.updateTags(tag);
+      recipesCubit!.updateTags(tag);
+
+      expect(recipesCubit!.state.selectedTags.contains(1), false);
+      expect(recipesCubit!.state.selectedTagsCounter, 0);
+    });
+
+    test('likeRecipe - лайкает рецепт', () async {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      when(mockFeedRepository.getRecipes(query: null, tags: [])).thenAnswer((_) async => testRecipesList);
+
+      when(mockRecipeRepository.getRecipesTags()).thenAnswer((_) async => testRecipeTags);
+
+      await recipesCubit!.loadRecipesList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockAboutRecipeRepository.likeRecipe('test-recipe-slug')).thenAnswer((_) async => Future.value());
+
+      recipesCubit!.likeRecipe('test-recipe-slug', 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(recipesCubit!.state.recipesList[0].wasLikedByMe, true);
+      expect(recipesCubit!.state.recipesList[0].likesCount, 11);
+    });
+
+    test('addRecipeToFavorite - добавляет рецепт в избранное', () async {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      when(mockFeedRepository.getRecipes(query: null, tags: [])).thenAnswer((_) async => testRecipesList);
+
+      when(mockRecipeRepository.getRecipesTags()).thenAnswer((_) async => testRecipeTags);
+
+      await recipesCubit!.loadRecipesList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockAboutRecipeRepository.addToFavorite('test-recipe-slug')).thenAnswer((_) async => Future.value());
+
+      recipesCubit!.addRecipeToFavorite('test-recipe-slug', 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(recipesCubit!.state.recipesList[0].isFavorite, true);
+    });
+
+    test('removeRecipeFromFavorite - удаляет рецепт из избранного', () async {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      when(mockFeedRepository.getRecipes(query: null, tags: [])).thenAnswer((_) async => [testRecipe.copyWith(isFavorite: true)]);
+
+      when(mockRecipeRepository.getRecipesTags()).thenAnswer((_) async => testRecipeTags);
+
+      await recipesCubit!.loadRecipesList();
+      await Future.delayed(const Duration(milliseconds: 100));
+
+      when(mockAboutRecipeRepository.removeFromFavorite('test-recipe-slug')).thenAnswer((_) async => Future.value());
+
+      recipesCubit!.removeRecipeFromFavorite('test-recipe-slug', 0);
+      await Future.delayed(const Duration(milliseconds: 300));
+
+      expect(recipesCubit!.state.recipesList[0].isFavorite, false);
+    });
+
+    test('deleteRecipe - удаляет рецепт', () async {
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      when(mockAboutRecipeRepository.deleteRecipe('test-recipe-slug')).thenAnswer((_) async => Future.value());
+
+      final result = await recipesCubit!.deleteRecipe('test-recipe-slug');
+
+      expect(result, true);
+      verify(mockAboutRecipeRepository.deleteRecipe('test-recipe-slug')).called(1);
+    });
+  });
+}

test/features/recipes/presentation/widgets/basic_widget_test.dart

@@ -0,0 +1,255 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/features/create_recipe/reporitories/recipe_repository.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/recipes_cubit/recipes_cubit.dart';
+import 'package:eatvio_app/features/feed/presentation/bloc/recipes_cubit/recipes_state.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/recipes.dart';
+import 'package:eatvio_app/features/feed/presentation/widgets/recipes_widget.dart';
+import 'package:eatvio_app/features/feed/repositories/feed_repository.dart';
+import 'package:eatvio_app/features/recipe/repositories/about_recipe_repository.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:network_image_mock/network_image_mock.dart';
+import 'package:visibility_detector/visibility_detector.dart';
+
+import 'basic_widget_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<FeedRepository>(), MockSpec<RecipeRepository>(), MockSpec<AboutRecipeRepository>()])
+void main() {
+  group('Recipes Basic Widget Tests', () {
+    late MockFeedRepository mockFeedRepository;
+    late MockRecipeRepository mockRecipeRepository;
+    late MockAboutRecipeRepository mockAboutRecipeRepository;
+    late RecipesCubit recipesCubit;
+
+    const testRecipe = Recipe(
+      id: 1,
+      image: 'test-image.jpg',
+      state: 'active',
+      cookingTime: 30,
+      activeCookingTime: 15,
+      ingredients: [],
+      description: 'Test recipe description',
+      steps: [],
+      videoUrl: null,
+      createdAt: null,
+      updatedAt: null,
+      title: 'Test Recipe',
+      type: 'main',
+      slug: 'test-recipe-slug',
+      commentsCount: 5,
+      wasLikedByMe: false,
+      isFavorite: false,
+      calories: 300.0,
+      servings: 4,
+      likesCount: 10,
+      viewsCount: 100,
+      tags: [],
+      author: Author(authorSlug: '', authorName: '', authorProfileIcon: 'https://example.com/icon.jpg', authorIsMe: false),
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockFeedRepository = MockFeedRepository();
+      mockRecipeRepository = MockRecipeRepository();
+      mockAboutRecipeRepository = MockAboutRecipeRepository();
+      recipesCubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+      VisibilityDetectorController.instance.updateInterval = Duration.zero;
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!recipesCubit.isClosed) {
+        recipesCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<RecipesCubit>(
+        create: (context) => recipesCubit,
+        child: Portal(
+          child: wrapInScaffold
+              ? Scaffold(body: SingleChildScrollView(child: child))
+              : SizedBox(width: 800, height: 1200, child: SingleChildScrollView(child: child)),
+        ),
+      );
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: widget,
+      );
+    }
+
+    Widget createRecipesTestWidget(Widget child) {
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: Portal(
+          child: Scaffold(
+            body: BlocProvider<RecipesCubit>(
+              create: (context) => recipesCubit,
+              child: LayoutBuilder(
+                builder: (context, constraints) => SizedBox(
+                  width: constraints.maxWidth > 0 ? constraints.maxWidth : 800,
+                  height: constraints.maxHeight > 0 ? constraints.maxHeight : 600,
+                  child: child,
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+    }
+
+    testWidgets('should create RecipesCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = RecipesCubit(feedRepository: mockFeedRepository, recipeRepository: mockRecipeRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      // Assert
+      expect(cubit, isA<RecipesCubit>());
+      expect(cubit.state.recipesList, isEmpty);
+
+      cubit.close();
+    });
+
+    testWidgets('should display RecipesWidget with recipe title', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        recipesCubit.emit(RecipesState.initial().copyWith(recipesList: [testRecipe], isLoading: false));
+        const widget = RecipesWidget(recipe: testRecipe, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.text('Test Recipe'), findsOneWidget);
+        expect(find.byType(RecipesWidget), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display RecipesWidget with description when description is present', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        recipesCubit.emit(RecipesState.initial().copyWith(recipesList: [testRecipe], isLoading: false));
+        const widget = RecipesWidget(recipe: testRecipe, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.text('Test Recipe'), findsOneWidget);
+        expect(find.byType(RecipesWidget), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display RecipesWidget structure correctly', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        recipesCubit.emit(RecipesState.initial().copyWith(recipesList: [testRecipe], isLoading: false));
+        const widget = RecipesWidget(recipe: testRecipe, index: 0);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(RecipesWidget), findsOneWidget);
+        expect(find.text('Test Recipe'), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display Recipes widget with loading state', (WidgetTester tester) async {
+      // Arrange
+      recipesCubit.emit(RecipesState.initial());
+      final widget = Recipes(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createRecipesTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(find.byType(Recipes), findsOneWidget);
+    });
+
+    testWidgets('should display Recipes widget with loaded state', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        recipesCubit.emit(RecipesState.initial().copyWith(recipesList: [testRecipe], isLoading: false));
+        final widget = Recipes(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createRecipesTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(Recipes), findsOneWidget);
+        expect(find.byType(RefreshIndicator), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+
+    testWidgets('should display Recipes widget with error state', (WidgetTester tester) async {
+      // Arrange
+      recipesCubit.emit(RecipesState.initial().copyWith(isLoading: false, errorMessage: 'Error message'));
+      final widget = Recipes(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+      // Act
+      await tester.pumpWidget(createRecipesTestWidget(widget));
+      await tester.pump();
+
+      // Assert
+      expect(find.byType(Recipes), findsOneWidget);
+    });
+
+    testWidgets('should display Recipes widget with multiple recipes', (WidgetTester tester) async {
+      await mockNetworkImagesFor(() async {
+        // Arrange
+        final testRecipe2 = testRecipe.copyWith(id: 2, title: 'Test Recipe 2');
+        recipesCubit.emit(RecipesState.initial().copyWith(recipesList: [testRecipe, testRecipe2], isLoading: false));
+        final widget = Recipes(handleVisibility: ({required visibleFraction, required id, required type}) {});
+
+        // Act
+        await tester.pumpWidget(createRecipesTestWidget(widget));
+        await tester.pump();
+
+        // Assert
+        expect(find.byType(Recipes), findsOneWidget);
+        expect(find.byType(ListView), findsOneWidget);
+      });
+      await tester.pump(const Duration(milliseconds: 600));
+    });
+  });
+}

test/features/recipes/presentation/widgets/widgets_test.dart

@@ -0,0 +1,253 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/theme/theme_helper.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+import 'package:eatvio_app/features/feed/models/recipes_model.dart' as recipes;
+import 'package:eatvio_app/features/recipe/presentation/widgets/ingredients_widget.dart';
+import 'package:eatvio_app/features/recipe/presentation/widgets/steps_widget.dart';
+import 'package:eatvio_app/generated/l10n.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_portal/flutter_portal.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+import 'package:network_image_mock/network_image_mock.dart';
+
+void main() {
+  group('Recipes Widgets Tests', () {
+    setUp(() async {
+      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'));
+    });
+
+    Widget createTestWidget(Widget child) {
+      return MaterialApp(
+        theme: ThemeHelper().themeData(),
+        localizationsDelegates: const [
+          S.delegate,
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        supportedLocales: const [Locale('ru')],
+        home: Portal(
+          child: Scaffold(body: SingleChildScrollView(child: child)),
+        ),
+      );
+    }
+
+    group('IngredientsWidget', () {
+      testWidgets('should display IngredientsWidget with ingredients', (WidgetTester tester) async {
+        // Arrange
+        const recipe = recipes.Recipe(
+          id: 1,
+          image: 'test-image.jpg',
+          state: 'active',
+          cookingTime: 30,
+          activeCookingTime: 15,
+          ingredients: [
+            recipes.Ingredient(name: 'Flour', unit: 'g', portion: '200', productId: 1),
+            recipes.Ingredient(name: 'Sugar', unit: 'g', portion: '100', productId: 2),
+          ],
+          description: 'Test recipe',
+          steps: [],
+          videoUrl: null,
+          createdAt: null,
+          updatedAt: null,
+          title: 'Test Recipe',
+          type: 'main',
+          slug: 'test-recipe',
+          commentsCount: 0,
+          wasLikedByMe: false,
+          isFavorite: false,
+          calories: 300.0,
+          servings: 4,
+          likesCount: 0,
+          viewsCount: 0,
+          tags: [],
+          author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        );
+        const widget = IngredientsWidget(recipe: recipe);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 300));
+
+        // Assert
+        expect(find.byType(IngredientsWidget), findsOneWidget);
+        expect(find.byType(ExpansionTile), findsOneWidget);
+        // The ingredients text may be formatted with units, so just check the widget structure
+      });
+
+      testWidgets('should display IngredientsWidget with empty ingredients', (WidgetTester tester) async {
+        // Arrange
+        const recipe = recipes.Recipe(
+          id: 1,
+          image: 'test-image.jpg',
+          state: 'active',
+          cookingTime: 30,
+          activeCookingTime: 15,
+          ingredients: [],
+          description: 'Test recipe',
+          steps: [],
+          videoUrl: null,
+          createdAt: null,
+          updatedAt: null,
+          title: 'Test Recipe',
+          type: 'main',
+          slug: 'test-recipe',
+          commentsCount: 0,
+          wasLikedByMe: false,
+          isFavorite: false,
+          calories: 300.0,
+          servings: 4,
+          likesCount: 0,
+          viewsCount: 0,
+          tags: [],
+          author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        );
+        const widget = IngredientsWidget(recipe: recipe);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(IngredientsWidget), findsOneWidget);
+      });
+    });
+
+    group('StepsWidget', () {
+      testWidgets('should display StepsWidget with steps', (WidgetTester tester) async {
+        await mockNetworkImagesFor(() async {
+          // Arrange
+          const recipe = recipes.Recipe(
+            id: 1,
+            image: 'test-image.jpg',
+            state: 'active',
+            cookingTime: 30,
+            activeCookingTime: 15,
+            ingredients: [],
+            description: 'Test recipe',
+            steps: [
+              recipes.Step(image: 'step1.jpg', description: 'Step 1 description'),
+              recipes.Step(image: 'step2.jpg', description: 'Step 2 description'),
+            ],
+            videoUrl: null,
+            createdAt: null,
+            updatedAt: null,
+            title: 'Test Recipe',
+            type: 'main',
+            slug: 'test-recipe',
+            commentsCount: 0,
+            wasLikedByMe: false,
+            isFavorite: false,
+            calories: 300.0,
+            servings: 4,
+            likesCount: 0,
+            viewsCount: 0,
+            tags: [],
+            author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+          );
+          const widget = StepsWidget(recipe: recipe);
+
+          // Act
+          await tester.pumpWidget(createTestWidget(widget));
+          await tester.pump();
+          await tester.pump(const Duration(milliseconds: 100));
+
+          // Assert
+          expect(find.byType(StepsWidget), findsOneWidget);
+          expect(find.text('Step 1 description'), findsOneWidget);
+          expect(find.text('Step 2 description'), findsOneWidget);
+        });
+        await tester.pump(const Duration(milliseconds: 600));
+      });
+
+      testWidgets('should display StepsWidget with steps without images', (WidgetTester tester) async {
+        // Arrange
+        const recipe = recipes.Recipe(
+          id: 1,
+          image: 'test-image.jpg',
+          state: 'active',
+          cookingTime: 30,
+          activeCookingTime: 15,
+          ingredients: [],
+          description: 'Test recipe',
+          steps: [
+            recipes.Step(image: '', description: 'Step 1 description'),
+            recipes.Step(image: '', description: 'Step 2 description'),
+          ],
+          videoUrl: null,
+          createdAt: null,
+          updatedAt: null,
+          title: 'Test Recipe',
+          type: 'main',
+          slug: 'test-recipe',
+          commentsCount: 0,
+          wasLikedByMe: false,
+          isFavorite: false,
+          calories: 300.0,
+          servings: 4,
+          likesCount: 0,
+          viewsCount: 0,
+          tags: [],
+          author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        );
+        const widget = StepsWidget(recipe: recipe);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(StepsWidget), findsOneWidget);
+        expect(find.text('Step 1 description'), findsOneWidget);
+        expect(find.text('Step 2 description'), findsOneWidget);
+      });
+
+      testWidgets('should display StepsWidget with empty steps', (WidgetTester tester) async {
+        // Arrange
+        const recipe = recipes.Recipe(
+          id: 1,
+          image: 'test-image.jpg',
+          state: 'active',
+          cookingTime: 30,
+          activeCookingTime: 15,
+          ingredients: [],
+          description: 'Test recipe',
+          steps: [],
+          videoUrl: null,
+          createdAt: null,
+          updatedAt: null,
+          title: 'Test Recipe',
+          type: 'main',
+          slug: 'test-recipe',
+          commentsCount: 0,
+          wasLikedByMe: false,
+          isFavorite: false,
+          calories: 300.0,
+          servings: 4,
+          likesCount: 0,
+          viewsCount: 0,
+          tags: [],
+          author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+        );
+        const widget = StepsWidget(recipe: recipe);
+
+        // Act
+        await tester.pumpWidget(createTestWidget(widget));
+        await tester.pump();
+        await tester.pump(const Duration(milliseconds: 100));
+
+        // Assert
+        expect(find.byType(StepsWidget), findsOneWidget);
+      });
+    });
+  });
+}

test/features/recipes/repositories/about_recipe_repository_test.dart

@@ -0,0 +1,119 @@
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/recipe/repositories/about_recipe_repository.dart';
+import 'package:eatvio_app/features/recipe/services/about_recipe_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+
+import 'about_recipe_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<AboutRecipeService>()])
+void main() {
+  group('AboutRecipeRepository', () {
+    late AboutRecipeRepository aboutRecipeRepository;
+    late MockAboutRecipeService mockAboutRecipeService;
+
+    setUp(() {
+      mockAboutRecipeService = MockAboutRecipeService();
+      aboutRecipeRepository = AboutRecipeRepository(recipeService: mockAboutRecipeService);
+    });
+
+    test('getRecipe returns Recipe by id', () async {
+      const id = '1';
+      const expected = Recipe(
+        id: 1,
+        image: 'https://someurl.com/img.jpg',
+        state: 'active',
+        cookingTime: 30,
+        activeCookingTime: 15,
+        ingredients: [],
+        description: 'Test recipe description',
+        steps: [],
+        videoUrl: null,
+        createdAt: null,
+        updatedAt: null,
+        title: 'Test Recipe',
+        type: 'main',
+        slug: 'test-recipe-slug',
+        commentsCount: 5,
+        wasLikedByMe: false,
+        isFavorite: false,
+        calories: 300.0,
+        servings: 4,
+        likesCount: 10,
+        viewsCount: 100,
+        tags: [],
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      );
+
+      when(mockAboutRecipeService.getRecipe(id)).thenAnswer((_) async => expected);
+
+      final result = await aboutRecipeRepository.getRecipe(id);
+
+      expect(result, isA<Recipe>());
+      expect(result.id, 1);
+      expect(result.title, 'Test Recipe');
+      verify(mockAboutRecipeService.getRecipe(id)).called(1);
+    });
+
+    test('likeRecipe likes recipe by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.likeRecipe(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await aboutRecipeRepository.likeRecipe(slug);
+
+      verify(mockAboutRecipeService.likeRecipe(slug: slug)).called(1);
+    });
+
+    test('addToFavorite adds recipe to favorite by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.addToFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await aboutRecipeRepository.addToFavorite(slug);
+
+      verify(mockAboutRecipeService.addToFavorite(slug: slug)).called(1);
+    });
+
+    test('removeFromFavorite removes recipe from favorite by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.removeFromFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await aboutRecipeRepository.removeFromFavorite(slug);
+
+      verify(mockAboutRecipeService.removeFromFavorite(slug: slug)).called(1);
+    });
+
+    test('deleteRecipe deletes recipe by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.deleteRecipe(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await aboutRecipeRepository.deleteRecipe(slug);
+
+      verify(mockAboutRecipeService.deleteRecipe(slug: slug)).called(1);
+    });
+
+    test('getRecipe rethrows exception on error', () async {
+      const id = '1';
+
+      when(mockAboutRecipeService.getRecipe(id)).thenThrow(Exception('Network error'));
+
+      expect(() => aboutRecipeRepository.getRecipe(id), throwsException);
+      verify(mockAboutRecipeService.getRecipe(id)).called(1);
+    });
+
+    test('likeRecipe rethrows exception on error', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.likeRecipe(slug: slug)).thenThrow(Exception('Network error'));
+
+      expect(() => aboutRecipeRepository.likeRecipe(slug), throwsException);
+      verify(mockAboutRecipeService.likeRecipe(slug: slug)).called(1);
+    });
+  });
+}
+

test/features/recipes/repositories/my_recipes_repository_test.dart

@@ -0,0 +1,127 @@
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/recipe/models/my_recipe_model.dart';
+import 'package:eatvio_app/features/recipe/repositories/my_recipes_repository.dart';
+import 'package:eatvio_app/features/recipe/services/my_recipes_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'my_recipes_repository_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyRecipesService>()])
+void main() {
+  group('MyRecipesRepository', () {
+    late MyRecipesRepository myRecipesRepository;
+    late MockMyRecipesService mockMyRecipesService;
+
+    setUp(() {
+      mockMyRecipesService = MockMyRecipesService();
+      myRecipesRepository = MyRecipesRepository(myRecipesService: mockMyRecipesService);
+    });
+
+    test('getMyRecipes returns list of recipes', () async {
+      const expectedPagination = MyRecipePaginationModel(
+        data: [
+          MyRecipeModel(
+            id: 1,
+            image: 'https://someurl.com/img.jpg',
+            state: 'published',
+            cookingTime: 30,
+            activeCookingTime: 20,
+            description: 'Test recipe description',
+            steps: [
+              Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1 description'),
+            ],
+            videoUrl: 'https://someurl.com/video.mp4',
+            title: 'Test Recipe',
+            slug: 'test-recipe',
+            calories: 250.0,
+            likesCount: 5,
+            viewsCount: 10,
+          ),
+        ],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expectedPagination);
+
+      final result = await myRecipesRepository.getMyRecipes();
+
+      expect(result, isA<List<MyRecipeModel>>());
+      expect(result.length, 1);
+      expect(result.first.title, 'Test Recipe');
+      expect(result.first.id, 1);
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+
+    test('getMyRecipes returns empty list', () async {
+      const expectedPagination = MyRecipePaginationModel(
+        data: [],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expectedPagination);
+
+      final result = await myRecipesRepository.getMyRecipes();
+
+      expect(result, isA<List<MyRecipeModel>>());
+      expect(result.length, 0);
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+
+    test('getMyRecipes returns multiple recipes', () async {
+      const expectedPagination = MyRecipePaginationModel(
+        data: [
+          MyRecipeModel(
+            id: 1,
+            image: 'https://someurl.com/img1.jpg',
+            state: 'published',
+            cookingTime: 30,
+            activeCookingTime: 20,
+            description: 'First recipe',
+            steps: null,
+            videoUrl: null,
+            title: 'First Recipe',
+            slug: 'first-recipe',
+            calories: 250.0,
+            likesCount: 5,
+            viewsCount: 10,
+          ),
+          MyRecipeModel(
+            id: 2,
+            image: 'https://someurl.com/img2.jpg',
+            state: 'draft',
+            cookingTime: 45,
+            activeCookingTime: 30,
+            description: 'Second recipe',
+            steps: [
+              Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1'),
+            ],
+            videoUrl: 'https://someurl.com/video.mp4',
+            title: 'Second Recipe',
+            slug: 'second-recipe',
+            calories: 350.0,
+            likesCount: 8,
+            viewsCount: 15,
+          ),
+        ],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expectedPagination);
+
+      final result = await myRecipesRepository.getMyRecipes();
+
+      expect(result, isA<List<MyRecipeModel>>());
+      expect(result.length, 2);
+      expect(result.first.title, 'First Recipe');
+      expect(result.last.title, 'Second Recipe');
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+
+    test('getMyRecipes rethrows exception on error', () async {
+      when(mockMyRecipesService.getMyRecipes()).thenThrow(Exception('Network error'));
+
+      expect(() => myRecipesRepository.getMyRecipes(), throwsException);
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+  });
+}
+

test/features/recipes/services/about_recipe_service_test.dart

@@ -0,0 +1,98 @@
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/recipe/services/about_recipe_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
+
+import 'about_recipe_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<AboutRecipeService>()])
+void main() {
+  group('AboutRecipeService', () {
+    late MockAboutRecipeService mockAboutRecipeService;
+
+    setUp(() {
+      mockAboutRecipeService = MockAboutRecipeService();
+    });
+
+    test('likeRecipe likes recipe by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.likeRecipe(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockAboutRecipeService.likeRecipe(slug: slug);
+
+      verify(mockAboutRecipeService.likeRecipe(slug: slug)).called(1);
+    });
+
+    test('addToFavorite adds recipe to favorite by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.addToFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockAboutRecipeService.addToFavorite(slug: slug);
+
+      verify(mockAboutRecipeService.addToFavorite(slug: slug)).called(1);
+    });
+
+    test('removeFromFavorite removes recipe from favorite by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.removeFromFavorite(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockAboutRecipeService.removeFromFavorite(slug: slug);
+
+      verify(mockAboutRecipeService.removeFromFavorite(slug: slug)).called(1);
+    });
+
+    test('getRecipe returns Recipe by id', () async {
+      const id = '1';
+      const expected = Recipe(
+        id: 1,
+        image: 'https://someurl.com/img.jpg',
+        state: 'active',
+        cookingTime: 30,
+        activeCookingTime: 15,
+        ingredients: [],
+        description: 'Test recipe description',
+        steps: [],
+        videoUrl: null,
+        createdAt: null,
+        updatedAt: null,
+        title: 'Test Recipe',
+        type: 'main',
+        slug: 'test-recipe-slug',
+        commentsCount: 5,
+        wasLikedByMe: false,
+        isFavorite: false,
+        calories: 300.0,
+        servings: 4,
+        likesCount: 10,
+        viewsCount: 100,
+        tags: [],
+        author: Author(authorSlug: '', authorName: '', authorProfileIcon: '', authorIsMe: false),
+      );
+
+      when(mockAboutRecipeService.getRecipe(id)).thenAnswer((_) async => expected);
+
+      final result = await mockAboutRecipeService.getRecipe(id);
+
+      expect(result, isA<Recipe>());
+      expect(result.id, 1);
+      expect(result.title, 'Test Recipe');
+      verify(mockAboutRecipeService.getRecipe(id)).called(1);
+    });
+
+    test('deleteRecipe deletes recipe by slug', () async {
+      const slug = 'test-recipe-slug';
+
+      when(mockAboutRecipeService.deleteRecipe(slug: slug)).thenAnswer((_) async => Future.value());
+
+      await mockAboutRecipeService.deleteRecipe(slug: slug);
+
+      verify(mockAboutRecipeService.deleteRecipe(slug: slug)).called(1);
+    });
+  });
+}
+

test/features/recipes/services/my_recipes_service_test.dart

@@ -0,0 +1,151 @@
+import 'package:eatvio_app/features/feed/models/recipes_model.dart';
+import 'package:eatvio_app/features/recipe/models/my_recipe_model.dart';
+import 'package:eatvio_app/features/recipe/services/my_recipes_service.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+
+import 'my_recipes_service_test.mocks.dart';
+
+@GenerateNiceMocks([MockSpec<MyRecipesService>()])
+void main() {
+  group('MyRecipesService', () {
+    late MockMyRecipesService mockMyRecipesService;
+
+    setUp(() {
+      mockMyRecipesService = MockMyRecipesService();
+    });
+
+    test('getMyRecipes returns pagination with recipes', () async {
+      const expected = MyRecipePaginationModel(
+        data: [
+          MyRecipeModel(
+            id: 1,
+            image: 'https://someurl.com/img.jpg',
+            state: 'published',
+            cookingTime: 30,
+            activeCookingTime: 20,
+            description: 'Test recipe description',
+            steps: [
+              Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1 description'),
+              Step(image: 'https://someurl.com/step2.jpg', description: 'Step 2 description'),
+            ],
+            videoUrl: 'https://someurl.com/video.mp4',
+            title: 'Test Recipe',
+            slug: 'test-recipe',
+            calories: 250.0,
+            likesCount: 5,
+            viewsCount: 10,
+          ),
+        ],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expected);
+
+      final result = await mockMyRecipesService.getMyRecipes();
+
+      expect(result, isA<MyRecipePaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.title, 'Test Recipe');
+      expect(result.data.first.id, 1);
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+
+    test('getMyRecipes returns pagination with multiple recipes', () async {
+      const expected = MyRecipePaginationModel(
+        data: [
+          MyRecipeModel(
+            id: 1,
+            image: 'https://someurl.com/img1.jpg',
+            state: 'published',
+            cookingTime: 30,
+            activeCookingTime: 20,
+            description: 'First recipe description',
+            steps: [
+              Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1'),
+            ],
+            videoUrl: 'https://someurl.com/video1.mp4',
+            title: 'First Recipe',
+            slug: 'first-recipe',
+            calories: 250.0,
+            likesCount: 5,
+            viewsCount: 10,
+          ),
+          MyRecipeModel(
+            id: 2,
+            image: 'https://someurl.com/img2.jpg',
+            state: 'draft',
+            cookingTime: 45,
+            activeCookingTime: 30,
+            description: 'Second recipe description',
+            steps: null,
+            videoUrl: null,
+            title: 'Second Recipe',
+            slug: 'second-recipe',
+            calories: 350.0,
+            likesCount: 8,
+            viewsCount: 15,
+          ),
+        ],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expected);
+
+      final result = await mockMyRecipesService.getMyRecipes();
+
+      expect(result, isA<MyRecipePaginationModel>());
+      expect(result.data.length, 2);
+      expect(result.data.first.title, 'First Recipe');
+      expect(result.data.last.title, 'Second Recipe');
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+
+    test('getMyRecipes returns empty pagination', () async {
+      const expected = MyRecipePaginationModel(
+        data: [],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expected);
+
+      final result = await mockMyRecipesService.getMyRecipes();
+
+      expect(result, isA<MyRecipePaginationModel>());
+      expect(result.data.length, 0);
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+
+    test('getMyRecipes returns recipe with null steps and videoUrl', () async {
+      const expected = MyRecipePaginationModel(
+        data: [
+          MyRecipeModel(
+            id: 3,
+            image: 'https://someurl.com/img3.jpg',
+            state: 'draft',
+            cookingTime: 15,
+            activeCookingTime: 10,
+            description: 'Simple recipe without steps',
+            steps: null,
+            videoUrl: null,
+            title: 'Simple Recipe',
+            slug: 'simple-recipe',
+            calories: 150.0,
+            likesCount: 2,
+            viewsCount: 5,
+          ),
+        ],
+      );
+
+      when(mockMyRecipesService.getMyRecipes()).thenAnswer((_) async => expected);
+
+      final result = await mockMyRecipesService.getMyRecipes();
+
+      expect(result, isA<MyRecipePaginationModel>());
+      expect(result.data.length, 1);
+      expect(result.data.first.steps, isNull);
+      expect(result.data.first.videoUrl, isNull);
+      expect(result.data.first.state, 'draft');
+      verify(mockMyRecipesService.getMyRecipes()).called(1);
+    });
+  });
+}
+