car-interface-android/test/pin_service_test.dart

import 'package:cardash_launcher/data/models/slot_assignment.dart';
import 'package:cardash_launcher/data/models/slot_type.dart';
import 'package:cardash_launcher/data/repositories/settings_repository.dart';
import 'package:cardash_launcher/data/services/pin_service.dart';
import 'package:cardash_launcher/data/services/secure_store.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:shared_preferences/shared_preferences.dart';

class MemorySecureStore implements SecureStore {
  final Map<String, String> values = {};

  @override
  Future<String?> read(String key) async => values[key];

  @override
  Future<void> write(String key, String value) async => values[key] = value;

  @override
  Future<void> delete(String key) async => values.remove(key);
}

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  group('settings repository', () {
    test('persists and clears a shortcut assignment', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);
      const assignment = SlotAssignment(
        packageName: 'com.example.waze',
        activityName: 'com.example.waze.Main',
        label: 'Waze',
      );

      expect(repository.slot(SlotType.navigation), isNull);
      await repository.setSlot(SlotType.navigation, assignment);
      final restored = repository.slot(SlotType.navigation);
      expect(restored, isNotNull);
      expect(restored!.packageName, 'com.example.waze');
      expect(restored.label, 'Waze');

      await repository.clearSlot(SlotType.navigation);
      expect(repository.slot(SlotType.navigation), isNull);
    });

    test('stores a custom night window', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);
      await repository.setNightWindow(
        startMinutes: 20 * 60,
        endMinutes: 6 * 60,
      );
      expect(repository.nightStartMinutes, 20 * 60);
      expect(repository.nightEndMinutes, 6 * 60);
    });

    test('the first-run launcher hint is shown once', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);

      expect(repository.homeRoleHintShown, isFalse);
      await repository.setHomeRoleHintShown(true);
      expect(repository.homeRoleHintShown, isTrue);
    });

    test('records the first launch once for a new installation', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);
      final now = DateTime(2026, 1, 1, 12);

      expect(repository.firstLaunchAt, isNull);
      expect(await repository.ensureFirstLaunchAt(now), now);
      expect(repository.firstLaunchAt, now);
      expect(await repository.ensureFirstLaunchAt(DateTime(2026, 1, 2)), now);
    });

    test(
      'an upgraded installation never reopens the onboarding window',
      () async {
        SharedPreferences.setMockInitialValues({'settings.theme': 'dark'});
        final prefs = await SharedPreferences.getInstance();
        final repository = SettingsRepository(prefs);

        final first = await repository.ensureFirstLaunchAt(
          DateTime(2026, 1, 1),
        );
        expect(first.millisecondsSinceEpoch, 0);
      },
    );

    test('speed and temperature preferences persist', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);

      expect(repository.speedEnabled, isTrue);
      expect(repository.speedUseObd, isTrue);
      expect(repository.temperatureEnabled, isFalse);
      expect(repository.temperatureUseObd, isTrue);

      await repository.ensureTelemetryDefaults();
      expect(repository.temperatureEnabled, isFalse);
      await repository.setTemperatureEnabled(true);
      expect(repository.temperatureEnabled, isTrue);

      await repository.setSpeedEnabled(false);
      await repository.setSpeedUseObd(false);
      await repository.setTemperatureEnabled(false);
      await repository.setTemperatureUseObd(false);

      expect(repository.speedEnabled, isFalse);
      expect(repository.speedUseObd, isFalse);
      expect(repository.temperatureEnabled, isFalse);
      expect(repository.temperatureUseObd, isFalse);
    });

    test('temperature migrates on for an existing OBD install', () async {
      SharedPreferences.setMockInitialValues({
        'obd.adapterAddress': '00:11:22:33:44:55',
      });
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);

      await repository.ensureTelemetryDefaults();
      expect(repository.temperatureEnabled, isTrue);

      await repository.setTemperatureEnabled(false);
      await repository.ensureTelemetryDefaults();
      expect(repository.temperatureEnabled, isFalse);
    });

    test('temperature migrates on for an existing weather install', () async {
      SharedPreferences.setMockInitialValues({
        'weather.locationTemperature': true,
      });
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);

      await repository.ensureTelemetryDefaults();
      expect(repository.temperatureEnabled, isTrue);
    });

    test('OBD adapter and weather preferences persist', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);

      expect(repository.obdAdapterAddress, isNull);
      expect(repository.keepScreenOn, isTrue);
      expect(repository.weatherLocationTemperature, isFalse);
      await repository.setObdAdapterAddress('00:11:22:33:44:55');
      await repository.setWeatherLocationTemperature(true);
      await repository.setKeepScreenOn(false);
      expect(repository.obdAdapterAddress, '00:11:22:33:44:55');
      expect(repository.weatherLocationTemperature, isTrue);
      expect(repository.keepScreenOn, isFalse);

      await repository.setObdAdapterAddress(null);
      expect(repository.obdAdapterAddress, isNull);
    });

    test('home buttons default to enabled and persist a toggle', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);

      expect(repository.slotEnabled(SlotType.navigation), isTrue);
      expect(repository.slotEnabled(SlotType.music), isTrue);
      expect(repository.slotEnabled(SlotType.radio), isTrue);

      await repository.setSlotEnabled(SlotType.music, false);
      expect(repository.slotEnabled(SlotType.music), isFalse);
      expect(repository.slotEnabled(SlotType.navigation), isTrue);
    });

    test('pinned apps round-trip through the repository', () async {
      SharedPreferences.setMockInitialValues({});
      final prefs = await SharedPreferences.getInstance();
      final repository = SettingsRepository(prefs);
      const pinned = [
        SlotAssignment(
          packageName: 'com.example.one',
          activityName: 'com.example.one.Main',
          label: 'One',
          iconAsset: 'assets/icons/star.svg',
        ),
        SlotAssignment(
          packageName: 'com.example.two',
          activityName: 'com.example.two.Main',
          label: 'Two',
        ),
      ];

      await repository.setPinnedApps(pinned);
      final restored = repository.pinnedApps;
      expect(restored.length, 2);
      expect(restored.first.label, 'One');
      expect(restored.first.hasCustomIcon, isTrue);
      expect(restored.first.iconAsset, 'assets/icons/star.svg');
      expect(restored.last.packageName, 'com.example.two');
      expect(restored.last.hasCustomIcon, isFalse);

      await repository.setPinnedApps(const []);
      expect(repository.pinnedApps, isEmpty);
    });
  });

  group('pin service', () {
    test('sets, verifies and clears a four-digit PIN', () async {
      final store = MemorySecureStore();
      final service = PinService(store, iterations: 50);

      await service.setPin('1234');
      expect(await service.isPinSet(), isTrue);
      expect(await service.verify('1234'), isTrue);
      expect(await service.verify('9999'), isFalse);
      expect(store.values['cardash.pin.hash'], isNot(contains('1234')));

      await service.clearPin();
      expect(await service.isPinSet(), isFalse);
    });

    test('rejects PINs that are not four digits', () {
      final service = PinService(MemorySecureStore(), iterations: 10);
      expect(() => service.setPin('12'), throwsArgumentError);
      expect(() => service.setPin('abcd'), throwsArgumentError);
    });
  });
}