Javier Bautista Fernández
0b7919e72e
Verificacion silenciosa en segundo plano con queryPastPurchases, al abrir o volver a la app y al cargar Android Auto. Solo revoca tras dos respuestas validas de Play sin la compra separadas 12h; sin red o con error no toca nada. Reactiva el PRO automaticamente si Play confirma la compra.
513 lines
17 KiB
Dart
513 lines
17 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:pluriwave/estado/estado_entitlement.dart';
|
|
import 'package:pluriwave/servicios/servicio_audio.dart'
|
|
show registrarInvalidacionArbolAuto;
|
|
import 'package:pluriwave/servicios/servicio_compras.dart';
|
|
import 'package:pluriwave/servicios/verificacion_licencia.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
/// Fake [PuertoCompras] (Design ADR-2): never touches `in_app_purchase`,
|
|
/// lets each test drive [emitir] to simulate the purchase stream.
|
|
class _PuertoComprasFalso implements PuertoCompras {
|
|
final _eventos = StreamController<EventoCompra>.broadcast();
|
|
int comprasIntentadas = 0;
|
|
int restaurosIntentados = 0;
|
|
int consultasPropiedad = 0;
|
|
|
|
/// What the silent ownership query answers. Defaults to [desconocido] so
|
|
/// every pre-existing test keeps its old behavior (fail-open: no change).
|
|
ResultadoVerificacionLicencia propiedad =
|
|
ResultadoVerificacionLicencia.desconocido;
|
|
|
|
@override
|
|
Stream<EventoCompra> get eventos => _eventos.stream;
|
|
|
|
@override
|
|
Future<void> comprar() async {
|
|
comprasIntentadas++;
|
|
}
|
|
|
|
@override
|
|
Future<void> restaurar() async {
|
|
restaurosIntentados++;
|
|
}
|
|
|
|
@override
|
|
Future<ResultadoVerificacionLicencia> consultarPropiedad() async {
|
|
consultasPropiedad++;
|
|
return propiedad;
|
|
}
|
|
|
|
void emitir(EventoCompra evento) => _eventos.add(evento);
|
|
|
|
Future<void> dispose() => _eventos.close();
|
|
}
|
|
|
|
/// Mutable clock for the throttle/spacing rules of the license check.
|
|
class _Reloj {
|
|
DateTime ahora = DateTime(2026, 9, 18, 10);
|
|
|
|
DateTime call() => ahora;
|
|
}
|
|
|
|
/// Lets every microtask/async continuation of the fire-and-forget license
|
|
/// check settle (mock prefs + fake port complete immediately).
|
|
Future<void> _asentar() async {
|
|
for (var i = 0; i < 10; i++) {
|
|
await Future<void>.delayed(Duration.zero);
|
|
}
|
|
}
|
|
|
|
void main() {
|
|
TestWidgetsFlutterBinding.ensureInitialized();
|
|
|
|
setUp(() {
|
|
SharedPreferences.setMockInitialValues({});
|
|
});
|
|
|
|
group('EstadoEntitlement', () {
|
|
test('por defecto es free (sin flag persistida)', () async {
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.esPremium, isFalse);
|
|
});
|
|
|
|
test('carga premium desde una flag persistida previamente', () async {
|
|
SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
});
|
|
|
|
test('comprar() con éxito desbloquea premium y persiste', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final prefs = await SharedPreferences.getInstance();
|
|
final estado = EstadoEntitlement(prefs: prefs, compras: compras);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
var notificaciones = 0;
|
|
estado.addListener(() => notificaciones++);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.comprada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
expect(estado.compraEnCurso, isFalse);
|
|
expect(compras.comprasIntentadas, 1);
|
|
expect(prefs.getBool('compra_premium_v1'), isTrue);
|
|
expect(notificaciones, greaterThan(0));
|
|
});
|
|
|
|
test('comprar() cancelada deja el tier free sin cargo', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.cancelada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.esPremium, isFalse);
|
|
expect(estado.compraEnCurso, isFalse);
|
|
});
|
|
|
|
test(
|
|
'comprar() ya premium es idempotente: no reintenta la compra',
|
|
() async {
|
|
SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
await estado.comprar();
|
|
|
|
expect(compras.comprasIntentadas, 0);
|
|
expect(estado.esPremium, isTrue);
|
|
},
|
|
);
|
|
|
|
test('restaurar() encuentra una compra y desbloquea premium', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.restaurar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.restaurada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
expect(compras.restaurosIntentados, 1);
|
|
});
|
|
|
|
test('restaurar() sin compra previa mantiene free sin error', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.restaurar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.noEncontrada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.esPremium, isFalse);
|
|
expect(estado.compraEnCurso, isFalse);
|
|
});
|
|
|
|
test('tras restaurar() sin compras el paywall NO queda bloqueado: se '
|
|
'puede volver a comprar', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.restaurar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
expect(estado.compraEnCurso, isTrue);
|
|
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.noEncontrada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
// `compraEnCurso` deshabilita AMBOS botones de `hoja_premium.dart`
|
|
// (comprar y restaurar): si se queda pegado en `true`, el usuario ya no
|
|
// puede pagar nunca más.
|
|
expect(estado.compraEnCurso, isFalse);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
expect(compras.comprasIntentadas, 1);
|
|
});
|
|
|
|
test(
|
|
'un error en el flujo de compra no bloquea al pagador (fail-open)',
|
|
() async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.error));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
// Fail-open: un error NUNCA escribe `false` sobre una flag ya premium,
|
|
// y tampoco inventa un `true` para un usuario free.
|
|
expect(estado.esPremium, isFalse);
|
|
},
|
|
);
|
|
|
|
group('resultadoUsuario (FIX 3, code review)', () {
|
|
test(
|
|
'un error en el flujo de compra expone ResultadoEntitlementUsuario.error',
|
|
() async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.resultadoUsuario, isNull);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.error));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(estado.resultadoUsuario, ResultadoEntitlementUsuario.error);
|
|
},
|
|
);
|
|
|
|
test('restaurar() sin compra previa expone su propio resultado '
|
|
'(restauracionSinCompras), distinto de un error', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.restaurar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.noEncontrada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
expect(
|
|
estado.resultadoUsuario,
|
|
ResultadoEntitlementUsuario.restauracionSinCompras,
|
|
);
|
|
expect(
|
|
estado.resultadoUsuario,
|
|
isNot(ResultadoEntitlementUsuario.error),
|
|
);
|
|
});
|
|
|
|
test('consumirResultadoUsuario() limpia la señal y notifica a los '
|
|
'listeners', () async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.error));
|
|
await Future<void>.delayed(Duration.zero);
|
|
expect(estado.resultadoUsuario, isNotNull);
|
|
|
|
var notificaciones = 0;
|
|
estado.addListener(() => notificaciones++);
|
|
estado.consumirResultadoUsuario();
|
|
|
|
expect(estado.resultadoUsuario, isNull);
|
|
expect(notificaciones, greaterThan(0));
|
|
|
|
// También se limpia (probado por separado) el resultado de una
|
|
// restauración sin compras.
|
|
unawaited(estado.restaurar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.noEncontrada));
|
|
await Future<void>.delayed(Duration.zero);
|
|
expect(estado.resultadoUsuario, isNotNull);
|
|
|
|
estado.consumirResultadoUsuario();
|
|
expect(estado.resultadoUsuario, isNull);
|
|
});
|
|
|
|
test(
|
|
'nunca expone el texto interno/de desarrollador de EventoCompra.mensaje',
|
|
() async {
|
|
final compras = _PuertoComprasFalso();
|
|
addTearDown(compras.dispose);
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
unawaited(estado.comprar());
|
|
await Future<void>.delayed(Duration.zero);
|
|
compras.emitir(
|
|
const EventoCompra(
|
|
TipoEventoCompra.error,
|
|
mensaje: 'Producto no encontrado en Play Console',
|
|
),
|
|
);
|
|
await Future<void>.delayed(Duration.zero);
|
|
|
|
// resultadoUsuario es un enum tipado -- estructuralmente incapaz
|
|
// de filtrar el string interno de EventoCompra.mensaje hacia la
|
|
// UI.
|
|
expect(estado.resultadoUsuario, ResultadoEntitlementUsuario.error);
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
group('verificacion silenciosa de licencia (reembolsos)', () {
|
|
late _PuertoComprasFalso compras;
|
|
late _Reloj reloj;
|
|
late int invalidaciones;
|
|
|
|
setUp(() {
|
|
compras = _PuertoComprasFalso();
|
|
reloj = _Reloj();
|
|
invalidaciones = 0;
|
|
registrarInvalidacionArbolAuto(() => invalidaciones++);
|
|
});
|
|
|
|
tearDown(() async {
|
|
registrarInvalidacionArbolAuto(() {});
|
|
await compras.dispose();
|
|
});
|
|
|
|
Future<EstadoEntitlement> crear({required bool premium}) async {
|
|
SharedPreferences.setMockInitialValues({'compra_premium_v1': premium});
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
compras: compras,
|
|
reloj: reloj.call,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await _asentar();
|
|
return estado;
|
|
}
|
|
|
|
test('se dispara sola al cargar, sin bloquear la carga', () async {
|
|
final estado = await crear(premium: true);
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
expect(compras.consultasPropiedad, 1);
|
|
});
|
|
|
|
test('desconocido (offline) conserva premium sin notificar nada', () async {
|
|
final estado = await crear(premium: true);
|
|
var notificaciones = 0;
|
|
estado.addListener(() => notificaciones++);
|
|
|
|
reloj.ahora = reloj.ahora.add(const Duration(days: 2));
|
|
await estado.refrescarLicencia();
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
expect(notificaciones, 0);
|
|
expect(invalidaciones, 0);
|
|
});
|
|
|
|
test('una sola ausencia no revoca', () async {
|
|
compras.propiedad = ResultadoVerificacionLicencia.noPoseida;
|
|
final estado = await crear(premium: true);
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
});
|
|
|
|
test('revocacion confirmada: notifica, invalida el arbol de Auto y NUNCA '
|
|
'toca resultadoUsuario ni compraEnCurso', () async {
|
|
compras.propiedad = ResultadoVerificacionLicencia.noPoseida;
|
|
final estado = await crear(premium: true);
|
|
final prefs = await SharedPreferences.getInstance();
|
|
|
|
// A restore the user started stays in flight, untouched.
|
|
unawaited(estado.restaurar());
|
|
await _asentar();
|
|
expect(estado.compraEnCurso, isTrue);
|
|
|
|
var notificaciones = 0;
|
|
estado.addListener(() => notificaciones++);
|
|
|
|
reloj.ahora = reloj.ahora.add(const Duration(days: 1));
|
|
await estado.refrescarLicencia();
|
|
|
|
expect(estado.esPremium, isFalse);
|
|
expect(prefs.getBool('compra_premium_v1'), isFalse);
|
|
expect(notificaciones, greaterThan(0));
|
|
expect(invalidaciones, 1);
|
|
expect(estado.resultadoUsuario, isNull);
|
|
expect(estado.compraEnCurso, isTrue);
|
|
});
|
|
|
|
test('poseida con la flag en false desbloquea en silencio', () async {
|
|
compras.propiedad = ResultadoVerificacionLicencia.poseida;
|
|
final estado = await crear(premium: false);
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
expect(invalidaciones, 1);
|
|
expect(estado.resultadoUsuario, isNull);
|
|
expect(estado.compraEnCurso, isFalse);
|
|
});
|
|
|
|
test('refrescarLicencia recoge un cambio hecho por otra via (Android '
|
|
'Auto) en prefs', () async {
|
|
final estado = await crear(premium: true);
|
|
final prefs = await SharedPreferences.getInstance();
|
|
|
|
await prefs.setBool('compra_premium_v1', false);
|
|
await estado.refrescarLicencia();
|
|
|
|
expect(estado.esPremium, isFalse);
|
|
});
|
|
|
|
test('una compra real reinicia el contador de ausencias', () async {
|
|
compras.propiedad = ResultadoVerificacionLicencia.noPoseida;
|
|
final estado = await crear(premium: false);
|
|
final prefs = await SharedPreferences.getInstance();
|
|
await prefs.setInt(claveAusenciasLicencia, 1);
|
|
|
|
compras.emitir(const EventoCompra(TipoEventoCompra.comprada));
|
|
await _asentar();
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
expect(prefs.getInt(claveAusenciasLicencia), isNull);
|
|
});
|
|
|
|
test('sin puerto de compras no verifica nada', () async {
|
|
SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
|
|
final estado = EstadoEntitlement(
|
|
prefs: await SharedPreferences.getInstance(),
|
|
reloj: reloj.call,
|
|
);
|
|
addTearDown(estado.dispose);
|
|
await _asentar();
|
|
await estado.refrescarLicencia();
|
|
|
|
expect(estado.esPremium, isTrue);
|
|
});
|
|
});
|
|
|
|
group('esPremiumPersistido (headless, sin BuildContext)', () {
|
|
test('lee la flag persistida directamente desde prefs', () async {
|
|
SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
|
|
final prefs = await SharedPreferences.getInstance();
|
|
|
|
expect(await esPremiumPersistido(prefs: prefs), isTrue);
|
|
});
|
|
|
|
test('por defecto (sin flag) resuelve a free', () async {
|
|
final prefs = await SharedPreferences.getInstance();
|
|
|
|
expect(await esPremiumPersistido(prefs: prefs), isFalse);
|
|
});
|
|
|
|
test(
|
|
'resuelve sin prefs inyectadas (SharedPreferences.getInstance)',
|
|
() async {
|
|
SharedPreferences.setMockInitialValues({'compra_premium_v1': true});
|
|
|
|
expect(await esPremiumPersistido(), isTrue);
|
|
},
|
|
);
|
|
});
|
|
}
|