"
A MFTDescriptorSystemTest is a test class for testing the behavior of MFTDescriptorSystem
"
Class {
	#name : 'MFTDescriptorSystemTest',
	#superclass : 'TestCase',
	#instVars : [
		'session',
		'login'
	],
	#category : 'MyFitnessTracker-Glorp-Tests',
	#package : 'MyFitnessTracker-Glorp-Tests'
}

{ #category : 'running' }
MFTDescriptorSystemTest >> newInMemoryLogin [

	| dbFile |
	dbFile := '/tmp/mft-test.db' asFileReference.
	dbFile ifExists: [ dbFile delete ].

	^ Login new
		  database: UDBCSQLite3Platform new;
		  host: '';
		  databaseName: dbFile pathString;
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> persist: anObject [

	session transact: [ session register: anObject ].
	self assert: anObject id notNil.
	^ anObject id
]

{ #category : 'running' }
MFTDescriptorSystemTest >> readOneOf: aClass where: aBlock [

	^ session readOneOf: aClass where: aBlock
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleEquipment [

	^ MFTEquipment new
		  englishName: 'test barbell';
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleExercise [

	^ MFTExercise new
		  englishName: 'test bench press';
		  frenchName: 'developpe couche test';
		  equipment: self sampleEquipment;
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleMuscle [

	^ MFTMuscle new
		  latinName: 'musculus testus';
		  englishName: 'test muscle';
		  description: 'A muscle used only by persistence tests.';
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleMuscleGroup [

	^ MFTMuscleGroup new
		  englishName: 'test group';
		  frenchName: 'groupe test';
		  muscles: { self sampleMuscle };
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleRepScheme [

	^ MFTRepScheme from: 6 to: 10
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleRoutine [

	^ MFTRoutine new
		  title: 'Test Heavy Duty routine';
		  workouts: { self sampleWorkoutPrescription };
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleSetGroupLog [

	| setGroupLog |
	setGroupLog := MFTSetGroupLog forPrescription:
		               self sampleStraightSetGroupPrescription.
	setGroupLog
		notes: 'Reached positive failure with strict form.';
		sets: { self sampleSetLog }.
	^ setGroupLog
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleSetLog [

	^ (MFTSetLog forPrescription: self sampleSetPrescription)
		  reps: 8;
		  load: 100.5;
		  failureAchieved: true;
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleSetPrescription [

	^ MFTSetPrescription
		  exercise: self sampleExercise
		  repScheme: self sampleRepScheme
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleStraightSetGroupPrescription [

	^ MFTStraightSetGroupPrescription withSets:
		  { self sampleSetPrescription }
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleTrainee [

	^ MFTTrainee new
		  currentRoutine: self sampleRoutine;
		  logBook: self sampleWorkoutLogBook;
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleWorkoutLog [

	^ MFTWorkoutLog new
		  prescription: self sampleWorkoutPrescription;
		  start: (DateAndTime fromString: '2026-05-09T10:00:00+00:00');
		  finish: (DateAndTime fromString: '2026-05-09T10:42:00+00:00');
		  setGroups: { self sampleSetGroupLog };
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleWorkoutLogBook [

	| logBook |
	logBook := MFTWorkoutLogBook new.
	logBook logWorkout: self sampleWorkoutLog.
	^ logBook
]

{ #category : 'running' }
MFTDescriptorSystemTest >> sampleWorkoutPrescription [

	^ MFTWorkoutPrescription new
		  title: 'Test Heavy Duty workout';
		  setGroups: { self sampleStraightSetGroupPrescription };
		  yourself
]

{ #category : 'running' }
MFTDescriptorSystemTest >> setUp [

	super setUp.

	login := self newInMemoryLogin.
	session := MFTDescriptorSystem sessionForLogin: login.

	session login.
	session dropTables: session system allTables.
	session createTables: session system allTables
]

{ #category : 'running' }
MFTDescriptorSystemTest >> tearDown [

	session ifNotNil: [ session logout ].
	session := nil.
	login := nil.
	super tearDown
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testDescriptorSystemCreatesAllDeclaredTables [

	| createdTableNames expectedTableNames |
	createdTableNames := session system allTables collect: [ :each |
		                     each name ].
	expectedTableNames := session system allTableNames.

	expectedTableNames do: [ :each |
		self
			assert: (createdTableNames includes: each)
			description: 'Missing table in descriptor system: ' , each ]
]

{ #category : 'tests' }
MFTDescriptorSystemTest >> testEquipmentCanBePersistedAndReloaded [

	| equipment loaded |
	equipment := self sampleEquipment.
	self persist: equipment.

	loaded := session
		          readOneOf: MFTEquipment
		          where: [ :each | each id = equipment id ].

	self assert: loaded notNil.
	self assert: loaded englishName equals: 'test barbell'
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testExerciseReloadsItsEquipment [

	| exercise loaded |
	exercise := self sampleExercise.
	self persist: exercise.

	loaded := self
		          readOneOf: MFTExercise
		          where: [ :each | each englishName = 'test bench press' ].

	self assert: loaded frenchName equals: 'developpe couche test'.
	self assert: loaded equipment englishName equals: 'test barbell'
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testMuscleCanBePersistedAndReloaded [

	| muscle loaded |
	muscle := self sampleMuscle.
	self persist: muscle.
	session reset.

	loaded := self
		          readOneOf: MFTMuscle
		          where: [ :each | each latinName = 'musculus testus' ].

	self deny: loaded identicalTo: muscle.
	self assert: loaded englishName equals: 'test muscle'.
	self assert: loaded description equals: muscle description
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testMuscleGroupReloadsItsMuscles [

	| muscleGroup loaded |
	muscleGroup := self sampleMuscleGroup.
	self persist: muscleGroup.

	loaded := self
		          readOneOf: MFTMuscleGroup
		          where: [ :each | each englishName = 'test group' ].

	self assert: loaded frenchName equals: 'groupe test'.
	self assert: loaded muscles size equals: 1.
	self assert: loaded muscles first latinName equals: 'musculus testus'
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testRepSchemeCanBePersistedAndReloaded [

	| repScheme loaded |
	repScheme := self sampleRepScheme.
	self persist: repScheme.

	loaded := self
		          readOneOf: MFTRepScheme
		          where: [ :each | each minReps = 6 ].

	self assert: loaded minReps equals: 6.
	self assert: loaded maxReps equals: 10
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testRoutineReloadsWorkoutPrescriptionsInOrder [

	| routine loaded |
	routine := self sampleRoutine.
	self persist: routine.

	loaded := self
		          readOneOf: MFTRoutine
		          where: [ :each | each title = 'Test Heavy Duty routine' ].

	self assert: loaded workouts size equals: 1.
	self
		assert: loaded workouts first title
		equals: 'Test Heavy Duty workout'
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testSetLogReloadsPrescriptionAndExecutionData [

	| setLog loaded |
	setLog := self sampleSetLog.
	self persist: setLog.

	loaded := self
		          readOneOf: MFTSetLog
		          where: [ :each | each id = setLog id ].

	self assert: loaded reps equals: 8.
	self assert: loaded load equals: 100.5.
	self assert: loaded failureAchieved.
	self
		assert: loaded prescription exercise englishName
		equals: 'test bench press'
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testSetPrescriptionReloadsExerciseAndRepScheme [

	| prescription loaded |
	prescription := self sampleSetPrescription.
	self persist: prescription.

	loaded := self
		          readOneOf: MFTSetPrescription
		          where: [ :each | each id = prescription id ].

	self assert: loaded exercise englishName equals: 'test bench press'.
	self assert: loaded repScheme minReps equals: 6.
	self assert: loaded repScheme maxReps equals: 10
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testWorkoutLogReloadsPrescriptionSetGroupsAndLoggedSets [

	| workoutLog loaded loadedSet |
	workoutLog := self sampleWorkoutLog.
	self persist: workoutLog.

	loaded := self
		          readOneOf: MFTWorkoutLog
		          where: [ :each | each id = workoutLog id ].
	loadedSet := loaded sets first.

	self
		assert: loaded prescription title
		equals: 'Test Heavy Duty workout'.
	self assert: loaded setGroups size equals: 1.
	self assert: loadedSet reps equals: 8.
	self assert: loadedSet load equals: 100.5.
	self assert: loadedSet failureAchieved
]

{ #category : 'running' }
MFTDescriptorSystemTest >> testWorkoutPrescriptionReloadsSetGroupsAndSets [

	| workout loaded |
	workout := self sampleWorkoutPrescription.
	self persist: workout.

	loaded := self
		          readOneOf: MFTWorkoutPrescription
		          where: [ :each | each title = 'Test Heavy Duty workout' ].

	self assert: loaded setGroups size equals: 1.
	self assert: loaded sets size equals: 1.
	self
		assert: loaded sets first exercise englishName
		equals: 'test bench press'
]