ignis_app/test/user_location_provider_test.dart

import 'dart:async';

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:geolocator/geolocator.dart';
import 'package:ignis_app/features/homes/providers/location_providers.dart';
import 'package:ignis_app/features/homes/services/location_platform_service.dart';

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  test(
    'location watcher does not auto-request permission when denied',
    () async {
      final service = _FakeLocationPlatformService();
      final container = ProviderContainer(
        overrides: [locationPlatformServiceProvider.overrideWithValue(service)],
      );
      addTearDown(() async {
        await service.dispose();
        container.dispose();
      });

      final notifier = container.read(userLocationProvider.notifier);
      await notifier.startWatching();
      await notifier.refresh();

      expect(service.requestPermissionCalls, 0);
      expect(service.getPositionStreamCalls, 0);
      expect(
        container.read(userLocationProvider).issue,
        UserLocationIssue.permissionDenied,
      );
    },
  );

  test('location watcher resumes after permission is granted later', () async {
    final service = _FakeLocationPlatformService();
    final container = ProviderContainer(
      overrides: [locationPlatformServiceProvider.overrideWithValue(service)],
    );
    addTearDown(() async {
      await service.dispose();
      container.dispose();
    });

    final notifier = container.read(userLocationProvider.notifier);
    await notifier.startWatching();

    service.permission = LocationPermission.always;
    await notifier.ensureWatchingStarted();

    expect(service.requestPermissionCalls, 0);
    expect(service.getPositionStreamCalls, 1);
  });

  test('explicit location request asks Android and starts watching', () async {
    final service = _FakeLocationPlatformService();
    service.requestPermissionResult = LocationPermission.always;
    final container = ProviderContainer(
      overrides: [locationPlatformServiceProvider.overrideWithValue(service)],
    );
    addTearDown(() async {
      await service.dispose();
      container.dispose();
    });

    final notifier = container.read(userLocationProvider.notifier);
    await notifier.startWatching();
    await notifier.requestPermission();

    expect(service.requestPermissionCalls, 1);
    expect(service.getPositionStreamCalls, 1);
  });
}

class _FakeLocationPlatformService implements LocationPlatformService {
  final StreamController<Position> _positionController =
      StreamController<Position>.broadcast();

  bool locationServiceEnabled = true;
  LocationPermission permission = LocationPermission.denied;
  LocationPermission requestPermissionResult = LocationPermission.denied;
  int requestPermissionCalls = 0;
  int getPositionStreamCalls = 0;

  Future<void> dispose() async {
    await _positionController.close();
  }

  @override
  Future<LocationPermission> checkPermission() async => permission;

  @override
  Stream<Position> getPositionStream({
    required LocationSettings locationSettings,
  }) {
    getPositionStreamCalls += 1;
    return _positionController.stream;
  }

  @override
  Future<Position> getCurrentPosition({
    required LocationSettings locationSettings,
  }) {
    throw UnimplementedError();
  }

  @override
  Future<Position?> getLastKnownPosition() async => null;

  @override
  Future<bool> isLocationServiceEnabled() async => locationServiceEnabled;

  @override
  Future<bool> openAppSettings() async => true;

  @override
  Future<bool> openLocationSettings() async => true;

  @override
  Future<LocationPermission> requestPermission() async {
    requestPermissionCalls += 1;
    permission = requestPermissionResult;
    return permission;
  }
}