Test Plan

Emmanuel BRUNO
emmanuel.bruno@univ-tln.fr

Université de Toulon

LIS UMR CNRS 7020

2025-03-17

Test Plan for Fitness Tracking Application

This document outlines the comprehensive testing approach for the fitness tracking application. It defines the testing strategy, scope, methodologies, and resources required to ensure the application meets quality standards before release.

1. Test Strategy Overview

1.1 Testing Objectives

  • Verify that all implemented features work according to requirements
  • Ensure the application is stable and handles errors gracefully
  • Validate that the user interface is intuitive and accessible
  • Confirm that the application performs efficiently across supported devices
  • Verify data integrity and persistence functionality

1.2 Testing Scope

In Scope

  • All MVP features (Must Have priority)
  • Core database functionality
  • User interface and experience
  • Device compatibility (supported Android versions)
  • Offline functionality
  • Performance under normal conditions

Out of Scope

  • Integration with third-party services unless specifically required for MVP
  • Stress testing beyond normal usage patterns
  • Compatibility with unsupported devices or OS versions
  • Security penetration testing (will be addressed separately)

1.3 Testing Types

  • Unit Testing: Component-level testing of individual functions and classes
  • Integration Testing: Testing of interactions between components
  • UI Testing: Automated and manual validation of user interfaces
  • Functional Testing: Validation of feature requirements
  • Regression Testing: Ensuring new changes don’t break existing functionality
  • Usability Testing: Testing with representative users
  • Performance Testing: Measuring responsiveness and resource usage
  • Accessibility Testing: Validating compliance with accessibility standards

1.4 Testing Environments

  • Development: Local emulators and devices during feature development
  • Test: Dedicated test environments with representative data
  • Staging: Pre-production environment for final validation

1.5 Testing Tools

  • Unit Tests: JUnit, Mockito, Kotlin Test
  • UI Automation: Espresso, UI Automator
  • Database Testing: Room testing framework
  • API Testing: Retrofit test utilities, MockWebServer
  • Performance Testing: Android Profiler, Firebase Performance Monitoring
  • Accessibility Testing: Android Accessibility Scanner

2. Test Plans by Priority

2.1 MVP Features (Must Have)

2.1.1 E01-F01: Browsing Workout Programs

Test Scenarios:

  1. List Loading
    • Verify workout program list loads correctly
    • Validate sorting and filtering functionality
    • Test search functionality with various inputs
  2. Offline Access
    • Verify previously loaded programs are accessible offline
    • Validate appropriate messaging for new content when offline
  3. Performance
    • Measure loading time with 50+ workout programs
    • Verify scrolling performance is smooth

Automated Tests:

// Unit tests for workout program repository
@Test
fun loadWorkoutPrograms_returnsCorrectData()
@Test
fun filterWorkoutPrograms_byDifficulty_returnsMatchingPrograms()
@Test
fun cacheWorkoutPrograms_makesThemAvailableOffline()

// UI tests for workout program list
@Test
fun workoutListScreen_displaysAllPrograms()
@Test
fun searchBar_filtersPrograms()
@Test
fun difficultyFilter_showsOnlyMatchingPrograms()

Manual Tests:

  • Verify all UI elements are displayed correctly
  • Validate the UX flow matches wireframes
  • Test filter combinations to ensure correct results
  • Verify offline indicator appears appropriately

2.1.2 E01-F02: Viewing Workout Program Details

Test Scenarios:

  1. Detail Loading
    • Verify all program details display correctly
    • Validate exercise lists and parameters are shown
    • Test navigation between program days
  2. Exercise Demonstrations
    • Verify exercise demonstration displays correctly
    • Validate form instructions are visible

Automated Tests:

// Unit tests
@Test
fun loadProgramDetails_returnsCompleteInformation()
@Test
fun calculateProgramMetrics_returnsAccurateValues()

// UI tests
@Test
fun programDetailScreen_showsAllRequiredInformation()
@Test
fun daySelector_loadsCorrectExercises()

Manual Tests:

  • Verify all UI elements match wireframe designs
  • Test navigation between days in multi-day programs
  • Validate exercise details are complete and accurate

2.1.3 E01-F03: Starting and Following a Workout Session

Test Scenarios:

  1. Session Initialization
    • Verify workout starts correctly from program details
    • Validate initial exercise and instructions display
  2. Exercise Navigation
    • Test progression through exercises
    • Verify completion tracking works correctly
  3. Set Recording
    • Validate weight/rep inputs work correctly
    • Test validation of input values

Automated Tests:

// Unit tests
@Test
fun initializeWorkoutSession_createsCorrectSessionState()
@Test
fun recordSet_updatesSessionData()
@Test
fun completeExercise_progressesToNext()

// UI tests
@Test
fun startWorkout_displaysFirstExerciseCorrectly()
@Test
fun completeAllSets_enablesNextExerciseButton()

Manual Tests:

  • Follow complete workout flow from start to finish
  • Test different input methods for recording sets
  • Verify proper feedback during workout progression

2.1.4 E01-F04: Managing Workout Session State

Test Scenarios:

  1. Pause and Resume
    • Verify session pauses correctly
    • Test resuming from paused state
  2. Interruption Recovery
    • Test app closure during workout
    • Validate state recovery after restart
  3. Session Completion
    • Verify proper completion of session
    • Test summary display after completion

Automated Tests:

// Unit tests
@Test
fun pauseWorkout_savesCurrentState()
@Test
fun resumeWorkout_restoresCorrectState()
@Test
fun recoverFromCrash_restoresWorkoutSession()

// Integration tests
@Test
fun workoutStatePersistence_survivesAppRestart()

Manual Tests:

  • Force-close app during workout and verify recovery
  • Test device restart during workout
  • Verify session timers behave correctly during pause/resume

2.1.5 E02-F01: Recording Exercise Performance

Test Scenarios:

  1. Data Entry
    • Test weight and rep input mechanisms
    • Validate difficulty rating selection
  2. Performance History
    • Verify previous performance is displayed
    • Test personal record detection
  3. Input Validation
    • Test boundary values for inputs
    • Verify invalid inputs are handled properly

Automated Tests:

// Unit tests
@Test
fun recordExerciseSet_storesDataCorrectly()
@Test
fun detectPersonalRecord_identifiesNewRecords()
@Test
fun validateSetInputs_rejectsInvalidValues()

// UI tests
@Test
fun weightInput_acceptsValidFormats()
@Test
fun repInput_enforcesValidRange()

Manual Tests:

  • Test different input combinations (weights, reps, duration)
  • Verify personal record notifications appear correctly
  • Test edge cases like very high weight values or rep counts

2.1.6 E02-F02: Viewing Workout History and Statistics

Test Scenarios:

  1. History Display
    • Verify workout list displays correctly
    • Test calendar view functionality
  2. Detailed History
    • Validate individual workout details show correctly
    • Test exercise-by-exercise history
  3. Statistics Calculation
    • Verify volume and other metrics are calculated correctly
    • Test time period filters on statistics

Automated Tests:

// Unit tests
@Test
fun loadWorkoutHistory_returnsChronologicalList()
@Test
fun calculateWorkoutStatistics_computesCorrectValues()
@Test
fun filterWorkoutsByDate_returnsMatchingWorkouts()

// UI tests
@Test
fun historyScreen_displaysWorkoutsInCorrectOrder()
@Test
fun calendarView_highlightsWorkoutDays()

Manual Tests:

  • Verify history display with various workout types
  • Test navigation between calendar and list views
  • Validate statistic calculations manually with sample data

2.1.7 E05-F01: Advanced Exercise Search and Filtering

Test Scenarios:

  1. Search Functionality
    • Test search with various terms
    • Verify partial matching works correctly
  2. Filter Application
    • Test single and multiple filters
    • Verify filter combinations work correctly
  3. Result Display
    • Validate search results format
    • Test sorting options on results

Automated Tests:

// Unit tests
@Test
fun searchExercises_returnsMatchingResults()
@Test
fun applyFilters_restrictsResultsCorrectly()
@Test
fun combineSearchAndFilters_returnsCorrectResults()

// UI tests
@Test
fun searchExerciseScreen_displaysMatchingResults()
@Test
fun filterByMuscleGroup_showsOnlyRelevantExercises()

Manual Tests:

  • Test complex search and filter combinations
  • Verify search result ordering matches selected sort option
  • Test edge cases like special characters in search terms

2.1.8 E05-F03: Exercise Information and Tutorials

Test Scenarios:

  1. Exercise Detail Display
    • Verify exercise information displays completely
    • Test muscle group visualization
  2. Tutorial Playback
    • Validate video playback functions
    • Test video controls and options
  3. Offline Access
    • Verify cached content is available offline
    • Test appropriate messaging for uncached content

Automated Tests:

// Unit tests
@Test
fun loadExerciseDetails_returnsCompleteInformation()
@Test
fun cacheExerciseMedia_makesContentAvailableOffline()

// UI tests
@Test
fun exerciseDetailScreen_showsAllRequiredInformation()
@Test
fun videoPlayer_controlsWorkCorrectly()

Manual Tests:

  • Verify video quality and playback performance
  • Test offline access to previously viewed exercises
  • Validate tutorial content accuracy

2.2 Database and Persistence Testing (Must Have)

Test Scenarios:

  1. Data Creation and Retrieval
    • Test creating and reading all entity types
    • Verify relationship integrity
  2. Data Updates and Deletion
    • Test updating entity properties
    • Validate deletion and cascade behaviors
  3. Transaction Handling
    • Test multi-entity transactions
    • Verify rollback on errors
  4. Database Migration
    • Test migration between schema versions
    • Verify data integrity after migration

Automated Tests:

// Room database tests
@Test
fun insertAndReadUserProfile_maintainsAllProperties()
@Test
fun workoutSessionWithExercises_saveAndRetrieveCorrectly()
@Test
fun transactionRollback_occursOnError()
@Test
fun databaseMigration_preservesExistingData()

Manual Tests:

  • Verify database inspection tools work correctly
  • Test database size with large datasets
  • Validate export/import functionality for backups

3. Test Plans for Should Have Features

3.1 E01-F05: Program Structure Management

Key Test Areas: - Creation of multi-week programs - Assignment of workouts to program days - Progressive overload calculations

3.2 E01-F06: Program Templates and Methodologies

Key Test Areas: - Template-based program creation - Methodology-specific calculations - Customization of template parameters

3.3 E01-F07: Program Progress Tracking

Key Test Areas: - Progress visualization across program - Schedule adherence tracking - Missed workout handling

3.4 E02-F03: Visualizing Performance Progress

Key Test Areas: - Chart rendering performance - Data point accuracy - Time range filtering

3.5 E03-F01: Creating Custom Workout Sessions

Key Test Areas: - Exercise selection and configuration - Workout template saving - Custom workout validation

3.6 E03-F02: Modifying Workouts During Active Sessions

Key Test Areas: - Adding/removing exercises mid-workout - State management during modifications - Data integrity after changes

3.7 E04-F01: Modifying Existing Workout Programs

Key Test Areas: - Exercise order modification - Set/rep scheme adjustments - Program duplication

3.8 E04-F02: Exercise Substitution in Programs

Key Test Areas: - Alternative exercise suggestions - Substitution persistence - Muscle group matching accuracy

3.9 E05-F02: Creating Custom Exercises

Key Test Areas: - Custom exercise creation form - Media upload functionality - Custom exercise integration with workouts

3.10 E05-F04: Exercise Progression Tracking

Key Test Areas: - Historical performance graphs - Personal record tracking - Progression recommendation algorithms

3.11 E05-F06: Equipment Management

Key Test Areas: - Equipment profile creation - Equipment-based filtering - Equipment substitution recommendations

4. Non-Functional Testing

4.1 Performance Testing

Test Objectives: - Verify app responsiveness meets requirements - Validate efficient resource usage - Test behavior under varying load conditions

Key Metrics: - Startup time - Screen transition time - Database operation duration - Memory usage - Battery consumption

Automated Tests:

// Performance tests
@Test
fun appStartup_completesWithinTimeLimit()
@Test
fun scrollingLargeExerciseList_maintainsSmoothFramerate()
@Test
fun databaseQueries_completeWithinThresholds()

Manual Tests: - Monitor CPU and memory usage during typical workflows - Test battery consumption during 1-hour workout session - Verify performance on minimum-spec devices

4.2 Usability and Accessibility Testing

Test Objectives: - Verify the app is usable across all personas - Validate accessibility compliance - Test screen reader compatibility

Key Areas: - Text size adjustments - Color contrast ratios - Touch target sizes - Screen reader announced content - One-handed operation

Automated Tests:

// Accessibility tests
@Test
fun allScreens_haveContentDescriptions()
@Test
fun allInteractiveElements_haveMinimumSize()

Manual Tests: - Test with screen readers enabled - Verify keyboard navigation where applicable - Test with various text size settings

4.3 Offline Functionality Testing

Test Objectives: - Verify core functions work without internet - Validate data synchronization after reconnection - Test appropriate messaging for online-only features

Key Areas: - Workout execution without internet - Exercise library browsing offline - Data persistence during offline periods

Automated Tests:

// Offline functionality tests
@Test
fun completingWorkoutOffline_savesDataCorrectly()
@Test
fun reconnectingAfterOffline_synchronizesData()

Manual Tests: - Turn on airplane mode during various workflows - Test transition between online and offline states - Verify appropriate messaging for unavailable features

5. Testing Schedule

5.1 MVP Phase

Week Testing Focus Deliverables
1-2 Unit testing for core models Core model test suite
3-4 Repository and data layer tests Data layer test coverage report
5-6 UI component tests UI test suite
7-8 Integration testing Integration test report
9-10 Full functional testing Functional test results
11-12 Non-functional and regression testing Final test report for MVP

5.2 Release 1.0 Phase

Week Testing Focus Deliverables
1-2 New feature unit testing Feature test suite
3-4 UI and integration tests UI/Integration test results
5-6 Full functional testing Functional test results
7-8 Regression and non-functional testing Final test report for Release 1.0

6. Bug Triage and Management

6.1 Bug Severity Levels

  • Critical: Application crashes, data loss, or security vulnerabilities
  • Major: Significant feature malfunction affecting user experience
  • Minor: Small issues that don’t significantly impact functionality
  • Trivial: Visual glitches or minor UI inconsistencies

6.2 Bug Resolution Prioritization

Severity MVP Phase Release 1.0 Release 2.0
Critical Must fix Must fix Must fix
Major Must fix Must fix Should fix
Minor Should fix Should fix Could fix
Trivial Could fix Could fix Won’t fix

6.3 Bug Lifecycle

  1. Discovery: Bug is found and documented
  2. Triage: Severity and priority assigned
  3. Assignment: Bug assigned to developer
  4. Resolution: Developer fixes the bug
  5. Verification: QA verifies the fix
  6. Closure: Bug is marked as resolved

7. Test Data Management

7.1 Test Data Requirements

  • Standard user profiles representing personas
  • Pre-populated workout programs of varying types
  • Exercise library with complete metadata
  • Sample workout history with performance data

7.2 Test Data Creation

  • Programmatic generation of test data
  • Manual curation of edge cases
  • Anonymized real-world usage patterns (where available)

7.3 Test Data Refreshing

  • Reset to baseline before each test run
  • Automated cleanup of test-generated data
  • Version control of test data sets

8. Risks and Mitigations

Risk Impact Likelihood Mitigation
Device fragmentation issues High Medium Comprehensive device test matrix
Database performance with large datasets High Medium Performance testing with scaled data
Offline sync conflicts Medium High Thorough conflict resolution testing
Battery consumption issues Medium Medium Regular profiling and optimization
Accessibility compliance gaps High Medium Early and frequent accessibility testing

9. Exit Criteria

9.1 MVP Release

  • All MVP feature test cases pass
  • No critical or major bugs remain open
  • Performance metrics meet defined thresholds
  • Usability testing with all personas completed successfully
  • Offline functionality verified across core features

9.2 Release 1.0

  • All Release 1.0 feature test cases pass
  • No critical bugs remain open
  • Major bugs addressed or have workarounds
  • Regression testing confirms MVP features remain functional
  • Performance and battery usage within acceptable parameters

10. Team Responsibilities

Role Responsibilities
Developers Unit tests, integration tests, test-driven development
QA Engineers Test planning, manual testing, automated UI testing
UX Designers Usability testing coordination, accessibility reviews
Product Owner Acceptance criteria validation, user testing oversight