Expand test coverage for auth and suspected location

AuthService:
- restoreLoginLocal: simulate mode not-logged-in, cross-mode isolation
- Round-trip: restoreLogin caches name, restoreLoginLocal reads it
- restoreLogin: verify cache overwrite with fresh fetch
- 401 logout: verify cached display name is also cleared

AuthState:
- refreshIfNeeded: token rejection clears username, name updates
- onUploadModeChanged: not-logged-in clears state, error handling
- getAccessToken: delegation to service

SuspectedLocationState:
- refreshIfNeeded: offline mode pass-through, progress cleanup
- init (full): offlineMode parameter forwarding

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

test/services/auth_service_test.dart

@@ -268,6 +268,15 @@ void main() {
       verifyNever(() => mockClient.get(any(), headers: any(named: 'headers')));
     });
 
+    test('returns null in simulate mode when not logged in', () async {
+      SharedPreferences.setMockInitialValues({});
+      service = createService(mode: UploadMode.simulate);
+
+      final result = await service.restoreLoginLocal();
+
+      expect(result, isNull);
+    });
+
     test('uses correct key per mode (sandbox)', () async {
       SharedPreferences.setMockInitialValues({
         'osm_token_sandbox': jsonEncode({'accessToken': 'sandbox-token'}),
@@ -279,6 +288,89 @@ void main() {
 
       expect(result, equals('SandboxLocal'));
     });
+
+    test('does not cross-read production cache when in sandbox mode', () async {
+      SharedPreferences.setMockInitialValues({
+        'osm_token_sandbox': jsonEncode({'accessToken': 'sandbox-token'}),
+        'cached_display_name_production': 'ProdUser',
+        // No sandbox cache key
+      });
+      service = createService(mode: UploadMode.sandbox);
+
+      final result = await service.restoreLoginLocal();
+
+      // Should return empty string (no sandbox cache), not ProdUser
+      expect(result, equals(''));
+    });
+  });
+
+  group('restoreLogin then restoreLoginLocal round-trip', () {
+    test('restoreLogin caches name, then restoreLoginLocal reads it', () async {
+      SharedPreferences.setMockInitialValues({
+        'osm_token_prod': jsonEncode({'accessToken': 'valid-token'}),
+      });
+      service = createService();
+
+      // First call: network fetch caches the name
+      when(() => mockClient.get(any(), headers: any(named: 'headers')))
+          .thenAnswer((_) async => http.Response(
+                jsonEncode({
+                  'user': {'display_name': 'NetworkUser'}
+                }),
+                200,
+              ));
+      await service.restoreLogin();
+
+      // Create a new service instance to simulate app restart
+      service = createService();
+      final result = await service.restoreLoginLocal();
+
+      expect(result, equals('NetworkUser'));
+      // Only one HTTP call (from the first restoreLogin)
+      verify(() => mockClient.get(any(), headers: any(named: 'headers'))).called(1);
+    });
+  });
+
+  group('restoreLogin updates stale cache', () {
+    test('overwrites old cached name with fresh fetch', () async {
+      SharedPreferences.setMockInitialValues({
+        'osm_token_prod': jsonEncode({'accessToken': 'valid-token'}),
+        'cached_display_name_production': 'OldName',
+      });
+      service = createService();
+
+      when(() => mockClient.get(any(), headers: any(named: 'headers')))
+          .thenAnswer((_) async => http.Response(
+                jsonEncode({
+                  'user': {'display_name': 'NewName'}
+                }),
+                200,
+              ));
+
+      await service.restoreLogin();
+
+      final prefs = await SharedPreferences.getInstance();
+      expect(prefs.getString('cached_display_name_production'), equals('NewName'));
+    });
+  });
+
+  group('401/403 clears cached display name', () {
+    test('logout on 401 also clears cached display name', () async {
+      SharedPreferences.setMockInitialValues({
+        'osm_token_prod': jsonEncode({'accessToken': 'expired-token'}),
+        'cached_display_name_production': 'CachedUser',
+      });
+      service = createService();
+
+      when(() => mockClient.get(any(), headers: any(named: 'headers')))
+          .thenAnswer((_) async => http.Response('Unauthorized', 401));
+
+      await service.restoreLogin();
+
+      final prefs = await SharedPreferences.getInstance();
+      expect(prefs.getString('osm_token_prod'), isNull);
+      expect(prefs.getString('cached_display_name_production'), isNull);
+    });
   });
 
   group('isLoggedIn', () {

test/state/auth_state_test.dart

@@ -118,6 +118,42 @@ void main() {
 
       expect(state.isLoggedIn, isFalse);
     });
+
+    test('clears username when restoreLogin returns null (token rejected)', () async {
+      // First set up a logged-in state via init
+      when(() => mockAuth.setUploadMode(any())).thenReturn(null);
+      when(() => mockAuth.isLoggedIn()).thenAnswer((_) async => true);
+      when(() => mockAuth.restoreLoginLocal())
+          .thenAnswer((_) async => 'InitialUser');
+      await state.init(UploadMode.production);
+      expect(state.isLoggedIn, isTrue);
+
+      // Now refreshIfNeeded returns null (token was rejected, user logged out)
+      when(() => mockAuth.restoreLogin()).thenAnswer((_) async => null);
+
+      await state.refreshIfNeeded();
+
+      expect(state.isLoggedIn, isFalse);
+      expect(state.username, equals(''));
+    });
+
+    test('updates username when restoreLogin returns new name', () async {
+      // Set up initial state
+      when(() => mockAuth.setUploadMode(any())).thenReturn(null);
+      when(() => mockAuth.isLoggedIn()).thenAnswer((_) async => true);
+      when(() => mockAuth.restoreLoginLocal())
+          .thenAnswer((_) async => 'OldUser');
+      await state.init(UploadMode.production);
+      expect(state.username, equals('OldUser'));
+
+      // refreshIfNeeded fetches updated name
+      when(() => mockAuth.restoreLogin())
+          .thenAnswer((_) async => 'UpdatedUser');
+
+      await state.refreshIfNeeded();
+
+      expect(state.username, equals('UpdatedUser'));
+    });
   });
 
   group('login', () {
@@ -187,18 +223,47 @@ void main() {
     });
 
     test('clears username when not logged in for new mode', () async {
-      // First set up a logged-in state
+      // Start logged in
       when(() => mockAuth.login()).thenAnswer((_) async => 'User');
       await state.login();
       expect(state.isLoggedIn, isTrue);
 
-      // Switch mode where user is not logged in
+      // Switch to sandbox where user is not logged in
       when(() => mockAuth.setUploadMode(any())).thenReturn(null);
       when(() => mockAuth.isLoggedIn()).thenAnswer((_) async => false);
 
       await state.onUploadModeChanged(UploadMode.sandbox);
 
       expect(state.isLoggedIn, isFalse);
     });
+
+    test('handles error during mode change gracefully', () async {
+      when(() => mockAuth.setUploadMode(any())).thenReturn(null);
+      when(() => mockAuth.isLoggedIn()).thenThrow(Exception('storage error'));
+
+      await state.onUploadModeChanged(UploadMode.sandbox);
+
+      expect(state.isLoggedIn, isFalse);
+    });
+  });
+
+  group('getAccessToken', () {
+    test('delegates to auth service', () async {
+      when(() => mockAuth.getAccessToken())
+          .thenAnswer((_) async => 'my-token');
+
+      final token = await state.getAccessToken();
+
+      expect(token, equals('my-token'));
+    });
+
+    test('returns null when no token', () async {
+      when(() => mockAuth.getAccessToken())
+          .thenAnswer((_) async => null);
+
+      final token = await state.getAccessToken();
+
+      expect(token, isNull);
+    });
   });
 }

test/state/suspected_location_state_test.dart

@@ -78,6 +78,37 @@ void main() {
 
       expect(state.isLoading, isFalse);
     });
+
+    test('passes offlineMode through to service', () async {
+      when(() => mockService.refreshIfNeeded(offlineMode: true))
+          .thenAnswer((_) async => false);
+
+      await state.refreshIfNeeded(offlineMode: true);
+
+      verify(() => mockService.refreshIfNeeded(offlineMode: true)).called(1);
+      expect(state.isLoading, isFalse);
+    });
+
+    test('clears download progress after refresh', () async {
+      when(() => mockService.refreshIfNeeded(offlineMode: false))
+          .thenAnswer((_) async => true);
+
+      await state.refreshIfNeeded();
+
+      expect(state.downloadProgress, isNull);
+    });
+  });
+
+  group('init (full — with network)', () {
+    test('calls service.init with offlineMode', () async {
+      when(() => mockService.init(offlineMode: true))
+          .thenAnswer((_) async {});
+      when(() => mockService.isEnabled).thenReturn(false);
+
+      await state.init(offlineMode: true);
+
+      verify(() => mockService.init(offlineMode: true)).called(1);
+    });
   });
 
   group('selection', () {