test: add tests for theme editor & search screens

lib/src/features/settings/presentation/screens/theme_editor_screen.dart

···
 
 class _ThemeEditorScreenState extends ConsumerState<ThemeEditorScreen> {
   late String _name;
+  late TextEditingController _nameController;
   late String _basePackId;
   late ThemeRoleOverrides _overrides;
   late TypographyScale _typographyScale;
···
   @override
   void initState() {
     super.initState();
+    _nameController = TextEditingController();
     _loadOrCreateDraft();
   }
 
+  @override
+  void dispose() {
+    _nameController.dispose();
+    super.dispose();
+  }
+
   Future<void> _loadOrCreateDraft() async {
+    await Future.microtask(() {});
     if (widget.customThemeId != null) {
       final repo = ref.read(customThemeRepositoryProvider);
       final existing = await repo.getById(widget.customThemeId!);
···
         setState(() {
           _existingId = existing.id;
           _name = existing.name;
+          _nameController.text = _name;
           _basePackId = existing.basePackId;
           _overrides = existing.overrides;
           _typographyScale = existing.typographyScale;
···
     final themeState = ref.read(themeControllerProvider);
     setState(() {
       _name = 'My Custom Theme';
+      _nameController.text = _name;
       _basePackId = themeState.currentPackId;
       _overrides = ThemeRoleOverrides.empty;
       _typographyScale = TypographyScale.normal;
···
                 labelText: 'Theme Name',
                 border: OutlineInputBorder(),
               ),
-              controller: TextEditingController(text: _name),
+
+              controller: _nameController,
               onChanged: (value) {
-                _name = value;
-                _isDirty = true;
+                setState(() {
+                  _name = value;
+                  _isDirty = true;
+                });
               },
             ),
           ),

test/src/features/search/presentation/search_screen_test.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/core/domain/post.dart';
+import 'package:lazurite/src/core/utils/pagination.dart';
+import 'package:lazurite/src/features/search/application/search_providers.dart';
+import 'package:lazurite/src/features/search/infrastructure/search_repository.dart';
+import 'package:lazurite/src/features/search/presentation/search_screen.dart';
+import 'package:lazurite/src/features/search/presentation/widgets/search_bar_widget.dart';
+import 'package:lazurite/src/infrastructure/db/app_database.dart' hide Post;
+import 'package:mocktail/mocktail.dart';
+
+class MockSearchRepository extends Mock implements SearchRepository {}
+
+class TestApp extends StatelessWidget {
+  const TestApp({required this.home, super.key});
+
+  final Widget home;
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(home: home);
+  }
+}
+
+void main() {
+  late MockSearchRepository mockRepository;
+
+  setUp(() {
+    mockRepository = MockSearchRepository();
+
+    when(() => mockRepository.watchRecentSearches()).thenAnswer((_) => Stream.value([]));
+    when(() => mockRepository.saveRecentSearch(any())).thenAnswer((_) async {});
+  });
+
+  Widget createSubject({String? initialQuery}) {
+    return ProviderScope(
+      overrides: [searchRepositoryProvider.overrideWithValue(mockRepository)],
+      child: TestApp(home: SearchScreen(initialQuery: initialQuery)),
+    );
+  }
+
+  group('SearchScreen', () {
+    testWidgets('shows recent searches when query is empty', (tester) async {
+      when(() => mockRepository.watchRecentSearches()).thenAnswer(
+        (_) => Stream.value([
+          RecentSearche(id: 1, query: 'flutter', searchedAt: DateTime.now()),
+          RecentSearche(id: 2, query: 'dart', searchedAt: DateTime.now()),
+        ]),
+      );
+
+      await tester.pumpWidget(createSubject());
+      await tester.pumpAndSettle();
+
+      expect(find.text('Recent Searches'), findsOneWidget);
+      expect(find.text('flutter'), findsOneWidget);
+      expect(find.text('dart'), findsOneWidget);
+      expect(find.byType(SearchBarWidget), findsOneWidget);
+    });
+
+    testWidgets('shows empty state when no recent searches', (tester) async {
+      when(() => mockRepository.watchRecentSearches()).thenAnswer((_) => Stream.value([]));
+
+      await tester.pumpWidget(createSubject());
+      await tester.pumpAndSettle();
+
+      expect(find.text('Search for posts and people'), findsOneWidget);
+      expect(find.text('Type a query to find posts or people'), findsOneWidget);
+    });
+
+    testWidgets('performs search and shows results', (tester) async {
+      const query = 'bluesky';
+      final posts = [
+        Post(
+          uri: 'at://did:plc:123/app.bsky.feed.post/1',
+          cid: 'cid1',
+          author: const Author(did: 'did:plc:123', handle: 'alice.test', displayName: 'Alice'),
+          record: {},
+          text: 'Hello Bluesky!',
+          indexedAt: DateTime.now(),
+        ),
+      ];
+      final result = PaginatedResult(items: posts, cursor: null);
+
+      when(() => mockRepository.searchPosts(query, cursor: null)).thenAnswer((_) async => result);
+      when(
+        () => mockRepository.searchActors(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+
+      await tester.pumpWidget(createSubject());
+      await tester.pumpAndSettle();
+
+      await tester.enterText(find.byType(TextField), query);
+      await tester.testTextInput.receiveAction(TextInputAction.search);
+      await tester.pumpAndSettle();
+
+      expect(find.text('Posts'), findsOneWidget);
+      expect(find.text('People'), findsOneWidget);
+
+      expect(find.text('Hello Bluesky!'), findsOneWidget);
+      expect(find.text('Alice'), findsOneWidget);
+
+      verify(() => mockRepository.searchPosts(query, cursor: null)).called(1);
+    });
+
+    testWidgets('initial query populates search bar and results', (tester) async {
+      const query = 'initial';
+      when(
+        () => mockRepository.searchPosts(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+      when(
+        () => mockRepository.searchActors(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+
+      await tester.pumpWidget(createSubject(initialQuery: query));
+      await tester.pumpAndSettle();
+
+      expect(find.text(query), findsOneWidget);
+      expect(find.byType(TabBar), findsOneWidget);
+    });
+
+    testWidgets('clearing search returns to recent searches', (tester) async {
+      const query = 'test';
+      when(
+        () => mockRepository.searchPosts(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+      when(
+        () => mockRepository.searchActors(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+
+      await tester.pumpWidget(createSubject(initialQuery: query));
+      await tester.pumpAndSettle();
+
+      expect(find.byIcon(Icons.clear), findsOneWidget);
+      await tester.tap(find.byIcon(Icons.clear));
+      await tester.pumpAndSettle();
+
+      expect(find.text('Search for posts and people'), findsOneWidget);
+      expect(find.byType(TabBar), findsNothing);
+    });
+
+    testWidgets('switches between Posts and People tabs', (tester) async {
+      const query = 'test';
+      when(
+        () => mockRepository.searchPosts(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+      when(
+        () => mockRepository.searchActors(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+
+      await tester.pumpWidget(createSubject(initialQuery: query));
+      await tester.pumpAndSettle();
+
+      expect(find.text('No posts found'), findsOneWidget);
+
+      await tester.tap(find.text('People'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('No people found'), findsOneWidget);
+    });
+
+    testWidgets('retry on error', (tester) async {
+      const query = 'error';
+      when(() => mockRepository.searchPosts(query, cursor: null)).thenThrow('Network Error');
+      when(
+        () => mockRepository.searchActors(query, cursor: null),
+      ).thenAnswer((_) async => const PaginatedResult(items: [], cursor: null));
+
+      await tester.pumpWidget(createSubject(initialQuery: query));
+      await tester.pumpAndSettle();
+
+      expect(find.text('Error: Network Error'), findsOneWidget);
+      expect(find.text('Retry'), findsOneWidget);
+
+      await tester.tap(find.text('Retry'));
+      await tester.pump(); // Start retry
+      await tester.pump(const Duration(milliseconds: 100));
+
+      verify(() => mockRepository.searchPosts(query, cursor: null)).called(greaterThan(1));
+    });
+  });
+}

test/src/features/settings/presentation/screens/theme_editor_screen_test.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:go_router/go_router.dart';
+import 'package:lazurite/src/app/providers.dart';
+import 'package:lazurite/src/app/theme_controller.dart';
+import 'package:lazurite/src/app/theming/custom_theme_draft.dart';
+import 'package:lazurite/src/app/theming/theme_pack.dart';
+import 'package:lazurite/src/app/theming/theme_spec.dart';
+import 'package:lazurite/src/app/theming/theme_variant.dart';
+import 'package:lazurite/src/features/settings/presentation/screens/theme_editor_screen.dart';
+import 'package:lazurite/src/features/settings/presentation/widgets/color_role_picker.dart';
+import 'package:lazurite/src/infrastructure/db/daos/local_settings_dao.dart';
+import 'package:lazurite/src/infrastructure/theming/custom_theme_repository.dart';
+import 'package:mocktail/mocktail.dart';
+
+class MockCustomThemeRepository extends Mock implements CustomThemeRepository {}
+
+class MockLocalSettingsDao extends Mock implements LocalSettingsDao {}
+
+class TestApp extends StatelessWidget {
+  const TestApp({required this.home, super.key});
+
+  final Widget home;
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp.router(
+      routerConfig: GoRouter(
+        routes: [
+          GoRoute(
+            path: '/',
+            builder: (context, state) => Scaffold(
+              body: Center(
+                child: TextButton(
+                  onPressed: () => context.push('/editor'),
+                  child: const Text('Push'),
+                ),
+              ),
+            ),
+          ),
+          GoRoute(path: '/editor', builder: (context, state) => home),
+        ],
+      ),
+    );
+  }
+}
+
+void main() {
+  late MockCustomThemeRepository mockRepository;
+  late MockLocalSettingsDao mockSettingsDao;
+
+  const testPack = ThemePack(
+    id: 'test_pack',
+    name: 'Test Pack',
+    variants: [
+      ThemeVariant(
+        id: 'test_variant',
+        name: 'Test Variant',
+        brightness: Brightness.dark,
+        spec: ThemeSpec(
+          primary: Colors.blue,
+          secondary: Colors.teal,
+          tertiary: Colors.amber,
+          surface: Colors.black,
+          surfaceContainerLow: Colors.black12,
+          surfaceContainerHigh: Colors.black26,
+          outlineVariant: Colors.grey,
+        ),
+        derivedScheme: ColorScheme.dark(),
+      ),
+    ],
+  );
+
+  setUp(() {
+    mockRepository = MockCustomThemeRepository();
+    mockSettingsDao = MockLocalSettingsDao();
+
+    registerFallbackValue(
+      CustomThemeDraft.create(
+        name: 'fallback',
+        basePackId: 'fallback',
+        overrides: ThemeRoleOverrides.empty,
+      ),
+    );
+
+    when(() => mockRepository.getById(any())).thenAnswer((invocation) async {
+      final id = invocation.positionalArguments.first as String;
+      return CustomThemeDraft.create(
+        name: 'Generic Draft',
+        basePackId: 'test_pack',
+        overrides: ThemeRoleOverrides.empty,
+      ).copyWith(id: id);
+    });
+
+    when(() => mockSettingsDao.get(ThemeSettingsKeys.themeMode)).thenAnswer((_) async => 'dark');
+    when(
+      () => mockSettingsDao.get(ThemeSettingsKeys.themePackId),
+    ).thenAnswer((_) async => 'test_pack');
+    when(() => mockSettingsDao.get(ThemeSettingsKeys.customThemeId)).thenAnswer((_) async => null);
+    when(
+      () => mockSettingsDao.get(ThemeSettingsKeys.dynamicColorEnabled),
+    ).thenAnswer((_) async => 'false');
+
+    when(() => mockSettingsDao.set(any(), any())).thenAnswer((_) async {});
+    when(() => mockSettingsDao.remove(any())).thenAnswer((_) async => 1);
+  });
+
+  Widget createSubject({String? customThemeId}) {
+    return ProviderScope(
+      overrides: [
+        customThemeRepositoryProvider.overrideWithValue(mockRepository),
+        localSettingsDaoProvider.overrideWithValue(mockSettingsDao),
+        availableThemePacksProvider.overrideWith((ref) => [testPack]),
+      ],
+      child: TestApp(home: ThemeEditorScreen(customThemeId: customThemeId)),
+    );
+  }
+
+  group('ThemeEditorScreen', () {
+    testWidgets('reset clears overrides', (tester) async {
+      await tester.pumpWidget(createSubject());
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('My Custom Theme'), findsOneWidget);
+      expect(find.text('Test Pack'), findsOneWidget);
+      expect(find.byType(ColorRolePicker), findsNWidgets(7));
+    });
+
+    testWidgets('loads default state for new theme', (tester) async {
+      await tester.pumpWidget(createSubject());
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('My Custom Theme'), findsOneWidget);
+      expect(find.text('Test Pack'), findsOneWidget);
+      expect(find.byType(ColorRolePicker), findsNWidgets(7));
+    });
+
+    testWidgets('loads existing theme data', (tester) async {
+      final existingDraft = CustomThemeDraft.create(
+        name: 'Existing Theme',
+        basePackId: 'test_pack',
+        overrides: const ThemeRoleOverrides(primary: Colors.red),
+      ).copyWith(id: 'existing_id');
+
+      when(() => mockRepository.getById('existing_id')).thenAnswer((_) async => existingDraft);
+
+      await tester.pumpWidget(createSubject(customThemeId: 'existing_id'));
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('Existing Theme'), findsOneWidget);
+    });
+
+    testWidgets('updates override when color picked', (tester) async {
+      await tester.pumpWidget(createSubject());
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('Primary'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('Select Color'), findsOneWidget);
+    });
+
+    testWidgets('save creates new theme and sets it', (tester) async {
+      when(
+        () => mockRepository.save(any()),
+      ).thenAnswer((_) async => const ValidationResult.valid());
+
+      await tester.pumpWidget(createSubject());
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('Save'));
+      await tester.pumpAndSettle();
+
+      verify(() => mockRepository.save(any(that: isA<CustomThemeDraft>()))).called(1);
+
+      verify(() => mockSettingsDao.set(ThemeSettingsKeys.customThemeId, any())).called(1);
+
+      expect(find.byType(ThemeEditorScreen), findsNothing);
+    });
+
+    testWidgets('save updates existing theme', (tester) async {
+      final existingDraft = CustomThemeDraft.create(
+        name: 'Existing',
+        basePackId: 'test_pack',
+        overrides: ThemeRoleOverrides.empty,
+      ).copyWith(id: 'existing_id');
+
+      when(() => mockRepository.getById('existing_id')).thenAnswer((_) async => existingDraft);
+      when(
+        () => mockRepository.save(any()),
+      ).thenAnswer((_) async => const ValidationResult.valid());
+
+      await tester.pumpWidget(createSubject(customThemeId: 'existing_id'));
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      await tester.enterText(find.byType(TextField), 'Updated Name');
+      await tester.pump();
+
+      await tester.tap(find.text('Save'));
+      await tester.pump();
+      await tester.pump();
+
+      verify(() => mockRepository.save(any())).called(1);
+    });
+
+    testWidgets('shows error snackbar on save failure', (tester) async {
+      when(
+        () => mockRepository.save(any()),
+      ).thenAnswer((_) async => const ValidationResult.invalid('Save failed'));
+
+      await tester.pumpWidget(createSubject());
+      await tester.tap(find.text('Push'));
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('Save'));
+      await tester.pump();
+      await tester.pump();
+
+      expect(find.text('Save failed'), findsOneWidget);
+      expect(find.byType(ThemeEditorScreen), findsOneWidget);
+    });
+  });
+}