Don't try to load user trophies in the gym mode when offline

Author: rolandgeider

lib/widgets/routines/gym_mode/summary.dart

@@ -26,8 +26,10 @@ import 'package:wger/l10n/generated/app_localizations.dart';
 import 'package:wger/models/trophies/user_trophy.dart';
 import 'package:wger/models/workouts/session.dart';
 import 'package:wger/providers/gym_state_notifier.dart';
+import 'package:wger/providers/network_provider.dart';
 import 'package:wger/providers/routines_notifier.dart';
 import 'package:wger/providers/trophy_notifier.dart';
+import 'package:wger/widgets/core/error.dart';
 import 'package:wger/widgets/core/progress_indicator.dart';
 import 'package:wger/widgets/routines/gym_mode/navigation.dart';
 
@@ -52,10 +54,17 @@ class _WorkoutSummaryState extends ConsumerState<WorkoutSummary> {
   void didChangeDependencies() {
     super.didChangeDependencies();
     if (!_didInit) {
-      final languageCode = Localizations.localeOf(context).languageCode;
-      _trophyFuture = ref
-          .read(trophyStateProvider.notifier)
-          .fetchUserTrophies(language: languageCode);
+      // Trophies are REST-only and only enrich the summary (PR count + markers).
+      // Fetch them when the server is reachable; offline we skip the doomed
+      // request so the local session stats render right away.
+      if (ref.read(networkStatusProvider)) {
+        final languageCode = Localizations.localeOf(context).languageCode;
+        _trophyFuture = ref
+            .read(trophyStateProvider.notifier)
+            .fetchUserTrophies(language: languageCode);
+      } else {
+        _trophyFuture = Future<void>.value();
+      }
       _didInit = true;
     }
   }
@@ -79,9 +88,13 @@ class _WorkoutSummaryState extends ConsumerState<WorkoutSummary> {
             future: _trophyFuture,
             builder: (context, snapshot) {
               if (snapshot.hasError) {
-                widget._logger.warning(snapshot.error);
-                widget._logger.warning(snapshot.stackTrace);
-                return Center(child: Text('Error: ${snapshot.error}'));
+                // An error reaching here is a genuine, unexpected exception worth surfacing
+                widget._logger.warning(
+                  'Could not fetch user trophies',
+                  snapshot.error,
+                  snapshot.stackTrace,
+                );
+                return StreamErrorIndicator(snapshot.error!, stacktrace: snapshot.stackTrace);
               }
               if (snapshot.connectionState == ConnectionState.waiting || routine == null) {
                 return const BoxedProgressIndicator();

test/routine/gym_mode/gym_mode_test.dart

@@ -19,6 +19,7 @@
 import 'package:clock/clock.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart' as riverpod;
+import 'package:flutter_riverpod/misc.dart' as riverpod;
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mockito/annotations.dart';
 import 'package:mockito/mockito.dart';
@@ -35,6 +36,7 @@ import 'package:wger/providers/gym_state.dart';
 import 'package:wger/providers/network_provider.dart';
 import 'package:wger/providers/routines_notifier.dart';
 import 'package:wger/providers/routines_repository.dart';
+import 'package:wger/providers/trophy_repository.dart';
 import 'package:wger/providers/workout_session_repository.dart';
 import 'package:wger/screens/gym_mode.dart';
 import 'package:wger/screens/routine_screen.dart';
@@ -52,7 +54,7 @@ import '../../../test_data/routines.dart';
 import '../../fake_connectivity.dart';
 import 'gym_mode_test.mocks.dart';
 
-@GenerateMocks([WorkoutSessionRepository, ExerciseRepository, RoutinesRepository])
+@GenerateMocks([WorkoutSessionRepository, ExerciseRepository, RoutinesRepository, TrophyRepository])
 void main() {
   installFakeConnectivity();
 
@@ -89,13 +91,18 @@ void main() {
     ).thenAnswer((_) async => testRoutine);
   });
 
-  Widget renderGymMode({locale = 'en', bool isOnline = true}) {
+  Widget renderGymMode({
+    locale = 'en',
+    bool isOnline = true,
+    List<riverpod.Override> extraOverrides = const [],
+  }) {
     return riverpod.ProviderScope(
       overrides: [
         networkStatusProvider.overrideWithValue(isOnline),
         routinesRepositoryProvider.overrideWithValue(mockRoutinesRepo),
         exerciseRepositoryProvider.overrideWithValue(mockExerciseRepo),
         workoutSessionRepositoryProvider.overrideWithValue(mockSessionRepo),
+        ...extraOverrides,
         // The repetition + weight unit catalogues are tiny direct-Drift
         // stream providers, overriding them inline is the established
         // pattern (see also [exerciseCategoriesProvider] etc.).
@@ -365,6 +372,79 @@ void main() {
     });
   });
 
+  testWidgets('offline summary shows the local session stats', (WidgetTester tester) async {
+    // The trophy fetch is REST-only; offline it is skipped so the locally
+    // stored session stats (duration, volume) render right away instead of
+    // waiting behind a doomed network request. The clock matches a session in
+    // the test routine so there is data to show.
+    await withClock(Clock.fixed(DateTime(2021, 5, 1, 14, 33)), () async {
+      await tester.pumpWidget(renderGymMode(isOnline: false));
+      await tester.pumpAndSettle();
+
+      // Prime the keepAlive routines stream (see the offline test above).
+      final container = riverpod.ProviderScope.containerOf(
+        tester.element(find.byType(TextButton)),
+      );
+      container.listen(routinesRiverpodProvider, (_, _) {});
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.byType(TextButton));
+      await tester.pumpAndSettle();
+
+      // Jump straight to the summary via the menu's "End workout" shortcut.
+      await tester.tap(find.byIcon(Icons.menu));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('End workout'));
+      await tester.pumpAndSettle();
+
+      expect(find.byType(WorkoutSummary), findsOneWidget);
+      expect(find.byType(StreamErrorIndicator), findsNothing);
+      expect(find.text('Duration'), findsOneWidget);
+      expect(find.text('Volume'), findsOneWidget);
+    });
+  });
+
+  testWidgets('summary surfaces an unexpected trophy-fetch error', (WidgetTester tester) async {
+    // Network/server errors are swallowed by the repository, so an error that
+    // does reach the summary is a genuine exception and must be shown, not
+    // hidden behind the stats.
+    final mockTrophyRepo = MockTrophyRepository();
+    when(mockTrophyRepo.fetchTrophies(language: anyNamed('language'))).thenAnswer((_) async => []);
+    when(
+      mockTrophyRepo.fetchProgression(
+        filterQuery: anyNamed('filterQuery'),
+        language: anyNamed('language'),
+      ),
+    ).thenAnswer((_) async => []);
+    when(
+      mockTrophyRepo.fetchUserTrophies(
+        filterQuery: anyNamed('filterQuery'),
+        language: anyNamed('language'),
+      ),
+    ).thenThrow(Exception('unexpected'));
+
+    await withClock(Clock.fixed(DateTime(2021, 5, 1, 14, 33)), () async {
+      await tester.pumpWidget(
+        renderGymMode(
+          extraOverrides: [trophyRepositoryProvider.overrideWithValue(mockTrophyRepo)],
+        ),
+      );
+      await tester.pumpAndSettle();
+      await tester.tap(find.byType(TextButton));
+      await tester.pumpAndSettle();
+
+      // Jump straight to the summary via the menu's "End workout" shortcut.
+      await tester.tap(find.byIcon(Icons.menu));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('End workout'));
+      await tester.pumpAndSettle();
+
+      expect(find.byType(WorkoutSummary), findsOneWidget);
+      expect(find.byType(StreamErrorIndicator), findsOneWidget);
+      expect(find.text('Duration'), findsNothing);
+    });
+  });
+
   testWidgets(
     'fresh session with exercise pages off: first swipe to a log page does not crash',
     (WidgetTester tester) async {