fix: analyzer issue

Reviewed-on: eatvio/eatvio_app#780

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(
+                        Expanded(
-                          onTap: () {
+                          child: GestureDetector(
-                            GoRouter.of(context).pushNamed(UserDetailsScreen.name, extra: customerProfile!.slug);
+                            onTap: () {
-                          },
+                              GoRouter.of(context).pushNamed(UserDetailsScreen.name, extra: customerProfile!.slug);
-                          child: InfoBouble(
+                            },
-                            radius: 12,
+                            child: InfoBouble(
-                            backgroundColor: appTheme.whiteA700,
+                              radius: 12,
-                            children: [Text('Анкета пользователя', style: TextStyles.textMMediumAuto.copyWith(color: appTheme.blueA400))],
+                              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(
+      decoration: BoxDecoration(color: backgroundColor ?? appTheme.gray50, borderRadius: BorderRadius.circular(radius)),
-        color: backgroundColor ?? appTheme.gray50,
+      child: Row(mainAxisSize: MainAxisSize.min, mainAxisAlignment: mainAxisAlignment, children: children),
-        borderRadius: BorderRadius.circular(radius),
-      ),
-      child: Row(mainAxisSize: MainAxisSize.min, 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(
+    return GestureDetector(
-      crossAxisAlignment: CrossAxisAlignment.start,
+      onTap: onTap,
-      children: [
+      child: Column(
-        Row(
+        crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
+        children: [
-            Expanded(
+          Row(
-              child: Text(notificationsText, style: TextStyles.textMMedium.copyWith(color: appTheme.black)),
+            children: [
-            ),
+              Expanded(
-            if (!isRead)
+                child: Text(notificationsText, style: TextStyles.textMMedium.copyWith(color: appTheme.black)),
-              Container(
-                decoration: BoxDecoration(color: appTheme.blueA400, shape: BoxShape.circle),
-                width: 8,
-                height: 8,
               ),
-          ],
+              if (!isRead)
-        ),
+                Container(
-        const SizedBox(height: 4),
+                  decoration: BoxDecoration(color: appTheme.blueA400, shape: BoxShape.circle),
-        Text(
+                  width: 8,
-          '${createdAt.day} ${_getMonthName(createdAt.month)} ${createdAt.hour.toString().padLeft(2, '0')}:${createdAt.minute.toString().padLeft(2, '0')}',
+                  height: 8,
-          style: TextStyles.textSMedium.copyWith(color: appTheme.gray600),
+                ),
-        ),
+            ],
-      ],
+          ),
+          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({
+  const PaymentBanner({super.key, required this.successfulPayment});
-    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),
+      padding: const EdgeInsets.symmetric(vertical: 16),
-        child: Stack(children: [
+      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,
+                color: widget.successfulPayment ? appTheme.blueA400 : appTheme.strongRed,
-                  borderRadius: const BorderRadius.only(topRight: Radius.circular(20), bottomRight: Radius.circular(20))),
+                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(
+                        child: Text(s.cunsutation_was_paid_successfully, style: TextStyles.textLSemibold.copyWith(color: appTheme.black)),
-                          s.cunsutation_was_paid_successfully,
-                          style: TextStyles.textLSemibold.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 8,
                       ),
+                      const SizedBox(height: 8),
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
+                        child: Text(s.wait_for_start_day, style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black)),
-                          s.wait_for_start_day,
-                          style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 16,
                       ),
+                      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: ButtonStyle(
-                                  ButtonStyle(side: const WidgetStatePropertyAll(BorderSide.none), backgroundColor: WidgetStatePropertyAll(appTheme.blueA400)),
+                                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: ButtonStyle(
-                                  ButtonStyle(side: const WidgetStatePropertyAll(BorderSide.none), backgroundColor: WidgetStatePropertyAll(appTheme.blueA400)),
+                                side: const WidgetStatePropertyAll(BorderSide.none),
+                                backgroundColor: WidgetStatePropertyAll(appTheme.blueA400),
+                              ),
                               onPressed: () {
                                 GoRouter.of(context).pop();
                               },
-                            )
+                            ),
                     ]
                   : [
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
+                        child: Text(s.smth_went_wrong_payment_failed, style: TextStyles.textLSemibold.copyWith(color: appTheme.black)),
-                          s.smth_went_wrong_payment_failed,
-                          style: TextStyles.textLSemibold.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 8,
                       ),
+                      const SizedBox(height: 8),
                       SizedBox(
                         width: size.width * 0.6,
-                        child: Text(
+                        child: Text(s.try_again_2, style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black)),
-                          s.try_again_2,
-                          style: TextStyles.textMMediumAuto.copyWith(color: appTheme.black),
-                        ),
-                      ),
-                      const SizedBox(
-                        height: 16,
                       ),
+                      const SizedBox(height: 16),
                       isLoading
                           ? const Center(child: Loader())
                           : CustomOutlinedButton(
                               text: s.pay,
                               height: 52,
                               buttonTextStyle: TextStyles.textMSemibold.copyWith(color: appTheme.whiteA700),
-                              buttonStyle:
+                              buttonStyle: ButtonStyle(
-                                  ButtonStyle(side: const WidgetStatePropertyAll(BorderSide.none), backgroundColor: WidgetStatePropertyAll(appTheme.blueA400)),
+                                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(
+                                  GoRouter.of(context).pushReplacement(PaymentScreen.path, extra: {'url': paymentLink, 'planId': planId});
-                                    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 = [];
+  List<CircumferenceModel> circumferencePoints = [];  int _selectedChipIndex = 0;
-  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

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/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/widgets/basic_widget_test.dart

@@ -0,0 +1,278 @@
+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/feed/models/recipes_model.dart' as recipes;
+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/presentation/widgets/my_recipe_widget.dart';
+import 'package:eatvio_app/features/recipe/presentation/widgets/my_recipes_tab.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: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<MyRecipesRepository>(), MockSpec<AboutRecipeRepository>()])
+void main() {
+  group('MyRecipes Basic Widget Tests', () {
+    late MockMyRecipesRepository mockMyRecipesRepository;
+    late MockAboutRecipeRepository mockAboutRecipeRepository;
+    late MyRecipesCubit myRecipesCubit;
+
+    const testRecipe = MyRecipeModel(
+      id: 1,
+      image: 'test-image.jpg',
+      state: 'active',
+      cookingTime: 30,
+      activeCookingTime: 20,
+      description: 'Test recipe description',
+      steps: [
+        recipes.Step(image: 'https://someurl.com/step1.jpg', description: 'Step 1 description'),
+        recipes.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,
+    );
+
+    setUp(() async {
+      await sl.reset();
+      dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+      mockMyRecipesRepository = MockMyRecipesRepository();
+      mockAboutRecipeRepository = MockAboutRecipeRepository();
+      myRecipesCubit = MyRecipesCubit(myRecipesRepository: mockMyRecipesRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+      sl.registerLazySingleton<AppConfig>(() => AppConfig(buildType: AppBuildType.tests)..setBaseUrl('http://localhost'));
+    });
+
+    tearDown(() async {
+      await Future.delayed(const Duration(milliseconds: 100));
+      if (!myRecipesCubit.isClosed) {
+        myRecipesCubit.close();
+      }
+    });
+
+    Widget createTestWidget(Widget child, {bool wrapInScaffold = true}) {
+      final widget = BlocProvider<MyRecipesCubit>(
+        create: (context) => myRecipesCubit,
+        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 MyRecipesCubit successfully', (WidgetTester tester) async {
+      // Arrange & Act
+      final cubit = MyRecipesCubit(myRecipesRepository: mockMyRecipesRepository, aboutRecipeRepository: mockAboutRecipeRepository);
+
+      // Assert
+      expect(cubit, isA<MyRecipesCubit>());
+      expect(cubit.state, isA<MyRecipesStateLoading>());
+
+      cubit.close();
+    });
+
+    testWidgets('should display MyRecipesTab with all tabs', (WidgetTester tester) async {
+      // Arrange
+      const widget = MyRecipesTab();
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.byType(MyRecipesTab), findsOneWidget);
+      expect(find.byType(AnimatedOptionButton), findsNWidgets(2));
+    });
+
+    testWidgets('should handle tab selection in MyRecipesTab', (WidgetTester tester) async {
+      // Arrange
+      bool callbackCalled = false;
+      final widget = MyRecipesTab(
+        additionalOnTap: () {
+          callbackCalled = true;
+        },
+      );
+
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Act
+      final tabButtons = find.byType(AnimatedOptionButton);
+      expect(tabButtons, findsNWidgets(2));
+
+      await tester.tap(tabButtons.at(0));
+      await tester.pump();
+
+      // Assert
+      expect(callbackCalled, true);
+    });
+
+    testWidgets('should display MyRecipeWidget with recipe title', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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 Recipe'), findsOneWidget);
+      expect(find.byType(MyRecipeWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyRecipeWidget with description when description is present', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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 Recipe'), findsOneWidget);
+      expect(find.byType(MyRecipeWidget), findsOneWidget);
+    });
+
+    testWidgets('should display MyRecipeWidget buttons', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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(MyRecipeWidget), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyRecipeWidget with cooking time', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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(MyRecipeWidget), findsOneWidget);
+      expect(find.text('Test Recipe'), findsOneWidget);
+    });
+
+    testWidgets('should display MyRecipeWidget with steps count', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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(MyRecipeWidget), findsOneWidget);
+      expect(find.text('Test Recipe'), findsOneWidget);
+    });
+
+    testWidgets('should display MyRecipeWidget with calories', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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(MyRecipeWidget), findsOneWidget);
+      expect(find.text('Test Recipe'), findsOneWidget);
+    });
+
+    testWidgets('should display MyRecipeWidget with null steps', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      final recipeWithoutSteps = testRecipe.copyWith(steps: null);
+      final widget = MyRecipeWidget(recipe: recipeWithoutSteps);
+
+      // 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(MyRecipeWidget), findsOneWidget);
+      expect(find.text('Test Recipe'), findsOneWidget);
+    });
+
+    testWidgets('should display MyRecipeWidget structure correctly', (WidgetTester tester) async {
+      // Arrange
+      myRecipesCubit.emit(const MyRecipesState.loaded(recipes: [testRecipe], selectedState: 'active'));
+      const widget = MyRecipeWidget(recipe: testRecipe);
+
+      // 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(MyRecipeWidget), findsOneWidget);
+      expect(find.text('Test Recipe'), findsOneWidget);
+      expect(find.byType(CustomOutlinedButton), findsWidgets);
+    });
+
+    testWidgets('should display MyRecipesTab structure correctly', (WidgetTester tester) async {
+      // Arrange
+      const widget = MyRecipesTab();
+
+      // Act
+      await tester.pumpWidget(createTestWidget(widget));
+      await tester.pumpAndSettle();
+
+      // Assert
+      expect(find.byType(MyRecipesTab), findsOneWidget);
+      expect(find.byType(AnimatedOptionButton), findsNWidgets(2));
+    });
+  });
+}

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/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);
+    });
+  });
+}
+