mobile-eda/test/unit/theme_settings_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import 'package:mobile_eda/core/theme/eda_theme.dart';
import 'package:mobile_eda/core/config/settings_provider.dart';

void main() {
  group('EdaTheme Tests', () {
    test('light theme should have correct brightness', () {
      final theme = EdaTheme.lightTheme;
      expect(theme.brightness, Brightness.light);
    });

    test('dark theme should have correct brightness', () {
      final theme = EdaTheme.darkTheme;
      expect(theme.brightness, Brightness.dark);
    });

    test('light theme scaffold background should be light', () {
      final theme = EdaTheme.lightTheme;
      expect(theme.scaffoldBackgroundColor, EdaTheme.lightScaffoldBg);
    });

    test('dark theme scaffold background should be dark', () {
      final theme = EdaTheme.darkTheme;
      expect(theme.scaffoldBackgroundColor, EdaTheme.darkScaffoldBg);
    });

    test('light and dark themes should have different primary colors', () {
      final lightPrimary = EdaTheme.lightTheme.colorScheme.primary;
      final darkPrimary = EdaTheme.darkTheme.colorScheme.primary;
      expect(lightPrimary, isNot(equals(darkPrimary)));
    });

    test('canvas background colors should be different between themes', () {
      expect(EdaTheme.lightCanvasBg, isNot(equals(EdaTheme.darkCanvasBg)));
    });

    test('grid colors should be different between themes', () {
      expect(EdaTheme.lightGridColor, isNot(equals(EdaTheme.darkGridColor)));
    });
  });

  group('ThemeModeNotifier Tests', () {
    testWidgets('initial theme mode should be system', (WidgetTester tester) async {
      await tester.pumpWidget(
        const ProviderScope(
          child: MaterialApp(home: Scaffold()),
        ),
      );

      final container = ProviderContainer();
      addTearDown(container.dispose);
      
      final themeMode = container.read(themeModeProvider);
      expect(themeMode, ThemeModeType.system);
    });

    testWidgets('should update theme mode when setThemeMode is called', (WidgetTester tester) async {
      final container = ProviderContainer();
      addTearDown(container.dispose);
      
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.dark);
      
      expect(container.read(themeModeProvider), ThemeModeType.dark);
    });

    testWidgets('toggleDarkMode should switch between light and dark', (WidgetTester tester) async {
      final container = ProviderContainer();
      addTearDown(container.dispose);
      
      // Start with system, set to light first
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.light);
      expect(container.read(themeModeProvider), ThemeModeType.light);
      
      // Toggle to dark
      container.read(themeModeProvider.notifier).toggleDarkMode();
      expect(container.read(themeModeProvider), ThemeModeType.dark);
      
      // Toggle back to light
      container.read(themeModeProvider.notifier).toggleDarkMode();
      expect(container.read(themeModeProvider), ThemeModeType.light);
    });

    testWidgets('flutterThemeMode should return correct ThemeMode', (WidgetTester tester) async {
      final container = ProviderContainer();
      addTearDown(container.dispose);
      
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.system);
      expect(container.read(themeModeProvider.notifier).flutterThemeMode, ThemeMode.system);
      
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.light);
      expect(container.read(themeModeProvider.notifier).flutterThemeMode, ThemeMode.light);
      
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.dark);
      expect(container.read(themeModeProvider.notifier).flutterThemeMode, ThemeMode.dark);
    });

    testWidgets('isDarkMode should return correct boolean', (WidgetTester tester) async {
      final container = ProviderContainer();
      addTearDown(container.dispose);
      
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.light);
      expect(container.read(themeModeProvider.notifier).isDarkMode, false);
      
      container.read(themeModeProvider.notifier).setThemeMode(ThemeModeType.dark);
      expect(container.read(themeModeProvider.notifier).isDarkMode, true);
    });
  });

  group('AppSettings Tests', () {
    test('default settings should have correct values', () {
      final settings = AppSettings();
      
      expect(settings.themeMode, ThemeModeType.system);
      expect(settings.language, LanguageType.system);
      expect(settings.gridSize, 10.0);
      expect(settings.showGrid, true);
      expect(settings.snapToGrid, true);
      expect(settings.autoSave, true);
      expect(settings.autoSaveIntervalMinutes, 5);
      expect(settings.enableAnimations, true);
      expect(settings.enableAntialiasing, true);
      expect(settings.renderQuality, RenderQuality.balanced);
    });

    test('copyWith should create independent copy', () {
      final original = AppSettings();
      final copy = original.copyWith(
        themeMode: ThemeModeType.dark,
        gridSize: 20.0,
      );
      
      expect(original.themeMode, ThemeModeType.system);
      expect(copy.themeMode, ThemeModeType.dark);
      expect(original.gridSize, 10.0);
      expect(copy.gridSize, 20.0);
    });

    test('locale should return correct Locale for each language', () {
      expect(AppSettings(language: LanguageType.system).locale, isNull);
      expect(AppSettings(language: LanguageType.chineseSimple).locale, const Locale('zh', 'CN'));
      expect(AppSettings(language: LanguageType.chineseTraditional).locale, const Locale('zh', 'TW'));
      expect(AppSettings(language: LanguageType.english).locale, const Locale('en', 'US'));
      expect(AppSettings(language: LanguageType.arabic).locale, const Locale('ar', 'SA'));
    });

    test('isRtl should return true only for Arabic', () {
      expect(AppSettings(language: LanguageType.system).isRtl, false);
      expect(AppSettings(language: LanguageType.chineseSimple).isRtl, false);
      expect(AppSettings(language: LanguageType.chineseTraditional).isRtl, false);
      expect(AppSettings(language: LanguageType.english).isRtl, false);
      expect(AppSettings(language: LanguageType.arabic).isRtl, true);
    });

    test('languageDisplayName should return correct display name', () {
      expect(AppSettings(language: LanguageType.system).languageDisplayName, '系统语言');
      expect(AppSettings(language: LanguageType.chineseSimple).languageDisplayName, '简体中文');
      expect(AppSettings(language: LanguageType.chineseTraditional).languageDisplayName, '繁體中文');
      expect(AppSettings(language: LanguageType.english).languageDisplayName, 'English');
      expect(AppSettings(language: LanguageType.arabic).languageDisplayName, 'العربية');
    });
  });

  group('RenderQuality Tests', () {
    test('RenderQuality enum should have correct values', () {
      expect(RenderQuality.values.length, 3);
      expect(RenderQuality.values[0], RenderQuality.high);
      expect(RenderQuality.values[1], RenderQuality.balanced);
      expect(RenderQuality.values[2], RenderQuality.performance);
    });
  });

  group('LanguageType Tests', () {
    test('LanguageType enum should have correct values', () {
      expect(LanguageType.values.length, 5);
      expect(LanguageType.values[0], LanguageType.system);
      expect(LanguageType.values[1], LanguageType.chineseSimple);
      expect(LanguageType.values[2], LanguageType.chineseTraditional);
      expect(LanguageType.values[3], LanguageType.english);
      expect(LanguageType.values[4], LanguageType.arabic);
    });
  });
}