pluriwave/test/servicios/servicio_alarmas_android_test.dart

import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pluriwave/modelos/alarma_musical.dart';
import 'package:pluriwave/modelos/emisora.dart';
import 'package:pluriwave/servicios/servicio_alarmas_android.dart';

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  const channel = MethodChannel('pluriwave/alarm_scheduler');
  late List<MethodCall> llamadas;

  setUp(() {
    llamadas = [];
    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
        .setMockMethodCallHandler(channel, (call) async {
          llamadas.add(call);
          switch (call.method) {
            case 'scheduleAlarm':
              return true;
            case 'requestIgnoreBatteryOptimizations':
              return true;
          }
          return null;
        });
  });

  tearDown(() {
    TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
        .setMockMethodCallHandler(channel, null);
  });

  test(
    'programar incluye emisora de respaldo y fade en el payload nativo',
    () async {
      final servicio = ServicioAlarmasAndroid(channel: channel);
      final alarma = AlarmaMusical(
        id: 'a1',
        nombre: 'Con respaldo',
        hora: 7,
        minuto: 30,
        tipoProgramacion: TipoProgramacionAlarma.diaria,
        diasSemana: const [],
        proximaEjecucion: DateTime(2099, 1, 1, 7, 30),
        emisora: const Emisora(
          uuid: 'uuid-principal',
          nombre: 'Principal FM',
          url: 'https://principal.example/stream',
        ),
        emisoraFallback: const Emisora(
          uuid: 'uuid-respaldo',
          nombre: 'Respaldo FM',
          url: 'https://respaldo.example/stream',
        ),
        fadeInSegundos: 12,
      );

      await servicio.programar(alarma);

      final llamada = llamadas.singleWhere((c) => c.method == 'scheduleAlarm');
      final args = llamada.arguments as Map<Object?, Object?>;
      expect(args['fallbackStationName'], 'Respaldo FM');
      expect(args['fallbackStationUrl'], 'https://respaldo.example/stream');
      expect(args['fadeInSegundos'], 12);
      expect(args['fallbackSound'], SonidoInternoAlarma.amanecer.name);
    },
  );

  test(
    'programar sin emisora de respaldo envia campos de respaldo nulos',
    () async {
      final servicio = ServicioAlarmasAndroid(channel: channel);
      final alarma = AlarmaMusical(
        id: 'a2',
        nombre: 'Sin respaldo',
        hora: 8,
        minuto: 0,
        tipoProgramacion: TipoProgramacionAlarma.diaria,
        diasSemana: const [],
        proximaEjecucion: DateTime(2099, 1, 1, 8, 0),
      );

      await servicio.programar(alarma);

      final llamada = llamadas.singleWhere((c) => c.method == 'scheduleAlarm');
      final args = llamada.arguments as Map<Object?, Object?>;
      expect(args.containsKey('fallbackStationName'), isTrue);
      expect(args['fallbackStationName'], isNull);
      expect(args.containsKey('fallbackStationUrl'), isTrue);
      expect(args['fallbackStationUrl'], isNull);
      expect(args['fadeInSegundos'], 0);
    },
  );

  test(
    'solicitarExencionBateria invoca requestIgnoreBatteryOptimizations',
    () async {
      final servicio = ServicioAlarmasAndroid(channel: channel);

      final abierto = await servicio.solicitarExencionBateria();

      expect(abierto, isTrue);
      expect(
        llamadas.map((c) => c.method),
        contains('requestIgnoreBatteryOptimizations'),
      );
    },
  );

  test(
    'forzarVolumenMediaParaAlarma invoca overrideMediaVolumeForRing con fraction',
    () async {
      final servicio = ServicioAlarmasAndroid(channel: channel);

      await servicio.forzarVolumenMediaParaAlarma(1.0);

      final llamada = llamadas.singleWhere(
        (c) => c.method == 'overrideMediaVolumeForRing',
      );
      expect(llamada.arguments, {'fraction': 1.0});
    },
  );

  test(
    'restaurarVolumenMedia invoca restoreMediaVolume sin argumentos',
    () async {
      final servicio = ServicioAlarmasAndroid(channel: channel);

      await servicio.restaurarVolumenMedia();

      final llamada = llamadas.singleWhere(
        (c) => c.method == 'restoreMediaVolume',
      );
      expect(llamada.arguments, <String, Object?>{});
    },
  );
}