Skip to content

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

16.8 KB
Raw Blame
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:gymmane/l10n/l10n.dart';
import 'package:gymmane/models/note.dart';
import 'package:gymmane/models/workout.dart';
import 'package:gymmane/services/local_store.dart';
import 'package:gymmane/services/plan_share.dart';
import 'package:gymmane/state/fit_state.dart';
import 'package:shared_preferences/shared_preferences.dart';

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  group('#160 nombre del entreno libre', () {
    setUp(() async {
      SharedPreferences.setMockInitialValues({});
      await Store.instance.init();
      fit.resetAllData();
      fit.onboarded = true;
    });

    Routine routineOf(List<String> ids) {
      final id = fit.createRoutine('Cardio');
      for (final ex in ids) {
        fit.toggleRoutineExercise(id, ex);
      }
      return fit.routines.firstWhere((r) => r.id == id);
    }

    LoggedSession finishFree() {
      fit.startRoutine(routineOf(['running']));
      fit.endCountdown();
      fit.session!.routineId = null;
      fit.toggleSet(0, 0);
      fit.finishSession();
      return fit.filedSession!;
    }

    test('se le pone nombre al acabar y se guarda', () {
      final s = finishFree();
      expect(fit.sessionTitle(s), isNull);
      fit.renameSession(s, '  Pierna  ');
      expect(s.name, 'Pierna');
      expect(fit.sessionTitle(s), 'Pierna');
      expect(LoggedSession.fromJson(s.toJson()).name, 'Pierna');
      expect(fit.workoutText(s).split('\n').first, 'Pierna');
    });

    test('seguir entrenando y volver a acabar no pierde el nombre', () {
      final s = finishFree();
      fit.renameSession(s, 'Torso');
      fit.continueSession();
      expect(fit.session!.name, 'Torso');
      fit.finishSession();
      expect(fit.filedSession!.name, 'Torso');
    });

    test('reabrir un entreno guardado conserva el nombre', () {
      final s = finishFree();
      fit.renameSession(s, 'Brazos');
      fit.saveAndExit();
      fit.resumeLoggedSession(fit.sessions.last);
      expect(fit.session!.name, 'Brazos');
    });

    test('las de rutina se titulan con la rutina si no se renombran', () {
      final r = routineOf(['running']);
      fit.renameRoutine(r.id, 'Cardio suave');
      fit.startRoutine(fit.routines.firstWhere((x) => x.id == r.id));
      fit.endCountdown();
      fit.toggleSet(0, 0);
      fit.finishSession();
      expect(fit.sessionTitle(fit.filedSession!), 'Cardio suave');
    });
  });

  group('vista en lista', () {
    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);
    }

    DateTime day(int offset) {
      final n = DateTime.now();
      return DateTime(n.year, n.month, n.day + offset, 10);
    }

    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('sets inside a live workout', () {
    setUp(() async {
      SharedPreferences.setMockInitialValues({});
      await Store.instance.init();
      fit.resetAllData();
      fit.setUnits('kg');
    });

    tearDown(() {
      if (fit.session != null) fit.saveAndExit();
    });

    String idOf(String name) => fit.matchExerciseByName(name)!.id;

    Routine routineWith(List<String> ids, {String name = 'Push'}) {
      final id = fit.createRoutine(name);
      for (final ex in ids) {
        fit.toggleRoutineExercise(id, ex);
      }
      return fit.routines.firstWhere((r) => r.id == id);
    }

    test('changing a set carries over to the sets that still match it', () {
      final r = routineWith([idOf('Barbell Bench Press')]);
      fit.startRoutine(r);
      final sets = fit.session!.exercises.first.sets;
      for (var j = 0; j < sets.length; j++) {
        fit.setSessionWeight(0, j, 60);
        fit.setSessionReps(0, j, 10);
      }
      fit.setSessionWeight(0, sets.length - 1, 70);

      fit.setSessionWeight(0, 0, 62.5);
      fit.setSessionReps(0, 0, 8);
      expect(sets.first.weight, 62.5);
      for (var j = 1; j < sets.length - 1; j++) {
        expect(sets[j].weight, 62.5);
        expect(sets[j].reps, 8);
      }
      expect(sets.last.weight, 70);
      expect(sets.last.reps, 8);
    });

    test('a set can be removed and brought back', () {
      final r = routineWith([idOf('Barbell Bench Press')]);
      fit.startRoutine(r);
      final sets = fit.session!.exercises.single.sets;
      final before = sets.length;
      final gone = fit.removeSet(0, 1)!;
      expect(sets.length, before - 1);
      fit.insertSet(0, 1, gone);
      expect(sets.length, before);
      expect(identical(sets[1], gone), isTrue);
    });

    test('a warm-up added by mistake goes away in one tap', () {
      final r = routineWith([idOf('Barbell Bench Press')]);
      fit.startRoutine(r);
      final working = fit.session!.exercises.single.sets.length;
      fit.addWarmupSets(0);
      expect(fit.hasWarmup(0), isTrue);
      fit.removeWarmupSets(0);
      expect(fit.hasWarmup(0), isFalse);
      expect(fit.session!.exercises.single.sets.length, working);
    });

    test('jumping and reordering keep the exercise you are on', () {
      final ids = [idOf('Barbell Bench Press'), idOf('Barbell Full Squat'), idOf('Pull Up')];
      final r = routineWith(ids);
      fit.toggleChain(r.id, ids[0]);
      fit.startRoutine(r);
      fit.goToExercise(1);
      expect(fit.currentExercise!.id, ids[1]);
      fit.reorderSessionExercise(2, 0);
      expect(fit.session!.exercises.first.id, ids[2]);
      expect(fit.currentExercise!.id, ids[1]);
      expect(fit.session!.exercises.every((e) => !e.linkedNext || e.id != ids[2]), isTrue);
    });
  });

  group('terminar el entreno solo', () {
    setUp(() async {
      SharedPreferences.setMockInitialValues({});
      await Store.instance.init();
      fit.resetAllData();
      fit.setUnits('kg');
    });

    tearDown(() {
      if (fit.session != null) fit.saveAndExit();
    });

    Routine oneSetEach(List<String> names) {
      final id = fit.createRoutine('Push');
      for (final name in names) {
        final ex = fit.matchExerciseByName(name)!.id;
        fit.toggleRoutineExercise(id, ex);
        fit.bumpRoutineSets(id, ex, -2);
      }
      return fit.routines.firstWhere((r) => r.id == id);
    }

    Future<void> wait(Duration d) => Future<void>.delayed(d + const Duration(milliseconds: 200));

    group('#67 terminar solo', () {
      test('al marcar la última serie del último ejercicio se abre el resumen', () async {
        fit.startRoutine(oneSetEach(['Barbell Bench Press', 'Barbell Squat']));
        fit.endCountdown();
        expect(fit.route, 'session');

        fit.toggleSet(0, 0);
        await wait(WorkoutState.advanceDelay);
        expect(fit.session!.currentIndex, 1);

        fit.toggleSet(1, 0);
        expect(fit.isSessionComplete, isFalse, reason: 'primero se ve el tic marcado');
        await wait(WorkoutState.finishDelay);
        expect(fit.isSessionComplete, isTrue);
        expect(fit.sessions, hasLength(1));
      });

      test('desmarcar a tiempo lo cancela', () async {
        fit.startRoutine(oneSetEach(['Barbell Bench Press']));
        fit.endCountdown();
        fit.toggleSet(0, 0);
        fit.toggleSet(0, 0);
        await wait(WorkoutState.finishDelay);
        expect(fit.isSessionComplete, isFalse);
      });

      test('con el paso automático apagado espera al botón', () async {
        fit.toggleAutoAdvance();
        fit.startRoutine(oneSetEach(['Barbell Bench Press']));
        fit.endCountdown();
        fit.toggleSet(0, 0);
        await wait(WorkoutState.finishDelay);
        expect(fit.isSessionComplete, isFalse);
        fit.toggleAutoAdvance();
      });

      test('si quedan series atrás, vuelve a ellas en vez de terminar', () async {
        fit.startRoutine(oneSetEach(['Barbell Bench Press', 'Barbell Squat']));
        fit.endCountdown();
        fit.goToExercise(1);
        fit.toggleSet(1, 0);
        await wait(WorkoutState.finishDelay);
        expect(fit.isSessionComplete, isFalse);
        expect(fit.session!.currentIndex, 0);
      });
    });

    test('#58 el paso automático queda contado para avisar del cambio', () async {
      fit.startRoutine(oneSetEach(['Barbell Bench Press', 'Barbell Squat']));
      fit.endCountdown();
      final before = fit.autoMoves;
      fit.goToExercise(1);
      expect(fit.autoMoves, before, reason: 'moverse a mano no avisa');
      fit.goToExercise(0);
      fit.toggleSet(0, 0);
      await wait(WorkoutState.advanceDelay);
      expect(fit.autoMoves, before + 1);
    });

    test('el check puesto a mano se quita con otro toque', () {
      final today = fit.todayIndex;
      fit.toggleCheckin(today);
      expect(fit.isDayDone(today), isTrue);
      fit.toggleCheckin(today);
      expect(fit.isDayDone(today), isFalse);
      expect(fit.dateForWeekday(today).day, DateTime.now().day);
    });
  });

  group('#224 notas en el entreno', () {
    setUp(() async {
      SharedPreferences.setMockInitialValues({});
      await Store.instance.init();
      fit.resetAllData();
      fit.onboarded = true;
    });

    DateTime ago(int days, [int hour = 18]) {
      final n = DateTime.now();
      return DateTime(n.year, n.month, n.day - days, hour);
    }

    DateTime dayAgo(int days) {
      final n = DateTime.now();
      return DateTime(n.year, n.month, n.day - days);
    }

    void logged(String id, int days, List<LoggedSet> sets) =>
        fit.sessions.add(LoggedSession(ago(days), 1200, [LoggedExercise(id, id, 'back', sets)]));

    test('una nota fijada sale siempre en el entreno', () {
      fit.saveNote(exerciseId: 'row', date: ago(10), kind: NoteKind.note, text: 'Asiento en el 2', pinned: true);
      logged('row', 5, [LoggedSet(8, 40)]);
      expect(fit.workoutNotesFor('row').map((n) => n.text), ['Asiento en el 2']);
    });

    test('una nota sin fijar y que no es plan no molesta', () {
      fit.saveNote(exerciseId: 'row', date: ago(1), kind: NoteKind.done, text: 'Buen día');
      expect(fit.workoutNotesFor('row'), isEmpty);
    });

    test('la próxima vez sale hoy, la próxima vez y luego desaparece', () {
      fit.saveNote(exerciseId: 'row', date: ago(0), kind: NoteKind.plan, text: 'Sube a 45');
      expect(fit.workoutNotesFor('row').single.text, 'Sube a 45');
      final old = fit.notes.single;
      fit.notes[0] = GymNote(
        id: old.id,
        exerciseId: 'row',
        date: dayAgo(3),
        kind: NoteKind.plan,
        text: old.text,
        createdAt: old.createdAt,
      );
      logged('row', 3, [LoggedSet(8, 40)]);
      expect(fit.workoutNotesFor('row').single.text, 'Sube a 45');
      logged('row', 1, [LoggedSet(8, 45)]);
      expect(fit.workoutNotesFor('row'), isEmpty);
    });

    test('solo sale el plan más reciente', () {
      fit.saveNote(exerciseId: 'row', date: ago(2), kind: NoteKind.plan, text: 'Viejo');
      fit.saveNote(exerciseId: 'row', date: ago(1), kind: NoteKind.plan, text: 'Nuevo');
      expect(fit.workoutNotesFor('row').map((n) => n.text), ['Nuevo']);
    });

    test('fijar y soltar se guarda, y una nota general no se puede fijar', () {
      fit.saveNote(exerciseId: 'row', date: ago(0), kind: NoteKind.note, text: 'Polea 19');
      final id = fit.notes.single.id;
      fit.setNotePinned(id, true);
      final data = jsonDecode(jsonEncode(fit.toJson())) as Map<String, dynamic>;
      fit.applyBackup(data);
      expect(fit.noteById(id)!.pinned, isTrue);
      fit.setNotePinned(id, false);
      expect(fit.workoutNotesFor('row'), isEmpty);
      fit.saveNote(exerciseId: '', date: ago(0), kind: NoteKind.note, text: 'General', pinned: true);
      expect(fit.notes.last.pinned, isFalse);
    });

    test('editar sin decir nada conserva la chincheta', () {
      fit.saveNote(exerciseId: 'row', date: ago(0), kind: NoteKind.note, text: 'A', pinned: true);
      final id = fit.notes.single.id;
      fit.saveNote(id: id, exerciseId: 'row', date: ago(0), kind: NoteKind.note, text: 'B');
      expect(fit.noteById(id)!.pinned, isTrue);
    });
  });

  group('series cluster y duplicadas', () {
    setUp(() async {
      SharedPreferences.setMockInitialValues({});
      await Store.instance.init();
      fit.resetAllData();
      fit.onboarded = true;
      fit.setUnits('kg');
      setAppLanguage('en');
    });

    group('#250 series cluster', () {
      test('es un tipo de serie más y no rompe los guardados viejos', () {
        expect(SetKind.values.last, SetKind.cluster);
        expect(setKindFrom(SetKind.restPause.index), SetKind.restPause);
        final back = LoggedSet.fromJson(LoggedSet(9, 80, kind: SetKind.cluster).toJson());
        expect(back.kind, SetKind.cluster);
        expect(back.counts, isTrue);
      });

      test('viaja en el plan compartido', () {
        final plans = parsePlan('{"name":"A","exercises":[{"name":"Barbell Full Squat",'
            '"plan":[{"type":"cluster","reps":12,"weight":100}]}]}');
        expect(plans.single.items.single.plan.single.kind, SetKind.cluster.index);
        fit.applyPlan(plans);
        final r = fit.routines.single;
        expect(fit.exportPlanJson([r]), contains('"type": "cluster"'));
      });
    });

    group('deslizar para duplicar una serie', () {
      test('la copia va justo debajo, sin marcar, y se puede deshacer', () {
        fit.startWorkout();
        fit.toggleMuscle('chest');
        fit.trainContinue();
        fit.startSession();
        final sets = fit.session!.exercises.first.sets;
        final before = sets.length;
        fit.setSessionReps(0, 0, 7);
        fit.setSessionWeight(0, 0, 42.5);
        fit.toggleSet(0, 0);
        final copy = fit.duplicateSet(0, 0)!;
        expect(sets.length, before + 1);
        expect(identical(sets[1], copy), isTrue);
        expect(copy.done, isFalse);
        expect((copy.reps, copy.weight), (7, 42.5));
        fit.removeSetObject(0, copy);
        expect(sets.length, before);
        expect(sets.contains(copy), isFalse);
      });
    });
  });

  group('#122 salir del entreno', () {
    setUp(() async {
      SharedPreferences.setMockInitialValues({});
      await Store.instance.init();
      fit.resetAllData();
      fit.setUnits('kg');
    });

    tearDown(() {
      if (fit.session != null) fit.saveAndExit();
    });

    String idOf(String name) => fit.matchExerciseByName(name)!.id;

    Routine routineOf(List<String> names) {
      final id = fit.createRoutine('Push');
      for (final name in names) {
        fit.toggleRoutineExercise(id, idOf(name));
      }
      return fit.routines.firstWhere((r) => r.id == id);
    }

    test('salir pausa y deja volver donde estabas', () {
      fit.startRoutine(routineOf(['Barbell Bench Press']));
      fit.endCountdown();
      fit.stepOutOfSession();
      expect(fit.route, 'home');
      expect(fit.sessionPaused, isTrue);
      expect(fit.sessionParked, isTrue);

      fit.stepBackIntoSession();
      expect(fit.route, 'session');
      expect(fit.sessionPaused, isFalse);
    });

    test('empezar otra cosa con uno aparcado vuelve al aparcado', () {
      fit.startRoutine(routineOf(['Barbell Bench Press']));
      fit.endCountdown();
      final session = fit.session;
      fit.stepOutOfSession();
      fit.startRoutine(routineOf(['Barbell Squat']));
      expect(fit.session, same(session));
      expect(fit.route, 'session');
    });
  });
}