pluriwave/test/servicios/diagnostico_alarmas_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:pluriwave/servicios/diagnostico_alarmas.dart';
import 'package:pluriwave/servicios/servicio_alarmas_android.dart';

/// Builds a fully-OK snapshot by default; each test overrides only the
/// field(s) it wants to fail, so failures are exercised independently.
DiagnosticoAlarmasAndroid _diag({
  bool puedeProgramarExactas = true,
  bool notificacionesPermitidas = true,
  bool puedeUsarPantallaCompleta = true,
  bool ignoraOptimizacionBateria = true,
  int alarmasNativasPendientes = 1,
  String fabricante = 'Google',
  int versionSdk = 34,
}) => DiagnosticoAlarmasAndroid(
  puedeProgramarExactas: puedeProgramarExactas,
  notificacionesPermitidas: notificacionesPermitidas,
  puedeUsarPantallaCompleta: puedeUsarPantallaCompleta,
  ignoraOptimizacionBateria: ignoraOptimizacionBateria,
  alarmasNativasPendientes: alarmasNativasPendientes,
  fabricante: fabricante,
  versionSdk: versionSdk,
);

void main() {
  group('construirItemsDiagnosticoAlarmas', () {
    test(
      'caso todo OK: los 5 items quedan en estado ok y en orden estable',
      () {
        final items = construirItemsDiagnosticoAlarmas(
          diagnostico: _diag(),
          hayAlarmasActivas: true,
        );

        expect(items, hasLength(5));
        expect(items.map((item) => item.senal).toList(), const [
          SenalDiagnosticoAlarma.alarmasExactas,
          SenalDiagnosticoAlarma.notificaciones,
          SenalDiagnosticoAlarma.pantallaCompleta,
          SenalDiagnosticoAlarma.optimizacionBateria,
          SenalDiagnosticoAlarma.alarmasNativasPendientes,
        ]);
        expect(
          items.every((item) => item.estado == EstadoSenalDiagnostico.ok),
          isTrue,
          reason: 'ningun item deberia requerir atencion en el caso todo OK',
        );
        expect(items.any((item) => item.requiereAtencion), isFalse);
      },
    );

    test('alarmas exactas queda en atencion cuando el permiso no esta '
        'concedido, sin afectar a los demas items (falla independiente)', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(puedeProgramarExactas: false),
        hayAlarmasActivas: true,
      );

      final exactas = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.alarmasExactas,
      );
      expect(exactas.estado, EstadoSenalDiagnostico.atencion);
      expect(exactas.accion, AccionDiagnosticoAlarma.abrirAlarmasExactas);
      expect(
        items
            .where(
              (item) => item.senal != SenalDiagnosticoAlarma.alarmasExactas,
            )
            .every((item) => item.estado == EstadoSenalDiagnostico.ok),
        isTrue,
      );
    });

    test('notificaciones queda en atencion cuando no estan permitidas, sin '
        'afectar a los demas items (falla independiente)', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(notificacionesPermitidas: false),
        hayAlarmasActivas: true,
      );

      final notificaciones = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.notificaciones,
      );
      expect(notificaciones.estado, EstadoSenalDiagnostico.atencion);
      expect(
        notificaciones.accion,
        AccionDiagnosticoAlarma.abrirNotificaciones,
      );
      expect(
        items
            .where(
              (item) => item.senal != SenalDiagnosticoAlarma.notificaciones,
            )
            .every((item) => item.estado == EstadoSenalDiagnostico.ok),
        isTrue,
      );
    });

    test('pantalla completa queda en atencion cuando no se puede usar, sin '
        'afectar a los demas items (falla independiente)', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(puedeUsarPantallaCompleta: false),
        hayAlarmasActivas: true,
      );

      final pantalla = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.pantallaCompleta,
      );
      expect(pantalla.estado, EstadoSenalDiagnostico.atencion);
      expect(pantalla.accion, AccionDiagnosticoAlarma.abrirPantallaCompleta);
      expect(
        items
            .where(
              (item) => item.senal != SenalDiagnosticoAlarma.pantallaCompleta,
            )
            .every((item) => item.estado == EstadoSenalDiagnostico.ok),
        isTrue,
      );
    });

    test('optimizacion de bateria queda en atencion cuando la app no esta '
        'exenta, sin afectar a los demas items (falla independiente)', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(ignoraOptimizacionBateria: false),
        hayAlarmasActivas: true,
      );

      final bateria = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.optimizacionBateria,
      );
      expect(bateria.estado, EstadoSenalDiagnostico.atencion);
      expect(bateria.accion, AccionDiagnosticoAlarma.abrirOptimizacionBateria);
      expect(
        items
            .where(
              (item) =>
                  item.senal != SenalDiagnosticoAlarma.optimizacionBateria,
            )
            .every((item) => item.estado == EstadoSenalDiagnostico.ok),
        isTrue,
      );
    });

    test('alarmas nativas pendientes queda en atencion cuando hay alarmas '
        'activas pero ninguna llego a registrarse en el sistema (la senal '
        'mas diagnostica del reporte: el disparo nunca llego al SO)', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(alarmasNativasPendientes: 0),
        hayAlarmasActivas: true,
      );

      final nativas = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.alarmasNativasPendientes,
      );
      expect(nativas.estado, EstadoSenalDiagnostico.atencion);
      expect(nativas.accion, AccionDiagnosticoAlarma.ninguna);
      expect(
        items
            .where(
              (item) =>
                  item.senal != SenalDiagnosticoAlarma.alarmasNativasPendientes,
            )
            .every((item) => item.estado == EstadoSenalDiagnostico.ok),
        isTrue,
      );
    });

    test('alarmas nativas pendientes queda OK cuando no hay ninguna alarma '
        'activa, aunque el conteo nativo sea cero (nada deberia estar '
        'registrado todavia)', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(alarmasNativasPendientes: 0),
        hayAlarmasActivas: false,
      );

      final nativas = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.alarmasNativasPendientes,
      );
      expect(nativas.estado, EstadoSenalDiagnostico.ok);
    });

    test('alarmas nativas pendientes queda OK cuando hay alarmas activas y al '
        'menos una esta registrada en el sistema', () {
      final items = construirItemsDiagnosticoAlarmas(
        diagnostico: _diag(alarmasNativasPendientes: 3),
        hayAlarmasActivas: true,
      );

      final nativas = items.singleWhere(
        (item) => item.senal == SenalDiagnosticoAlarma.alarmasNativasPendientes,
      );
      expect(nativas.estado, EstadoSenalDiagnostico.ok);
    });
  });

  group('fabricanteRequiereGuiaAutostart', () {
    test('un fabricante desconocido no requiere guia de autostart', () {
      expect(fabricanteRequiereGuiaAutostart('Google'), isFalse);
      expect(fabricanteRequiereGuiaAutostart('Fairphone'), isFalse);
      expect(fabricanteRequiereGuiaAutostart(''), isFalse);
    });

    test(
      'Xiaomi (y sus sub-marcas Redmi/POCO) requieren guia de autostart',
      () {
        expect(fabricanteRequiereGuiaAutostart('Xiaomi'), isTrue);
        expect(fabricanteRequiereGuiaAutostart('Redmi'), isTrue);
        expect(fabricanteRequiereGuiaAutostart('POCO'), isTrue);
      },
    );

    test('otros fabricantes conocidos por matar procesos en segundo plano '
        'tambien requieren guia', () {
      for (final fabricante in [
        'HUAWEI',
        'OPPO',
        'vivo',
        'OnePlus',
        'samsung',
      ]) {
        expect(
          fabricanteRequiereGuiaAutostart(fabricante),
          isTrue,
          reason: '$fabricante deberia requerir guia de autostart',
        );
      }
    });

    test('la comparacion no distingue mayusculas/minusculas ni espacios', () {
      expect(fabricanteRequiereGuiaAutostart('XIAOMI'), isTrue);
      expect(fabricanteRequiereGuiaAutostart('  xiaomi  '), isTrue);
    });
  });
}