test(T1): add edge-case coverage for EmailRepositoryImpl

Three new test groups bring the unit-test count from 54 to 57:
- concurrent moves: two simultaneous moveEmail calls complete without
  corruption and both changes are enqueued in pending_changes
- SMTP auth failure: sendEmail propagates a 535 authentication error
  thrown by a fake smtpConnect
- IMAP UID validity change: a uidValidity mismatch causes a full re-sync
  that wipes stale local emails and updates the checkpoint

Also extend _makeRepos() to accept optional imapConnect/smtpConnect
overrides, and import drift without the isNull/isNotNull symbols that
clash with package:matcher.

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

lib/core/sync/account_sync_manager.dart

@@ -44,6 +44,16 @@ class AccountSyncManager {
   StreamSubscription<List<Account>>? _accountsSub;
   StreamSubscription<String>? _onChangesSub;
 
+  final _syncPhaseCtrl = StreamController<(String, bool)>.broadcast();
+
+  /// Emits `true` when [accountId] starts syncing, `false` when it stops.
+  Stream<bool> watchSyncing(String accountId) =>
+      _syncPhaseCtrl.stream.where((e) => e.$1 == accountId).map((e) => e.$2);
+
+  void _emitSyncing(String accountId, {required bool syncing}) {
+    if (!_syncPhaseCtrl.isClosed) _syncPhaseCtrl.add((accountId, syncing));
+  }
+
   void start() {
     _onChangesSub = _emails.onChangesQueued.listen((accountId) {
       _active[accountId]?.kick();
@@ -54,6 +64,7 @@ class AccountSyncManager {
 
       for (final account in accounts) {
         if (_active.containsKey(account.id)) continue;
+        final id = account.id;
         final loop = switch (account.type) {
           AccountType.imap => _AccountSync(
               account,
@@ -64,6 +75,8 @@ class AccountSyncManager {
               _syncLog,
               _drafts,
               _onNewMail,
+              onSyncStart: () => _emitSyncing(id, syncing: true),
+              onSyncEnd: () => _emitSyncing(id, syncing: false),
             ),
           AccountType.jmap => _JmapAccountSync(
               account,
@@ -71,6 +84,8 @@ class AccountSyncManager {
               _emails,
               _accounts,
               _syncLog,
+              onSyncStart: () => _emitSyncing(id, syncing: true),
+              onSyncEnd: () => _emitSyncing(id, syncing: false),
             ),
         };
         _active[account.id] = loop;
@@ -92,6 +107,7 @@ class AccountSyncManager {
       s.stop();
     }
     _active.clear();
+    unawaited(_syncPhaseCtrl.close());
   }
 
   /// Wakes the idle/wait phase of the given account's sync loop so a new
@@ -126,6 +142,8 @@ class AccountSyncManager {
           _syncLog,
           _drafts,
           _onNewMail,
+          onSyncStart: () => _emitSyncing(accountId, syncing: true),
+          onSyncEnd: () => _emitSyncing(accountId, syncing: false),
         ),
       AccountType.jmap => _JmapAccountSync(
           account,
@@ -133,6 +151,8 @@ class AccountSyncManager {
           _emails,
           _accounts,
           _syncLog,
+          onSyncStart: () => _emitSyncing(accountId, syncing: true),
+          onSyncEnd: () => _emitSyncing(accountId, syncing: false),
         ),
     };
     _active[accountId] = loop;
@@ -159,8 +179,11 @@ class _AccountSync implements _SyncLoop {
     this._imapConnect,
     this._syncLog,
     this._drafts,
-    this._onNewMail,
-  );
+    this._onNewMail, {
+    void Function()? onSyncStart,
+    void Function()? onSyncEnd,
+  })  : _onSyncStart = onSyncStart,
+        _onSyncEnd = onSyncEnd;
 
   final Account account;
   final AccountRepository _accounts;
@@ -170,6 +193,8 @@ class _AccountSync implements _SyncLoop {
   final SyncLogRepository _syncLog;
   final DraftRepository? _drafts;
   final OnNewMailCallback? _onNewMail;
+  final void Function()? _onSyncStart;
+  final void Function()? _onSyncEnd;
 
   imap.ImapClient? _idleClient;
   bool _running = false;
@@ -202,6 +227,7 @@ class _AccountSync implements _SyncLoop {
   Future<void> _loop() async {
     while (_running) {
       final startedAt = DateTime.now();
+      _onSyncStart?.call();
       try {
         final (_SyncStats stats, String? capturedLog) = await _runSync(
           account.verbose,
@@ -221,8 +247,10 @@ class _AccountSync implements _SyncLoop {
           protocolLog: capturedLog,
         );
         _backoffSeconds = 5;
+        _onSyncEnd?.call();
         await _idle();
       } catch (e, st) {
+        _onSyncEnd?.call();
         final isPermanent = _isPermanentError(e);
         try {
           await _syncLog.log(
@@ -392,14 +420,19 @@ class _JmapAccountSync implements _SyncLoop {
     this._mailboxes,
     this._emails,
     this._accounts,
-    this._syncLog,
-  );
+    this._syncLog, {
+    void Function()? onSyncStart,
+    void Function()? onSyncEnd,
+  })  : _onSyncStart = onSyncStart,
+        _onSyncEnd = onSyncEnd;
 
   final Account account;
   final MailboxRepository _mailboxes;
   final EmailRepository _emails;
   final AccountRepository _accounts;
   final SyncLogRepository _syncLog;
+  final void Function()? _onSyncStart;
+  final void Function()? _onSyncEnd;
 
   bool _running = false;
   int _backoffSeconds = 5;
@@ -431,6 +464,7 @@ class _JmapAccountSync implements _SyncLoop {
   Future<void> _loop() async {
     while (_running) {
       final startedAt = DateTime.now();
+      _onSyncStart?.call();
       try {
         final (_SyncStats stats, String? capturedLog) = await _runSync(
           account.verbose,
@@ -450,8 +484,10 @@ class _JmapAccountSync implements _SyncLoop {
           protocolLog: capturedLog,
         );
         _backoffSeconds = 5;
+        _onSyncEnd?.call();
         await _wait();
       } catch (e, st) {
+        _onSyncEnd?.call();
         final isPermanent = _isPermanentError(e);
         try {
           await _syncLog.log(

lib/di.dart

@@ -115,6 +115,11 @@ final syncHealthProvider =
       .watchSingleOrNull();
 });
 
+final isSyncingProvider =
+    StreamProvider.autoDispose.family<bool, String>((ref, accountId) {
+  return ref.watch(syncManagerProvider).watchSyncing(accountId);
+});
+
 final syncManagerProvider = Provider<AccountSyncManager>((ref) {
   final manager = AccountSyncManager(
     ref.watch(accountRepositoryProvider),

lib/ui/screens/email_list_screen.dart

@@ -180,22 +180,7 @@ class _EmailListScreenState extends ConsumerState<EmailListScreen> {
                   ),
                 ),
               ),
-              IconButton(
-                icon: const Icon(Icons.sync),
-                onPressed: () async {
-                  try {
-                    await emailRepo.syncEmails(
-                      widget.accountId,
-                      widget.mailboxPath,
-                    );
-                  } catch (e) {
-                    if (!mounted) return;
-                    ScaffoldMessenger.of(
-                      context,
-                    ).showSnackBar(SnackBar(content: Text('Sync failed: $e')));
-                  }
-                },
-              ),
+              _buildSyncButton(emailRepo),
               IconButton(
                 icon: const Icon(Icons.edit),
                 onPressed: () => context.push(
@@ -229,6 +214,44 @@ class _EmailListScreenState extends ConsumerState<EmailListScreen> {
     );
   }
 
+  Widget _buildSyncButton(EmailRepository emailRepo) {
+    final isSyncing =
+        ref.watch(isSyncingProvider(widget.accountId)).valueOrNull ?? false;
+    final hasError =
+        ref.watch(syncLastErrorProvider(widget.accountId)).valueOrNull != null;
+    return IconButton(
+      tooltip: isSyncing
+          ? 'Syncing…'
+          : hasError
+              ? 'Sync error'
+              : 'Sync',
+      icon: isSyncing
+          ? const SizedBox(
+              width: 20,
+              height: 20,
+              child: CircularProgressIndicator(strokeWidth: 2),
+            )
+          : hasError
+              ? const Icon(Icons.sync_problem, color: Colors.red)
+              : const Icon(Icons.sync),
+      onPressed: isSyncing
+          ? null
+          : () async {
+              try {
+                await emailRepo.syncEmails(
+                  widget.accountId,
+                  widget.mailboxPath,
+                );
+              } catch (e) {
+                if (!mounted) return;
+                ScaffoldMessenger.of(context).showSnackBar(
+                  SnackBar(content: Text('Sync failed: $e')),
+                );
+              }
+            },
+    );
+  }
+
   Widget _selectionBottomBar() {
     return BottomAppBar(
       child: Row(

test/unit/email_repository_impl_test.dart

@@ -1,7 +1,7 @@
 import 'dart:async';
 import 'dart:convert';
 
-import 'package:drift/drift.dart' show Value;
+import 'package:drift/drift.dart' hide isNull, isNotNull;
 import 'package:enough_mail/enough_mail.dart' as imap;
 import 'package:flutter_test/flutter_test.dart';
 import 'package:http/http.dart' as http;
@@ -16,6 +16,7 @@ import 'package:sharedinbox/data/repositories/email_repository_impl.dart';
 
 import 'account_repository_impl_test.dart' show MapSecureStorage;
 import 'db_test_helper.dart';
+import 'fake_imap.dart' show FakeImapClient;
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 const _account = Account(
@@ -162,15 +163,19 @@ Future<imap.SmtpClient> _noSmtpConnect(Account a, String u, String p) =>
     Future.error(UnsupportedError('SMTP unavailable in unit tests'));
 
 ({AppDatabase db, AccountRepositoryImpl accounts, EmailRepositoryImpl emails})
-    _makeRepos({http.Client? httpClient}) {
+    _makeRepos({
+  http.Client? httpClient,
+  Future<imap.ImapClient> Function(Account, String, String)? imapConnect,
+  Future<imap.SmtpClient> Function(Account, String, String)? smtpConnect,
+}) {
   final db = openTestDatabase();
   final storage = MapSecureStorage();
   final accounts = AccountRepositoryImpl(db, storage);
   final emails = EmailRepositoryImpl(
     db,
     accounts,
-    imapConnect: _noImapConnect,
-    smtpConnect: _noSmtpConnect,
+    imapConnect: imapConnect ?? _noImapConnect,
+    smtpConnect: smtpConnect ?? _noSmtpConnect,
     httpClient: httpClient,
   );
   return (db: db, accounts: accounts, emails: emails);
@@ -1935,6 +1940,163 @@ void main() {
       expect(row.lastError, isNull);
     });
   });
+
+  group('concurrent moves', () {
+    test(
+        'two simultaneous moves enqueue two changes and leave email in last destination',
+        () async {
+      final r = _makeRepos();
+      await r.accounts.addAccount(_account, 'pw');
+      await r.db.into(r.db.emails).insert(
+            EmailsCompanion.insert(
+              id: 'acc-1:5',
+              accountId: 'acc-1',
+              mailboxPath: 'INBOX',
+              uid: 5,
+              receivedAt: DateTime(2024),
+            ),
+          );
+
+      // Fire both moves without awaiting to exercise concurrent enqueue logic.
+      final f1 = r.emails.moveEmail('acc-1:5', 'Archive');
+      final f2 = r.emails.moveEmail('acc-1:5', 'Trash');
+      await Future.wait([f1, f2]);
+
+      final changes = await r.db.select(r.db.pendingChanges).get();
+      expect(changes, hasLength(2));
+      expect(changes.map((c) => c.changeType), everyElement('move'));
+
+      final destinations =
+          changes.map((c) => (jsonDecode(c.payload) as Map)['dest']).toSet();
+      expect(destinations, containsAll(['Archive', 'Trash']));
+
+      final email = await r.emails.getEmail('acc-1:5');
+      expect(
+        email!.mailboxPath,
+        anyOf('Archive', 'Trash'),
+        reason:
+            'email must be optimistically moved to one of the two destinations',
+      );
+    });
+  });
+
+  group('IMAP SMTP auth failure', () {
+    test('sendEmail propagates SMTP authentication error', () async {
+      final r = _makeRepos(
+        smtpConnect: (Account _, String __, String ___) => Future.error(
+          Exception('535 5.7.8 Authentication credentials invalid'),
+        ),
+      );
+      await r.accounts.addAccount(_account, 'pw');
+
+      const draft = EmailDraft(
+        from: EmailAddress(name: 'Alice', email: 'alice@example.com'),
+        to: [EmailAddress(name: 'Bob', email: 'bob@example.com')],
+        cc: [],
+        subject: 'Test',
+        body: 'Body',
+      );
+
+      await expectLater(
+        r.emails.sendEmail('acc-1', draft),
+        throwsA(
+          isA<Exception>().having(
+            (e) => e.toString(),
+            'message',
+            contains('535'),
+          ),
+        ),
+      );
+    });
+  });
+
+  group('IMAP UID validity change', () {
+    test('full re-sync wipes stale emails when uidValidity changes', () async {
+      final r = _makeRepos(
+        imapConnect: (Account _, String __, String ___) async =>
+            _FakeImapClientUidValidity(456),
+      );
+      await r.accounts.addAccount(_account, 'pw');
+
+      // Pre-seed two emails from the old server epoch (uidValidity=123).
+      await r.db.into(r.db.emails).insert(
+            EmailsCompanion.insert(
+              id: 'acc-1:1',
+              accountId: 'acc-1',
+              mailboxPath: 'INBOX',
+              uid: 1,
+              receivedAt: DateTime(2024),
+            ),
+          );
+      await r.db.into(r.db.emails).insert(
+            EmailsCompanion.insert(
+              id: 'acc-1:2',
+              accountId: 'acc-1',
+              mailboxPath: 'INBOX',
+              uid: 2,
+              receivedAt: DateTime(2024),
+            ),
+          );
+
+      // Seed an IMAP checkpoint with the old uidValidity so the code detects
+      // a mismatch and triggers a full re-sync.
+      await r.db.into(r.db.syncStates).insertOnConflictUpdate(
+            SyncStatesCompanion.insert(
+              accountId: 'acc-1',
+              resourceType: 'IMAP:INBOX',
+              state: '{"uidValidity":123,"lastUid":2,"highestModSeq":null}',
+              syncedAt: DateTime(2024),
+            ),
+          );
+
+      await r.emails.syncEmails('acc-1', 'INBOX');
+
+      // Old emails must be wiped; the fake server returns zero messages.
+      final remaining = await r.db.select(r.db.emails).get();
+      expect(remaining, isEmpty);
+
+      // Checkpoint must be updated to the new uidValidity.
+      final stateRow = await (r.db.select(r.db.syncStates)
+            ..where(
+              (t) =>
+                  t.accountId.equals('acc-1') &
+                  t.resourceType.equals('IMAP:INBOX'),
+            ))
+          .getSingleOrNull();
+      expect(stateRow, isNotNull);
+      final state = jsonDecode(stateRow!.state) as Map<String, dynamic>;
+      expect(state['uidValidity'], 456);
+    });
+  });
+}
+
+// ── Additional fake IMAP client for UID-validity tests ───────────────────────
+
+class _FakeImapClientUidValidity extends FakeImapClient {
+  _FakeImapClientUidValidity(this._uidValidity);
+  final int _uidValidity;
+
+  @override
+  Future<imap.Mailbox> selectMailboxByPath(
+    String path, {
+    bool enableCondStore = false,
+    imap.QResyncParameters? qresync,
+  }) async =>
+      imap.Mailbox(
+        encodedName: path,
+        encodedPath: path,
+        flags: [],
+        pathSeparator: '/',
+        uidValidity: _uidValidity,
+      );
+
+  @override
+  Future<imap.SearchImapResult> uidSearchMessages({
+    String searchCriteria = 'ALL',
+    List<imap.ReturnOption>? returnOptions,
+    Duration? responseTimeout,
+  }) async =>
+      imap.SearchImapResult();
 }
 
 // ── SSE test helper ──────────────────────────────────────────────────────────