eatvio_app/test/features/consultations/services/consultation_service_test.dart

import 'package:dio/dio.dart';
import 'package:eatvio_app/core/enums/filters_comparison_enum.dart';
import 'package:eatvio_app/features/consultations/models/consultation_model.dart';
import 'package:eatvio_app/features/consultations/services/consultation_service.dart';
import 'package:eatvio_app/features/finances_and_consultations_archive/models/consultant_finance_model.dart';
import 'package:eatvio_app/features/finances_and_consultations_archive/models/statistic_model.dart';
import 'package:eatvio_app/features/finances_and_consultations_archive/models/user_purchases_model.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';

import 'consultation_service_test.mocks.dart';

@GenerateMocks([Dio])
void main() {
  group('ConsultationService', () {
    late ConsultationService service;
    late MockDio mockDio;

    setUp(() {
      mockDio = MockDio();
      service = ConsultationService(mockDio);
    });

    test('getConsultations - успешное получение консультаций', () async {
      final mockData = {
        'data': [],
        'links': {},
        'meta': {'current_page': 1, 'last_page': 1, 'total': 0, 'per_page': 10},
      };

      when(mockDio.get('/api/consultations', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/consultations'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getConsultations();

      expect(result, isA<ConsultationPaginationModel>());
      verify(
        mockDio.get(
          '/api/consultations',
          queryParameters: {
            'filters[last_state][\$notIn][]': const [
              'initied',
              'in_coordination',
              'start_date_has_been_set',
              'pending_payment',
              'canceled_by_the_initiator',
              'charge_was_collected',
            ],
            'sort[]': 'created_at:desc',
          },
        ),
      ).called(1);
    });

    test('getConsultations - пробрасывает ошибку', () async {
      when(mockDio.get(any, queryParameters: anyNamed('queryParameters'))).thenThrow(DioException(requestOptions: RequestOptions(path: '/api/consultations')));

      expect(() => service.getConsultations(), throwsA(isA<DioException>()));
    });

    test('getFilteredConsultations - успешное получение с фильтрами notInArray', () async {
      final mockData = {
        'data': [],
        'links': {},
        'meta': {'current_page': 1, 'last_page': 1, 'total': 0, 'per_page': 10},
      };

      when(mockDio.get('/api/consultations', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/consultations'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getFilteredConsultations(stateComparison: FiltersComparisonEnum.notInArray);

      expect(result, isA<ConsultationPaginationModel>());
      verify(
        mockDio.get(
          '/api/consultations',
          queryParameters: {
            'filters[last_state][\$notIn][]': const [
              'initied',
              'in_coordination',
              'start_date_has_been_set',
              'pending_payment',
              'canceled_by_the_initiator',
              'charge_was_collected',
            ],
            'sort[]': 'created_at:desc',
          },
        ),
      ).called(1);
    });

    test('getFilteredConsultations - успешное получение с фильтром state', () async {
      final mockData = {
        'data': [],
        'links': {},
        'meta': {'current_page': 1, 'last_page': 1, 'total': 0, 'per_page': 10},
      };

      when(mockDio.get('/api/consultations', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/consultations'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getFilteredConsultations(state: 'done', stateComparison: FiltersComparisonEnum.equal);

      expect(result, isA<ConsultationPaginationModel>());
      verify(mockDio.get('/api/consultations', queryParameters: {'filters[last_state][\$eq]': 'done', 'sort[]': 'created_at:desc'})).called(1);
    });

    test('getFilteredConsultations - успешное получение с фильтром date', () async {
      final mockData = {
        'data': [],
        'links': {},
        'meta': {'current_page': 1, 'last_page': 1, 'total': 0, 'per_page': 10},
      };

      when(mockDio.get('/api/consultations', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/consultations'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getFilteredConsultations(date: '2024-01-01', dateComparison: FiltersComparisonEnum.greaterThan);

      expect(result, isA<ConsultationPaginationModel>());
      verify(mockDio.get('/api/consultations', queryParameters: {'filters[start_date][\$gt]': '2024-01-01', 'sort[]': 'created_at:desc'})).called(1);
    });

    test('getFilteredConsultations - пробрасывает ошибку', () async {
      when(mockDio.get(any, queryParameters: anyNamed('queryParameters'))).thenThrow(DioException(requestOptions: RequestOptions(path: '/api/consultations')));

      expect(() => service.getFilteredConsultations(), throwsA(isA<DioException>()));
    });

    test('getStatistics - успешное получение статистики', () async {
      final mockData = {'total': 10, 'in_progress': 5, 'finished': 3, 'canceled': 2};

      when(mockDio.get('/api/consultations/statistics')).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/consultations/statistics'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getStatistics();

      expect(result, isA<StatisticModel>());
      expect(result.total, 10);
      expect(result.inProgress, 5);
      expect(result.finished, 3);
      expect(result.canceled, 2);
      verify(mockDio.get('/api/consultations/statistics')).called(1);
    });

    test('getStatistics - пробрасывает ошибку', () async {
      when(mockDio.get('/api/consultations/statistics')).thenThrow(DioException(requestOptions: RequestOptions(path: '/api/consultations/statistics')));

      expect(() => service.getStatistics(), throwsA(isA<DioException>()));
    });

    test('getConsultantFinances - успешное получение финансов', () async {
      final mockData = {
        'data': [
          {
            'start_date': '2024-01-01T00:00:00Z',
            'bank_id': 'bank-1',
            'title': 'Consultation',
            'clientName': 'Client Name',
            'duration': 60,
            'payment_price': 100000,
            'payment_status': 'COMPLETED',
          },
        ],
      };

      when(mockDio.get('/api/finances/my_finances', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/finances/my_finances'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getConsultantFinances(null, null);

      expect(result, isA<List<ConsultantFinanceModel>>());
      expect(result.length, 1);
      verify(mockDio.get('/api/finances/my_finances', queryParameters: {'sort[]': 'start_date:desc'})).called(1);
    });

    test('getConsultantFinances - успешное получение с фильтром date', () async {
      final mockData = {'data': []};

      when(mockDio.get('/api/finances/my_finances', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/finances/my_finances'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getConsultantFinances('2024-01-01', FiltersComparisonEnum.equal);

      expect(result, isA<List<ConsultantFinanceModel>>());
      verify(mockDio.get('/api/finances/my_finances', queryParameters: {'filters[start_date][\$eq]': '2024-01-01', 'sort[]': 'start_date:desc'})).called(1);
    });

    test('getConsultantFinances - пробрасывает ошибку', () async {
      when(
        mockDio.get(any, queryParameters: anyNamed('queryParameters')),
      ).thenThrow(DioException(requestOptions: RequestOptions(path: '/api/finances/my_finances')));

      expect(() => service.getConsultantFinances(null, null), throwsA(isA<DioException>()));
    });

    test('getUserPurchases - успешное получение покупок', () async {
      final mockData = {
        'data': [
          {
            'start_date': '2024-01-01T00:00:00Z',
            'bank_id': 'bank-1',
            'title': 'Plan Title',
            'consultantName': 'Consultant Name',
            'duration': 30,
            'price': 1000,
            'chosen_plan_last_state': 'paid',
          },
        ],
      };

      when(mockDio.get('/api/finances/my_purchases', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/finances/my_purchases'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getUserPurchases(null, null);

      expect(result, isA<List<UserPurchasesModel>>());
      expect(result.length, 1);
      verify(mockDio.get('/api/finances/my_purchases', queryParameters: {'sort[]': 'start_date:desc'})).called(1);
    });

    test('getUserPurchases - успешное получение с фильтром date', () async {
      final mockData = {'data': []};

      when(mockDio.get('/api/finances/my_purchases', queryParameters: anyNamed('queryParameters'))).thenAnswer(
        (_) async => Response(
          requestOptions: RequestOptions(path: '/api/finances/my_purchases'),
          statusCode: 200,
          data: mockData,
        ),
      );

      final result = await service.getUserPurchases('2024-01-01', FiltersComparisonEnum.greaterThan);

      expect(result, isA<List<UserPurchasesModel>>());
      verify(mockDio.get('/api/finances/my_purchases', queryParameters: {'filters[start_date][\$gt]': '2024-01-01', 'sort[]': 'start_date:desc'})).called(1);
    });

    test('getUserPurchases - пробрасывает ошибку', () async {
      when(
        mockDio.get(any, queryParameters: anyNamed('queryParameters')),
      ).thenThrow(DioException(requestOptions: RequestOptions(path: '/api/finances/my_purchases')));

      expect(() => service.getUserPurchases(null, null), throwsA(isA<DioException>()));
    });
  });
}