feat(tests): widget and unit tests for chat

This commit is contained in:
misha
2025-12-03 18:12:17 +03:00
parent 673aa86370
commit 9e33063c30
12 changed files with 2036 additions and 0 deletions

View File

@@ -0,0 +1,360 @@
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);
});
});
}