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

import 'package:dio/dio.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_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/order_id_to_conversation_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/models/chosen_plan_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 '../../../fixtures/fixture_reader.dart';
import 'chat_service_test.mocks.dart';

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

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

    test('getChatRooms - возвращает список комнат чата', () async {
      final paginationFixture = FixtureReader.readAsMap(
        'chat/chat_room_pagination_response.json',
      );
      final expectedPagination = ChatRoomPaginationModel.fromJson(
        paginationFixture,
      );

      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, 2);
      verify(mockChatService.getChatRooms(query: null, page: 1)).called(1);
    });

    test('getChatRooms - возвращает список комнат с запросом', () async {
      const query = 'test query';
      final paginationFixture = FixtureReader.readAsMap(
        'chat/chat_room_pagination_response.json',
      );
      final expectedPagination = ChatRoomPaginationModel.fromJson(
        paginationFixture,
      );

      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 = 'chat-1';
      final roomFixture = FixtureReader.readAsMap(
        'chat/chat_room_response.json',
      );
      final expectedRoom = chat_room.ChatRoomModel.fromJson(roomFixture);

      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';
      final messageFixture = FixtureReader.readAsMap(
        'chat/chat_message_response.json',
      );
      final expectedMessage = ChatMessageModel.fromJson(messageFixture);

      // ignore: null_argument_to_non_null_type
      when(
        mockChatService.sendMessage(
          slug: slug,
          data: data,
          mediaData: null,
          socketId: socketId,
        ),
      ).thenAnswer((_) async => expectedMessage);

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

      expect(result, isA<ChatMessageModel>());
      expect(result.data, data);
      verify(
        mockChatService.sendMessage(
          slug: slug,
          data: data,
          mediaData: null,
          socketId: socketId,
        ),
      ).called(1);
    });

    test('getChatMessages - возвращает сообщения чата', () async {
      const chatId = 'chat-1';
      const page = 1;
      final messagesFixture = FixtureReader.readAsMap(
        'chat/chat_messages_response.json',
      );
      final expectedMessages = ChatMessagesModel.fromJson(messagesFixture);

      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, 2);
      verify(mockChatService.getChatMessages(id: chatId, page: page)).called(1);
    });

    test(
      'getChatRoomIdByUserSlug - возвращает комнату по slug пользователя',
      () async {
        const slug = 'user-1';
        final roomFixture = FixtureReader.readAsMap(
          'chat/chat_room_response.json',
        );
        final expectedRoom = chat_room.ChatRoomModel.fromJson(roomFixture);

        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 paymentFixture = FixtureReader.readAsMap(
        'chat/payments/payment_response.json',
      );
      final expectedPayment = PaymentModel.fromJson(paymentFixture);

      when(
        mockChatService.getPaymentLink(id: planId, body: {'payment_provider': 'mock'}),
      ).thenAnswer((_) async => expectedPayment);

      final result = await mockChatService.getPaymentLink(
        id: planId,
        body: {'payment_provider': 'mock'},
      );

      expect(result, isA<PaymentModel>());
      expect(result.paymentUrl, 'https://example.com/checkout/payment-123');
      verify(mockChatService.getPaymentLink(id: planId, body: {'payment_provider': 'mock'})).called(1);
    });

    test(
      'getPaymentLink - возвращает ссылку на оплату alfa-bank',
      () async {
        const planId = 123;
        final requestFixture = FixtureReader.readAsMap(
          'chat/payments/payment_alfabank_request.json',
        );
        final requestBody = Map<String, String>.from(requestFixture);
        final paymentFixture = FixtureReader.readAsMap(
          'chat/payments/payment_response_alfa_bank.json',
        );
        final expectedPayment = PaymentModel.fromJson(paymentFixture);

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

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

        expect(result, isA<PaymentModel>());
        expect(result.paymentUrl, 'https://qr.nspk.ru/ASDFASDFASDFASDF');
        expect(result.orderId, 'alfa_c29_k15138_t1712345678_r1234');
        expect(result.paymentProvider, 'alfa-bank');
        verify(
          mockChatService.getPaymentLink(id: planId, body: requestBody),
        ).called(1);
      },
    );

    test('getChosenPlan - возвращает выбранный план', () async {
      const planId = 1;
      final chosenPlanFixture = FixtureReader.readAsMap(
        'chat/chosen_plan/chosen_plan_in_progress_response.json',
      );
      final expectedPlan = ChosenPlanModel.fromJson(chosenPlanFixture);

      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 complainFixture = FixtureReader.readAsMap(
          'chat/plan_complain_response.json',
        );
        final complainModel = PlanComplainModel.fromJson(complainFixture);

        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(
      'resolveOrderIdToConversation - возвращает модель по orderId',
      () async {
        const orderId = 'alfa_c29_k15138_t1712345678_r1234';
        final fixture = FixtureReader.readAsMap(
          'chat/payments/order_id_to_chat_uuid_response.json',
        );
        final expected = OrderIdToConversationModel.fromJson(fixture);

        when(
          mockChatService.resolveOrderIdToConversation(orderId: orderId),
        ).thenAnswer((_) async => expected);

        final result = await mockChatService.resolveOrderIdToConversation(
          orderId: orderId,
        );

        expect(result, isA<OrderIdToConversationModel>());
        expect(result.chosenPlanId, 12);
        verify(
          mockChatService.resolveOrderIdToConversation(orderId: orderId),
        ).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);
    });
  });
}