eatvio_app/test/features/chat/services/chat_service_test.dart

import 'package:dio/dio.dart';
import 'package:eatvio_app/core/models/pagination_model.dart';
import 'package:eatvio_app/features/chat/models/chat_message_model.dart';
import 'package:eatvio_app/features/chat/models/chat_messages_model.dart';
import 'package:eatvio_app/features/chat/models/chat_meta_model.dart';
import 'package:eatvio_app/features/chat/models/chat_room_model.dart' as chat_room;
import 'package:eatvio_app/features/chat/models/chat_room_pagination_model.dart';
import 'package:eatvio_app/features/chat/models/chat_room_settings_model.dart';
import 'package:eatvio_app/features/chat/models/chat_user_model.dart';
import 'package:eatvio_app/features/chat/models/payment_model.dart';
import 'package:eatvio_app/features/chat/models/plan_complain_model.dart';
import 'package:eatvio_app/features/chat/services/chat_service.dart';
import 'package:eatvio_app/features/plans/enums/chosen_plan_state_enum.dart';
import 'package:eatvio_app/features/plans/models/chosen_plan_model.dart';
import 'package:eatvio_app/features/feed/models/plan_pagination_model.dart';
import 'package:eatvio_app/features/feed/models/diets_pagination_model.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'package:retrofit/retrofit.dart';
import 'chat_service_test.mocks.dart';

@GenerateNiceMocks([MockSpec<ChatService>()])
void main() {
  group('ChatService', () {
    late MockChatService mockChatService;

    setUp(() {
      mockChatService = MockChatService();
    });

    test('getChatRooms - возвращает список комнат чата', () async {
      const expectedPagination = ChatRoomPaginationModel(
        data: [],
        unreadChatsCount: 0,
        meta: Meta(
          currentPage: 1,
          from: null,
          lastPage: 1,
          links: [],
          perPage: 10,
          to: null,
          total: 0,
        ),
      );

      when(mockChatService.getChatRooms(query: null, page: 1))
          .thenAnswer((_) async => expectedPagination);

      final result = await mockChatService.getChatRooms(query: null, page: 1);

      expect(result, isA<ChatRoomPaginationModel>());
      expect(result.data.length, 0);
      verify(mockChatService.getChatRooms(query: null, page: 1)).called(1);
    });

    test('getChatRooms - возвращает список комнат с запросом', () async {
      const query = 'test query';
      const expectedPagination = ChatRoomPaginationModel(
        data: [],
        unreadChatsCount: 0,
        meta: Meta(
          currentPage: 1,
          from: null,
          lastPage: 1,
          links: [],
          perPage: 10,
          to: null,
          total: 0,
        ),
      );

      when(mockChatService.getChatRooms(query: query, page: 1))
          .thenAnswer((_) async => expectedPagination);

      final result = await mockChatService.getChatRooms(query: query, page: 1);

      expect(result, isA<ChatRoomPaginationModel>());
      verify(mockChatService.getChatRooms(query: query, page: 1)).called(1);
    });

    test('getChatRoom - возвращает комнату чата по UUID', () async {
      const uuid = 'room-uuid-123';
      const expectedRoom = chat_room.ChatRoomModel(
        id: uuid,
        chatRoomSettings: ChatRoomSettingsModel(
          name: 'Test Room',
          state: 'active',
        ),
        users: chat_room.Users(
          sender: ChatUserModel(
            id: 1,
            slug: 'user-1',
            name: 'User 1',
            profilePhotoUrl: null,
          ),
          receiver: ChatUserModel(
            id: 2,
            slug: 'user-2',
            name: 'User 2',
            profilePhotoUrl: null,
          ),
        ),
        chosenPlanId: null,
      );

      when(mockChatService.getChatRoom(uuid: uuid))
          .thenAnswer((_) async => expectedRoom);

      final result = await mockChatService.getChatRoom(uuid: uuid);

      expect(result, isA<chat_room.ChatRoomModel>());
      expect(result.id, uuid);
      verify(mockChatService.getChatRoom(uuid: uuid)).called(1);
    });

    test('sendMessage - отправляет сообщение', () async {
      const slug = 'user-slug';
      const data = 'Test message';
      const socketId = 'socket-id-123';

      when(mockChatService.sendMessage(
        slug: slug,
        data: data,
        mediaData: null,
        socketId: socketId,
      )).thenAnswer((_) async => Future.value());

      await mockChatService.sendMessage(
        slug: slug,
        data: data,
        mediaData: null,
        socketId: socketId,
      );

      verify(mockChatService.sendMessage(
        slug: slug,
        data: data,
        mediaData: null,
        socketId: socketId,
      )).called(1);
    });

    test('getChatMessages - возвращает сообщения чата', () async {
      const chatId = 'chat-id-123';
      const page = 1;
      final expectedMessages = ChatMessagesModel(
        messagesList: [
          ChatMessageModel(
            id: 1,
            data: 'Message 1',
            mediaData: null,
            authorId: 1,
            updatedAt: DateTime.now(),
            isRead: false,
            isCurrentUserAuthor: true,
            roomId: chatId,
          ),
        ],
        meta: const ChatMetaModel(lastPage: 1),
      );

      when(mockChatService.getChatMessages(id: chatId, page: page))
          .thenAnswer((_) async => expectedMessages);

      final result = await mockChatService.getChatMessages(id: chatId, page: page);

      expect(result, isA<ChatMessagesModel>());
      expect(result.messagesList.length, 1);
      verify(mockChatService.getChatMessages(id: chatId, page: page)).called(1);
    });

    test('getChatRoomIdByUserSlug - возвращает комнату по slug пользователя', () async {
      const slug = 'user-slug';
      const expectedRoom = chat_room.ChatRoomModel(
        id: 'room-id',
        chatRoomSettings: ChatRoomSettingsModel(
          name: 'Test Room',
          state: 'active',
        ),
        users: chat_room.Users(
          sender: ChatUserModel(
            id: 1,
            slug: slug,
            name: 'User',
            profilePhotoUrl: null,
          ),
          receiver: ChatUserModel(
            id: 2,
            slug: 'other-user',
            name: 'Other User',
            profilePhotoUrl: null,
          ),
        ),
        chosenPlanId: null,
      );

      when(mockChatService.getChatRoomIdByUserSlug(user: slug))
          .thenAnswer((_) async => expectedRoom);

      final result = await mockChatService.getChatRoomIdByUserSlug(user: slug);

      expect(result, isA<chat_room.ChatRoomModel>());
      verify(mockChatService.getChatRoomIdByUserSlug(user: slug)).called(1);
    });

    test('markMessagesAsRead - отмечает сообщения как прочитанные', () async {
      const chatId = 'chat-id-123';
      final messageIds = [1, 2, 3];

      when(mockChatService.markMessagesAsRead(
        id: chatId,
        body: {'messages_ids': messageIds},
      )).thenAnswer((_) async => Future.value());

      await mockChatService.markMessagesAsRead(
        id: chatId,
        body: {'messages_ids': messageIds},
      );

      verify(mockChatService.markMessagesAsRead(
        id: chatId,
        body: {'messages_ids': messageIds},
      )).called(1);
    });

    test('cancelChosenPlan - отменяет выбранный план', () async {
      const planId = 123;

      when(mockChatService.cancelChosenPlan(id: planId))
          .thenAnswer((_) async => Future.value());

      await mockChatService.cancelChosenPlan(id: planId);

      verify(mockChatService.cancelChosenPlan(id: planId)).called(1);
    });

    test('choseStartPlanDate - выбирает дату начала плана', () async {
      const planId = 123;
      final date = {'start_date': '2024-01-15'};

      when(mockChatService.choseStartPlanDate(id: planId, date: date))
          .thenAnswer((_) async => Future.value());

      await mockChatService.choseStartPlanDate(id: planId, date: date);

      verify(mockChatService.choseStartPlanDate(id: planId, date: date)).called(1);
    });

    test('getPaymentLink - возвращает ссылку на оплату', () async {
      const planId = 123;
      final expectedPayment = PaymentModel(paymentUrl: 'https://payment.url');

      when(mockChatService.getPaymentLink(id: planId))
          .thenAnswer((_) async => expectedPayment);

      final result = await mockChatService.getPaymentLink(id: planId);

      expect(result, isA<PaymentModel>());
      expect(result.paymentUrl, 'https://payment.url');
      verify(mockChatService.getPaymentLink(id: planId)).called(1);
    });

    test('getChosenPlan - возвращает выбранный план', () async {
      const planId = 123;
      final expectedPlan = ChosenPlanModel(
        id: planId,
        optionType: 'standard',
        startDate: DateTime.now(),
        chosenPlanState: ChosenPlanStateEnum.stateInCoordination,
        chatId: 'chat-id',
        consultantId: 1,
        plan: const PlanModel(
          id: 456,
          slug: 'plan-slug',
          name: 'Test Plan',
          image: '',
          duration: 30,
          state: 'active',
          type: PlanType(
            fit: true,
            slim: false,
            behavior: false,
            wellness: false,
          ),
          details: '',
          packetsCount: 1,
          author: Author(
            authorSlug: 'author',
            authorName: 'Author',
            authorProfileIcon: '',
            authorIsMe: false,
          ),
          totalLikes: 0,
          totalViews: 0,
          totalComments: 0,
          isFavorite: false,
          minPriceOfOptions: 0.0,
          maxPriceOfOptions: 100.0,
          wasLikedByMe: false,
        ),
      );

      when(mockChatService.getChosenPlan(id: planId))
          .thenAnswer((_) async => expectedPlan);

      final result = await mockChatService.getChosenPlan(id: planId);

      expect(result, isA<ChosenPlanModel>());
      expect(result.id, planId);
      verify(mockChatService.getChosenPlan(id: planId)).called(1);
    });

    test('finishChosenPlan - завершает выбранный план', () async {
      const planId = 123;

      when(mockChatService.finishChosenPlan(id: planId))
          .thenAnswer((_) async => Future.value());

      await mockChatService.finishChosenPlan(id: planId);

      verify(mockChatService.finishChosenPlan(id: planId)).called(1);
    });

    test('complainAboutConsultation - отправляет жалобу на консультацию', () async {
      const planId = 123;
      final complainModel = PlanComplainModel(description: 'Test complaint');

      when(mockChatService.complainAboutConsultation(id: planId, body: complainModel))
          .thenAnswer((_) async => Future.value());

      await mockChatService.complainAboutConsultation(id: planId, body: complainModel);

      verify(mockChatService.complainAboutConsultation(id: planId, body: complainModel))
          .called(1);
    });

    test('getChatByUserSlug - возвращает HttpResponse', () async {
      const slug = 'user-slug';
      const chatId = 'chat-id-123';
      final response = HttpResponse(
        {'id': chatId},
        Response(
          requestOptions: RequestOptions(path: ''),
          statusCode: 200,
        ),
      );

      when(mockChatService.getChatByUserSlug(slug: slug))
          .thenAnswer((_) async => response);

      final result = await mockChatService.getChatByUserSlug(slug: slug);

      expect(result, isA<HttpResponse>());
      expect(result.data['id'], chatId);
      verify(mockChatService.getChatByUserSlug(slug: slug)).called(1);
    });
  });
}