games_app/prediqo_mobile/test/support_chat_section_test.dart

331 lines
11 KiB
Dart

import 'dart:async';
import 'package:dio/dio.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:prediqo_mobile/core/config/app_config.dart';
import 'package:prediqo_mobile/features/prediction/presentation/prediction_screen.dart';
import 'package:prediqo_mobile/core/di/injection.dart';
import 'package:prediqo_mobile/core/network/api_client.dart';
import 'package:prediqo_mobile/core/realtime/support_socket_service.dart';
import 'package:prediqo_mobile/data/models/support_models.dart';
import 'package:prediqo_mobile/data/repositories/support_repository.dart';
import 'package:prediqo_mobile/features/support/bloc/support_bloc.dart';
import 'package:prediqo_mobile/features/support/utils/support_ui_gate.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'support/e2e_fixtures.dart';
SupportMessageModel _msg(String id, {String body = 'Hello support'}) =>
SupportMessageModel(
id: id,
conversationId: 'c1',
senderType: 'user',
createdAt: '2026-09-24T10:00:00.000Z',
body: body,
);
class _FakeSupport extends SupportRepository {
_FakeSupport(super.api);
Completer<SupportConversationModel?>? convHold;
Completer<SupportMessagesPage>? messagesHold;
Object? failWith;
Object? sendFail;
var findCalls = 0;
var messageCalls = 0;
var sendCalls = 0;
SupportConversationModel? conversation =
const SupportConversationModel(id: 'c1', status: 'open');
List<SupportMessageModel> messages = [_msg('m1')];
@override
Future<SupportConversationModel?> findCurrentConversation() async {
findCalls++;
if (failWith != null) throw failWith!;
if (convHold != null) return convHold!.future;
return conversation;
}
@override
Future<SupportMessagesPage> getMessages(String conversationId) async {
messageCalls++;
if (failWith != null) throw failWith!;
if (messagesHold != null) return messagesHold!.future;
return SupportMessagesPage(messages: List.of(messages), staffTyping: false);
}
@override
Future<SupportMessageModel> sendMessage(String? conversationId, String body) async {
sendCalls++;
if (sendFail != null) throw sendFail!;
return _msg('sent-$sendCalls', body: body);
}
@override
Future<SupportMessageModel> sendImage(String? conversationId, String filePath) async {
sendCalls++;
if (sendFail != null) throw sendFail!;
return SupportMessageModel(
id: 'img-$sendCalls',
conversationId: conversationId ?? 'c1',
senderType: 'user',
createdAt: '2026-09-24T10:00:00.000Z',
attachmentUrl: '/uploads/img-$sendCalls.jpg',
attachmentName: 'img-$sendCalls.jpg',
attachmentMime: 'image/jpeg',
);
}
@override
Future<void> setTyping(String conversationId, bool active) async {}
}
Future<({_FakeSupport repo, SupportSocketService socket})> _boot() async {
configureE2eTestEnvironment();
if (sl.isRegistered<AppConfig>()) await sl.reset();
const config = AppConfig(
apiBaseUrl: 'http://localhost',
isProduction: false,
wsEnabled: false,
);
sl.registerSingleton<AppConfig>(config);
SharedPreferences.setMockInitialValues({});
final api = ApiClient(config: config);
sl.registerLazySingleton<ApiClient>(() => api);
final repo = _FakeSupport(api);
final socket = SupportSocketService(config, api, repo);
return (repo: repo, socket: socket);
}
Future<void> _waitUntil(
SupportBloc bloc,
bool Function(SupportState s) pred, {
Duration timeout = const Duration(seconds: 2),
}) async {
if (pred(bloc.state)) return;
await bloc.stream.firstWhere(pred).timeout(timeout);
}
void main() {
tearDown(() async {
if (sl.isRegistered<AppConfig>()) await sl.reset();
});
test('prediction resume reconnect ignores sheet/IME lifecycle blips', () {
expect(predictionIsRealBackgroundLifecycle(AppLifecycleState.inactive), isFalse);
expect(predictionIsRealBackgroundLifecycle(AppLifecycleState.hidden), isFalse);
expect(predictionIsRealBackgroundLifecycle(AppLifecycleState.resumed), isFalse);
expect(predictionIsRealBackgroundLifecycle(AppLifecycleState.paused), isTrue);
expect(predictionIsRealBackgroundLifecycle(AppLifecycleState.detached), isTrue);
expect(predictionBackgroundDwellAllowsReconnect(null), isFalse);
expect(
predictionBackgroundDwellAllowsReconnect(const Duration(milliseconds: 400)),
isFalse,
);
expect(
predictionBackgroundDwellAllowsReconnect(const Duration(milliseconds: 1500)),
isTrue,
);
});
test('first open emits loading then paints messages (no blank error)', () async {
final boot = await _boot();
final hold = Completer<SupportMessagesPage>();
boot.repo.messagesHold = hold;
final bloc = SupportBloc(boot.repo, boot.socket);
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.loading && s.messages.isEmpty && s.open);
expect(bloc.state.errorMessage, isNull);
hold.complete(
SupportMessagesPage(
messages: [_msg('m1', body: 'Loaded thread')],
staffTyping: false,
),
);
await _waitUntil(bloc, (s) => !s.loading && s.messages.isNotEmpty);
expect(bloc.state.messages.single.body, 'Loaded thread');
expect(bloc.state.retrying, isFalse);
bloc.add(const SupportPanelClosed());
await bloc.close();
});
test('load failure keeps retryable error; retry recovers', () async {
final boot = await _boot();
boot.repo.failWith = Exception('offline');
final bloc = SupportBloc(boot.repo, boot.socket);
bloc.add(const SupportPanelOpened());
await _waitUntil(
bloc,
(s) => s.errorMessage != null && !s.loading && s.messages.isEmpty,
);
expect(bloc.state.retrying, isFalse);
boot.repo.failWith = null;
boot.repo.messagesHold = Completer<SupportMessagesPage>();
final before = boot.repo.findCalls;
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.retrying && s.errorMessage != null);
expect(boot.repo.findCalls, greaterThan(before));
boot.repo.messagesHold!.complete(
SupportMessagesPage(messages: [_msg('ok', body: 'Recovered')], staffTyping: false),
);
await _waitUntil(bloc, (s) => s.messages.isNotEmpty && s.errorMessage == null);
expect(bloc.state.messages.single.body, 'Recovered');
expect(bloc.state.retrying, isFalse);
bloc.add(const SupportPanelClosed());
await bloc.close();
});
test('reopen soft-refreshes without clearing painted messages', () async {
final boot = await _boot();
final bloc = SupportBloc(boot.repo, boot.socket);
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.messages.isNotEmpty);
expect(bloc.state.messages.single.body, 'Hello support');
bloc.add(const SupportPanelClosed());
await _waitUntil(bloc, (s) => !s.open);
boot.repo.messagesHold = Completer<SupportMessagesPage>();
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.open);
expect(bloc.state.loading, isFalse);
expect(bloc.state.messages.single.body, 'Hello support');
boot.repo.messagesHold!.complete(
SupportMessagesPage(
messages: [_msg('m2', body: 'Fresh message')],
staffTyping: false,
),
);
await _waitUntil(bloc, (s) => s.messages.single.body == 'Fresh message');
bloc.add(const SupportPanelClosed());
await bloc.close();
});
test('soft-fail refresh keeps thread when getMessages throws', () async {
final boot = await _boot();
final bloc = SupportBloc(boot.repo, boot.socket);
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.messages.isNotEmpty);
boot.repo.failWith = Exception('offline');
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.open && !s.loading);
// Allow the in-flight soft refresh to settle.
await Future<void>.delayed(const Duration(milliseconds: 30));
expect(bloc.state.messages, isNotEmpty);
expect(bloc.state.errorMessage, isNull);
bloc.add(const SupportPanelClosed());
await bloc.close();
});
test('queues text offline then flushes when send recovers', () async {
final boot = await _boot();
final bloc = SupportBloc(boot.repo, boot.socket);
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.messages.isNotEmpty);
boot.repo.sendFail = DioException(
requestOptions: RequestOptions(path: '/support'),
type: DioExceptionType.connectionError,
);
bloc.add(const SupportSendRequested('queued hello'));
await _waitUntil(
bloc,
(s) => s.messages.any((m) => m.isPending && m.body == 'queued hello'),
);
expect(bloc.state.errorMessage, isNull);
boot.repo.sendFail = null;
bloc.add(const SupportOutboxFlushRequested());
await _waitUntil(
bloc,
(s) =>
s.messages.any((m) => m.body == 'queued hello' && !m.isPending) &&
s.messages.every((m) => !m.isPending),
);
bloc.add(const SupportPanelClosed());
await bloc.close();
});
test('queues image offline then flushes when send recovers', () async {
final boot = await _boot();
final bloc = SupportBloc(boot.repo, boot.socket);
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.messages.isNotEmpty);
boot.repo.sendFail = DioException(
requestOptions: RequestOptions(path: '/support'),
type: DioExceptionType.connectionError,
);
bloc.add(const SupportImageSendRequested('/tmp/photo.jpg'));
await _waitUntil(
bloc,
(s) => s.messages.any((m) => m.isPending && m.attachmentUrl == '/tmp/photo.jpg'),
);
expect(bloc.state.errorMessage, isNull);
boot.repo.sendFail = null;
bloc.add(const SupportOutboxFlushRequested());
await _waitUntil(
bloc,
(s) =>
s.messages.any(
(m) =>
!m.isPending &&
(m.attachmentUrl ?? '').startsWith('/uploads/'),
) &&
s.messages.every((m) => !m.isPending),
);
bloc.add(const SupportPanelClosed());
await bloc.close();
});
test('markPanelOpening suppresses game reconnect before open settles', () async {
final boot = await _boot();
final bloc = SupportBloc(boot.repo, boot.socket);
SupportUiGate.holdsGameRealtime = false;
SupportUiGate.predictionScreenActive = false;
expect(bloc.suppressesGameReconnect, isFalse);
bloc.markPanelOpening();
expect(bloc.suppressesGameReconnect, isTrue);
expect(SupportUiGate.holdsGameRealtime, isTrue);
bloc.add(const SupportPanelOpened());
await _waitUntil(bloc, (s) => s.open);
expect(bloc.suppressesGameReconnect, isTrue);
bloc.add(const SupportPanelClosed());
await _waitUntil(bloc, (s) => !s.open);
expect(bloc.suppressesGameReconnect, isFalse);
expect(SupportUiGate.holdsGameRealtime, isFalse);
await bloc.close();
});
test('defers Support WS while Predict screen is active', () {
SupportUiGate.holdsGameRealtime = true;
SupportUiGate.predictionScreenActive = true;
expect(SupportUiGate.shouldDeferSupportSocket, isTrue);
SupportUiGate.predictionScreenActive = false;
expect(SupportUiGate.shouldDeferSupportSocket, isFalse);
SupportUiGate.holdsGameRealtime = false;
});
}