From 1190e2d079d8ea96af57b9deee39305b2c98070a Mon Sep 17 00:00:00 2001 From: Krzysztof kuhy Rudnicki Date: Sat, 21 Nov 2026 06:50:31 +0100 Subject: [PATCH] Log screen tests: await work, not a fixed sleep The 200 ms settle flaked under load on origin/main too: the open chain or a tap's I/O outlasted it. The screen keeps its open chain in openChain; tests await it, or poll a bounded condition. Todo: 7808ee0a Co-Authored-By: Claude Opus 5.5 --- app/lib/screens/log_meal_logged_mixin.dart | 10 ++++++- app/lib/screens/log_meal_screen.dart | 2 +- app/pubspec.yaml | 2 +- app/test/screens/log_meal_autolog_test.dart | 10 ++++--- .../log_meal_claude_withdraw_test.dart | 16 ++++++++--- app/test/screens/log_meal_test_support.dart | 27 +++++++++++++++++++ 6 files changed, 58 insertions(+), 9 deletions(-) diff --git a/app/lib/screens/log_meal_logged_mixin.dart b/app/lib/screens/log_meal_logged_mixin.dart index 364f85f..fbc458e 100644 --- a/app/lib/screens/log_meal_logged_mixin.dart +++ b/app/lib/screens/log_meal_logged_mixin.dart @@ -22,6 +22,11 @@ mixin LogMealLoggedMixin /// The rows under the action row, oldest first. List loggedRows = const []; + /// The latest open-or-resume chain. Tests await it instead of guessing how + /// long real file I/O takes (a fixed sleep flaked under load). + @visibleForTesting + Future openChain = Future.value(); + /// Replaces the rows with [meals]: a new log retires the previous ones. void showLogged(List meals) { if (mounted) setState(() => loggedRows = meals); @@ -57,12 +62,15 @@ mixin LogMealLoggedMixin // single-flight, so calling super too would let the auto-log run before // the pull finished). Pause still pushes through the sync mixin. if (state == AppLifecycleState.resumed) { - unawaited(onOpenedOrResumed()); + startOpenChain(); return; } super.didChangeAppLifecycleState(state); } + /// Starts [onOpenedOrResumed] and keeps its future in [openChain]. + void startOpenChain() => openChain = onOpenedOrResumed(); + /// What a fresh open or a resume does: show the screen from the local log, /// pull what other devices logged, then auto-log what is still due. Future onOpenedOrResumed() async { diff --git a/app/lib/screens/log_meal_screen.dart b/app/lib/screens/log_meal_screen.dart index 1065a07..2f1aa3d 100644 --- a/app/lib/screens/log_meal_screen.dart +++ b/app/lib/screens/log_meal_screen.dart @@ -90,7 +90,7 @@ class _LogMealScreenState extends State unawaited(_onDescChanged()); // Health first, so a device that stalled earlier says so before a tick. unawaited(refreshSyncHealth()); - unawaited(onOpenedOrResumed()); + startOpenChain(); } @override diff --git a/app/pubspec.yaml b/app/pubspec.yaml index f8eb273..8b76375 100644 --- a/app/pubspec.yaml +++ b/app/pubspec.yaml @@ -2,7 +2,7 @@ name: diet_guard_app description: "Companion phone app for diet_guard: log meals on the go." publish_to: 'none' -version: 1.0.188+1 +version: 1.0.189+1 environment: sdk: ^3.12.2 diff --git a/app/test/screens/log_meal_autolog_test.dart b/app/test/screens/log_meal_autolog_test.dart index 3c81bf5..51ced3e 100644 --- a/app/test/screens/log_meal_autolog_test.dart +++ b/app/test/screens/log_meal_autolog_test.dart @@ -47,7 +47,7 @@ void main() { Future open(WidgetTester tester) async { await tester.pumpWidget(const MaterialApp(home: LogMealScreen())); - await settle(tester); + await settleOpen(tester); } testWidgets('opening in due mode logs the due dishes with no tap', ( @@ -72,7 +72,11 @@ void main() { await tester.runAsync(() async { await open(tester); await tester.tap(byIconLabel('Undo').first); - await settle(tester); + await settleUntil( + tester, + () async => + (await LogStorageService.instance.todayEntries()).length == 1, + ); expect(find.byIcon(Icons.restaurant), findsOneWidget); var live = await LogStorageService.instance.todayEntries(); expect(live.map((e) => e.desc), ['Danie 2']); @@ -130,7 +134,7 @@ void main() { (state as WidgetsBindingObserver).didChangeAppLifecycleState( AppLifecycleState.resumed, ); - await settle(tester); + await settleOpen(tester); final entries = await LogStorageService.instance.todayEntries(); expect(entries.map((e) => e.desc), ['Danie 1', 'Danie 2']); diff --git a/app/test/screens/log_meal_claude_withdraw_test.dart b/app/test/screens/log_meal_claude_withdraw_test.dart index 96c4f0a..2cd56c7 100644 --- a/app/test/screens/log_meal_claude_withdraw_test.dart +++ b/app/test/screens/log_meal_claude_withdraw_test.dart @@ -38,7 +38,7 @@ void main() { Future open(WidgetTester tester) async { await tester.pumpWidget(MaterialApp(home: LogMealScreen(relay: relay))); - await settle(tester); + await settleOpen(tester); } testWidgets('the request id is a ULID and the mode follows due mode', ( @@ -75,7 +75,12 @@ void main() { await settle(tester); await tester.tap(controlByLabel('Log meal')); - await settle(tester); + await settleUntil( + tester, + () async => + relay.cancelled.isNotEmpty && + byIconLabel('Ask Claude').evaluate().isNotEmpty, + ); expect(relay.cancelled, [relay.sent.single.requestId]); expect(byIconLabel('Ask Claude'), findsOneWidget); @@ -88,7 +93,12 @@ void main() { _claudeEntry(claudeEntryId(relay.sent.single.requestId)), ), ); - await settle(tester); + await settleUntil( + tester, + () async => + (await LogStorageService.instance.todayEntries()).length == + (claimed ? 2 : 1), + ); final live = await LogStorageService.instance.todayEntries(); expect(live, hasLength(claimed ? 2 : 1)); }); diff --git a/app/test/screens/log_meal_test_support.dart b/app/test/screens/log_meal_test_support.dart index 387e334..035d50f 100644 --- a/app/test/screens/log_meal_test_support.dart +++ b/app/test/screens/log_meal_test_support.dart @@ -4,6 +4,8 @@ library; import 'dart:io'; import 'package:diet_guard_app/screens/log_meal_due_mixin.dart'; +import 'package:diet_guard_app/screens/log_meal_logged_mixin.dart'; +import 'package:diet_guard_app/screens/log_meal_screen.dart'; import 'package:diet_guard_app/services/app_settings_service.dart'; import 'package:diet_guard_app/services/budget_history_service.dart'; import 'package:diet_guard_app/services/document_store_io.dart'; @@ -51,3 +53,28 @@ Future settle(WidgetTester tester) async { await Future.delayed(const Duration(milliseconds: 200)); await tester.pumpAndSettle(); } + +/// Waits for the screen's open-or-resume chain (sync, slots, catering +/// auto-log) to finish, then [settle]s. +Future settleOpen(WidgetTester tester) async { + final state = tester.state(find.byType(LogMealScreen)); + await (state as LogMealLoggedMixin).openChain; + await settle(tester); +} + +/// [settle]s, then keeps pumping until [done] holds or [timeout] passes. +/// +/// For chains a tap starts and nothing exposes: real file I/O outlasts the +/// fixed sleep in [settle] when the machine is loaded. +Future settleUntil( + WidgetTester tester, + Future Function() done, { + Duration timeout = const Duration(seconds: 5), +}) async { + final deadline = DateTime.now().add(timeout); + await settle(tester); + while (!await done() && DateTime.now().isBefore(deadline)) { + await Future.delayed(const Duration(milliseconds: 50)); + await tester.pumpAndSettle(); + } +}