Skip to content

Offline gym log for Android. No account, no ads, no internet.

Add tests for the latest requests

InlitX6049afe8838d
diff --git a/test/requests_17oct_test.dart b/test/requests_17oct_test.dart
new file mode 100644
index 0000000..cbcb6ac
--- /dev/null
+++ b/test/requests_17oct_test.dart
@@ -0,0 +1,153 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:gymmane/models/workout.dart';
+import 'package:gymmane/services/local_store.dart';
+import 'package:gymmane/state/fit_state.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+void main() {
+ TestWidgetsFlutterBinding.ensureInitialized();
+
+ setUp(() async {
+ SharedPreferences.setMockInitialValues({});
+ await Store.instance.init();
+ fit.resetAllData();
+ fit.onboarded = true;
+ });
+
+ Routine routineOf(List<String> ids) {
+ final id = fit.createRoutine('Core');
+ for (final ex in ids) {
+ fit.toggleRoutineExercise(id, ex);
+ }
+ return fit.routines.firstWhere((r) => r.id == id);
+ }
+
+ Future<void> endSide() async {
+ final past = DateTime.now().subtract(const Duration(milliseconds: 50));
+ fit.holdStartsAt = past.subtract(Duration(seconds: fit.holdTotal));
+ fit.holdEndsAt = past;
+ await Future<void>.delayed(const Duration(milliseconds: 300));
+ }
+
+ group('#213 cada lado', () {
+ test('la plancha lateral viene por lados y se puede quitar y volver a poner', () async {
+ expect(fit.isEachSide('side-plank-hold'), isTrue);
+ expect(fit.isEachSide('plank-hold'), isFalse);
+ fit.toggleEachSide('side-plank-hold');
+ fit.toggleEachSide('plank-hold');
+ expect(fit.isEachSide('side-plank-hold'), isFalse);
+ expect(fit.isEachSide('plank-hold'), isTrue);
+
+ fit.persistNow();
+ fit.eachSide.clear();
+ fit.eachSideOff.clear();
+ fit.loadFromStore();
+ expect(fit.isEachSide('side-plank-hold'), isFalse);
+ expect(fit.isEachSide('plank-hold'), isTrue);
+
+ fit.toggleEachSide('side-plank-hold');
+ expect(fit.eachSideOff, isNot(contains('side-plank-hold')));
+ expect(fit.eachSide, isNot(contains('side-plank-hold')));
+ });
+
+ test('solo cuenta en ejercicios por tiempo', () {
+ fit.setExerciseMode('side-plank-hold', 'weight');
+ expect(fit.isEachSide('side-plank-hold'), isFalse);
+ fit.setExerciseMode('side-plank-hold', 'time');
+ expect(fit.isEachSide('side-plank-hold'), isTrue);
+ });
+
+ test('corre un lado, avisa de cambiar y descansa solo tras el segundo', () async {
+ fit.startRoutine(routineOf(['side-plank-hold']));
+ fit.endCountdown();
+ final set = fit.session!.exercises.first.sets.first;
+ fit.startHold(0, 0);
+ expect(fit.holdSides, 2);
+ expect(fit.holdLength('side-plank-hold', 30), '0:30 × 2');
+
+ await endSide();
+ expect(fit.holding, isTrue);
+ expect(fit.holdSide, 1);
+ expect(fit.switchingSides, isTrue);
+ expect(set.done, isFalse);
+ expect(fit.session!.restRemaining, isNull);
+
+ await endSide();
+ expect(fit.holding, isFalse);
+ expect(set.done, isTrue);
+ expect(fit.session!.restRemaining, isNotNull);
+ fit.skipRest();
+ });
+
+ test('un aguante normal sigue siendo de una vez', () async {
+ fit.startRoutine(routineOf(['plank-hold']));
+ fit.endCountdown();
+ fit.startHold(0, 0);
+ expect(fit.holdSides, 1);
+ await endSide();
+ expect(fit.holding, isFalse);
+ expect(fit.session!.exercises.first.sets.first.done, isTrue);
+ fit.skipRest();
+ });
+
+ test('pararlo deja todo como al principio', () {
+ fit.startRoutine(routineOf(['side-plank-hold']));
+ fit.endCountdown();
+ fit.startHold(0, 0);
+ fit.stopHold();
+ expect(fit.holdSide, 0);
+ expect(fit.holdSides, 1);
+ expect(fit.session!.exercises.first.sets.first.done, isFalse);
+ });
+ });
+
+ group('#204 descanso a mano', () {
+ void rest() {
+ final bench = fit.matchExerciseByName('Bench Press')!.id;
+ fit.startRoutine(routineOf([bench]));
+ fit.endCountdown();
+ fit.toggleSet(0, 0);
+ expect(fit.session!.restRemaining, isNotNull);
+ }
+
+ test('fija el descanso al tiempo elegido', () {
+ rest();
+ fit.setRest(200);
+ expect(fit.restTotal, 200);
+ expect(fit.session!.restRemaining, inInclusiveRange(199, 200));
+ fit.skipRest();
+ });
+
+ test('cero lo salta y el tope es de diez minutos', () {
+ rest();
+ fit.setRest(5000);
+ expect(fit.session!.restRemaining, inInclusiveRange(599, 600));
+ fit.setRest(0);
+ expect(fit.session!.restRemaining, isNull);
+ });
+
+ test('con la sesión en pausa se queda congelado en el tiempo nuevo', () {
+ rest();
+ fit.toggleSessionPause();
+ fit.setRest(90);
+ expect(fit.session!.restFrozen, 90);
+ expect(fit.session!.restRemaining, 90);
+ fit.toggleSessionPause();
+ expect(fit.session!.restRemaining, inInclusiveRange(89, 90));
+ fit.skipRest();
+ });
+ });
+
+ group('#206 fotos tapadas en Progreso', () {
+ test('se recuerda al reiniciar', () {
+ expect(fit.hideShots, isFalse);
+ fit.toggleHideShots();
+ fit.persistNow();
+ fit.hideShots = false;
+ fit.loadFromStore();
+ expect(fit.hideShots, isTrue);
+ fit.resetAllData();
+ expect(fit.hideShots, isFalse);
+ });
+ });
+}
diff --git a/test/requests_18oct_test.dart b/test/requests_18oct_test.dart
new file mode 100644
index 0000000..7ea9a7d
--- /dev/null
+++ b/test/requests_18oct_test.dart
@@ -0,0 +1,212 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:gymmane/models/nutrition.dart';
+import 'package:gymmane/models/workout.dart';
+import 'package:gymmane/services/local_store.dart';
+import 'package:gymmane/state/fit_state.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+void main() {
+ TestWidgetsFlutterBinding.ensureInitialized();
+
+ setUp(() async {
+ SharedPreferences.setMockInitialValues({});
+ await Store.instance.init();
+ fit.resetAllData();
+ fit.onboarded = true;
+ });
+
+ String bench() => fit.matchExerciseByName('Bench Press')!.id;
+
+ Routine routine(String name) {
+ final id = fit.createRoutine(name);
+ fit.toggleRoutineExercise(id, bench());
+ return fit.routines.firstWhere((r) => r.id == id);
+ }
+
+ void train(Routine r, {DateTime? on}) {
+ fit.startRoutine(r, on: on);
+ fit.endCountdown();
+ fit.toggleSet(0, 0);
+ fit.finishSession();
+ }
+
+ DateTime day(int offset) {
+ final n = DateTime.now();
+ return DateTime(n.year, n.month, n.day + offset, 10);
+ }
+
+ group('rotación', () {
+ test('la siguiente es la que sigue a la última, sin mirar el día', () {
+ final a = routine('A'), b = routine('B'), c = routine('C');
+ fit.setRotation(true);
+ for (final r in [a, b, c]) {
+ fit.toggleRotationRoutine(r.id);
+ }
+ expect(fit.rotating, isTrue);
+ expect(fit.todayRoutine?.id, a.id);
+ expect(fit.routinesOn(day(3)).single.id, a.id);
+
+ train(a);
+ expect(fit.rotationNext?.id, b.id);
+ expect(fit.rotationStep, 1);
+ expect(fit.todayPlanDone, isTrue);
+ expect(fit.routinesOn(day(1)).single.id, b.id);
+
+ fit.skipRotation();
+ expect(fit.rotationNext?.id, c.id);
+ fit.restartRotation();
+ expect(fit.rotationNext?.id, a.id);
+ });
+
+ test('al terminar la última vuelve a la primera', () {
+ final a = routine('A'), b = routine('B');
+ fit.setRotation(true);
+ fit.toggleRotationRoutine(a.id);
+ fit.toggleRotationRoutine(b.id);
+ fit.setRotationNext(b.id);
+ train(b);
+ expect(fit.rotationNext?.id, a.id);
+ expect(fit.rotationStep, 0);
+ });
+
+ test('se guarda, y borrar una rutina pasa a la siguiente', () {
+ final a = routine('A'), b = routine('B'), c = routine('C');
+ fit.setRotation(true);
+ for (final r in [a, b, c]) {
+ fit.toggleRotationRoutine(r.id);
+ }
+ fit.setRotationNext(b.id);
+ fit.reorderRotation(2, 0);
+ expect(fit.rotationIds, [c.id, a.id, b.id]);
+
+ fit.persistNow();
+ fit.rotationIds.clear();
+ fit.rotation = false;
+ fit.loadFromStore();
+ expect(fit.rotating, isTrue);
+ expect(fit.rotationIds, [c.id, a.id, b.id]);
+ expect(fit.rotationNext?.id, b.id);
+
+ fit.deleteRoutine(b.id);
+ expect(fit.rotationIds, [c.id, a.id]);
+ expect(fit.rotationNext?.id, c.id);
+ });
+
+ test('al encenderla se llena con el plan semanal y al apagarla vuelve la semana', () {
+ final a = routine('A'), b = routine('B');
+ fit.assignRoutineToDay(DateTime.monday, a.id);
+ fit.assignRoutineToDay(DateTime.thursday, b.id);
+ fit.setRotation(true);
+ expect(fit.rotationIds, [a.id, b.id]);
+ fit.setRotation(false);
+ expect(fit.weeklyPlan[DateTime.monday], a.id);
+ expect(fit.weeklyPlan[DateTime.thursday], b.id);
+ });
+ });
+
+ group('mover la sesión de hoy', () {
+ test('pasa a otro día sin tocar el plan semanal y se deshace', () {
+ final a = routine('A');
+ final today = DateTime.now();
+ fit.assignRoutineToDay(today.weekday, a.id);
+ final undo = fit.moveRoutineDay(a.id, today, day(2));
+ expect(undo, isNotNull);
+ expect(fit.routinesOn(today), isEmpty);
+ expect(fit.routinesOn(day(2)).single.id, a.id);
+ expect(fit.weeklyPlan[today.weekday], a.id);
+ expect(fit.movedOn(today), isTrue);
+ expect(fit.isTrainingDay(today), isFalse);
+
+ fit.persistNow();
+ fit.planMoves.clear();
+ fit.loadFromStore();
+ expect(fit.routinesOn(day(2)).single.id, a.id);
+
+ undo!();
+ expect(fit.routinesOn(today).single.id, a.id);
+ expect(fit.movedOn(day(2)), isFalse);
+ });
+
+ test('volver al plan quita el cambio de ese día', () {
+ final a = routine('A');
+ final today = DateTime.now();
+ fit.assignRoutineToDay(today.weekday, a.id);
+ fit.moveRoutineDay(a.id, today, day(1));
+ fit.undoMoves(today);
+ expect(fit.routinesOn(today).single.id, a.id);
+ });
+ });
+
+ group('músculos sin entrenar', () {
+ test('cuenta los días desde la última serie del músculo principal', () {
+ final now = DateTime.now();
+ fit.sessions.add(LoggedSession(now.subtract(const Duration(days: 9)), 600, [
+ LoggedExercise(bench(), 'Bench Press', 'chest', [LoggedSet(8, 60)]),
+ ]));
+ final days = fit.daysSinceTrained();
+ expect(days['chest'], 9);
+ expect(days['quads'], isNull);
+ expect(fit.untrainedLongest(), isNot(contains('chest')));
+ expect(fit.untrainedLongest().length, 3);
+ });
+ });
+
+ group('vista en lista', () {
+ test('el ajuste se guarda y por defecto son tarjetas', () {
+ expect(fit.sessionLayout, 'cards');
+ fit.setSessionLayout('list');
+ fit.persistNow();
+ fit.sessionLayout = 'cards';
+ fit.loadFromStore();
+ expect(fit.listLayout, isTrue);
+ });
+
+ test('marcar una serie de otro ejercicio lo pone delante y descansa con su tiempo', () {
+ final id = fit.createRoutine('L');
+ final squat = fit.matchExerciseByName('Barbell Squat')!.id;
+ fit.toggleRoutineExercise(id, bench());
+ fit.toggleRoutineExercise(id, squat);
+ fit.setRoutineRest(id, squat, 200);
+ fit.startRoutine(fit.routines.firstWhere((r) => r.id == id));
+ fit.endCountdown();
+ fit.toggleSetAt(1, 0);
+ expect(fit.session!.currentIndex, 1);
+ expect(fit.restTotal, 200);
+ fit.skipRest();
+ });
+
+ test('copiar la serie anterior y mover ejercicios', () {
+ fit.sessions.add(LoggedSession(day(-2), 600, [
+ LoggedExercise(bench(), 'Bench Press', 'chest', [LoggedSet(6, 82.5)]),
+ ]));
+ final r = routine('P');
+ fit.startRoutine(r);
+ fit.endCountdown();
+ fit.copyPreviousSet(0, 0);
+ final st = fit.session!.exercises.first.sets.first;
+ expect(st.reps, 6);
+ expect(st.weight, 82.5);
+
+ fit.addExerciseToSession(fit.matchExerciseByName('Barbell Squat')!.id);
+ final first = fit.session!.exercises.first.id;
+ fit.moveSessionExercise(0, 1);
+ expect(fit.session!.exercises[1].id, first);
+ fit.moveSessionExercise(1, -1);
+ expect(fit.session!.exercises[0].id, first);
+ });
+ });
+ group('widgets de nutrición', () {
+ test('lo tocado en el widget se apunta con su hora y lo de otro día se ignora', () {
+ final now = DateTime.now();
+ final ms = now.subtract(const Duration(minutes: 5)).millisecondsSinceEpoch;
+ final old = now.subtract(const Duration(days: 2)).millisecondsSinceEpoch;
+ final food = fit.saveFood(name: 'Batido', macros: const Macros(kcal: 120, protein: 24));
+ final before = fit.waterOn(now);
+ final n = fit.takeWidgetLog('w,$ms,250;w,$old,250;s,$ms,${food.id};x,1,2;w,bad,3');
+ expect(n, 2);
+ expect(fit.waterOn(now), before + 250);
+ expect(fit.totalOn(now).protein.round(), 24);
+ expect(fit.waterSipsOn(now).last.at.millisecondsSinceEpoch, ms);
+ });
+ });
+}
diff --git a/test/requests_19oct_test.dart b/test/requests_19oct_test.dart
new file mode 100644
index 0000000..80a8560
--- /dev/null
+++ b/test/requests_19oct_test.dart
@@ -0,0 +1,284 @@
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:gymmane/models/workout.dart';
+import 'package:gymmane/services/local_store.dart';
+import 'package:gymmane/state/fit_state.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+void main() {
+ TestWidgetsFlutterBinding.ensureInitialized();
+
+ setUp(() async {
+ SharedPreferences.setMockInitialValues({});
+ await Store.instance.init();
+ fit.resetAllData();
+ fit.onboarded = true;
+ });
+
+ String bench() => fit.matchExerciseByName('Bench Press')!.id;
+ String squat() => fit.matchExerciseByName('Barbell Squat')!.id;
+
+ Routine routine(String name, [List<String>? ids]) {
+ final id = fit.createRoutine(name);
+ for (final e in ids ?? [bench()]) {
+ fit.toggleRoutineExercise(id, e);
+ }
+ return fit.routines.firstWhere((r) => r.id == id);
+ }
+
+ void train(Routine r) {
+ fit.startRoutine(r);
+ fit.endCountdown();
+ fit.toggleSet(0, 0);
+ fit.finishSession();
+ }
+
+ void close() => fit.saveAndExit();
+
+ DateTime day(int offset, [int hour = 10]) {
+ final n = DateTime.now();
+ return DateTime(n.year, n.month, n.day + offset, hour);
+ }
+
+ group('rotación a fondo', () {
+ Routine rotate(List<Routine> list) {
+ fit.setRotation(true);
+ for (final r in list) {
+ if (!fit.rotationIds.contains(r.id)) fit.toggleRotationRoutine(r.id);
+ }
+ return list.first;
+ }
+
+ test('A, B, C seguidas en días distintos dan la vuelta entera', () {
+ final a = routine('A'), b = routine('B'), c = routine('C');
+ rotate([a, b, c]);
+ final seen = <String>[];
+ for (var i = 0; i < 4; i++) {
+ final next = fit.rotationNext!;
+ seen.add(next.name);
+ train(next);
+ close();
+ }
+ expect(seen, ['A', 'B', 'C', 'A']);
+ expect(fit.rotationNext?.id, b.id);
+ });
+
+ test('hoy enseña la hecha y mañana la siguiente', () {
+ final a = routine('A'), b = routine('B');
+ rotate([a, b]);
+ train(a);
+ close();
+ expect(fit.routinesOn(DateTime.now()).single.id, a.id);
+ expect(fit.pendingRoutinesOn(DateTime.now()), isEmpty);
+ expect(fit.routinesOn(day(1)).single.id, b.id);
+ expect(fit.routinesOn(day(-1)), isEmpty);
+ });
+
+ test('una rutina fuera de la rotación no la mueve', () {
+ final a = routine('A'), b = routine('B'), x = routine('X');
+ rotate([a, b]);
+ train(x);
+ close();
+ expect(fit.rotationNext?.id, a.id);
+ });
+
+ test('hacer la B cuando tocaba la A salta a la C', () {
+ final a = routine('A'), b = routine('B'), c = routine('C');
+ rotate([a, b, c]);
+ train(b);
+ close();
+ expect(fit.rotationNext?.id, c.id);
+ });
+
+ test('volver al entreno desde el resumen no avanza dos veces', () {
+ final a = routine('A'), b = routine('B'), c = routine('C');
+ rotate([a, b, c]);
+ train(a);
+ expect(fit.rotationNext?.id, b.id);
+ fit.continueSession();
+ expect(fit.rotationNext?.id, a.id);
+ fit.finishSession();
+ expect(fit.rotationNext?.id, b.id);
+ close();
+ expect(fit.sessions.length, 1);
+ });
+
+ test('quitar la que tocaba pasa a la primera y vaciarla vuelve a la semana', () {
+ final a = routine('A'), b = routine('B');
+ fit.assignRoutineToDay(DateTime.now().weekday, a.id);
+ rotate([a, b]);
+ fit.setRotationNext(b.id);
+ fit.toggleRotationRoutine(b.id);
+ expect(fit.rotationNext?.id, a.id);
+ fit.toggleRotationRoutine(a.id);
+ expect(fit.rotating, isFalse);
+ expect(fit.routinesOn(DateTime.now()).single.id, a.id);
+ });
+
+ test('nada de rutinas vacías ni ids sueltos al cargar', () {
+ final a = routine('A'), b = routine('B');
+ rotate([a, b]);
+ fit.rotationIds.add('no-existe');
+ fit.persistNow();
+ fit.loadFromStore();
+ expect(fit.rotationRoutines.map((r) => r.id), [a.id, b.id]);
+ });
+ });
+
+ group('mover el día a fondo', () {
+ test('a un día que ya tiene rutina se suman las dos', () {
+ final a = routine('A'), b = routine('B');
+ final today = DateTime.now();
+ fit.toggleMultiPlan();
+ fit.assignRoutineToDay(today.weekday, a.id);
+ fit.assignRoutineToDay(day(1).weekday, b.id);
+ fit.moveRoutineDay(a.id, today, day(1));
+ expect(fit.routinesOn(day(1)).map((r) => r.id), [b.id, a.id]);
+ expect(fit.routinesOn(today), isEmpty);
+ expect(fit.routinesOn(day(8)).map((r) => r.id), [b.id]);
+ });
+
+ test('mover dos veces y deshacer la segunda deja la primera', () {
+ final a = routine('A');
+ final today = DateTime.now();
+ fit.assignRoutineToDay(today.weekday, a.id);
+ fit.moveRoutineDay(a.id, today, day(1));
+ final undo = fit.moveRoutineDay(a.id, day(1), day(2))!;
+ expect(fit.routinesOn(day(2)).single.id, a.id);
+ expect(fit.routinesOn(day(1)), isEmpty);
+ undo();
+ expect(fit.routinesOn(day(1)).single.id, a.id);
+ expect(fit.routinesOn(day(2)), isEmpty);
+ });
+
+ test('no mueve lo que no está ese día ni al mismo día', () {
+ final a = routine('A');
+ final today = DateTime.now();
+ expect(fit.moveRoutineDay(a.id, today, day(1)), isNull);
+ fit.assignRoutineToDay(today.weekday, a.id);
+ expect(fit.moveRoutineDay(a.id, today, DateTime.now()), isNull);
+ expect(fit.planMoves, isEmpty);
+ });
+
+ test('los cambios viejos se borran solos', () {
+ final a = routine('A');
+ fit.planMoves['2001-01-01'] = [a.id];
+ final today = DateTime.now();
+ fit.assignRoutineToDay(today.weekday, a.id);
+ fit.moveRoutineDay(a.id, today, day(1));
+ expect(fit.planMoves.containsKey('2001-01-01'), isFalse);
+ });
+
+ test('borrar la rutina la quita también de los días movidos', () {
+ final a = routine('A');
+ final today = DateTime.now();
+ fit.assignRoutineToDay(today.weekday, a.id);
+ fit.moveRoutineDay(a.id, today, day(1));
+ fit.deleteRoutine(a.id);
+ expect(fit.routinesOn(day(1)), isEmpty);
+ });
+ });
+
+ group('#81 entreno que pasa de medianoche', () {
+ test('cuenta en el día en que empezó', () {
+ final end = day(0, 1);
+ fit.sessions.add(LoggedSession(end, 2 * 3600, [
+ LoggedExercise(bench(), 'Bench Press', 'chest', [LoggedSet(8, 60)]),
+ ]));
+ expect(fit.trainedToday, isFalse);
+ expect(fit.sessionsOn(day(-1)).length, 1);
+ expect(fit.sessionsOn(DateTime.now()), isEmpty);
+ });
+ });
+
+ group('#212 series añadidas en la rutina', () {
+ test('añadir una serie se ofrece guardar y queda en la rutina', () {
+ final r = routine('A', [bench(), squat()]);
+ expect(fit.routineSets(r, bench()), 3);
+ fit.startRoutine(r);
+ fit.endCountdown();
+ fit.addSet(0);
+ fit.removeSet(1, 2);
+ fit.toggleSet(0, 0);
+ fit.finishSession();
+ expect(fit.sessionEditedRoutine, isTrue);
+ final changes = fit.sessionRoutineChanges;
+ expect(changes.added, isEmpty);
+ expect([for (final c in changes.sets) (c.ex.id, c.from, c.to)], [(bench(), 3, 4), (squat(), 3, 2)]);
+ fit.saveSessionIntoRoutine();
+ expect(fit.routineSets(r, bench()), 4);
+ expect(fit.routineSets(r, squat()), 2);
+ expect(fit.sessionEditedRoutine, isFalse);
+ });
+
+ test('con series planificadas copia la última', () {
+ final r = routine('A');
+ fit.setPlannedSets(r.id, bench(), const [
+ PlannedSet(kind: SetKind.warmup, reps: 10),
+ PlannedSet(reps: 8, weightKg: 60),
+ PlannedSet(reps: 6, weightKg: 70),
+ ]);
+ fit.startRoutine(r);
+ fit.endCountdown();
+ fit.addSet(0);
+ fit.toggleSet(0, 0);
+ fit.finishSession();
+ fit.saveSessionIntoRoutine();
+ final plan = fit.plannedSets(r, bench());
+ expect(plan.length, 4);
+ expect(plan.first.kind, SetKind.warmup);
+ expect(plan.last.reps, 6);
+ expect(plan.last.weightKg, 70);
+ });
+
+ test('sin cambios no molesta', () {
+ final r = routine('A');
+ train(r);
+ expect(fit.sessionEditedRoutine, isFalse);
+ });
+ });
+
+ group('#211 press inclinado en máquina', () {
+ test('está en el catálogo con su dibujo', () {
+ final ex = fit.exerciseById('incline-chest-press-machine');
+ expect(ex, isNotNull);
+ expect(ex!.equipment, 'Machine');
+ expect(File('assets/art/${ex.art}.txt').readAsLinesSync().where((l) => l.isNotEmpty).length, 2);
+ expect(fit.matchExerciseByName('Incline Chest Press (Machine)')?.id, ex.id);
+ });
+ });
+
+ group('descanso', () {
+ test('quitar segundos baja la barra y sumar la alarga', () {
+ final r = routine('A');
+ fit.setRoutineRest(r.id, bench(), 120);
+ fit.startRoutine(r);
+ fit.endCountdown();
+ fit.toggleSet(0, 0);
+ expect(fit.restTotal, 120);
+ fit.nudgeRest(-15);
+ fit.nudgeRest(-15);
+ expect(fit.restTotal, 120);
+ expect(fit.session!.restRemaining, lessThanOrEqualTo(90));
+ fit.nudgeRest(60);
+ expect(fit.restTotal, greaterThanOrEqualTo(fit.session!.restRemaining!));
+ fit.skipRest();
+ });
+
+ test('cuando el aviso nativo dice que acabó, se cierra el descanso', () {
+ final r = routine('A');
+ fit.startRoutine(r);
+ fit.endCountdown();
+ fit.toggleSet(0, 0);
+ final s = fit.session!;
+ s.restEndsAt = DateTime.now().subtract(const Duration(seconds: 1));
+ final tick = fit.restDoneTick;
+ fit.restElapsed();
+ expect(s.restEndsAt, isNull);
+ expect(fit.restDoneTick, tick + 1);
+ fit.restElapsed();
+ expect(fit.restDoneTick, tick + 1);
+ });
+ });
+}