Skip to content

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

16.2 KB
Raw Blame
import 'dart:convert';

import 'package:archive/archive.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:gymmane/services/workout_import.dart';
import 'package:gymmane/state/fit_state.dart';

const _hevy = '''
"title","start_time","end_time","description","exercise_title","superset_id","exercise_notes","set_index","set_type","weight_kg","reps","distance_km","duration_seconds","rpe"
"Morning","12 Jan 2024, 18:30","12 Jan 2024, 19:15","","Bench Press (Barbell)",,"",0,"warmup",20,10,,0,
"Morning","12 Jan 2024, 18:30","12 Jan 2024, 19:15","","Bench Press (Barbell)",,"",1,"normal",60,10,,0,8
"Morning","12 Jan 2024, 18:30","12 Jan 2024, 19:15","","Bench Press (Barbell)",,"",2,"normal",60,8,,0,9
"Morning","12 Jan 2024, 18:30","12 Jan 2024, 19:15","","Squat (Barbell)",,"",0,"normal",100,5,,0,8
''';

const _hevyLb = '''
"title","start_time","end_time","exercise_title","set_index","set_type","weight_kg","weight_lbs","reps"
"Push","12 Jan 2024, 18:30","12 Jan 2024, 19:00","Bench Press (Barbell)",0,"normal",,220,5
''';

const _strongPlain = '''
Date;Workout Name;Duration;Exercise Name;Set Order;Weight;Reps;Distance;Seconds;Notes;Workout Notes;RPE
2024-01-13 10:00:00;Legs;1h 5m;Squat (Barbell);1;100;5;;;;;
2024-01-13 10:00:00;Legs;1h 5m;Squat (Barbell);2;100;5;;;;;
''';

const _strongLb = '''
Date,Workout Name,Duration,Exercise Name,Set Order,Weight,Reps,Distance,Seconds,Notes,Workout Notes,RPE
2024-01-14 09:00:00,Push,30m,Bench Press (Barbell),1,220,5,,,,,
''';

const _fitnotesPlain = '''
Date,Exercise,Category,Weight,Reps,Distance,Distance Unit,Time,Comment
2024-01-15,Barbell Bench Press,Chest,60,10,,,,
2024-01-15,Barbell Squat,Legs,100,5,,,,
''';

const _fitnotesUnits = '''
Date,Exercise,Category,Weight (kg),Weight (lbs),Reps,Distance,Distance Unit,Time,Notes,Kind
2024-01-15,Bench Press,Chest,100.00,220.46,10,,,00:03:45,Good form,wr
''';

const _gymmane = '''
date,exercise,muscle,set,reps,weight_kg,volume_kg,est_1rm_kg
2024-01-16,Barbell Bench Press,chest,1,10,60,600,80
''';

const _generic = '''
Date,Exercise,Reps,Weight,RiR
2024-02-01,Bench Press,10,60,2
2024-02-01,Bench Press,8,62.5,1
2024-02-01,Squat,5,100,
''';

const _genericDe = '''
Datum;Übung;Wiederholungen;Gewicht
2024-02-02;Kniebeuge;5;100
''';

const _openGym = '''
{
  "unit": "kg",
  "routines": [],
  "customEx": [{"id": "im1", "n": "Sled Drag", "custom": true}],
  "bodyweight": [{"d": "2024-01-20", "w": 81.4, "t": 1705750000000}],
  "workouts": [
    {
      "id": "w1",
      "d": "2024-01-20",
      "start": 1705750000000,
      "end": 1705753600000,
      "name": "Push",
      "entries": [
        {"id": "0025", "sets": [
          {"w": 20, "r": 10, "done": true, "phase": "warmup"},
          {"w": 60, "r": 8, "done": true},
          {"w": 60, "r": 7, "done": true},
          {"w": 60, "r": 6, "done": false}
        ]},
        {"id": "0294", "sets": [{"w": 12, "r": 12, "done": true}]},
        {"id": "im1", "sets": [{"w": 40, "r": 20, "done": true}]},
        {"id": "9999", "sets": [{"w": 30, "r": 10, "done": true}]}
      ]
    }
  ]
}
''';

const _openGymLb = '''
{
  "unit": "lb",
  "routines": [],
  "workouts": [
    {"id": "w1", "d": "2024-01-21", "start": 1705836000000, "end": 1705836000000,
     "entries": [{"id": "0043", "sets": [{"w": 220, "r": 5, "done": true}]}]}
  ],
  "bodyweight": [{"d": "2024-01-21", "w": 180}]
}
''';

void main() {
  group('detección de formato', () {
    test('reconoce cada app', () {
      expect(detectFormat(_hevy), ImportFormat.hevy);
      expect(detectFormat(_strongPlain), ImportFormat.strong);
      expect(detectFormat(_fitnotesPlain), ImportFormat.fitnotes);
      expect(detectFormat(_fitnotesUnits), ImportFormat.fitnotes);
      expect(detectFormat(_gymmane), ImportFormat.gymmane);
      expect(detectFormat('a,b,c\n1,2,3'), ImportFormat.unknown);
      expect(detectFormat(_generic), ImportFormat.generic);
      expect(detectFormat(_genericDe), ImportFormat.generic);
      expect(detectFormat(''), ImportFormat.unknown);
    });

    test('solo se pregunta la unidad cuando el archivo no la dice', () {
      expect(needsUnitChoice(_strongPlain), isTrue);
      expect(needsUnitChoice(_fitnotesPlain), isTrue);
      expect(needsUnitChoice(_fitnotesUnits), isFalse);
      expect(needsUnitChoice(_hevy), isFalse);
      expect(needsUnitChoice(_gymmane), isFalse);
    });
  });

  group('CSV genérico de cualquier app', () {
    test('agrupa por día y respeta las columnas en inglés', () {
      final r = parseImport(_generic);
      expect(r.format, ImportFormat.generic);
      expect(r.sessions.length, 1);
      final s = r.sessions.first;
      expect(s.exercises.length, 2);
      expect(s.exercises.first.name, 'Bench Press');
      expect(s.exercises.first.sets.length, 2);
      expect(s.exercises.first.sets.first.weightKg, 60);
      expect(s.exercises.last.sets.single.reps, 5);
    });

    test('lee cabeceras en otro idioma y con punto y coma', () {
      final r = parseImport(_genericDe);
      expect(r.sessions.single.exercises.single.name, 'Kniebeuge');
      expect(r.sessions.single.exercises.single.sets.single.weightKg, 100);
    });

    test('pregunta la unidad porque la columna no la dice', () {
      expect(needsUnitChoice(_generic), isTrue);
    });
  });

  group('parseo', () {
    test('Hevy agrupa la sesión y saca la duración de start/end', () {
      final r = parseImport(_hevy);
      expect(r.sessions.length, 1);
      final s = r.sessions.first;
      expect(s.durationSec, 45 * 60);
      expect(s.exercises.length, 2);
      expect(s.exercises.first.sets.length, 2, reason: 'la serie de calentamiento no cuenta');
      expect(s.exercises.first.sets.first.weightKg, 60);
      expect(s.exercises.first.sets.first.reps, 10);
      expect(s.exercises[1].sets.single.weightKg, 100);
    });

    test('Hevy sin weight_kg cae a weight_lbs', () {
      final r = parseImport(_hevyLb);
      expect(r.sessions.single.exercises.single.sets.single.weightKg, closeTo(99.79, 0.05));
      expect(r.sessions.single.durationSec, 1800);
    });

    test('Strong con ; y kg', () {
      final r = parseImport(_strongPlain);
      expect(r.sessions.length, 1);
      final s = r.sessions.first;
      expect(s.durationSec, 3900);
      expect(s.exercises.single.sets.length, 2);
      expect(s.exercises.single.sets.first.weightKg, 100);
    });

    test('Strong en lb convierte a kg', () {
      final r = parseImport(_strongLb, isLb: true);
      final w = r.sessions.single.exercises.single.sets.single.weightKg;
      expect(w, closeTo(99.79, 0.05));
      expect(r.sessions.single.durationSec, 1800);
    });

    test('FitNotes agrupa por día y trae la categoría', () {
      final r = parseImport(_fitnotesPlain);
      expect(r.sessions.length, 1);
      expect(r.sessions.single.exercises.length, 2);
      expect(r.sessions.single.exercises.first.muscle, 'Chest');
    });

    test('FitNotes moderno usa la columna en kg y ignora la de lb', () {
      final r = parseImport(_fitnotesUnits, isLb: true);
      expect(r.sessions.single.exercises.single.sets.single.weightKg, 100);
    });

    test('GymMane propio', () {
      final r = parseImport(_gymmane);
      expect(r.sessions.single.exercises.single.sets.single.weightKg, 60);
    });

    test('un archivo sin filas útiles no rompe nada', () {
      expect(parseImport(_hevy.split('\n').first).sessions, isEmpty);
      expect(parseImport('cualquier cosa').sessions, isEmpty);
    });
  });

  group('StrongLifts', () {
    const csv = 'Date (yyyy/mm/dd),Workout,Workout Name,Exercise,Start Time (h:mm),End Time (h:mm),Notes,'
        'Set 1 (Reps),Set 1 (KG),Set 2 (Reps),Set 2 (KG),Set 3 (Reps),Set 3 (KG)\n'
        '2024/03/05,1,Workout A,Squat,6:30 PM,7:15 PM,felt strong,5,100,5,100,3,100\n'
        '2024/03/05,1,Workout A,Bench Press,6:30 PM,7:15 PM,,5,60,5,60,0,60\n'
        '2024/03/07,1,Workout B,Deadlift,7:00 AM,,,5,140,,,,\n';

    test('una fila por ejercicio con sus series en columnas', () {
      expect(detectFormat(csv), ImportFormat.stronglifts);
      expect(needsUnitChoice(csv), isFalse);
      final r = parseImport(csv);
      expect(r.sessions.length, 2);
      final a = r.sessions.first;
      expect(a.date, DateTime(2024, 3, 5, 18, 30));
      expect(a.durationSec, 45 * 60);
      expect(a.exercises.first.name, 'Squat');
      expect(a.exercises.first.sets.length, 3);
      expect(a.exercises.first.sets.first.note, 'felt strong');
      expect(a.exercises[1].sets.length, 2, reason: 'la serie con 0 reps no se hizo');
      expect(r.sessions.last.date, DateTime(2024, 3, 7, 7));
      expect(r.sessions.last.exercises.single.sets.single.weightKg, 140);
    });

    test('pasa a kg las columnas en libras', () {
      const lb = 'Date (yyyy/mm/dd),Workout,Exercise,Set 1 (Reps),Set 1 (LB)\n2024/03/05,1,Squat,5,225\n';
      expect(parseImport(lb).sessions.single.exercises.single.sets.single.weightKg, closeTo(102.06, 0.05));
    });
  });

  group('JEFIT', () {
    const text = '### WORKOUT SESSIONS ###\n'
        '_id,starttime,total_time\n'
        '7,1709661600,3600\n'
        '\n'
        '### EXERCISE LOGS ###\n'
        '_id,belongsession,ename,mydate,logs\n'
        '1,7,Barbell Bench Press,2024-03-05,"60x10,65x8,65x6"\n'
        '2,7,Pull Up,2024-03-05,"0x12,0x10"\n'
        '3,,Barbell Squat,2024-03-07,"100x5"\n';

    test('lee las secciones y las series peso x reps', () {
      expect(detectFormat(text), ImportFormat.jefit);
      expect(needsUnitChoice(text), isTrue, reason: 'JEFIT no dice la unidad');
      final r = parseImport(text);
      expect(r.sessions.length, 2);
      final s = r.sessions.first;
      expect(s.date, DateTime.fromMillisecondsSinceEpoch(1709661600 * 1000));
      expect(s.durationSec, 3600);
      expect(s.exercises.first.sets.map((e) => e.reps), [10, 8, 6]);
      expect(s.exercises.first.sets.last.weightKg, 65);
      expect(s.exercises.last.sets.first.weightKg, 0);
      expect(r.sessions.last.date, DateTime(2024, 3, 7));
    });

    test('convierte a kg si el usuario dice que eran libras', () {
      final r = parseImport(text, isLb: true);
      expect(r.sessions.first.exercises.first.sets.first.weightKg, closeTo(27.22, 0.05));
    });

    test('recognises section headings with decorative hashes', () {
      const csv = '''
    ### WORKOUT SESSIONS #################################
    _id,starttime,total_time
    7,1709661600,3600

    ### EXERCISE LOGS ####################################
    _id,belongsession,ename,mydate,logs
    1,7,Barbell Bench Press,2024-03-05,"60x10,65x8"
    ''';

      expect(detectFormat(csv), ImportFormat.jefit);

      final result = parseImport(csv);

      expect(result.sessions, hasLength(1));
      expect(result.sessions.first.exercises, hasLength(1));
      expect(result.sessions.first.exercises.first.name, 'Barbell Bench Press');
      expect(result.sessions.first.exercises.first.sets, hasLength(2));
    });
  });

  group('openGym', () {
    test('reconoce el backup y lo parsea', () {
      expect(detectFormat(_openGym), ImportFormat.openGym);
      expect(needsUnitChoice(_openGym), isFalse);
      final r = parseImport(_openGym);
      final s = r.sessions.single;
      expect(s.date, DateTime.fromMillisecondsSinceEpoch(1705750000000));
      expect(s.durationSec, 3600);
      expect(s.exercises.length, 3, reason: 'el ejercicio que no está en el catálogo se cae');
      expect(s.exercises.first.id, 'EIeI8Vf');
      expect(s.exercises.first.sets.length, 2,
          reason: 'fuera el calentamiento y la serie sin marcar');
      expect(s.exercises.first.sets.first.weightKg, 60);
      expect(s.exercises[1].id, 'NbVPDMW');
      expect(s.exercises.last.name, 'Sled Drag');
      expect(r.weights.single.kg, 81.4);
    });

    test('convierte a kg cuando el backup está en libras', () {
      final r = parseImport(_openGymLb);
      expect(r.sessions.single.exercises.single.sets.single.weightKg, closeTo(99.79, 0.05));
      expect(r.sessions.single.durationSec, 0);
      expect(r.weights.single.kg, closeTo(81.65, 0.05));
    });

    test('saca el backup del zip con fotos y vídeos de openGym', () {
      final data = utf8.encode(_openGym);
      final zip = ZipEncoder().encode(Archive()
        ..addFile(ArchiveFile('README.txt', 4, utf8.encode('hola')))
        ..addFile(ArchiveFile('media/abc.jpg', 3, [1, 2, 3]))
        ..addFile(ArchiveFile('opengym-backup.json', data.length, data)));
      final raw = openGymBackupFromZip(zip)!;
      expect(detectFormat(raw), ImportFormat.openGym);
      expect(parseImport(raw).sessions.single.exercises.length, 3);
      expect(openGymBackupFromZip(ZipEncoder().encode(Archive()..addFile(ArchiveFile('weight.csv', 3, [1, 2, 3])))), isNull);
    });

    test('no confunde un backup de GymMane con uno de openGym', () {
      expect(detectFormat('{"sessions": [], "routines": []}'), ImportFormat.unknown);
    });
  });

  group('fusión en el estado', () {
    setUp(() => fit.sessions.clear());

    test('empareja con el catálogo, salta duplicados y marca los no encontrados', () {
      final known = fit.allExercises.first;
      final ps = ParsedSession(DateTime(2024, 1, 1), 0)
        ..exercises.add(ParsedExercise(known.name, null)..sets.add(ParsedSet(5, 100)));

      expect(fit.importParsedSessions([ps]), 1);
      expect(fit.sessions.last.exercises.first.id, known.id);
      expect(fit.importParsedSessions([ps]), 0);

      final ps2 = ParsedSession(DateTime(2024, 1, 2), 0)
        ..exercises.add(ParsedExercise('Zzz Nonexistent Lift 9000', null)..sets.add(ParsedSet(5, 50)));
      expect(fit.importParsedSessions([ps2]), 1);
      expect(fit.sessions.last.exercises.first.id, startsWith('imp:'));
    });

    test('importar un CSV real deja el historial listo para las estadísticas', () {
      final r = parseImport(_hevy);
      expect(fit.importParsedSessions(r.sessions), 1);
      final logged = fit.sessions.single;
      expect(logged.setCount, 3);
      expect(logged.volume, 60 * 10 + 60 * 8 + 100 * 5);
      expect(logged.durationSec, 45 * 60);
    });
  });

  group('Fitbod', () {
    const csv = 'Date,Exercise,Reps,Weight(kg),Duration(s),Distance(m),Incline,Resistance,isWarmup,Note,multiplier\n'
        '2024-03-04 18:02:11 +0000,Barbell Bench Press,10,40.0,0.0,0.0,0.0,0.0,true,,1.0\n'
        '2024-03-04 18:02:11 +0000,Barbell Bench Press,8,60.0,0.0,0.0,0.0,0.0,false,,1.0\n'
        '2024-03-04 18:02:11 +0000,Barbell Bench Press,8,62.5,0.0,0.0,0.0,0.0,false,,1.0\n'
        '2024-03-06 18:10:00 +0000,Barbell Squat,5,100.0,0.0,0.0,0.0,0.0,false,,1.0\n';

    test('detects the export and skips warm-ups', () {
      expect(detectFormat(csv), ImportFormat.fitbod);
      expect(needsUnitChoice(csv), isFalse);
      final r = parseImport(csv);
      expect(r.sessions.length, 2);
      final bench = r.sessions.first.exercises.single;
      expect(bench.sets.map((s) => s.weightKg), [60.0, 62.5]);
    });
  });

  group('deportes y cardio', () {
    const hevySports = '''
"title","start_time","end_time","description","exercise_title","superset_id","exercise_notes","set_index","set_type","weight_kg","reps","distance_km","duration_seconds","rpe"
"Club","10 Feb 2024, 18:00","10 Feb 2024, 19:30","","Badminton",,"",0,"normal",,,,3600,
"Domingo","11 Feb 2024, 10:00","11 Feb 2024, 11:40","","Soccer",,"",0,"normal",,,6.2,5400,
"Domingo","11 Feb 2024, 10:00","11 Feb 2024, 11:40","","Juggling Drill",,"",0,"normal",,,,600,
''';

    test('una fila solo con tiempo o distancia ya no se pierde', () {
      final r = parseImport(hevySports);
      expect(r.sessions, hasLength(2));
      final club = r.sessions.firstWhere((s) => s.exercises.first.name == 'Badminton');
      expect(club.exercises.single.sets.single.sec, 3600);
      expect(club.exercises.single.sets.single.reps, 0);
      final soccer = r.sessions.firstWhere((s) => s.exercises.first.name == 'Soccer');
      expect(soccer.exercises.first.sets.single.km, closeTo(6.2, 0.001));
    });

    test('los deportes caen en el catálogo y lo desconocido se guarda igual', () {
      fit.sessions.clear();
      expect(fit.importParsedSessions(parseImport(hevySports).sessions), 2);
      final ids = [for (final s in fit.sessions) for (final e in s.exercises) e.id];
      expect(ids, containsAll(['badminton', 'football']));
      expect(ids.where((id) => id.startsWith('imp:')), hasLength(1));
      final soccer = fit.sessions.expand((s) => s.exercises).firstWhere((e) => e.id == 'football');
      expect(soccer.sets.single.sec, 5400);
    });
  });
}