blomios/GameTime
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(gestion): suppression en cascade exercice/programme/séance-modèle (ticket #37)

Browse Source 
Ajoute la suppression avec gestion des dépendances en cascade sur les
écrans bibliothèque d'exercices, programme et séance-modèle, avec les
use cases et le bootstrap applicatif associés. flutter analyze propre,
58/58 tests verts, build APK debug validé.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Blomios
2026-07-18 10:33:06 +02:00
parent 7434790da2
commit 1a0d01f038
10 changed files with 881 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/application/app_bootstrap.dart
View File

@ -58,6 +58,7 @@ final class AppBootstrap implements AppDependencies {
database: database,
exerciseUseCases: ExerciseUseCases(
repository: exerciseRepository,
programRepository: programRepository,
clock: clock,
ids: ids,
originDeviceId: originDeviceId,
@ -73,6 +74,7 @@ final class AppBootstrap implements AppDependencies {
programUseCases: ProgramUseCases(
programRepository: programRepository,
exerciseRepository: exerciseRepository,
templateRepository: templateRepository,
clock: clock,
ids: ids,
originDeviceId: originDeviceId,

156
lib/application/use_cases.dart
View File

@ -8,12 +8,14 @@ const Object _useCaseUnchanged = Object();
final class ExerciseUseCases {
const ExerciseUseCases({
required this.repository,
required this.programRepository,
required this.clock,
required this.ids,
required this.originDeviceId,
});
final ExerciseRepository repository;
final ProgramRepository programRepository;
final Clock clock;
final IdGenerator ids;
final String originDeviceId;
@ -181,6 +183,35 @@ final class ExerciseUseCases {
await repository.save(archived);
return archived;
}
Future<Exercise> delete(String id) async {
final exercise = await repository.findById(id);
if (exercise == null) {
throw const DomainException('Exercise not found.');
}
final now = clock.now();
final deleted = exercise.copyWith(
metadata: exercise.metadata.markDeleted(now),
);
final programs = await programRepository.listActive();
for (final program in programs) {
final keptExercises = program.exercises
.where((programExercise) => programExercise.sourceExerciseId != id)
.toList();
if (keptExercises.length == program.exercises.length) {
continue;
}
await programRepository.replaceExercises(
program.copyWith(
metadata: program.metadata.touch(now),
exercises: _repositionProgramExercises(keptExercises, now),
),
now,
);
}
await repository.save(deleted);
return deleted;
}
}
final class MediaUseCases {
@ -272,6 +303,7 @@ final class ProgramUseCases {
const ProgramUseCases({
required this.programRepository,
required this.exerciseRepository,
required this.templateRepository,
required this.clock,
required this.ids,
required this.originDeviceId,
@ -279,6 +311,7 @@ final class ProgramUseCases {
final ProgramRepository programRepository;
final ExerciseRepository exerciseRepository;
final WorkoutTemplateRepository templateRepository;
final Clock clock;
final IdGenerator ids;
final String originDeviceId;
@ -287,6 +320,14 @@ final class ProgramUseCases {
Future<List<Program>> listActive() => programRepository.listActive();
Future<bool> isUsedInWorkoutTemplates(String id) async {
final templates = await templateRepository.listActive();
return templates.any(
(template) =>
template.programs.any((program) => program.sourceProgramId == id),
);
}
Future<Program> create({
required String name,
required int defaultRestSeconds,
@ -399,6 +440,50 @@ final class ProgramUseCases {
await programRepository.saveExercise(programExercise);
return programExercise;
}
Future<Program> delete(String id) async {
final program = await programRepository.findById(id);
if (program == null) {
throw const DomainException('Program not found.');
}
final now = clock.now();
final deleted = program.copyWith(
metadata: program.metadata.markDeleted(now),
);
final templates = await templateRepository.listActive();
for (final template in templates) {
final keptPrograms = template.programs
.where((templateProgram) => templateProgram.sourceProgramId != id)
.toList();
if (keptPrograms.length == template.programs.length) {
continue;
}
final repositionedPrograms = _repositionWorkoutTemplatePrograms(
keptPrograms,
now,
);
final keptProgramIds = repositionedPrograms
.map((templateProgram) => templateProgram.metadata.id)
.toSet();
await templateRepository.replaceComposition(
WorkoutTemplate(
metadata: template.metadata.touch(now),
name: template.name,
lastStartedAt: template.lastStartedAt,
programs: repositionedPrograms,
overrides: template.overrides
.where(
(override) =>
keptProgramIds.contains(override.workoutTemplateProgramId),
)
.toList(),
),
now,
);
}
await programRepository.save(deleted);
return deleted;
}
}
final class ProgramExerciseConfig {
@ -608,6 +693,21 @@ final class WorkoutTemplateUseCases {
await templateRepository.saveOverride(override);
return override;
}
Future<WorkoutTemplate> delete(String id) async {
final template = await templateRepository.findById(id);
if (template == null) {
throw const DomainException('Workout template not found.');
}
final now = clock.now();
final deleted = WorkoutTemplate(
metadata: template.metadata.markDeleted(now),
name: template.name,
lastStartedAt: template.lastStartedAt,
);
await templateRepository.save(deleted);
return deleted;
}
}
final class WorkoutTemplateProgramConfig {
@ -1323,6 +1423,62 @@ final class SetResultPositionState {
final ActiveSetResult? result;
}
List<ProgramExercise> _repositionProgramExercises(
List<ProgramExercise> exercises,
DateTime now,
) {
return [
for (var index = 0; index < exercises.length; index++)
ProgramExercise(
metadata: exercises[index].metadata.touch(now),
programId: exercises[index].programId,
sourceExerciseId: exercises[index].sourceExerciseId,
position: index,
exerciseNameSnapshot: exercises[index].exerciseNameSnapshot,
exerciseDescriptionSnapshot:
exercises[index].exerciseDescriptionSnapshot,
exerciseImageMediaIdSnapshot:
exercises[index].exerciseImageMediaIdSnapshot,
exerciseVideoMediaIdSnapshot:
exercises[index].exerciseVideoMediaIdSnapshot,
exerciseArchivedSnapshot: exercises[index].exerciseArchivedSnapshot,
availableTimeSnapshot: exercises[index].availableTimeSnapshot,
availableRepsSnapshot: exercises[index].availableRepsSnapshot,
availableScoreSnapshot: exercises[index].availableScoreSnapshot,
scoreInputModeSnapshot: exercises[index].scoreInputModeSnapshot,
scoreLabelSnapshot: exercises[index].scoreLabelSnapshot,
scoreUnitSnapshot: exercises[index].scoreUnitSnapshot,
setsCount: exercises[index].setsCount,
timeEnabled: exercises[index].timeEnabled,
repsEnabled: exercises[index].repsEnabled,
scoreEnabled: exercises[index].scoreEnabled,
targetTimeSeconds: exercises[index].targetTimeSeconds,
targetReps: exercises[index].targetReps,
targetScore: exercises[index].targetScore,
targetScoreTimeMs: exercises[index].targetScoreTimeMs,
restSecondsOverride: exercises[index].restSecondsOverride,
),
];
}
List<WorkoutTemplateProgram> _repositionWorkoutTemplatePrograms(
List<WorkoutTemplateProgram> programs,
DateTime now,
) {
return [
for (var index = 0; index < programs.length; index++)
WorkoutTemplateProgram(
metadata: programs[index].metadata.touch(now),
workoutTemplateId: programs[index].workoutTemplateId,
sourceProgramId: programs[index].sourceProgramId,
position: index,
programNameSnapshot: programs[index].programNameSnapshot,
defaultRestSecondsSnapshot: programs[index].defaultRestSecondsSnapshot,
programSnapshotJson: programs[index].programSnapshotJson,
),
];
}
void _validateExerciseDefaultTargets({
required bool hasTimeMeasure,
required bool hasRepsMeasure,

68
lib/presentation/exercise_library_screen.dart
View File

@ -157,6 +157,7 @@ final class _ExerciseLibraryScreenState extends State<ExerciseLibraryScreen> {
return ExerciseListTile(
exercise: exercise,
onTap: () => _openForm(exercise: exercise),
onDelete: () => _confirmDelete(exercise),
);
}, childCount: filtered.length * 2 - 1),
),
@ -203,13 +204,64 @@ final class _ExerciseLibraryScreenState extends State<ExerciseLibraryScreen> {
_reload();
}
}
Future<void> _confirmDelete(Exercise exercise) async {
final used = await widget.exerciseUseCases.isUsedInPrograms(
exercise.metadata.id,
);
if (!mounted) return;
final confirmed = await showDialog<bool>(
context: context,
builder: (context) => AlertDialog(
title: Text('Supprimer ${exercise.name} ?'),
content: Text(
used
? 'Cet exercice est utilisé dans un ou plusieurs programmes. '
'Le supprimer le retirera de ces programmes. Continuer ?'
: 'Cette action est irréversible.',
),
actions: [
TextButton(
onPressed: () => Navigator.of(context).pop(false),
child: const Text('Annuler'),
),
FilledButton.icon(
onPressed: () => Navigator.of(context).pop(true),
icon: const Icon(Icons.delete_outline),
label: const Text('Supprimer'),
),
],
),
);
if (confirmed != true) return;
try {
await widget.exerciseUseCases.delete(exercise.metadata.id);
if (!mounted) return;
_reload();
} on Exception catch (error) {
_showSnackBar(error.toString());
}
}
void _showSnackBar(String message) {
if (!mounted) return;
ScaffoldMessenger.of(
context,
).showSnackBar(SnackBar(content: Text(message)));
}
}
final class ExerciseListTile extends StatelessWidget {
const ExerciseListTile({required this.exercise, this.onTap, super.key});
const ExerciseListTile({
required this.exercise,
this.onTap,
this.onDelete,
super.key,
});
final Exercise exercise;
final VoidCallback? onTap;
final VoidCallback? onDelete;
@override
Widget build(BuildContext context) {
@ -258,7 +310,19 @@ final class ExerciseListTile extends StatelessWidget {
),
],
),
trailing: const Icon(Icons.chevron_right),
trailing: onDelete == null
? const Icon(Icons.chevron_right)
: Row(
mainAxisSize: MainAxisSize.min,
children: [
IconButton(
tooltip: 'Supprimer l’exercice',
icon: const Icon(Icons.delete_outline),
onPressed: onDelete,
),
const Icon(Icons.chevron_right),
],
),
);
}
}

57
lib/presentation/program_screen.dart
View File

@ -69,7 +69,17 @@ final class _ProgramListScreenState extends State<ProgramListScreen> {
return ListTile(
title: Text(program.name),
subtitle: Text(_programSummary(program)),
trailing: const Icon(Icons.chevron_right),
trailing: Wrap(
spacing: 8,
children: [
IconButton(
tooltip: 'Supprimer le programme',
icon: const Icon(Icons.delete_outline),
onPressed: () => _confirmDelete(program),
),
const Icon(Icons.chevron_right),
],
),
onTap: () => _openForm(program: program),
);
},
@ -100,6 +110,51 @@ final class _ProgramListScreenState extends State<ProgramListScreen> {
_reload();
}
}
Future<void> _confirmDelete(Program program) async {
final used = await widget.programUseCases.isUsedInWorkoutTemplates(
program.metadata.id,
);
if (!mounted) return;
final confirmed = await showDialog<bool>(
context: context,
builder: (context) => AlertDialog(
title: Text('Supprimer ${program.name} ?'),
content: Text(
used
? 'Ce programme est utilisé dans une ou plusieurs séances. '
'Le supprimer le retirera de ces séances. Continuer ?'
: 'Cette action est irréversible.',
),
actions: [
TextButton(
onPressed: () => Navigator.of(context).pop(false),
child: const Text('Annuler'),
),
FilledButton.icon(
onPressed: () => Navigator.of(context).pop(true),
icon: const Icon(Icons.delete_outline),
label: const Text('Supprimer'),
),
],
),
);
if (confirmed != true) return;
try {
await widget.programUseCases.delete(program.metadata.id);
if (!mounted) return;
_reload();
} on Exception catch (error) {
_showSnackBar(error.toString());
}
}
void _showSnackBar(String message) {
if (!mounted) return;
ScaffoldMessenger.of(
context,
).showSnackBar(SnackBar(content: Text(message)));
}
}
final class ProgramFormScreen extends StatefulWidget {

41
lib/presentation/workout_template_screen.dart
View File

@ -72,6 +72,11 @@ final class _WorkoutTemplateListScreenState
trailing: Wrap(
spacing: 8,
children: [
IconButton(
tooltip: 'Supprimer la séance',
icon: const Icon(Icons.delete_outline),
onPressed: () => _confirmDelete(template),
),
TextButton(
onPressed: () => _start(template),
child: const Text('Lancer'),
@ -140,6 +145,42 @@ final class _WorkoutTemplateListScreenState
),
);
}
Future<void> _confirmDelete(WorkoutTemplate template) async {
final confirmed = await showDialog<bool>(
context: context,
builder: (context) => AlertDialog(
title: Text('Supprimer ${template.name} ?'),
content: const Text('Cette action est irréversible.'),
actions: [
TextButton(
onPressed: () => Navigator.of(context).pop(false),
child: const Text('Annuler'),
),
FilledButton.icon(
onPressed: () => Navigator.of(context).pop(true),
icon: const Icon(Icons.delete_outline),
label: const Text('Supprimer'),
),
],
),
);
if (confirmed != true) return;
try {
await widget.workoutTemplateUseCases.delete(template.metadata.id);
if (!mounted) return;
_reload();
} on Exception catch (error) {
_showSnackBar(error.toString());
}
}
void _showSnackBar(String message) {
if (!mounted) return;
ScaffoldMessenger.of(
context,
).showSnackBar(SnackBar(content: Text(message)));
}
}
final class WorkoutTemplateFormScreen extends StatefulWidget {

283
test/application/use_cases_test.dart
View File

@ -156,6 +156,165 @@ void main() {
);
});
test('delete exercise removes it from referencing programs', () async {
final exerciseRepository = _FakeExerciseRepository()
..exercise = Exercise(
metadata: _metadata('exercise-1'),
name: 'Squat',
hasTimeMeasure: false,
hasRepsMeasure: true,
hasScoreMeasure: false,
defaultTargetReps: 10,
);
final programRepository = _FakeProgramRepository()
..programs.add(
Program(
metadata: _metadata('program-1'),
name: 'Jambes',
defaultRestSeconds: 60,
exercises: [
_programExercise(
id: 'program-exercise-1',
programId: 'program-1',
sourceExerciseId: 'exercise-1',
position: 0,
),
_programExercise(
id: 'program-exercise-2',
programId: 'program-1',
sourceExerciseId: 'exercise-2',
position: 1,
),
],
),
);
final useCase = _exerciseUseCase(
exerciseRepository,
programRepository: programRepository,
);
final deleted = await useCase.delete('exercise-1');
expect(deleted.metadata.deletedAt, isNotNull);
expect(exerciseRepository.listActive(), completion(isEmpty));
expect(programRepository.programs.single.exercises, hasLength(1));
expect(
programRepository.programs.single.exercises.single.sourceExerciseId,
'exercise-2',
);
expect(programRepository.programs.single.exercises.single.position, 0);
});
test(
'delete program removes it from referencing workout templates',
() async {
final programRepository = _FakeProgramRepository()
..programs.add(
Program(
metadata: _metadata('program-1'),
name: 'Jambes',
defaultRestSeconds: 60,
),
);
final templateRepository = _FakeWorkoutTemplateRepository()
..templates.add(
WorkoutTemplate(
metadata: _metadata('template-1'),
name: 'Séance',
programs: [
_templateProgram(
id: 'template-program-1',
workoutTemplateId: 'template-1',
sourceProgramId: 'program-1',
position: 0,
),
_templateProgram(
id: 'template-program-2',
workoutTemplateId: 'template-1',
sourceProgramId: 'program-2',
position: 1,
),
],
overrides: [
WorkoutTemplateExerciseOverride(
metadata: _metadata('override-1'),
workoutTemplateProgramId: 'template-program-1',
snapshotProgramExerciseId: 'exercise-snapshot-1',
targetRepsOverride: 8,
),
],
),
);
final useCase = ProgramUseCases(
programRepository: programRepository,
exerciseRepository: _FakeExerciseRepository(),
templateRepository: templateRepository,
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
);
final deleted = await useCase.delete('program-1');
expect(deleted.metadata.deletedAt, isNotNull);
expect(programRepository.listActive(), completion(isEmpty));
final template = templateRepository.templates.single;
expect(template.programs, hasLength(1));
expect(template.programs.single.sourceProgramId, 'program-2');
expect(template.programs.single.position, 0);
expect(template.overrides, isEmpty);
},
);
test('delete workout template hides it from active list', () async {
final templateRepository = _FakeWorkoutTemplateRepository()
..templates.add(
WorkoutTemplate(metadata: _metadata('template-1'), name: 'Séance'),
);
final useCase = WorkoutTemplateUseCases(
templateRepository: templateRepository,
programRepository: _FakeProgramRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
);
final deleted = await useCase.delete('template-1');
expect(deleted.metadata.deletedAt, isNotNull);
expect(templateRepository.listActive(), completion(isEmpty));
});
test('history stays unchanged after deleting its source template', () async {
final templateRepository = _FakeWorkoutTemplateRepository()
..templates.add(
WorkoutTemplate(metadata: _metadata('template-1'), name: 'Séance'),
);
final history = WorkoutHistory(
metadata: _metadata('history-1'),
sourceWorkoutTemplateId: 'template-1',
nameSnapshot: 'Séance historique',
startedAt: DateTime.utc(2026, 7, 17, 10),
endedAt: DateTime.utc(2026, 7, 17, 11),
totalActiveMs: 3600000,
completed: true,
historySnapshotJson: '{"name":"Séance historique"}',
);
final useCase = WorkoutTemplateUseCases(
templateRepository: templateRepository,
programRepository: _FakeProgramRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
);
await useCase.delete('template-1');
expect(history.sourceWorkoutTemplateId, 'template-1');
expect(history.nameSnapshot, 'Séance historique');
expect(history.historySnapshotJson, '{"name":"Séance historique"}');
});
test('Workout template use case rejects active measure overrides', () async {
final useCase = WorkoutTemplateUseCases(
templateRepository: _FakeWorkoutTemplateRepository(),
@ -612,15 +771,59 @@ final class _FakeIds implements IdGenerator {
}
}
ExerciseUseCases _exerciseUseCase(_FakeExerciseRepository repository) {
ExerciseUseCases _exerciseUseCase(
_FakeExerciseRepository repository, {
_FakeProgramRepository? programRepository,
}) {
return ExerciseUseCases(
repository: repository,
programRepository: programRepository ?? _FakeProgramRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
);
}
ProgramExercise _programExercise({
required String id,
required String programId,
required String sourceExerciseId,
required int position,
}) {
return ProgramExercise(
metadata: _metadata(id),
programId: programId,
sourceExerciseId: sourceExerciseId,
position: position,
exerciseNameSnapshot: 'Exercise $id',
availableTimeSnapshot: false,
availableRepsSnapshot: true,
availableScoreSnapshot: false,
setsCount: 3,
timeEnabled: false,
repsEnabled: true,
scoreEnabled: false,
targetReps: 10,
);
}
WorkoutTemplateProgram _templateProgram({
required String id,
required String workoutTemplateId,
required String sourceProgramId,
required int position,
}) {
return WorkoutTemplateProgram(
metadata: _metadata(id),
workoutTemplateId: workoutTemplateId,
sourceProgramId: sourceProgramId,
position: position,
programNameSnapshot: 'Program $id',
defaultRestSecondsSnapshot: 60,
programSnapshotJson: '{"exercises":[]}',
);
}
final class _FakeExerciseRepository implements ExerciseRepository {
Exercise? exercise;
final saved = <Exercise>[];
@ -635,7 +838,9 @@ final class _FakeExerciseRepository implements ExerciseRepository {
@override
Future<List<Exercise>> listActive() async =>
exercise == null ? const [] : [exercise!];
exercise == null || exercise!.metadata.deletedAt != null
? const []
: [exercise!];
@override
Future<void> save(Exercise exercise) async {
@ -646,20 +851,38 @@ final class _FakeExerciseRepository implements ExerciseRepository {
final class _FakeWorkoutTemplateRepository
implements WorkoutTemplateRepository {
@override
Future<WorkoutTemplate?> findById(String id) async => null;
final templates = <WorkoutTemplate>[];
@override
Future<List<WorkoutTemplate>> listActive() async => const [];
Future<WorkoutTemplate?> findById(String id) async {
for (final template in templates) {
if (template.metadata.id == id && template.metadata.deletedAt == null) {
return template;
}
}
return null;
}
@override
Future<List<WorkoutTemplate>> listActive() async {
return templates
.where((template) => template.metadata.deletedAt == null)
.toList();
}
@override
Future<void> replaceComposition(
WorkoutTemplate template,
DateTime deletedAt,
) async {}
) async {
await save(template);
}
@override
Future<void> save(WorkoutTemplate template) async {}
Future<void> save(WorkoutTemplate template) async {
templates.removeWhere((saved) => saved.metadata.id == template.metadata.id);
templates.add(template);
}
@override
Future<void> saveOverride(WorkoutTemplateExerciseOverride override) async {}
@ -669,20 +892,54 @@ final class _FakeWorkoutTemplateRepository
}
final class _FakeProgramRepository implements ProgramRepository {
@override
Future<Program?> findById(String id) async => null;
final programs = <Program>[];
@override
Future<List<Program>> listActive() async => const [];
Future<Program?> findById(String id) async {
for (final program in programs) {
if (program.metadata.id == id && program.metadata.deletedAt == null) {
return program;
}
}
return null;
}
@override
Future<void> replaceExercises(Program program, DateTime deletedAt) async {}
Future<List<Program>> listActive() async {
return programs
.where((program) => program.metadata.deletedAt == null)
.toList();
}
@override
Future<void> save(Program program) async {}
Future<void> replaceExercises(Program program, DateTime deletedAt) async {
await save(program);
}
@override
Future<void> saveExercise(ProgramExercise exercise) async {}
Future<void> save(Program program) async {
programs.removeWhere((saved) => saved.metadata.id == program.metadata.id);
programs.add(program);
}
@override
Future<void> saveExercise(ProgramExercise exercise) async {
final index = programs.indexWhere(
(program) => program.metadata.id == exercise.programId,
);
if (index == -1) {
return;
}
final program = programs[index];
programs[index] = program.copyWith(
exercises: [
...program.exercises.where(
(saved) => saved.metadata.id != exercise.metadata.id,
),
exercise,
],
);
}
}
ActiveWorkoutSessionUseCases _activeUseCase(

81
test/presentation/exercise_library_screen_test.dart
View File

@ -148,17 +148,87 @@ void main() {
expect(find.text('Image importée.'), findsOneWidget);
},
);
testWidgets(
'supprimer un exercice demande confirmation puis le retire de la liste',
(tester) async {
final exerciseRepository = _FakeExerciseRepository()
..referenced = true
..exercises.add(
Exercise(
metadata: _metadata('exercise-1'),
name: 'Squat',
hasTimeMeasure: true,
hasRepsMeasure: false,
hasScoreMeasure: false,
defaultTargetTimeSeconds: 45,
),
);
await tester.pumpWidget(
MaterialApp(
home: ExerciseLibraryScreen(
exerciseUseCases: _exerciseUseCases(exerciseRepository),
mediaUseCases: _mediaUseCases(exerciseRepository),
),
),
);
await tester.pump();
await tester.pump();
await tester.tap(find.byTooltip('Supprimer l’exercice'));
await tester.pumpAndSettle();
expect(find.text('Supprimer Squat ?'), findsOneWidget);
expect(
find.textContaining('Le supprimer le retirera de ces programmes.'),
findsOneWidget,
);
await tester.tap(find.text('Annuler'));
await tester.pumpAndSettle();
expect(find.text('Squat'), findsOneWidget);
expect(exerciseRepository.saved, isEmpty);
await tester.tap(find.byTooltip('Supprimer l’exercice'));
await tester.pumpAndSettle();
await tester.tap(find.widgetWithText(FilledButton, 'Supprimer'));
await tester.pumpAndSettle();
expect(find.text('Squat'), findsNothing);
expect(exerciseRepository.saved.single.metadata.deletedAt, isNotNull);
},
);
}
ExerciseUseCases _exerciseUseCases(_FakeExerciseRepository repository) {
return ExerciseUseCases(
repository: repository,
programRepository: _FakeProgramRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
);
}
final class _FakeProgramRepository implements ProgramRepository {
@override
Future<Program?> findById(String id) async => null;
@override
Future<List<Program>> listActive() async => const [];
@override
Future<void> replaceExercises(Program program, DateTime deletedAt) async {}
@override
Future<void> save(Program program) async {}
@override
Future<void> saveExercise(ProgramExercise exercise) async {}
}
MediaUseCases _mediaUseCases(
_FakeExerciseRepository exerciseRepository, {
_FakeMediaStorage? storage,
@ -174,16 +244,15 @@ MediaUseCases _mediaUseCases(
}
final class _FakeMediaPicker implements MediaSourcePicker {
const _FakeMediaPicker({this.imagePath, this.videoPath});
const _FakeMediaPicker({this.imagePath});
final String? imagePath;
final String? videoPath;
@override
Future<String?> pickPath(MediaKind kind) async {
return switch (kind) {
MediaKind.image => imagePath,
MediaKind.video => videoPath,
MediaKind.video => null,
};
}
}
@ -235,7 +304,11 @@ final class _FakeExerciseRepository implements ExerciseRepository {
Future<bool> isReferencedByProgram(String id) async => referenced;
@override
Future<List<Exercise>> listActive() async => exercises;
Future<List<Exercise>> listActive() async {
return exercises
.where((exercise) => exercise.metadata.deletedAt == null)
.toList();
}
@override
Future<void> save(Exercise exercise) async {

2
test/presentation/home_screen_test.dart
View File

@ -131,6 +131,7 @@ final class _FakeBootstrap implements AppDependencies {
),
exerciseUseCases = ExerciseUseCases(
repository: _FakeExerciseRepository(),
programRepository: _FakeProgramRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
@ -146,6 +147,7 @@ final class _FakeBootstrap implements AppDependencies {
programUseCases = ProgramUseCases(
programRepository: _FakeProgramRepository(),
exerciseRepository: _FakeExerciseRepository(),
templateRepository: _FakeWorkoutTemplateRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',

123
test/presentation/program_screen_test.dart
View File

@ -233,11 +233,83 @@ void main() {
findsOneWidget,
);
});
testWidgets(
'supprimer un programme demande confirmation puis le retire de la liste',
(tester) async {
final programRepository = _FakeProgramRepository()
..programs.add(
Program(
metadata: _metadata('program-1'),
name: 'Jambes',
defaultRestSeconds: 60,
),
);
final templateRepository = _FakeWorkoutTemplateRepository()
..templates.add(
WorkoutTemplate(
metadata: _metadata('template-1'),
name: 'Séance jambes',
programs: [
WorkoutTemplateProgram(
metadata: _metadata('template-program-1'),
workoutTemplateId: 'template-1',
sourceProgramId: 'program-1',
position: 0,
programNameSnapshot: 'Jambes',
defaultRestSecondsSnapshot: 60,
programSnapshotJson: '{"exercises":[]}',
),
],
),
);
final exerciseRepository = _FakeExerciseRepository();
await tester.pumpWidget(
MaterialApp(
home: ProgramListScreen(
programUseCases: _programUseCases(
programRepository,
exerciseRepository,
templateRepository: templateRepository,
),
exerciseUseCases: _exerciseUseCases(exerciseRepository),
),
),
);
await tester.pump();
await tester.pump();
await tester.tap(find.byTooltip('Supprimer le programme'));
await tester.pumpAndSettle();
expect(find.text('Supprimer Jambes ?'), findsOneWidget);
expect(
find.textContaining('Le supprimer le retirera de ces séances.'),
findsOneWidget,
);
await tester.tap(find.text('Annuler'));
await tester.pumpAndSettle();
expect(find.text('Jambes'), findsOneWidget);
expect(programRepository.saved, isEmpty);
await tester.tap(find.byTooltip('Supprimer le programme'));
await tester.pumpAndSettle();
await tester.tap(find.widgetWithText(FilledButton, 'Supprimer'));
await tester.pumpAndSettle();
expect(find.text('Jambes'), findsNothing);
expect(programRepository.saved.single.metadata.deletedAt, isNotNull);
},
);
}
ExerciseUseCases _exerciseUseCases(_FakeExerciseRepository repository) {
return ExerciseUseCases(
repository: repository,
programRepository: _FakeProgramRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
@ -246,17 +318,55 @@ ExerciseUseCases _exerciseUseCases(_FakeExerciseRepository repository) {
ProgramUseCases _programUseCases(
_FakeProgramRepository programRepository,
_FakeExerciseRepository exerciseRepository,
) {
_FakeExerciseRepository exerciseRepository, {
_FakeWorkoutTemplateRepository? templateRepository,
}) {
return ProgramUseCases(
programRepository: programRepository,
exerciseRepository: exerciseRepository,
templateRepository: templateRepository ?? _FakeWorkoutTemplateRepository(),
clock: _FakeClock(DateTime.utc(2026, 7, 17, 12)),
ids: _FakeIds(),
originDeviceId: 'device-1',
);
}
final class _FakeWorkoutTemplateRepository
implements WorkoutTemplateRepository {
final templates = <WorkoutTemplate>[];
@override
Future<WorkoutTemplate?> findById(String id) async => null;
@override
Future<List<WorkoutTemplate>> listActive() async {
return templates
.where((template) => template.metadata.deletedAt == null)
.toList();
}
@override
Future<void> replaceComposition(
WorkoutTemplate template,
DateTime deletedAt,
) async {
templates.removeWhere((item) => item.metadata.id == template.metadata.id);
templates.add(template);
}
@override
Future<void> save(WorkoutTemplate template) async {
templates.removeWhere((item) => item.metadata.id == template.metadata.id);
templates.add(template);
}
@override
Future<void> saveOverride(WorkoutTemplateExerciseOverride override) async {}
@override
Future<void> saveProgram(WorkoutTemplateProgram program) async {}
}
EntityMetadata _metadata(String id) {
return EntityMetadata(
id: id,
@ -313,6 +423,7 @@ final class _FakeExerciseRepository implements ExerciseRepository {
final class _FakeProgramRepository implements ProgramRepository {
final programs = <Program>[];
final saved = <Program>[];
@override
Future<Program?> findById(String id) async {
@ -325,7 +436,11 @@ final class _FakeProgramRepository implements ProgramRepository {
}
@override
Future<List<Program>> listActive() async => programs;
Future<List<Program>> listActive() async {
return programs
.where((program) => program.metadata.deletedAt == null)
.toList();
}
@override
Future<void> replaceExercises(Program program, DateTime deletedAt) async {
@ -335,6 +450,8 @@ final class _FakeProgramRepository implements ProgramRepository {
@override
Future<void> save(Program program) async {
saved.add(program);
programs.removeWhere((item) => item.metadata.id == program.metadata.id);
programs.add(program);
}

94
test/presentation/workout_template_screen_test.dart
View File

@ -69,6 +69,7 @@ void main() {
programUseCases: ProgramUseCases(
programRepository: programRepository,
exerciseRepository: _FakeExerciseRepository(),
templateRepository: templateRepository,
clock: clock,
ids: _FakeIds(),
originDeviceId: 'device-1',
@ -108,6 +109,81 @@ void main() {
expect(activeRepository.saveCount, 0);
},
);
testWidgets(
'supprimer une séance demande confirmation puis la retire de la liste',
(tester) async {
final clock = _FakeClock(DateTime.utc(2026, 7, 17, 12));
final templateRepository = _FakeWorkoutTemplateRepository([
_workoutTemplate(),
]);
final activeRepository = _FakeActiveSessionRepository();
final programRepository = _FakeProgramRepository();
final historyRepository = _FakeWorkoutHistoryRepository();
await tester.pumpWidget(
MaterialApp(
home: WorkoutTemplateListScreen(
workoutTemplateUseCases: WorkoutTemplateUseCases(
templateRepository: templateRepository,
programRepository: programRepository,
clock: clock,
ids: _FakeIds(),
originDeviceId: 'device-1',
),
programUseCases: ProgramUseCases(
programRepository: programRepository,
exerciseRepository: _FakeExerciseRepository(),
templateRepository: templateRepository,
clock: clock,
ids: _FakeIds(),
originDeviceId: 'device-1',
),
activeUseCases: ActiveWorkoutSessionUseCases(
sessionRepository: activeRepository,
templateRepository: templateRepository,
clock: clock,
ids: _FakeIds(),
originDeviceId: 'device-1',
),
closeUseCase: CloseWorkoutSessionUseCase(
sessionRepository: activeRepository,
historyRepository: historyRepository,
clock: clock,
ids: _FakeIds(),
originDeviceId: 'device-1',
),
historyUseCases: WorkoutHistoryUseCases(
repository: historyRepository,
clock: clock,
),
),
),
);
await tester.pump();
await tester.pump();
await tester.tap(find.byTooltip('Supprimer la séance'));
await tester.pumpAndSettle();
expect(find.text('Supprimer Séance jambes ?'), findsOneWidget);
expect(find.text('Cette action est irréversible.'), findsOneWidget);
await tester.tap(find.text('Annuler'));
await tester.pumpAndSettle();
expect(find.text('Séance jambes'), findsOneWidget);
expect(templateRepository.saved, isEmpty);
await tester.tap(find.byTooltip('Supprimer la séance'));
await tester.pumpAndSettle();
await tester.tap(find.widgetWithText(FilledButton, 'Supprimer'));
await tester.pumpAndSettle();
expect(find.text('Séance jambes'), findsNothing);
expect(templateRepository.saved.single.metadata.deletedAt, isNotNull);
},
);
}
WorkoutTemplate _workoutTemplate() {
@ -201,6 +277,7 @@ final class _FakeWorkoutTemplateRepository
_FakeWorkoutTemplateRepository(this.templates);
final List<WorkoutTemplate> templates;
final saved = <WorkoutTemplate>[];
@override
Future<WorkoutTemplate?> findById(String id) async {
@ -211,16 +288,27 @@ final class _FakeWorkoutTemplateRepository
}
@override
Future<List<WorkoutTemplate>> listActive() async => templates;
Future<List<WorkoutTemplate>> listActive() async {
return templates
.where((template) => template.metadata.deletedAt == null)
.toList();
}
@override
Future<void> replaceComposition(
WorkoutTemplate template,
DateTime deletedAt,
) async {}
) async {
templates.removeWhere((item) => item.metadata.id == template.metadata.id);
templates.add(template);
}
@override
Future<void> save(WorkoutTemplate template) async {}
Future<void> save(WorkoutTemplate template) async {
saved.add(template);
templates.removeWhere((item) => item.metadata.id == template.metadata.id);
templates.add(template);
}
@override
Future<void> saveOverride(WorkoutTemplateExerciseOverride override) async {}