FreeTLab
d8e67a5204
Full time-domain audit (three shipped date bugs prompted it) found one
root cause and two latent travel defects, all now fixed:
Day-stepping used add(Duration(days: 1)), which shifts the absolute
instant by exactly 86400s — documented Dart behavior (sdk#47666), so
crossing a DST transition drifted the wall hour by +-1h permanently
for the rest of the candidate scan (verified: 2026-03-28 07:30
Europe/Madrid + "1 day" = 08:30). The native Calendar engine preserves
wall time, and the single-authority fix made the drifted Dart verdict
win. Candidates now advance by calendar reconstruction (_siguienteDia:
DateTime(y, m, d+1, hora, minuto)), the same wall-clock-preserving
semantics as Calendar.add(DAY_OF_YEAR, 1) plus AOSP DeskClock's
defensive hour/minute re-assertion, keeping both engines in agreement
through any transition.
Instant-valued fields (snoozeHasta/snoozeOrigen/proximaEjecucion/
ultimaEjecucionGestionada/creadaEn/actualizadaEn) serialized as
offset-less local ISO, so re-parsing after a device timezone change
reinterpreted the same wall fields as a different instant. They now
serialize as UTC ("Z"); reads normalize to local, and legacy
offset-less payloads parse identically — no migration. fechaUnica
stays local on purpose: it is a wall-clock date.
One-shot alarms sent fechaUnica's midnight epoch to the native side,
whose boot/travel re-arm derives the calendar day back from it in the
CURRENT zone — a westward shift rolled the date to the previous day.
The channel now anchors the date at local noon, keeping it stable
across real-world zone shifts.
Property tests lock the no-drift guarantee (400 daily / 200 weekday
iterations must all land exactly at hora:minuto — on DST-observing
dev machines this crosses real transitions), plus UTC round-trip,
legacy-payload compatibility, and wall-date preservation tests.
322 lines
9.6 KiB
Dart
322 lines
9.6 KiB
Dart
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:pluriwave/modelos/alarma_musical.dart';
|
|
import 'package:pluriwave/servicios/servicio_alarmas.dart';
|
|
import 'package:pluriwave/servicios/servicio_programacion_alarmas.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
void main() {
|
|
group('ServicioProgramacionAlarmas', () {
|
|
final servicio = ServicioProgramacionAlarmas();
|
|
|
|
test('calcula la próxima alarma diaria futura', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a1',
|
|
nombre: 'Diaria',
|
|
hora: 7,
|
|
minuto: 30,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 5, 21, 7),
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 5, 21, 7, 30));
|
|
});
|
|
|
|
test('salta vacaciones si la alarma no debe sonar esos días', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a2',
|
|
nombre: 'Laboral',
|
|
hora: 8,
|
|
minuto: 0,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
sonarEnVacaciones: false,
|
|
);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 8, 1, 7),
|
|
vacaciones: [
|
|
RangoVacaciones(
|
|
id: 'v1',
|
|
nombre: 'Verano',
|
|
inicio: DateTime(2026, 8),
|
|
fin: DateTime(2026, 8, 3),
|
|
),
|
|
],
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 8, 4, 8));
|
|
});
|
|
|
|
test('saltar próxima solo omite esa ejecución', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a3',
|
|
nombre: 'Diaria',
|
|
hora: 9,
|
|
minuto: 0,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
);
|
|
final omitida = DateTime(2026, 5, 22, 9);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 5, 22, 8),
|
|
excepciones: [
|
|
ExcepcionAlarma(alarmaId: 'a3', ejecucion: omitida, tipo: 'skipNext'),
|
|
],
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 5, 23, 9));
|
|
});
|
|
|
|
test('snooze solo permite 3, 5 o 10 minutos y cae a 5', () {
|
|
expect(
|
|
servicio.calcularSnooze(DateTime(2026, 5, 21, 7), 10),
|
|
DateTime(2026, 5, 21, 7, 10),
|
|
);
|
|
expect(
|
|
servicio.calcularSnooze(DateTime(2026, 5, 21, 7), 99),
|
|
DateTime(2026, 5, 21, 7, 5),
|
|
);
|
|
});
|
|
|
|
test(
|
|
'servicio limpia proxima ejecucion obsoleta al recalcular unica vencida',
|
|
() async {
|
|
SharedPreferences.setMockInitialValues({});
|
|
final servicioAlarmas = ServicioAlarmas(
|
|
reloj: () => DateTime(2026, 5, 22, 10),
|
|
);
|
|
final alarma = AlarmaMusical(
|
|
id: 'a4',
|
|
nombre: 'Unica vencida',
|
|
hora: 9,
|
|
minuto: 0,
|
|
tipoProgramacion: TipoProgramacionAlarma.unica,
|
|
diasSemana: const [],
|
|
fechaUnica: DateTime(2026, 5, 22),
|
|
proximaEjecucion: DateTime(2026, 5, 22, 9),
|
|
);
|
|
|
|
final guardada = await servicioAlarmas.guardarAlarma(alarma);
|
|
|
|
expect(guardada.alarmas.single.proximaEjecucion, isNull);
|
|
},
|
|
);
|
|
|
|
test('mantiene alarma unica creada dentro del mismo minuto', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a5',
|
|
nombre: 'Ahora',
|
|
hora: 20,
|
|
minuto: 13,
|
|
tipoProgramacion: TipoProgramacionAlarma.unica,
|
|
diasSemana: const [],
|
|
fechaUnica: DateTime(2026, 5, 23),
|
|
);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 5, 23, 20, 13, 45),
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 5, 23, 20, 13, 47));
|
|
});
|
|
|
|
test('calcula siguiente diaria despues de ejecucion completada', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a6',
|
|
nombre: 'Diaria',
|
|
hora: 7,
|
|
minuto: 30,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
proximaEjecucion: DateTime(2026, 5, 25, 7, 30),
|
|
);
|
|
|
|
final siguiente = servicio.calcularSiguienteDespuesDeEjecucion(
|
|
alarma: alarma,
|
|
ejecucion: DateTime(2026, 5, 25, 7, 30),
|
|
);
|
|
|
|
expect(siguiente, DateTime(2026, 5, 26, 7, 30));
|
|
});
|
|
|
|
test('no reutiliza ejecucion gestionada aunque siga en tolerancia', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a9',
|
|
nombre: 'Diaria gestionada',
|
|
hora: 7,
|
|
minuto: 30,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
ultimaEjecucionGestionada: DateTime(2026, 5, 25, 7, 30),
|
|
);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 5, 25, 7, 30, 20),
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 5, 26, 7, 30));
|
|
});
|
|
|
|
test('la hora de pared nunca deriva al iterar dias (DST-safe): diaria', () {
|
|
// Property lock for the DST drift bug: advancing candidates with
|
|
// add(Duration(days: 1)) shifts the ABSOLUTE instant by 86400s, so on
|
|
// DST-observing machines (this repo's dev machine runs Europe/Madrid)
|
|
// crossing 2026-03-29 / 2026-10-25 drifted the wall hour +-1h
|
|
// permanently. Iterating a full year of next-occurrences must keep
|
|
// every result at exactly hora:minuto.
|
|
final alarma = AlarmaMusical(
|
|
id: 'dst-diaria',
|
|
nombre: 'Diaria DST',
|
|
hora: 7,
|
|
minuto: 30,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
);
|
|
|
|
var proxima =
|
|
servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 1, 5, 6, 0),
|
|
)!;
|
|
for (var i = 0; i < 400; i++) {
|
|
expect(
|
|
proxima.hour,
|
|
7,
|
|
reason: 'deriva de hora de pared en ${proxima.toIso8601String()}',
|
|
);
|
|
expect(proxima.minute, 30);
|
|
proxima =
|
|
servicio.calcularSiguienteDespuesDeEjecucion(
|
|
alarma: alarma,
|
|
ejecucion: proxima,
|
|
)!;
|
|
}
|
|
});
|
|
|
|
test('la hora de pared nunca deriva al iterar dias (DST-safe): '
|
|
'dias de semana', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'dst-semana',
|
|
nombre: 'Semana DST',
|
|
hora: 7,
|
|
minuto: 30,
|
|
tipoProgramacion: TipoProgramacionAlarma.diasSemana,
|
|
diasSemana: const [1, 3, 5],
|
|
);
|
|
|
|
var proxima =
|
|
servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 1, 5, 6, 0),
|
|
)!;
|
|
for (var i = 0; i < 200; i++) {
|
|
expect(
|
|
proxima.hour,
|
|
7,
|
|
reason: 'deriva de hora de pared en ${proxima.toIso8601String()}',
|
|
);
|
|
expect(proxima.minute, 30);
|
|
expect(const [1, 3, 5], contains(proxima.weekday));
|
|
proxima =
|
|
servicio.calcularSiguienteDespuesDeEjecucion(
|
|
alarma: alarma,
|
|
ejecucion: proxima,
|
|
)!;
|
|
}
|
|
});
|
|
|
|
test('mantiene la ocurrencia diaria cuyo disparo acaba de pasar', () {
|
|
// Contract the native AlarmScheduler.computeNextTriggerMillis MUST
|
|
// mirror: a trigger that just passed within toleranciaDisparoInminente
|
|
// (90s) and has NOT been handled is kept (normalized to desde + 2s),
|
|
// never skipped to tomorrow. The native side lacking this window is
|
|
// what recomputed the next occurrence as tomorrow and cancelled the
|
|
// in-flight fire, so the alarm never rang until the screen was turned
|
|
// on. If this expectation changes, the native constant
|
|
// IMMINENT_TOLERANCE_MILLIS must change with it.
|
|
final alarma = AlarmaMusical(
|
|
id: 'a-inminente-diaria',
|
|
nombre: 'Diaria inminente',
|
|
hora: 22,
|
|
minuto: 35,
|
|
tipoProgramacion: TipoProgramacionAlarma.diaria,
|
|
diasSemana: const [],
|
|
);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 7, 11, 22, 35, 30),
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 7, 11, 22, 35, 32));
|
|
});
|
|
|
|
test('mantiene la ocurrencia por dias de semana recien pasada', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a-inminente-semana',
|
|
nombre: 'Semana inminente',
|
|
hora: 22,
|
|
minuto: 35,
|
|
tipoProgramacion: TipoProgramacionAlarma.diasSemana,
|
|
diasSemana: const [1, 2, 3, 4, 5, 6, 7],
|
|
);
|
|
|
|
final proxima = servicio.calcularProxima(
|
|
alarma: alarma,
|
|
desde: DateTime(2026, 7, 11, 22, 35, 30),
|
|
);
|
|
|
|
expect(proxima, DateTime(2026, 7, 11, 22, 35, 32));
|
|
});
|
|
|
|
test('calcula siguiente por dias de semana despues de ejecucion', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a7',
|
|
nombre: 'Laboral',
|
|
hora: 8,
|
|
minuto: 0,
|
|
tipoProgramacion: TipoProgramacionAlarma.diasSemana,
|
|
diasSemana: const [DateTime.monday, DateTime.wednesday],
|
|
proximaEjecucion: DateTime(2026, 5, 25, 8),
|
|
);
|
|
|
|
final siguiente = servicio.calcularSiguienteDespuesDeEjecucion(
|
|
alarma: alarma,
|
|
ejecucion: DateTime(2026, 5, 25, 8),
|
|
);
|
|
|
|
expect(siguiente, DateTime(2026, 5, 27, 8));
|
|
});
|
|
|
|
test('alarma unica completada no calcula siguiente', () {
|
|
final alarma = AlarmaMusical(
|
|
id: 'a8',
|
|
nombre: 'Unica',
|
|
hora: 8,
|
|
minuto: 0,
|
|
tipoProgramacion: TipoProgramacionAlarma.unica,
|
|
diasSemana: const [],
|
|
fechaUnica: DateTime(2026, 5, 25),
|
|
proximaEjecucion: DateTime(2026, 5, 25, 8),
|
|
);
|
|
|
|
final siguiente = servicio.calcularSiguienteDespuesDeEjecucion(
|
|
alarma: alarma,
|
|
ejecucion: DateTime(2026, 5, 25, 8),
|
|
);
|
|
|
|
expect(siguiente, isNull);
|
|
});
|
|
});
|
|
}
|