1784 lines
63 KiB
Dart
1784 lines
63 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:ducafe_ui_core/ducafe_ui_core.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:forui/forui.dart';
|
|
import 'package:get/get.dart';
|
|
|
|
import 'package:pj_supermarket_cloud/common/index.dart';
|
|
import 'package:pj_supermarket_cloud/pages/terminal/menu_query/controller.dart';
|
|
import 'package:pj_supermarket_cloud/pages/terminal/menu_query/reservation_menu_repository.dart';
|
|
import 'package:pj_supermarket_cloud/pages/terminal/menu_query/reservation_recognition_gateway.dart';
|
|
import 'package:pj_supermarket_cloud/pages/terminal/menu_query/reservation_sub_screen_gateway.dart';
|
|
import 'package:pj_supermarket_cloud/pages/terminal/menu_query/reservation_verification_gateway.dart';
|
|
import 'package:pj_supermarket_cloud/pages/terminal/menu_query/view.dart';
|
|
|
|
void main() {
|
|
testWidgets('页面配置决定查询方式顺序和默认项，进入页面不自动识别', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final repository = _ImmediateRepository(_result('张*明', 1));
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: () async => const ReservationQueryPagePreferences(
|
|
methodOrder: [
|
|
ReservationRecognitionMethod.face,
|
|
ReservationRecognitionMethod.card,
|
|
],
|
|
defaultMethod: ReservationRecognitionMethod.face,
|
|
nameMaskEnabled: false,
|
|
verificationEnabled: true,
|
|
quickVerificationEnabled: true,
|
|
selectedMealSlot: ReservationMealSlot.noon,
|
|
verificationDateScope: ReservationVerificationDateScope.all,
|
|
),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
|
|
expect(controller.methodOrder, [
|
|
ReservationRecognitionMethod.face,
|
|
ReservationRecognitionMethod.card,
|
|
]);
|
|
expect(controller.method.value, ReservationRecognitionMethod.face);
|
|
expect(controller.autoRecognitionEnabled.value, isFalse);
|
|
expect(controller.continuousRecognitionEnabled.value, isTrue);
|
|
expect(controller.nameMaskEnabled.value, isFalse);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.idle);
|
|
expect(controller.verificationEnabled.value, isTrue);
|
|
expect(controller.quickVerificationEnabled.value, isTrue);
|
|
expect(controller.selectedMealSlot.value, ReservationMealSlot.noon);
|
|
expect(
|
|
controller.verificationDateScope.value,
|
|
ReservationVerificationDateScope.all,
|
|
);
|
|
expect(recognition.faceCallbacks, isEmpty);
|
|
expect(recognition.cardCallbacks, isEmpty);
|
|
|
|
await controller.startRecognition();
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
await recognition.emitFaceAt(0, '1001');
|
|
expect(repository.calls.single.maskName, isFalse);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('恢复并缓存最近餐段，查询中和非常规餐段不会覆盖选择', (tester) async {
|
|
final savedMealSlots = <ReservationMealSlot>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: _FakeRecognitionGateway(),
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: () async => const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.card,
|
|
selectedMealSlot: ReservationMealSlot.noon,
|
|
),
|
|
mealSlotSaver: (mealSlot) async => savedMealSlots.add(mealSlot),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
expect(controller.selectedMealSlot.value, ReservationMealSlot.noon);
|
|
expect(controller.mealSlotC.value, {'2'});
|
|
|
|
controller.selectMealSlot(ReservationMealSlot.night);
|
|
await tester.pump();
|
|
expect(controller.selectedMealSlot.value, ReservationMealSlot.night);
|
|
expect(controller.mealSlotC.value, {'3'});
|
|
expect(savedMealSlots, [ReservationMealSlot.night]);
|
|
|
|
controller.status.value = ReservationMenuQueryStatus.querying;
|
|
controller.selectMealSlot(ReservationMealSlot.morning);
|
|
controller.selectMealSlot(ReservationMealSlot.lateNight);
|
|
await tester.pump();
|
|
expect(controller.selectedMealSlot.value, ReservationMealSlot.night);
|
|
expect(savedMealSlots, [ReservationMealSlot.night]);
|
|
});
|
|
|
|
testWidgets('快速核销只发布今天识别前预选餐段的核销弹框请求', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final requests = <ReservationQuickVerificationRequest>[];
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_resultWithBreakfastAndNoon()),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _quickVerificationPreferences,
|
|
mealSlotSaver: (_) async {},
|
|
errorNotifier: errors.add,
|
|
now: () => DateTime(2026, 7, 24, 11, 30),
|
|
);
|
|
final subscription =
|
|
controller.quickVerificationRequests.listen(requests.add);
|
|
addTearDown(subscription.cancel);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
controller.selectMealSlot(ReservationMealSlot.noon);
|
|
expect(controller.selectedMealSlot.value, ReservationMealSlot.noon);
|
|
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
await tester.pump();
|
|
|
|
expect(requests, hasLength(1));
|
|
expect(requests.single.day.date, '2026-07-24');
|
|
expect(requests.single.meal.hourType, '2');
|
|
expect(requests.single.meal.orderIds, [2002]);
|
|
expect(errors, isEmpty);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('快速核销没有当天预选餐段时保留结果并提示操作员', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final requests = <ReservationQuickVerificationRequest>[];
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_resultWithBreakfastAndNoon()),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _quickVerificationPreferences,
|
|
mealSlotSaver: (_) async {},
|
|
errorNotifier: errors.add,
|
|
now: () => DateTime(2026, 7, 24, 18),
|
|
);
|
|
final subscription =
|
|
controller.quickVerificationRequests.listen(requests.add);
|
|
addTearDown(subscription.cancel);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
controller.selectMealSlot(ReservationMealSlot.night);
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-002');
|
|
await tester.pump();
|
|
|
|
expect(requests, isEmpty);
|
|
expect(errors, ['当前用户今天没有可核销的晚餐预约']);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value, isNotNull);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('持续自动饭卡在结果期继续读卡并用下一位结果覆盖', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_result('张*明', 1),
|
|
_result('李*华', 1),
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
|
|
expect(controller.autoRecognitionEnabled.value, isTrue);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
|
|
final first = recognition.emitCardAt(0, 'CARD-001');
|
|
final duplicate = recognition.emitCardAt(0, 'CARD-001');
|
|
await first;
|
|
await duplicate;
|
|
expect(repository.calls, hasLength(1));
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value?.maskedName, '张*明');
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
|
|
// 第一张卡未移开时可能被新一轮读到，但不应重复请求同一位用户。
|
|
await recognition.emitCardAt(1, 'CARD-001');
|
|
expect(repository.calls, hasLength(1));
|
|
expect(controller.result.value?.maskedName, '张*明');
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
expect(recognition.cardCallbacks, hasLength(3));
|
|
|
|
await recognition.emitCardAt(2, 'CARD-002');
|
|
|
|
expect(repository.calls, [
|
|
const _QueryCall(identityValue: 'CARD-001', maskName: true),
|
|
const _QueryCall(identityValue: 'CARD-002', maskName: true),
|
|
]);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value?.maskedName, '李*华');
|
|
expect(subScreen.updates.last.scenario, 'success');
|
|
expect(subScreen.updates.last.maskedName, '李*华');
|
|
expect(recognition.cardCallbacks, hasLength(4));
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('持续自动饭卡读到空卡时保留上次结果并继续等待', (tester) async {
|
|
final repository = _ImmediateRepository(_result('张*明', 1));
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
errorNotifier: errors.add,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
recognitionFailureRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
expect(controller.result.value?.maskedName, '张*明');
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
|
|
recognition.cardFailures[1](
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.identify,
|
|
'未读取到有效饭卡，请重新刷卡',
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
|
|
expect(repository.calls, hasLength(1));
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value?.maskedName, '张*明');
|
|
expect(subScreen.updates.last.scenario, 'success');
|
|
expect(subScreen.updates.last.maskedName, '张*明');
|
|
expect(recognition.cardCallbacks, hasLength(3));
|
|
expect(errors, isEmpty);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('持续自动饭卡的新卡查询失败时保留上次结果', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_result('张*明', 1),
|
|
null,
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
errorNotifier: errors.add,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
recognitionFailureRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
await recognition.emitCardAt(1, 'CARD-002');
|
|
|
|
expect(repository.calls, hasLength(2));
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value?.maskedName, '张*明');
|
|
expect(subScreen.updates.last.scenario, 'success');
|
|
expect(subScreen.updates.last.maskedName, '张*明');
|
|
expect(errors, ['未获取到预约查询结果']);
|
|
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
expect(recognition.cardCallbacks, hasLength(3));
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('持续自动饭卡的新卡查询成功但无预约时清空旧菜单并提示', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_result('张*明', 1),
|
|
_result('李*华', 0),
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
errorNotifier: errors.add,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
await recognition.emitCardAt(1, 'CARD-002');
|
|
|
|
expect(repository.calls, hasLength(2));
|
|
expect(controller.status.value, ReservationMenuQueryStatus.empty);
|
|
expect(controller.result.value?.maskedName, '李*华');
|
|
expect(controller.result.value?.days, isEmpty);
|
|
expect(subScreen.updates.last.scenario, 'empty');
|
|
expect(subScreen.updates.last.maskedName, '李*华');
|
|
expect(errors, ['当前用户暂无有效预约']);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('持续自动识别关闭时饭卡结果期不会重新布防读卡器', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardSingleRoundPreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value?.maskedName, '张*明');
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('饭卡和人脸结果弹框展示期间暂停识别，关闭后才自动开始下一轮', (tester) async {
|
|
for (final recognitionMethod in ReservationRecognitionMethod.values) {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader:
|
|
recognitionMethod == ReservationRecognitionMethod.card
|
|
? _autoCardPreferences
|
|
: _autoFacePreferences,
|
|
);
|
|
controller.onInit();
|
|
await tester.pump();
|
|
|
|
if (recognitionMethod == ReservationRecognitionMethod.card) {
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
} else {
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
await recognition.emitFaceAt(0, '1001');
|
|
}
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
|
|
expect(await controller.beginResultDialogPresentation(), isTrue);
|
|
expect(await controller.beginResultDialogPresentation(), isFalse);
|
|
expect(controller.remainingSeconds.value, 0);
|
|
await controller.startRecognition();
|
|
await tester.pump(const Duration(seconds: 61));
|
|
|
|
if (recognitionMethod == ReservationRecognitionMethod.card) {
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
} else {
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
}
|
|
expect(controller.result.value, isNotNull);
|
|
|
|
await controller.endResultDialogPresentation();
|
|
expect(controller.result.value, isNull);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
if (recognitionMethod == ReservationRecognitionMethod.card) {
|
|
expect(recognition.cardCallbacks, hasLength(3));
|
|
} else {
|
|
expect(recognition.faceCallbacks, hasLength(2));
|
|
}
|
|
controller.onClose();
|
|
}
|
|
});
|
|
|
|
testWidgets('手动模式关闭菜单详情后保留当前结果并重新开始隐私倒计时', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
expect(controller.remainingSeconds.value, 60);
|
|
|
|
expect(await controller.beginResultDialogPresentation(), isTrue);
|
|
expect(controller.remainingSeconds.value, 0);
|
|
await controller.endResultDialogPresentation();
|
|
|
|
expect(controller.result.value, isNotNull);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.remainingSeconds.value, 60);
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
controller.onClose();
|
|
});
|
|
|
|
testWidgets('自动人脸模式进入页面即启动，切换饭卡后自动启动新方式', (tester) async {
|
|
final repository = _ImmediateRepository(_result('李*华', 1));
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoFacePreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
|
|
expect(controller.method.value, ReservationRecognitionMethod.face);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
expect(recognition.faceEmbeddedPreviews, [isTrue]);
|
|
|
|
await recognition.emitFaceAt(0, '1001');
|
|
expect(repository.calls, [
|
|
const _QueryCall(identityValue: '1001', maskName: true),
|
|
]);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
|
|
await controller.selectMethod(ReservationRecognitionMethod.card);
|
|
expect(controller.method.value, ReservationRecognitionMethod.card);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
});
|
|
|
|
testWidgets('持续人脸结果固定展示十秒并保留副屏组合页后识别下一位', (tester) async {
|
|
var now = DateTime(2026, 8, 7, 10);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('李*华', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoFacePreferences,
|
|
continuousFaceResultDuration: const Duration(seconds: 10),
|
|
now: () => now,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
|
|
expect(controller.continuousFaceRecognitionActive, isTrue);
|
|
expect(recognition.faceEmbeddedPreviews, [isTrue]);
|
|
expect(subScreen.updates.first.scenario, 'recognizing');
|
|
expect(subScreen.updates.first.continuousFaceRecognition, isTrue);
|
|
|
|
await recognition.emitFaceAt(0, '1001');
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.remainingSeconds.value, 10);
|
|
expect(subScreen.updates.last.scenario, 'success');
|
|
expect(subScreen.updates.last.continuousFaceRecognition, isTrue);
|
|
|
|
now = now.add(const Duration(seconds: 10));
|
|
await tester.pump(const Duration(seconds: 1));
|
|
await tester.pump();
|
|
|
|
expect(controller.result.value, isNull);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(recognition.faceCallbacks, hasLength(2));
|
|
expect(recognition.faceEmbeddedPreviews, [isTrue, isTrue]);
|
|
expect(subScreen.clearCalls, 0);
|
|
expect(subScreen.updates.last.scenario, 'recognizing');
|
|
expect(subScreen.updates.last.continuousFaceRecognition, isTrue);
|
|
});
|
|
|
|
testWidgets('持续人脸主屏在 1920x1080 保留常驻摄像头且无布局异常', (tester) async {
|
|
tester.view.physicalSize = const Size(1920, 1080);
|
|
tester.view.devicePixelRatio = 1;
|
|
addTearDown(tester.view.resetPhysicalSize);
|
|
addTearDown(tester.view.resetDevicePixelRatio);
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('李*华', 1)),
|
|
recognitionGateway: _FakeRecognitionGateway(),
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoFacePreferences,
|
|
);
|
|
Get.testMode = true;
|
|
Get.put(controller);
|
|
addTearDown(() async {
|
|
if (Get.isRegistered<ReservationMenuQueryController>()) {
|
|
await Get.delete<ReservationMenuQueryController>(force: true);
|
|
}
|
|
Get.reset();
|
|
});
|
|
|
|
await tester.pumpWidget(
|
|
ScreenUtilInit(
|
|
designSize: const Size(1920, 1080),
|
|
builder: (_, __) => MaterialApp(
|
|
home: FTheme(
|
|
data: FThemes.zinc.light,
|
|
child: const Scaffold(body: ReservationMenuQueryPage()),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
final preview = find.byKey(
|
|
const ValueKey('reservation-live-face-preview'),
|
|
);
|
|
expect(preview, findsOneWidget);
|
|
final previewSize = tester.getSize(preview);
|
|
expect(previewSize.width / previewSize.height, closeTo(16 / 9, 0.01));
|
|
expect(tester.takeException(), isNull);
|
|
|
|
await tester.pumpWidget(const SizedBox.shrink());
|
|
await Get.delete<ReservationMenuQueryController>(force: true);
|
|
Get.reset();
|
|
});
|
|
|
|
testWidgets('自动人脸被取消后暂停且不循环弹窗，仍可人工重新识别', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('李*华', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoFacePreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
|
|
recognition.faceFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.cancelled,
|
|
'已取消人脸识别',
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.identifyError);
|
|
expect(controller.errorMessage.value, '已取消人脸识别');
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
|
|
await controller.startRecognition();
|
|
expect(recognition.faceCallbacks, hasLength(2));
|
|
});
|
|
|
|
testWidgets('持续自动识别开启时饭卡正常等待超时会开启下一轮', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
|
|
recognition.cardFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.timeout,
|
|
'等待饭卡超时',
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(controller.errorMessage.value, isEmpty);
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
});
|
|
|
|
testWidgets('持续自动识别开启时首次刷卡失败会提示并继续等待下一张卡', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
errorNotifier: errors.add,
|
|
recognitionFailureRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
recognition.cardFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.identify,
|
|
'饭卡读取失败，请重新刷卡',
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(controller.errorMessage.value, isEmpty);
|
|
expect(errors, ['饭卡读取失败，请重新刷卡']);
|
|
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
});
|
|
|
|
testWidgets('持续自动识别开启时首次未查询出菜单会提示并继续等待下一张卡', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _SequenceRepository([null, _result('李*华', 1)]),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
errorNotifier: errors.add,
|
|
recognitionFailureRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(controller.result.value, isNull);
|
|
expect(controller.errorMessage.value, isEmpty);
|
|
expect(errors, ['未获取到预约查询结果']);
|
|
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
await recognition.emitCardAt(1, 'CARD-002');
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
expect(controller.result.value?.maskedName, '李*华');
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('持续自动识别关闭时饭卡等待超时暂停并保留人工重试', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardSingleRoundPreferences,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
recognition.cardFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.timeout,
|
|
'等待饭卡超时',
|
|
),
|
|
);
|
|
await tester.pump(const Duration(milliseconds: 30));
|
|
|
|
expect(controller.continuousRecognitionEnabled.value, isFalse);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.identifyError);
|
|
expect(controller.errorMessage.value, '等待饭卡超时');
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
});
|
|
|
|
testWidgets('持续自动识别不会对设备故障无限重试', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
recognition.cardFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.device,
|
|
'读卡器未连接，请检查设备后重试',
|
|
),
|
|
);
|
|
await tester.pump(const Duration(milliseconds: 30));
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.deviceError);
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
});
|
|
|
|
testWidgets('人脸会话未来上报正常超时时复用持续识别续轮策略', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('李*华', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoFacePreferences,
|
|
recognitionRestartDelay: const Duration(milliseconds: 10),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
recognition.faceFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.timeout,
|
|
'等待人脸超时',
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.pump(const Duration(milliseconds: 10));
|
|
|
|
expect(controller.status.value, ReservationMenuQueryStatus.recognizing);
|
|
expect(recognition.faceCallbacks, hasLength(2));
|
|
});
|
|
|
|
testWidgets('切换识别方式会取消旧饭卡超时续轮任务', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _autoCardPreferences,
|
|
recognitionRestartDelay: const Duration(seconds: 1),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
recognition.cardFailures.single(
|
|
const ReservationRecognitionFailure(
|
|
ReservationRecognitionFailureType.timeout,
|
|
'等待饭卡超时',
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await controller.selectMethod(ReservationRecognitionMethod.face);
|
|
await tester.pump(const Duration(seconds: 2));
|
|
|
|
expect(controller.method.value, ReservationRecognitionMethod.face);
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
});
|
|
|
|
testWidgets('重复识别只查询一次，旧响应不能覆盖新身份', (tester) async {
|
|
final repository = _CompleterRepository();
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
expect(recognition.cardCallbacks, hasLength(1));
|
|
|
|
final first = recognition.emitCardAt(0, 'old-card');
|
|
final duplicate = recognition.emitCardAt(0, 'old-card');
|
|
await tester.pump();
|
|
expect(repository.calls, hasLength(1));
|
|
await duplicate;
|
|
|
|
await controller.startRecognition();
|
|
expect(recognition.cardCallbacks, hasLength(2));
|
|
final second = recognition.emitCardAt(1, 'new-card');
|
|
await tester.pump();
|
|
expect(repository.calls, hasLength(2));
|
|
|
|
repository.completers[1].complete(_result('李*华', 1));
|
|
await second;
|
|
expect(controller.result.value?.maskedName, '李*华');
|
|
|
|
repository.completers[0].complete(_result('张*明', 1));
|
|
await first;
|
|
expect(controller.result.value?.maskedName, '李*华');
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('11 天本地分页、翻页续时并在到期后主副屏清空', (tester) async {
|
|
var now = DateTime(2026, 7, 24, 8);
|
|
final repository = _ImmediateRepository(_result('张*明', 11));
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
privacyDuration: const Duration(seconds: 3),
|
|
now: () => now,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'card-1');
|
|
expect(controller.totalPages, 2);
|
|
expect(controller.currentDays, hasLength(10));
|
|
expect(controller.remainingSeconds.value, 3);
|
|
|
|
now = now.add(const Duration(seconds: 2));
|
|
await tester.pump(const Duration(seconds: 1));
|
|
expect(controller.remainingSeconds.value, 1);
|
|
|
|
await controller.changePage(2);
|
|
expect(controller.currentDays, hasLength(1));
|
|
expect(controller.remainingSeconds.value, 3);
|
|
expect(subScreen.updates.last.currentPage, 2);
|
|
expect(subScreen.updates.last.days, hasLength(1));
|
|
|
|
now = now.add(const Duration(seconds: 3));
|
|
await tester.pump(const Duration(seconds: 1));
|
|
await tester.pump();
|
|
expect(controller.status.value, ReservationMenuQueryStatus.expired);
|
|
expect(controller.result.value, isNull);
|
|
expect(subScreen.clearCalls, 1);
|
|
});
|
|
|
|
testWidgets('断网时不调用预约接口，单屏不可用不影响主屏查询', (tester) async {
|
|
final offlineRepository = _ImmediateRepository(_result('张*明', 1));
|
|
final offlineRecognition = _FakeRecognitionGateway();
|
|
final offlineController = ReservationMenuQueryController(
|
|
repository: offlineRepository,
|
|
recognitionGateway: offlineRecognition,
|
|
subScreenGateway: _FakeSubScreenGateway(available: false),
|
|
networkAvailable: () => false,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
addTearDown(offlineController.onClose);
|
|
offlineController.onInit();
|
|
await tester.pump();
|
|
await offlineController.startRecognition();
|
|
await offlineRecognition.emitCardAt(0, 'card-offline');
|
|
expect(offlineRepository.calls, isEmpty);
|
|
expect(offlineController.status.value,
|
|
ReservationMenuQueryStatus.networkError);
|
|
|
|
final onlineRepository = _ImmediateRepository(_result('李*华', 1));
|
|
final onlineRecognition = _FakeRecognitionGateway();
|
|
final onlineController = ReservationMenuQueryController(
|
|
repository: onlineRepository,
|
|
recognitionGateway: onlineRecognition,
|
|
subScreenGateway: _FakeSubScreenGateway(available: false),
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
addTearDown(onlineController.onClose);
|
|
onlineController.onInit();
|
|
await tester.pump();
|
|
await onlineController.startRecognition();
|
|
await onlineRecognition.emitCardAt(0, 'card-online');
|
|
expect(onlineController.status.value, ReservationMenuQueryStatus.success);
|
|
expect(onlineController.result.value?.maskedName, '李*华');
|
|
await onlineController.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('人脸方式先显示识别页，识别成功后才发送预约查询状态', (tester) async {
|
|
final repository = _ImmediateRepository(_result('张*明', 1));
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _FakeSubScreenGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
subScreen.updates.clear();
|
|
|
|
await controller.selectMethod(ReservationRecognitionMethod.face);
|
|
expect(recognition.faceCallbacks, isEmpty);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.idle);
|
|
expect(
|
|
subScreen.updates.map((event) => event.scenario),
|
|
['idle'],
|
|
reason: '切换查询方式只同步等待态，不能提前进入识别或预约查询 loading',
|
|
);
|
|
subScreen.updates.clear();
|
|
|
|
await controller.startRecognition();
|
|
expect(recognition.faceCallbacks, hasLength(1));
|
|
expect(
|
|
subScreen.updates,
|
|
isEmpty,
|
|
reason: '人脸识别开始后由统一人脸协议接管副屏，不能提前发送预约 loading',
|
|
);
|
|
|
|
await recognition.emitFaceAt(0, '1001');
|
|
expect(repository.calls, [
|
|
const _QueryCall(identityValue: '1001', maskName: true),
|
|
]);
|
|
expect(
|
|
subScreen.updates.map((event) => event.scenario),
|
|
['loading', 'success'],
|
|
);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('副屏状态不回包也不能阻塞预约接口', (tester) async {
|
|
final repository = _ImmediateRepository(_result('张*明', 1));
|
|
final recognition = _FakeRecognitionGateway();
|
|
final subScreen = _HangingSubScreenGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: subScreen,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _defaultPreferences,
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
final recognitionFuture = recognition.emitCardAt(0, 'card-1');
|
|
await tester.pump();
|
|
|
|
expect(repository.calls, [
|
|
const _QueryCall(identityValue: 'card-1', maskName: true),
|
|
]);
|
|
subScreen.releaseUpdates();
|
|
await recognitionFuture;
|
|
expect(controller.status.value, ReservationMenuQueryStatus.success);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('饭卡核销提交点击餐段中勾选的多个订单，成功后刷新并播报', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_resultWithOrderIds('张*明', const [1001, 1002]),
|
|
_result('张*明', 0),
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final verification = _FakeVerificationGateway();
|
|
final spoken = <String>[];
|
|
final successes = <String>[];
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
verificationGateway: verification,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _verificationPreferences,
|
|
speaker: (message) async => spoken.add(message),
|
|
successNotifier: successes.add,
|
|
errorNotifier: errors.add,
|
|
now: () => DateTime(2026, 7, 24, 8),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
final day = controller.result.value!.days.single;
|
|
final meal = day.meals.single;
|
|
|
|
expect(
|
|
await controller.confirmVerification(day, meal, const [1001, 1002]),
|
|
isTrue,
|
|
);
|
|
expect(
|
|
verification.calls,
|
|
const [
|
|
_VerificationCall(
|
|
orderIds: [1001, 1002],
|
|
),
|
|
],
|
|
);
|
|
expect(repository.calls, [
|
|
const _QueryCall(identityValue: 'CARD-001', maskName: true),
|
|
const _QueryCall(identityValue: 'CARD-001', maskName: true),
|
|
]);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.empty);
|
|
expect(successes, ['已核销 2 笔预约，页面已刷新']);
|
|
expect(errors, isEmpty);
|
|
await tester.pump();
|
|
expect(spoken, ['2笔预约核销成功']);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('多笔预约部分核销成功时刷新结果并明确提示成功与失败数量', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_resultWithOrderIds('张*明', const [1001, 1002]),
|
|
_resultWithOrderIds('张*明', const [1002]),
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final verification = _FakeVerificationGateway(
|
|
result: const ReservationVerificationResult(
|
|
succeededOrderIds: [1001],
|
|
failedOrderIds: [1002],
|
|
),
|
|
);
|
|
final spoken = <String>[];
|
|
final successes = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
verificationGateway: verification,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _verificationPreferences,
|
|
speaker: (message) async => spoken.add(message),
|
|
successNotifier: successes.add,
|
|
now: () => DateTime(2026, 7, 24, 8),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
final day = controller.result.value!.days.single;
|
|
final meal = day.meals.single;
|
|
|
|
expect(
|
|
await controller.confirmVerification(day, meal, const [1001, 1002]),
|
|
isTrue,
|
|
);
|
|
expect(controller.result.value!.days.single.meals.single.orderIds, [1002]);
|
|
expect(successes, ['已核销 1 笔预约，1 笔未成功，页面已刷新']);
|
|
await tester.pump();
|
|
expect(spoken, ['1笔预约核销成功，1笔未成功']);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('人脸核销把识别证据会话绑定到所选订单且成功后不再清理', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_resultWithOrderIds('张*明', const [1002]),
|
|
_result('张*明', 0),
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final verification = _FakeVerificationGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
verificationGateway: verification,
|
|
networkAvailable: () => true,
|
|
speaker: (_) async {},
|
|
successNotifier: (_) {},
|
|
errorNotifier: (_) {},
|
|
preferencesLoader: () async => const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.face,
|
|
verificationEnabled: true,
|
|
verificationDateScope: ReservationVerificationDateScope.all,
|
|
),
|
|
now: () => DateTime(2026, 7, 24, 8),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitFaceAt(
|
|
0,
|
|
'1001',
|
|
evidenceSessionId: 'face-session-1',
|
|
);
|
|
final day = controller.result.value!.days.single;
|
|
final meal = day.meals.single;
|
|
|
|
expect(
|
|
await controller.confirmVerification(day, meal, const [1002]), isTrue);
|
|
expect(
|
|
verification.calls,
|
|
const [
|
|
_VerificationCall(
|
|
orderIds: [1002],
|
|
faceEvidenceSessionId: 'face-session-1',
|
|
),
|
|
],
|
|
);
|
|
|
|
await controller.clearForPrivacy();
|
|
expect(verification.discardedSessions, isEmpty);
|
|
});
|
|
|
|
testWidgets('人脸仅查询未核销时在隐私清屏中删除现场图片任务', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final verification = _FakeVerificationGateway();
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_result('张*明', 1)),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
verificationGateway: verification,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: () async => const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.face,
|
|
),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitFaceAt(
|
|
0,
|
|
'1001',
|
|
evidenceSessionId: 'face-session-unused',
|
|
);
|
|
|
|
await controller.clearForPrivacy();
|
|
expect(verification.discardedSessions, ['face-session-unused']);
|
|
});
|
|
|
|
testWidgets('点击午餐时传入早餐订单 ID 必须拒绝且不能调用核销接口', (tester) async {
|
|
final recognition = _FakeRecognitionGateway();
|
|
final verification = _FakeVerificationGateway();
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: _ImmediateRepository(_resultWithBreakfastAndNoon()),
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
verificationGateway: verification,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _verificationPreferences,
|
|
errorNotifier: errors.add,
|
|
now: () => DateTime(2026, 7, 24, 8),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
final day = controller.result.value!.days.single;
|
|
final noonMeal = day.meals.singleWhere(
|
|
ReservationMealSlot.noon.matches,
|
|
);
|
|
|
|
expect(
|
|
await controller.confirmVerification(day, noonMeal, const [2001]),
|
|
isFalse,
|
|
);
|
|
expect(verification.calls, isEmpty);
|
|
expect(errors, ['部分所选预约订单已失效，请重新查询']);
|
|
await controller.clearForPrivacy();
|
|
});
|
|
|
|
testWidgets('核销已成功但刷新失败时不误报失败，并清除旧结果', (tester) async {
|
|
final repository = _SequenceRepository([
|
|
_result('张*明', 1),
|
|
null,
|
|
]);
|
|
final recognition = _FakeRecognitionGateway();
|
|
final verification = _FakeVerificationGateway();
|
|
final spoken = <String>[];
|
|
final successes = <String>[];
|
|
final errors = <String>[];
|
|
final controller = ReservationMenuQueryController(
|
|
repository: repository,
|
|
recognitionGateway: recognition,
|
|
subScreenGateway: _FakeSubScreenGateway(),
|
|
verificationGateway: verification,
|
|
networkAvailable: () => true,
|
|
preferencesLoader: _verificationPreferences,
|
|
speaker: (message) async => spoken.add(message),
|
|
successNotifier: successes.add,
|
|
errorNotifier: errors.add,
|
|
now: () => DateTime(2026, 7, 24, 8),
|
|
);
|
|
addTearDown(controller.onClose);
|
|
|
|
controller.onInit();
|
|
await tester.pump();
|
|
await controller.startRecognition();
|
|
await recognition.emitCardAt(0, 'CARD-001');
|
|
final day = controller.result.value!.days.single;
|
|
final meal = day.meals.single;
|
|
|
|
expect(
|
|
await controller.confirmVerification(day, meal, meal.orderIds),
|
|
isTrue,
|
|
);
|
|
expect(successes, ['核销成功，请重新识别刷新结果']);
|
|
expect(errors, isEmpty);
|
|
expect(controller.result.value, isNull);
|
|
expect(controller.status.value, ReservationMenuQueryStatus.idle);
|
|
await tester.pump();
|
|
expect(spoken, ['核销成功']);
|
|
});
|
|
|
|
test('预约日期模型按 5、10、11 天正确分页', () {
|
|
for (final entry in const {5: 1, 10: 1, 11: 2}.entries) {
|
|
final display = ReservationMenuDisplayData.fromService(
|
|
_result('张*明', entry.key),
|
|
);
|
|
expect(display.totalPages, entry.value);
|
|
expect(display.pageDays(1), hasLength(entry.key.clamp(0, 10)));
|
|
if (entry.key == 11) expect(display.pageDays(2), hasLength(1));
|
|
}
|
|
});
|
|
|
|
test('后端字符串或数字订单 ID 正确解析，副屏消息不携带核销标识', () {
|
|
final serviceMeal = ServiceReservationMeal.fromJson({
|
|
'hourType': '2',
|
|
'mealTitle': '午餐',
|
|
'items': ['香菇滑鸡'],
|
|
'orderIds': ['2080112524665057281', 2081674128087121921],
|
|
'orders': [
|
|
{
|
|
'orderId': '2080112524665057281',
|
|
'items': [
|
|
{
|
|
'productId': '2085184283437215745',
|
|
'productName': '香菇滑鸡',
|
|
'productPic': '/menu/chicken.jpg',
|
|
'productCount': 2,
|
|
'spuType': 2,
|
|
'comboItems': [
|
|
{
|
|
'childSpuId': '2082059339085946881',
|
|
'name': '小青菜',
|
|
'picUrl': '/menu/vegetable.jpg',
|
|
'quantity': 1,
|
|
'sortOrder': 0,
|
|
'price': 200,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
final meal = ReservationMenuMealData.fromService(serviceMeal);
|
|
final day = ReservationMenuDayData(date: '2026-07-24', meals: [meal]);
|
|
|
|
expect(meal.orderIds, [2080112524665057281, 2081674128087121921]);
|
|
expect(meal.orders.single.orderId, 2080112524665057281);
|
|
expect(meal.orders.single.items.single.productName, '香菇滑鸡');
|
|
expect(meal.orders.single.items.single.productId, 2085184283437215745);
|
|
expect(meal.orders.single.items.single.productPic, '/menu/chicken.jpg');
|
|
expect(meal.orders.single.items.single.productCount, 2);
|
|
expect(meal.orders.single.items.single.spuType, 2);
|
|
expect(meal.orders.single.items.single.comboItems.single.name, '小青菜');
|
|
expect(meal.orders.single.items.single.comboItems.single.quantity, 1);
|
|
final serializedOrder = (serviceMeal.toJson()['orders'] as List<dynamic>)
|
|
.single as Map<String, dynamic>;
|
|
expect(serializedOrder['items'], [
|
|
{
|
|
'productId': 2085184283437215745,
|
|
'productName': '香菇滑鸡',
|
|
'productPic': '/menu/chicken.jpg',
|
|
'productCount': 2,
|
|
'spuType': 2,
|
|
'comboItems': [
|
|
{
|
|
'childSpuId': 2082059339085946881,
|
|
'name': '小青菜',
|
|
'picUrl': '/menu/vegetable.jpg',
|
|
'quantity': 1,
|
|
'sortOrder': 0,
|
|
'price': 200,
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
expect(day.toJson().toString(), isNot(contains('orderIds')));
|
|
expect(day.toJson().toString(), isNot(contains('orders')));
|
|
});
|
|
|
|
test('预约查询请求使用生成式 JSON 序列化并省略无关身份字段', () {
|
|
const cardRequest = ReservationMenuQueryRequest(
|
|
hardId: 100,
|
|
recognitionType: 'CARD',
|
|
maskName: true,
|
|
cardNumber: 'CARD-001',
|
|
);
|
|
expect(cardRequest.toJson(), {
|
|
'hardId': 100,
|
|
'recognitionType': 'CARD',
|
|
'maskName': true,
|
|
'cardNumber': 'CARD-001',
|
|
});
|
|
|
|
final restored = ReservationMenuQueryRequest.fromJson({
|
|
'hardId': 100,
|
|
'recognitionType': 'FACE',
|
|
'maskName': false,
|
|
'faceUserId': 300,
|
|
});
|
|
expect(restored.hardId, 100);
|
|
expect(restored.recognitionType, 'FACE');
|
|
expect(restored.maskName, isFalse);
|
|
expect(restored.cardNumber, isNull);
|
|
expect(restored.faceUserId, 300);
|
|
});
|
|
|
|
test('后端只返回午餐时仅补齐基础三餐，不生成夜间餐占位', () {
|
|
final day = ReservationMenuDisplayData.fromService(
|
|
_result('张*明', 1),
|
|
).days.single;
|
|
|
|
expect(
|
|
day.displayMeals.map((meal) => meal.title),
|
|
['早餐', '午餐', '晚餐'],
|
|
);
|
|
expect(
|
|
day.displayMeals.map((meal) => meal.reserved),
|
|
[false, true, false],
|
|
);
|
|
expect(day.displayMeals[1].hourType, '2');
|
|
});
|
|
|
|
test('后端返回夜间餐时追加展示并保留餐品数据', () {
|
|
const day = ReservationMenuDayData(
|
|
date: '2026-07-24',
|
|
meals: [
|
|
ReservationMenuMealData(
|
|
hourType: 'NOONING',
|
|
title: '午餐',
|
|
items: ['香菇滑鸡'],
|
|
),
|
|
ReservationMenuMealData(
|
|
hourType: 'LATE_NIGHT',
|
|
title: '夜间餐',
|
|
items: ['牛肉面'],
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(
|
|
day.displayMeals.map((meal) => meal.title),
|
|
['早餐', '午餐', '晚餐', '夜间餐'],
|
|
);
|
|
expect(day.displayMeals.last.reserved, isTrue);
|
|
expect(day.displayMeals.last.items, ['牛肉面']);
|
|
});
|
|
}
|
|
|
|
Future<ReservationQueryPagePreferences> _defaultPreferences() async =>
|
|
ReservationQueryPagePreferences.defaults;
|
|
|
|
Future<ReservationQueryPagePreferences> _autoCardPreferences() async =>
|
|
const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.card,
|
|
autoRecognitionEnabled: true,
|
|
);
|
|
|
|
Future<ReservationQueryPagePreferences> _autoFacePreferences() async =>
|
|
const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.face,
|
|
autoRecognitionEnabled: true,
|
|
);
|
|
|
|
Future<ReservationQueryPagePreferences>
|
|
_autoCardSingleRoundPreferences() async =>
|
|
const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.card,
|
|
autoRecognitionEnabled: true,
|
|
continuousRecognitionEnabled: false,
|
|
);
|
|
|
|
Future<ReservationQueryPagePreferences> _verificationPreferences() async =>
|
|
const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.card,
|
|
verificationEnabled: true,
|
|
verificationDateScope: ReservationVerificationDateScope.all,
|
|
);
|
|
|
|
/// 构建开启快速核销的测试偏好，保持生产默认值不被测试场景污染。
|
|
Future<ReservationQueryPagePreferences> _quickVerificationPreferences() async =>
|
|
const ReservationQueryPagePreferences(
|
|
methodOrder: ReservationRecognitionMethod.values,
|
|
defaultMethod: ReservationRecognitionMethod.card,
|
|
verificationEnabled: true,
|
|
quickVerificationEnabled: true,
|
|
verificationDateScope: ReservationVerificationDateScope.all,
|
|
);
|
|
|
|
class _CompleterRepository implements ReservationMenuRepository {
|
|
final calls = <_QueryCall>[];
|
|
final completers = <Completer<ServiceReservationMenuQuery?>>[];
|
|
|
|
@override
|
|
Future<ServiceReservationMenuQuery?> query({
|
|
required ReservationRecognitionMethod method,
|
|
required String identityValue,
|
|
required bool maskName,
|
|
}) {
|
|
calls.add(_QueryCall(identityValue: identityValue, maskName: maskName));
|
|
final completer = Completer<ServiceReservationMenuQuery?>();
|
|
completers.add(completer);
|
|
return completer.future;
|
|
}
|
|
}
|
|
|
|
class _ImmediateRepository implements ReservationMenuRepository {
|
|
_ImmediateRepository(this.value);
|
|
|
|
final ServiceReservationMenuQuery value;
|
|
final calls = <_QueryCall>[];
|
|
|
|
@override
|
|
Future<ServiceReservationMenuQuery?> query({
|
|
required ReservationRecognitionMethod method,
|
|
required String identityValue,
|
|
required bool maskName,
|
|
}) async {
|
|
calls.add(_QueryCall(identityValue: identityValue, maskName: maskName));
|
|
return value;
|
|
}
|
|
}
|
|
|
|
class _SequenceRepository implements ReservationMenuRepository {
|
|
_SequenceRepository(this.responses);
|
|
|
|
final List<ServiceReservationMenuQuery?> responses;
|
|
final calls = <_QueryCall>[];
|
|
int _index = 0;
|
|
|
|
@override
|
|
Future<ServiceReservationMenuQuery?> query({
|
|
required ReservationRecognitionMethod method,
|
|
required String identityValue,
|
|
required bool maskName,
|
|
}) async {
|
|
calls.add(_QueryCall(identityValue: identityValue, maskName: maskName));
|
|
return responses[_index++];
|
|
}
|
|
}
|
|
|
|
class _QueryCall {
|
|
const _QueryCall({required this.identityValue, required this.maskName});
|
|
|
|
final String identityValue;
|
|
final bool maskName;
|
|
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
other is _QueryCall &&
|
|
other.identityValue == identityValue &&
|
|
other.maskName == maskName;
|
|
|
|
@override
|
|
int get hashCode => Object.hash(identityValue, maskName);
|
|
|
|
@override
|
|
String toString() =>
|
|
'_QueryCall(identityValue: $identityValue, maskName: $maskName)';
|
|
}
|
|
|
|
/// 记录 Controller 批量核销调用并默认把全部传入订单标记为成功的测试网关。
|
|
class _FakeVerificationGateway implements ReservationVerificationGateway {
|
|
/// 创建默认全成功或返回指定逐笔结果的测试网关。
|
|
_FakeVerificationGateway({this.result});
|
|
|
|
/// 已收到的逐次批量核销调用。
|
|
final calls = <_VerificationCall>[];
|
|
|
|
/// Controller 要求清理的未使用人脸证据会话。
|
|
final discardedSessions = <String>[];
|
|
|
|
/// 测试指定的逐笔结果；为空时根据传入订单构造全部成功。
|
|
final ReservationVerificationResult? result;
|
|
|
|
/// 记录订单列表与人脸会话，并模拟所选订单全部核销成功。
|
|
@override
|
|
Future<ReservationVerificationResult> cancel({
|
|
required List<int> orderIds,
|
|
String? faceEvidenceSessionId,
|
|
}) async {
|
|
calls.add(
|
|
_VerificationCall(
|
|
orderIds: orderIds,
|
|
faceEvidenceSessionId: faceEvidenceSessionId,
|
|
),
|
|
);
|
|
return result ??
|
|
ReservationVerificationResult(
|
|
succeededOrderIds: List.unmodifiable(orderIds),
|
|
failedOrderIds: const [],
|
|
);
|
|
}
|
|
|
|
/// 记录 Controller 放弃的未绑定人脸证据会话。
|
|
@override
|
|
Future<void> discardFaceEvidence({
|
|
required String recognitionSessionId,
|
|
required String reason,
|
|
}) async {
|
|
discardedSessions.add(recognitionSessionId);
|
|
}
|
|
}
|
|
|
|
/// 一次批量核销调用的不可变断言快照。
|
|
class _VerificationCall {
|
|
/// 创建包含订单顺序和可选人脸证据会话的调用快照。
|
|
const _VerificationCall({
|
|
required this.orderIds,
|
|
this.faceEvidenceSessionId,
|
|
});
|
|
|
|
/// Controller 按当前餐段顺序提交的订单 ID。
|
|
final List<int> orderIds;
|
|
|
|
/// 人脸识别产生的证据会话；饭卡核销时为空。
|
|
final String? faceEvidenceSessionId;
|
|
|
|
/// 按订单顺序和证据会话比较两次核销调用。
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
other is _VerificationCall &&
|
|
listEquals(other.orderIds, orderIds) &&
|
|
other.faceEvidenceSessionId == faceEvidenceSessionId;
|
|
|
|
/// 生成与相等判断字段一致的哈希值。
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(Object.hashAll(orderIds), faceEvidenceSessionId);
|
|
}
|
|
|
|
class _FakeRecognitionGateway implements ReservationRecognitionGateway {
|
|
final cardCallbacks =
|
|
<Future<void> Function(ReservationRecognizedIdentity)>[];
|
|
final cardFailures = <void Function(ReservationRecognitionFailure failure)>[];
|
|
final faceCallbacks =
|
|
<Future<void> Function(ReservationRecognizedIdentity)>[];
|
|
final faceFailures = <void Function(ReservationRecognitionFailure failure)>[];
|
|
|
|
/// 每次人脸启动是否使用页面内嵌预览，用于校验持续模式不会再弹独立识别框。
|
|
final faceEmbeddedPreviews = <bool>[];
|
|
int stopAllCalls = 0;
|
|
|
|
Future<void> emitCardAt(int index, String value) {
|
|
return cardCallbacks[index](ReservationRecognizedIdentity(
|
|
identityValue: value,
|
|
));
|
|
}
|
|
|
|
Future<void> emitFaceAt(
|
|
int index,
|
|
String value, {
|
|
String? evidenceSessionId,
|
|
}) {
|
|
return faceCallbacks[index](ReservationRecognizedIdentity(
|
|
identityValue: value,
|
|
faceEvidenceSessionId: evidenceSessionId,
|
|
));
|
|
}
|
|
|
|
@override
|
|
Future<void> startCard({
|
|
required Future<void> Function(ReservationRecognizedIdentity identity)
|
|
onRecognized,
|
|
required void Function(ReservationRecognitionFailure failure) onFailure,
|
|
}) async {
|
|
cardCallbacks.add(onRecognized);
|
|
cardFailures.add(onFailure);
|
|
}
|
|
|
|
@override
|
|
Future<void> startFace({
|
|
required Future<void> Function(ReservationRecognizedIdentity identity)
|
|
onRecognized,
|
|
required void Function(ReservationRecognitionFailure failure) onFailure,
|
|
bool embeddedPreview = false,
|
|
}) async {
|
|
faceCallbacks.add(onRecognized);
|
|
faceFailures.add(onFailure);
|
|
faceEmbeddedPreviews.add(embeddedPreview);
|
|
}
|
|
|
|
@override
|
|
Future<void> stopAll() async {
|
|
stopAllCalls++;
|
|
}
|
|
|
|
@override
|
|
Future<void> stopCard() async {}
|
|
|
|
@override
|
|
Future<void> stopFace() async {}
|
|
}
|
|
|
|
class _FakeSubScreenGateway implements ReservationSubScreenGateway {
|
|
_FakeSubScreenGateway({this.available = true});
|
|
|
|
final bool available;
|
|
final updates = <SubScreenReservationQueryEvent>[];
|
|
int showCalls = 0;
|
|
int clearCalls = 0;
|
|
|
|
@override
|
|
bool get isAvailable => available;
|
|
|
|
@override
|
|
Future<void> show() async {
|
|
showCalls++;
|
|
}
|
|
|
|
@override
|
|
Future<void> update(SubScreenReservationQueryEvent event) async {
|
|
updates.add(event);
|
|
}
|
|
|
|
@override
|
|
Future<void> clear({
|
|
required String sessionId,
|
|
required int revision,
|
|
}) async {
|
|
clearCalls++;
|
|
}
|
|
}
|
|
|
|
class _HangingSubScreenGateway implements ReservationSubScreenGateway {
|
|
final _pendingUpdates = <Completer<void>>[];
|
|
|
|
@override
|
|
bool get isAvailable => true;
|
|
|
|
@override
|
|
Future<void> show() async {}
|
|
|
|
@override
|
|
Future<void> update(SubScreenReservationQueryEvent event) {
|
|
final completer = Completer<void>();
|
|
_pendingUpdates.add(completer);
|
|
return completer.future;
|
|
}
|
|
|
|
@override
|
|
Future<void> clear(
|
|
{required String sessionId, required int revision}) async {}
|
|
|
|
void releaseUpdates() {
|
|
for (final completer in _pendingUpdates) {
|
|
if (!completer.isCompleted) completer.complete();
|
|
}
|
|
}
|
|
}
|
|
|
|
ServiceReservationMenuQuery _result(String maskedName, int dayCount) {
|
|
final start = DateTime(2026, 7, 24);
|
|
final days = List<ServiceReservationDay>.generate(dayCount, (index) {
|
|
final date = start.add(Duration(days: index));
|
|
return ServiceReservationDay(
|
|
date:
|
|
'${date.year}-${date.month.toString().padLeft(2, '0')}-${date.day.toString().padLeft(2, '0')}',
|
|
meals: [
|
|
ServiceReservationMeal(
|
|
hourType: 'LUNCH',
|
|
mealTitle: '午餐',
|
|
items: const ['香菇滑鸡', '清炒时蔬'],
|
|
orderIds: [1001 + index],
|
|
),
|
|
],
|
|
);
|
|
});
|
|
return ServiceReservationMenuQuery(
|
|
maskedName: maskedName,
|
|
deptName: '三年级二班',
|
|
merchantName: '第一食堂',
|
|
totalDayCount: dayCount,
|
|
totalMealCount: dayCount,
|
|
days: days,
|
|
);
|
|
}
|
|
|
|
ServiceReservationMenuQuery _resultWithOrderIds(
|
|
String maskedName,
|
|
List<int> orderIds,
|
|
) {
|
|
return ServiceReservationMenuQuery(
|
|
maskedName: maskedName,
|
|
deptName: '三年级二班',
|
|
merchantName: '第一食堂',
|
|
totalDayCount: 1,
|
|
totalMealCount: orderIds.length,
|
|
days: [
|
|
ServiceReservationDay(
|
|
date: '2026-07-24',
|
|
meals: [
|
|
ServiceReservationMeal(
|
|
hourType: '2',
|
|
mealTitle: '午餐',
|
|
items: const ['香菇滑鸡', '清炒时蔬'],
|
|
orderIds: orderIds,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
ServiceReservationMenuQuery _resultWithBreakfastAndNoon() {
|
|
return ServiceReservationMenuQuery(
|
|
maskedName: '张*明',
|
|
deptName: '三年级二班',
|
|
merchantName: '第一食堂',
|
|
totalDayCount: 1,
|
|
totalMealCount: 2,
|
|
days: const [
|
|
ServiceReservationDay(
|
|
date: '2026-07-24',
|
|
meals: [
|
|
ServiceReservationMeal(
|
|
hourType: '1',
|
|
mealTitle: '早餐',
|
|
items: ['包子'],
|
|
orderIds: [2001],
|
|
),
|
|
ServiceReservationMeal(
|
|
hourType: '2',
|
|
mealTitle: '午餐',
|
|
items: ['香菇滑鸡'],
|
|
orderIds: [2002],
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|