feat: add unread notification count widget & notifier

doc/roadmap.txt

···
       - NotificationTypeIcon (like, repost, follow, mention, reply, quote)
 
 Phase 2: Unread Count and Mark as Seen
-- [ ] UnreadCountNotifier:
+- [x] UnreadCountNotifier:
       - watchUnreadCount stream
       - refresh from getUnreadCount API
-- [ ] UnreadBadge widget:
+- [x] UnreadBadge widget:
       - display count on tab icon
       - hide when zero, show "99+" for large counts
 - [ ] Mark as seen:

lib/src/core/widgets/tab_scaffold.dart

···
 import 'package:lazurite/src/features/auth/application/auth_providers.dart';
 import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/composer/presentation/widgets/global_compose_fab.dart';
+import 'package:lazurite/src/features/notifications/application/unread_count_notifier.dart';
+import 'package:lazurite/src/features/notifications/presentation/widgets/unread_badge.dart';
 
 /// Bottom navigation scaffold that wraps the tab content.
 ///
···
   Widget build(BuildContext context) {
     final authState = ref.watch(authProvider);
     final isAuthenticated = authState is AuthStateAuthenticated;
+    final unreadCountAsync = ref.watch(unreadCountProvider);
 
     _ensureHomeBranchWhenUnauthenticated(isAuthenticated);
+
+    final unreadCount = unreadCountAsync.when(
+      data: (count) => count,
+      loading: () => 0,
+      error: (_, _) => 0,
+    );
 
     return Scaffold(
       body: widget.navigationShell,
···
             widget.navigationShell.goBranch(0, initialLocation: true);
           }
         },
-        destinations: isAuthenticated ? _authenticatedDestinations : _unauthenticatedDestinations,
+        destinations: isAuthenticated
+            ? _buildAuthenticatedDestinations(unreadCount)
+            : _unauthenticatedDestinations,
       ),
       floatingActionButton: _shouldShowFab(context, isAuthenticated)
           ? const GlobalComposeFab()
···
   }
 }
 
-const _authenticatedDestinations = [
-  NavigationDestination(
-    icon: Icon(Icons.home_outlined),
-    selectedIcon: Icon(Icons.home),
-    label: 'Home',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.search_outlined),
-    selectedIcon: Icon(Icons.search),
-    label: 'Search',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.notifications_outlined),
-    selectedIcon: Icon(Icons.notifications),
-    label: 'Notifications',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.mail_outlined),
-    selectedIcon: Icon(Icons.mail),
-    label: 'Messages',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.person_outlined),
-    selectedIcon: Icon(Icons.person),
-    label: 'Profile',
-  ),
-];
+/// Builds authenticated navigation destinations with unread count badge.
+List<NavigationDestination> _buildAuthenticatedDestinations(int unreadCount) {
+  return [
+    const NavigationDestination(
+      icon: Icon(Icons.home_outlined),
+      selectedIcon: Icon(Icons.home),
+      label: 'Home',
+    ),
+    const NavigationDestination(
+      icon: Icon(Icons.search_outlined),
+      selectedIcon: Icon(Icons.search),
+      label: 'Search',
+    ),
+    NavigationDestination(
+      icon: UnreadBadge(count: unreadCount, child: const Icon(Icons.notifications_outlined)),
+      selectedIcon: UnreadBadge(count: unreadCount, child: const Icon(Icons.notifications)),
+      label: 'Notifications',
+    ),
+    const NavigationDestination(
+      icon: Icon(Icons.mail_outlined),
+      selectedIcon: Icon(Icons.mail),
+      label: 'Messages',
+    ),
+    const NavigationDestination(
+      icon: Icon(Icons.person_outlined),
+      selectedIcon: Icon(Icons.person),
+      label: 'Profile',
+    ),
+  ];
+}
 
 const _unauthenticatedDestinations = [
   NavigationDestination(

lib/src/features/notifications/application/unread_count_notifier.dart

···
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+import '../../../core/utils/logger.dart';
+import '../../../core/utils/logger_provider.dart';
+import '../../../features/auth/application/auth_providers.dart';
+import '../../../features/auth/domain/auth_state.dart';
+import 'notifications_providers.dart';
+
+part 'unread_count_notifier.g.dart';
+
+/// Notifier for managing unread notification count.
+///
+/// Watches the unread count stream from the database and provides
+/// reactive updates when notifications are marked as read.
+@riverpod
+class UnreadCountNotifier extends _$UnreadCountNotifier {
+  Logger get _logger => ref.read(loggerProvider('UnreadCountNotifier'));
+
+  bool get _isAuthenticated => ref.read(authProvider) is AuthStateAuthenticated;
+
+  @override
+  Stream<int> build() {
+    if (!_isAuthenticated) {
+      _logger.debug('Not authenticated, returning 0 unread count', {});
+      return Stream.value(0);
+    }
+
+    final repository = ref.watch(notificationsRepositoryProvider);
+    _logger.debug('Building unread count stream', {});
+    return repository.watchUnreadCount();
+  }
+}

lib/src/features/notifications/application/unread_count_notifier.g.dart

···
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'unread_count_notifier.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// ignore_for_file: type=lint, type=warning
+/// Notifier for managing unread notification count.
+///
+/// Watches the unread count stream from the database and provides
+/// reactive updates when notifications are marked as read.
+
+@ProviderFor(UnreadCountNotifier)
+final unreadCountProvider = UnreadCountNotifierProvider._();
+
+/// Notifier for managing unread notification count.
+///
+/// Watches the unread count stream from the database and provides
+/// reactive updates when notifications are marked as read.
+final class UnreadCountNotifierProvider extends $StreamNotifierProvider<UnreadCountNotifier, int> {
+  /// Notifier for managing unread notification count.
+  ///
+  /// Watches the unread count stream from the database and provides
+  /// reactive updates when notifications are marked as read.
+  UnreadCountNotifierProvider._()
+    : super(
+        from: null,
+        argument: null,
+        retry: null,
+        name: r'unreadCountProvider',
+        isAutoDispose: true,
+        dependencies: null,
+        $allTransitiveDependencies: null,
+      );
+
+  @override
+  String debugGetCreateSourceHash() => _$unreadCountNotifierHash();
+
+  @$internal
+  @override
+  UnreadCountNotifier create() => UnreadCountNotifier();
+}
+
+String _$unreadCountNotifierHash() => r'd92a51e1927057acc715ca32c4371e16e56b8707';
+
+/// Notifier for managing unread notification count.
+///
+/// Watches the unread count stream from the database and provides
+/// reactive updates when notifications are marked as read.
+
+abstract class _$UnreadCountNotifier extends $StreamNotifier<int> {
+  Stream<int> build();
+  @$mustCallSuper
+  @override
+  void runBuild() {
+    final ref = this.ref as $Ref<AsyncValue<int>, int>;
+    final element =
+        ref.element
+            as $ClassProviderElement<
+              AnyNotifier<AsyncValue<int>, int>,
+              AsyncValue<int>,
+              Object?,
+              Object?
+            >;
+    element.handleCreate(ref, build);
+  }
+}

lib/src/features/notifications/infrastructure/notifications_repository.dart

···
     return _dao.markAllAsRead();
   }
 
+  /// Returns a stream of the unread notification count.
+  ///
+  /// Emits updates whenever notifications are inserted, updated, or deleted.
+  Stream<int> watchUnreadCount() {
+    return _dao.watchUnreadCount();
+  }
+
   /// Encodes labels array to JSON string.
   String? _encodeLabels(dynamic labels) {
     if (labels == null) return null;

lib/src/features/notifications/presentation/widgets/unread_badge.dart

···
+import 'package:flutter/material.dart';
+
+/// Badge widget for displaying unread notification count.
+///
+/// Displays a numeric badge on the notifications tab icon. The badge
+/// automatically hides when count is zero and formats large counts as "99+".
+///
+/// Features:
+/// - Shows count for values > 0
+/// - Formats counts > 99 as "99+"
+/// - Hides badge when count is 0
+/// - Semantic label for screen readers
+/// - Adapts to Material Design theme
+class UnreadBadge extends StatelessWidget {
+  const UnreadBadge({required this.count, required this.child, super.key});
+
+  /// The unread notification count to display.
+  ///
+  /// When 0, the badge is hidden. When > 99, displays as "99+".
+  final int count;
+
+  /// The child widget to display the badge on (typically an Icon).
+  final Widget child;
+
+  /// Maximum count to display before showing "99+".
+  static const int _maxDisplayCount = 99;
+
+  @override
+  Widget build(BuildContext context) {
+    final isVisible = count > 0;
+    final displayText = count > _maxDisplayCount ? '99+' : '$count';
+
+    return Badge(
+      label: Text(displayText),
+      isLabelVisible: isVisible,
+      child: Semantics(
+        label: isVisible ? '$count unread notifications' : null,
+        excludeSemantics: !isVisible,
+        child: child,
+      ),
+    );
+  }
+}

lib/src/infrastructure/db/daos/notifications_dao.dart

···
       const NotificationsCompanion(isRead: Value(true)),
     );
   }
+
+  /// Gets a stream of the unread notification count.
+  ///
+  /// Emits updates whenever notifications are inserted, updated, or deleted.
+  Stream<int> watchUnreadCount() {
+    final query = selectOnly(notifications)..addColumns([notifications.uri.count()]);
+    query.where(notifications.isRead.equals(false));
+    return query.map((row) => row.read(notifications.uri.count()) ?? 0).watchSingle();
+  }
 }
 
 /// Represents a notification with its actor profile.

test/src/core/widgets/tab_scaffold_test.dart

···
+import 'dart:async';
+
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:go_router/go_router.dart';
···
 import 'package:lazurite/src/features/auth/application/auth_providers.dart';
 import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/composer/presentation/widgets/global_compose_fab.dart';
+import 'package:lazurite/src/features/notifications/application/unread_count_notifier.dart';
+import 'package:lazurite/src/features/notifications/presentation/widgets/unread_badge.dart';
 
 import '../../../helpers/pump_app.dart';
 
···
   }
 }
 
+class _TestUnreadCountNotifier extends UnreadCountNotifier {
+  _TestUnreadCountNotifier(this._stream);
+
+  final Stream<int> _stream;
+
+  @override
+  Stream<int> build() => _stream;
+}
+
 void main() {
   group('TabScaffold - Authenticated', () {
     testWidgets('renders NavigationBar with 5 destinations when authenticated', (tester) async {
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
       expect(find.byType(NavigationBar), findsOneWidget);
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
       expect(find.text('Home Content'), findsOneWidget);
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
       expect(find.byIcon(Icons.home), findsOneWidget);
···
 
         await tester.pumpRouterApp(
           router: router,
-          overrides: [authProvider.overrideWith(() => authNotifier)],
+          overrides: [
+            authProvider.overrideWith(() => authNotifier),
+            unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
+          ],
         );
 
         expect(find.byType(NavigationDestination), findsNWidgets(2));
···
 
         await tester.pumpRouterApp(
           router: router,
-          overrides: [authProvider.overrideWith(() => authNotifier)],
+          overrides: [
+            authProvider.overrideWith(() => authNotifier),
+            unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
+          ],
         );
 
         expect(find.byType(NavigationDestination), findsNWidgets(5));
···
 
         await tester.pumpRouterApp(
           router: router,
-          overrides: [authProvider.overrideWith(() => authNotifier)],
+          overrides: [
+            authProvider.overrideWith(() => authNotifier),
+            unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
+          ],
         );
 
         await tester.tap(find.text('Messages'));
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
 
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
 
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
 
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
 
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
 
···
           authProvider.overrideWith(
             () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
           ),
+          unreadCountProvider.overrideWith(() => _TestUnreadCountNotifier(Stream.value(0))),
         ],
       );
 
···
       await tester.tap(find.text('Profile'));
       await tester.pumpAndSettle();
       expect(find.byType(GlobalComposeFab), findsOneWidget);
+    });
+  });
+
+  group('TabScaffold - Unread Badge', () {
+    testWidgets('uses UnreadBadge widget for notifications tab', (tester) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(5);
+      await tester.pumpAndSettle();
+
+      expect(find.byType(UnreadBadge), findsAtLeastNWidgets(1));
+      expect(find.text('5'), findsOneWidget);
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('shows badge with count on notifications tab when unread count > 0', (
+      tester,
+    ) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(5);
+      await tester.pumpAndSettle();
+
+      expect(find.byType(Badge), findsAtLeastNWidgets(1));
+      expect(find.text('5'), findsOneWidget);
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('hides badge when unread count is 0', (tester) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(0);
+      await tester.pumpAndSettle();
+
+      final badges = tester.widgetList<Badge>(find.byType(Badge));
+      for (final badge in badges) {
+        expect(badge.isLabelVisible, false);
+      }
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('updates badge count reactively', (tester) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(3);
+      await tester.pumpAndSettle();
+      expect(find.text('3'), findsOneWidget);
+
+      unreadCountController.add(10);
+      await tester.pumpAndSettle();
+      expect(find.text('10'), findsOneWidget);
+      expect(find.text('3'), findsNothing);
+
+      unreadCountController.add(0);
+      await tester.pumpAndSettle();
+      final badges = tester.widgetList<Badge>(find.byType(Badge));
+      for (final badge in badges) {
+        expect(badge.isLabelVisible, false);
+      }
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('badge appears on both selected and unselected notification icons', (
+      tester,
+    ) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(7);
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('Notifications'));
+      await tester.pumpAndSettle();
+
+      expect(find.byType(Badge), findsAtLeastNWidgets(1));
+      expect(find.text('7'), findsOneWidget);
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('no badge shown when unauthenticated', (tester) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(() => _TestAuthNotifier(const AuthState.unauthenticated())),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(5);
+      await tester.pumpAndSettle();
+
+      expect(find.text('Notifications'), findsNothing);
+      expect(find.byType(Badge), findsNothing);
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('displays "99+" for counts greater than 99', (tester) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(150);
+      await tester.pumpAndSettle();
+
+      expect(find.text('99+'), findsOneWidget);
+      expect(find.text('150'), findsNothing);
+
+      await unreadCountController.close();
+    });
+
+    testWidgets('displays exact count for 99 notifications', (tester) async {
+      final router = _createTestRouter();
+      final unreadCountController = StreamController<int>();
+
+      await tester.pumpRouterApp(
+        router: router,
+        overrides: [
+          authProvider.overrideWith(
+            () => _TestAuthNotifier(AuthState.authenticated(_testSession())),
+          ),
+          unreadCountProvider.overrideWith(
+            () => _TestUnreadCountNotifier(unreadCountController.stream),
+          ),
+        ],
+      );
+
+      unreadCountController.add(99);
+      await tester.pumpAndSettle();
+
+      expect(find.text('99'), findsOneWidget);
+      expect(find.text('99+'), findsNothing);
+
+      await unreadCountController.close();
     });
   });
 }

test/src/features/notifications/application/unread_count_notifier_test.dart

···
+import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/core/auth/session_model.dart';
+import 'package:lazurite/src/core/utils/logger_provider.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
+import 'package:lazurite/src/features/notifications/application/notifications_providers.dart';
+import 'package:lazurite/src/features/notifications/application/unread_count_notifier.dart';
+import 'package:mocktail/mocktail.dart';
+
+import '../../../../helpers/mocks.dart';
+
+void main() {
+  late MockNotificationsRepository mockRepository;
+  late MockLogger mockLogger;
+
+  setUpAll(() {
+    registerFallbackValue(const AsyncLoading<int>());
+  });
+
+  ProviderContainer createContainer({bool authenticated = true}) {
+    return ProviderContainer(
+      overrides: [
+        notificationsRepositoryProvider.overrideWithValue(mockRepository),
+        loggerProvider('UnreadCountNotifier').overrideWithValue(mockLogger),
+        authProvider.overrideWith(() => _FakeAuthNotifier(authenticated: authenticated)),
+      ],
+    );
+  }
+
+  setUp(() {
+    mockRepository = MockNotificationsRepository();
+    mockLogger = MockLogger();
+
+    when(() => mockLogger.debug(any(), any())).thenReturn(null);
+    when(() => mockLogger.info(any(), any())).thenReturn(null);
+    when(() => mockLogger.error(any(), any(), any())).thenReturn(null);
+
+    when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(0));
+  });
+
+  group('UnreadCountNotifier', () {
+    test('build watches unread count stream when authenticated', () async {
+      final container = createContainer();
+      addTearDown(container.dispose);
+
+      container.read(unreadCountProvider);
+
+      await pumpEventQueue();
+
+      verify(() => mockRepository.watchUnreadCount()).called(1);
+    });
+
+    test('build returns 0 when not authenticated', () async {
+      final container = createContainer(authenticated: false);
+      addTearDown(container.dispose);
+
+      int? emittedValue;
+      container.listen(
+        unreadCountProvider,
+        (previous, next) {
+          next.whenData((value) => emittedValue = value);
+        },
+      );
+
+      await pumpEventQueue();
+
+      expect(emittedValue, 0);
+      verifyNever(() => mockRepository.watchUnreadCount());
+    });
+
+    test('stream emits unread count from repository', () async {
+      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(5));
+
+      final container = createContainer();
+      addTearDown(container.dispose);
+
+      int? emittedValue;
+      container.listen(
+        unreadCountProvider,
+        (previous, next) {
+          next.whenData((value) => emittedValue = value);
+        },
+      );
+
+      await pumpEventQueue();
+
+      expect(emittedValue, 5);
+      verify(() => mockRepository.watchUnreadCount()).called(1);
+    });
+
+    test('stream emits multiple updates as count changes', () async {
+      final controller = StreamController<int>();
+      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => controller.stream);
+
+      final container = createContainer();
+      addTearDown(() {
+        controller.close();
+        container.dispose();
+      });
+
+      final emittedValues = <int>[];
+      container.listen(
+        unreadCountProvider,
+        (previous, next) {
+          next.whenData((value) => emittedValues.add(value));
+        },
+      );
+
+      controller.add(3);
+      await pumpEventQueue();
+
+      controller.add(5);
+      await pumpEventQueue();
+
+      controller.add(0);
+      await pumpEventQueue();
+
+      expect(emittedValues, [3, 5, 0]);
+    });
+
+    test('stream handles zero unread count', () async {
+      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(0));
+
+      final container = createContainer();
+      addTearDown(container.dispose);
+
+      int? emittedValue;
+      container.listen(
+        unreadCountProvider,
+        (previous, next) {
+          next.whenData((value) => emittedValue = value);
+        },
+      );
+
+      await pumpEventQueue();
+
+      expect(emittedValue, 0);
+      verify(() => mockRepository.watchUnreadCount()).called(1);
+    });
+
+    test('stream handles large unread counts', () async {
+      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(9999));
+
+      final container = createContainer();
+      addTearDown(container.dispose);
+
+      int? emittedValue;
+      container.listen(
+        unreadCountProvider,
+        (previous, next) {
+          next.whenData((value) => emittedValue = value);
+        },
+      );
+
+      await pumpEventQueue();
+
+      expect(emittedValue, 9999);
+    });
+  });
+}
+
+class _FakeAuthNotifier extends AuthNotifier {
+  _FakeAuthNotifier({required this.authenticated});
+
+  final bool authenticated;
+
+  @override
+  AuthState build() {
+    if (authenticated) {
+      return AuthState.authenticated(
+        Session(
+          did: 'did:plc:test',
+          scope: 'test',
+          handle: 'test.bsky.social',
+          accessJwt: 'access',
+          refreshJwt: 'refresh',
+          pdsUrl: 'https://bsky.social',
+          dpopKey: {'kty': 'OKP'},
+          expiresAt: DateTime.now().add(const Duration(minutes: 30)),
+        ),
+      );
+    }
+
+    return const AuthState.unauthenticated();
+  }
+}

test/src/features/notifications/presentation/widgets/unread_badge_test.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/notifications/presentation/widgets/unread_badge.dart';
+
+void main() {
+  group('UnreadBadge', () {
+    testWidgets('displays badge with count when count > 0', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 5, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.byType(Badge), findsOneWidget);
+      expect(find.text('5'), findsOneWidget);
+
+      final badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isTrue);
+    });
+
+    testWidgets('hides badge when count is 0', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 0, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.byType(Badge), findsOneWidget);
+      final badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isFalse);
+    });
+
+    testWidgets('displays "99+" for counts greater than 99', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 150, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('99+'), findsOneWidget);
+      expect(find.text('150'), findsNothing);
+
+      final badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isTrue);
+    });
+
+    testWidgets('displays exact count for count = 99', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 99, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('99'), findsOneWidget);
+      expect(find.text('99+'), findsNothing);
+    });
+
+    testWidgets('displays "99+" for count = 100', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 100, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('99+'), findsOneWidget);
+      expect(find.text('100'), findsNothing);
+    });
+
+    testWidgets('displays single digit counts correctly', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 1, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('1'), findsOneWidget);
+    });
+
+    testWidgets('displays double digit counts correctly', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 42, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('42'), findsOneWidget);
+    });
+
+    testWidgets('renders child widget correctly', (tester) async {
+      const testIcon = Icon(Icons.notifications_outlined, key: Key('test-icon'));
+
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 3, child: testIcon)),
+        ),
+      );
+
+      expect(find.byKey(const Key('test-icon')), findsOneWidget);
+      expect(find.byIcon(Icons.notifications_outlined), findsOneWidget);
+    });
+
+    testWidgets('badge updates when count changes from 0 to positive', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 0, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      Badge badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isFalse);
+
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 5, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isTrue);
+      expect(find.text('5'), findsOneWidget);
+    });
+
+    testWidgets('badge updates when count changes from positive to 0', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 10, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      Badge badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isTrue);
+      expect(find.text('10'), findsOneWidget);
+
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 0, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      badge = tester.widget<Badge>(find.byType(Badge));
+      expect(badge.isLabelVisible, isFalse);
+    });
+
+    testWidgets('badge updates when count changes from below 99 to above 99', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 50, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('50'), findsOneWidget);
+
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(body: UnreadBadge(count: 150, child: Icon(Icons.notifications))),
+        ),
+      );
+
+      expect(find.text('99+'), findsOneWidget);
+      expect(find.text('50'), findsNothing);
+    });
+
+    group('Semantics', () {
+      testWidgets('provides semantic label when count > 0', (tester) async {
+        await tester.pumpWidget(
+          const MaterialApp(
+            home: Scaffold(body: UnreadBadge(count: 7, child: Icon(Icons.notifications))),
+          ),
+        );
+
+        expect(
+          tester.getSemantics(find.byType(Icon)),
+          matchesSemantics(label: '7 unread notifications'),
+        );
+      });
+
+      testWidgets('no semantic label when count is 0', (tester) async {
+        await tester.pumpWidget(
+          const MaterialApp(
+            home: Scaffold(body: UnreadBadge(count: 0, child: Icon(Icons.notifications))),
+          ),
+        );
+
+        final semantics = tester.getSemantics(find.byType(Icon));
+        expect(semantics.label, anyOf(isNull, isEmpty));
+      });
+
+      testWidgets('semantic label uses actual count for large numbers', (tester) async {
+        await tester.pumpWidget(
+          const MaterialApp(
+            home: Scaffold(body: UnreadBadge(count: 250, child: Icon(Icons.notifications))),
+          ),
+        );
+
+        expect(
+          tester.getSemantics(find.byType(Icon)),
+          matchesSemantics(label: '250 unread notifications'),
+        );
+      });
+    });
+
+    group('Edge Cases', () {
+      testWidgets('handles negative count gracefully', (tester) async {
+        await tester.pumpWidget(
+          const MaterialApp(
+            home: Scaffold(body: UnreadBadge(count: -5, child: Icon(Icons.notifications))),
+          ),
+        );
+
+        final badge = tester.widget<Badge>(find.byType(Badge));
+        expect(badge.isLabelVisible, isFalse);
+      });
+
+      testWidgets('handles very large counts', (tester) async {
+        await tester.pumpWidget(
+          const MaterialApp(
+            home: Scaffold(body: UnreadBadge(count: 999999, child: Icon(Icons.notifications))),
+          ),
+        );
+
+        expect(find.text('99+'), findsOneWidget);
+        expect(find.text('999999'), findsNothing);
+      });
+    });
+  });
+}