Skip to content

armgit / wger

Public Imported from GitHub
0

Self hosted FLOSS fitness/workout, nutrition and weight tracker

Add Personal Record trophy awarded every time a PR is beaten and test cases

Justind3d14f6ab7f7
diff --git a/wger/trophies/checkers/base.py b/wger/trophies/checkers/base.py
index 613b9850f..d36a6e65e 100644
--- a/wger/trophies/checkers/base.py
+++ b/wger/trophies/checkers/base.py
@@ -124,5 +124,16 @@ class BaseTrophyChecker(ABC):
"""
return True
+ def get_context_data(self) -> Optional[dict]:
+ """
+ Returns context information about the trophy.
+
+ Override this method in subclasses to return informative context.
+
+ Returns:
+ None if no context, dict context information otherwise
+ """
+ return None
+
def __repr__(self) -> str:
return f'<{self.__class__.__name__}(user={self.user.username}, trophy={self.trophy.name})>'
diff --git a/wger/trophies/checkers/personal_record.py b/wger/trophies/checkers/personal_record.py
new file mode 100644
index 000000000..caf5f84ac
--- /dev/null
+++ b/wger/trophies/checkers/personal_record.py
@@ -0,0 +1,143 @@
+# This file is part of wger Workout Manager <https://github.com/wger-project>.
+# Copyright (C) 2013 - 2021 wger Team
+#
+# wger Workout Manager is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# wger Workout Manager is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+from typing import Optional
+
+from wger.trophies.models.trophy import Trophy
+from wger.trophies.models.user_trophy import UserTrophy
+from .base import BaseTrophyChecker
+
+
+class PersonalRecordChecker(BaseTrophyChecker):
+ """
+ Checker for Personal Record (PR) repeatable trophy.
+
+ Used to detect when PRs are beaten and award trophies accordingly.
+
+ params:
+ log (WorkoutLog): workout log used to check if a PR was beaten.
+
+ """
+
+ def _estimate_one_rep_max(self):
+ """
+ Brzycki's formula: 1RM = weight * (36 / (37 - repetitions))
+ """
+ log = self.params.get('log', None)
+
+ if not log: raise ValueError("Log should not be None")
+
+ weight = getattr(log, 'weight', None)
+ repetitions = getattr(log, 'repetitions', None)
+
+ if weight is None:
+ raise ValueError("Weight should not be None")
+ if repetitions is None:
+ raise ValueError("Repetitions should not be None")
+
+ try:
+ reps = int(repetitions)
+ except (TypeError, ValueError):
+ raise ValueError("Repetitions must be an integer")
+
+ if reps == 37:
+ raise ValueError("In Brzycki's formula, repetitions cannot be equal to 37.")
+
+ try:
+ w = float(weight)
+ except (TypeError, ValueError):
+ raise ValueError("Weight must be a number")
+
+ return round(w * (36.0 / float(37 - reps)), 2)
+
+
+ def check(self) -> bool:
+ """Check if user has beaten Personal Record."""
+ log = self.params.get('log', None)
+
+ if not log:
+ return False
+
+ exercise = getattr(log, 'exercise', None)
+
+ pr_trophy = Trophy.objects.get(name="Personal Record")
+ if not pr_trophy:
+ raise Exception("Trophy 'Personal Record' not found.")
+
+ last_pr = UserTrophy.objects.filter(
+ user=log.user,
+ trophy=pr_trophy,
+ context_data__exercise_id=exercise.id,
+ ).order_by('-earned_at').first()
+
+ if last_pr and last_pr.context_data:
+ prev = last_pr.context_data.get('one_rep_max_estimate')
+ try:
+ current = self._estimate_one_rep_max()
+ except Exception:
+ return False
+
+ if prev is not None and prev >= current:
+ return False
+
+ return True
+
+
+ def get_progress(self) -> float:
+ """Get progress as percentage."""
+ return 100.0 if self.check() else 0.0
+
+ def get_context_data(self) -> Optional[dict]:
+ log = self.params.get('log', None)
+
+ if not log:
+ return None
+
+ session = getattr(log, 'session', None)
+ exercise = getattr(log, 'exercise', None)
+ repetitions_unit = getattr(log, 'repetitions_unit', None)
+ weight_unit = getattr(log, 'weight_unit', None)
+ repetitions = getattr(log, 'repetitions', None)
+ weight = getattr(log, 'weight', None)
+
+ try:
+ one_rm_estimate = self._estimate_one_rep_max()
+ except Exception as e:
+ print(f"PR estimation failed : {e}")
+ one_rm_estimate = None
+
+ return {
+ 'log_id': getattr(log, 'id', None),
+ 'date': getattr(log, 'date', None).isoformat(),
+ 'session_id': getattr(session, 'id', None) if session else None,
+ 'exercise_id': getattr(exercise, 'id', None) if exercise else None,
+ 'repetitions_unit_id': getattr(repetitions_unit, 'id', None) if repetitions_unit else None,
+ 'repetitions': float(repetitions) if repetitions else None,
+ 'weight_unit_id': getattr(weight_unit, 'id', None) if weight_unit else None,
+ 'weight': float(weight) if weight else None,
+ 'iteration': getattr(log, 'iteration', None),
+ 'one_rep_max_estimate': one_rm_estimate
+ }
+
+ def get_target_value(self) -> int:
+ return 'N/A'
+
+ def get_current_value(self) -> int:
+ return 'N/A'
+
+ def get_progress_display(self) -> str:
+ return 'N/A'
+
diff --git a/wger/trophies/checkers/registry.py b/wger/trophies/checkers/registry.py
index b7b5dee1c..bc96161bc 100644
--- a/wger/trophies/checkers/registry.py
+++ b/wger/trophies/checkers/registry.py
@@ -24,6 +24,7 @@ from typing import (
# Django
from django.contrib.auth.models import User
+from wger.trophies.models.trophy import Trophy
# Local
from .base import BaseTrophyChecker
@@ -34,6 +35,7 @@ from .streak import StreakChecker
from .time_based import TimeBasedChecker
from .volume import VolumeChecker
from .weekend_warrior import WeekendWarriorChecker
+from .personal_record import PersonalRecordChecker
logger = logging.getLogger(__name__)
@@ -57,6 +59,7 @@ class CheckerRegistry:
'time_based': TimeBasedChecker,
'date_based': DateBasedChecker,
'inactivity_return': InactivityReturnChecker,
+ 'personal_record': PersonalRecordChecker,
}
@classmethod
@@ -109,7 +112,7 @@ class CheckerRegistry:
def create_checker(
cls,
user: User,
- trophy: 'Trophy',
+ trophy: Trophy,
) -> Optional[BaseTrophyChecker]:
"""
Factory method to create a checker instance for a trophy.
diff --git a/wger/trophies/management/commands/load_trophies.py b/wger/trophies/management/commands/load_trophies.py
index fee11214b..dcbd6a4f1 100644
--- a/wger/trophies/management/commands/load_trophies.py
+++ b/wger/trophies/management/commands/load_trophies.py
@@ -140,6 +140,17 @@ class Command(BaseCommand):
'is_progressive': False,
'order': 9,
},
+ {
+ 'name': _('Personal Record'),
+ 'description': _('Repeatable Personal Record (PR) trophy'),
+ 'trophy_type': Trophy.TYPE_OTHER,
+ 'checker_class': 'personal_record',
+ 'checker_params': {},
+ 'is_hidden': True,
+ 'is_progressive': False,
+ 'is_repeatable': True,
+ 'order': 10,
+ },
]
created_count = 0
diff --git a/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py b/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py
index 1ab30018a..d1af1e7ab 100644
--- a/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py
+++ b/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py
@@ -9,6 +9,29 @@ class Migration(migrations.Migration):
('trophies', '0003_load_initial_trophies'),
]
+ def create_personal_record_trophy(apps, schema_editor):
+ Trophy = apps.get_model('trophies', 'Trophy')
+
+ if not Trophy.objects.filter(name='Personal Record').exists():
+ Trophy.objects.create(
+ name='Personal Record',
+ description='Repeatable Personal Record (PR) trophy',
+ trophy_type='other',
+ checker_class='personal_record',
+ checker_params={},
+ is_hidden=True,
+ is_progressive=False,
+ is_repeatable=True,
+ order=10,
+ )
+
+ print(f'Trophy migration: Created trophy \'Personal Record\'')
+
+
+ def remove_personal_record_trophy(apps, schema_editor):
+ Trophy = apps.get_model('trophies', 'Trophy')
+ Trophy.objects.filter(name='Personal Record').delete()
+
operations = [
migrations.AddField(
model_name='trophy',
@@ -20,4 +43,5 @@ class Migration(migrations.Migration):
name='context_data',
field=models.JSONField(blank=True, default=None, help_text='Additional information concerning this trophy', null=True, verbose_name='Context data'),
),
+ migrations.RunPython(create_personal_record_trophy, remove_personal_record_trophy),
]
diff --git a/wger/trophies/services/trophy.py b/wger/trophies/services/trophy.py
index 91242733b..3f52d91a8 100644
--- a/wger/trophies/services/trophy.py
+++ b/wger/trophies/services/trophy.py
@@ -72,14 +72,12 @@ class TrophyService:
if cls.should_skip_user(user):
return []
- # Get all active trophies the user hasn't earned
- earned_trophy_ids = UserTrophy.objects.filter(user=user).values_list('trophy_id', flat=True)
- unevaluated_trophies = Trophy.objects.filter(is_active=True, is_repeatable=False).exclude(
- id__in=earned_trophy_ids
- )
+ # Evaluate all active trophies. evaluate_trophy() will skip non-repeatable trophies
+ # the user already has, while repeatable trophies are always checked.
+ trophies = Trophy.objects.filter(is_active=True).order_by('order', 'name')
awarded = []
- for trophy in unevaluated_trophies:
+ for trophy in trophies:
user_trophy = cls.evaluate_trophy(user, trophy)
if user_trophy:
awarded.append(user_trophy)
@@ -116,7 +114,8 @@ class TrophyService:
try:
if checker.check():
- return cls.award_trophy(user, trophy, progress=100.0)
+ context = checker.get_context_data()
+ return cls.award_trophy(user, trophy, progress=100.0, context_data=context)
except Exception as e:
logger.error(
f'Error checking trophy {trophy.name} for user {user.id}: {e}', exc_info=True
@@ -125,7 +124,7 @@ class TrophyService:
return None
@classmethod
- def award_trophy(cls, user: User, trophy: Trophy, progress: float = 100.0) -> UserTrophy:
+ def award_trophy(cls, user: User, trophy: Trophy, progress: float = 100.0, context_data: Optional[dict]=None) -> UserTrophy:
"""
Award a trophy to a user.
@@ -135,17 +134,24 @@ class TrophyService:
user: The user to award the trophy to
trophy: The trophy to award
progress: The progress value (default 100 for earned)
+ context_data: Additional information regarding the trophy awarded
Returns:
The created UserTrophy instance
"""
if trophy.is_repeatable:
- user_trophy, created = UserTrophy.objects.create(user=user, trophy=trophy, progress=progress)
+ created = True
+ user_trophy = UserTrophy.objects.create(
+ user=user,
+ trophy=trophy,
+ progress=progress,
+ context_data=context_data
+ )
else:
user_trophy, created = UserTrophy.objects.get_or_create(
user=user,
trophy=trophy,
- defaults={'progress': progress},
+ defaults={'progress': progress, 'context_data': context_data},
)
if created:
diff --git a/wger/trophies/signals.py b/wger/trophies/signals.py
index 0cf54e134..068d4a510 100644
--- a/wger/trophies/signals.py
+++ b/wger/trophies/signals.py
@@ -36,7 +36,11 @@ from wger.manager.models import (
WorkoutLog,
WorkoutSession,
)
+from wger.trophies.checkers.registry import CheckerRegistry
+from wger.trophies.models.trophy import Trophy
+from wger.trophies.models.user_trophy import UserTrophy
from wger.trophies.services import UserStatisticsService
+from wger.trophies.services.trophy import TrophyService
from wger.trophies.tasks import evaluate_user_trophies_task
@@ -87,6 +91,16 @@ def workout_log_saved(sender, instance, created, **kwargs):
user=instance.user,
workout_log=instance,
)
+
+ # Personal Record award
+ trophy = Trophy.objects.get(name='Personal Record', is_active=True)
+ checker = CheckerRegistry.create_checker(instance.user, trophy)
+ checker.params = {'log': instance}
+ existing = UserTrophy.objects.filter(user=instance.user, trophy=trophy, context_data__log_id=instance.id).exists()
+ if not existing and checker and checker.check():
+ context = checker.get_context_data()
+ TrophyService.award_trophy(instance.user, trophy, progress=100.0, context_data=context)
+
else:
# Edited log - full recalculation for accuracy
UserStatisticsService.update_statistics(instance.user)
@@ -96,7 +110,6 @@ def workout_log_saved(sender, instance, created, **kwargs):
except Exception as e:
logger.error(f'Error updating statistics for user {instance.user_id}: {e}', exc_info=True)
-
@receiver(post_delete, sender=WorkoutLog)
def workout_log_deleted(sender, instance, **kwargs):
"""
diff --git a/wger/trophies/tests/test_checkers.py b/wger/trophies/tests/test_checkers.py
index d02f3fb0a..81ddbb952 100644
--- a/wger/trophies/tests/test_checkers.py
+++ b/wger/trophies/tests/test_checkers.py
@@ -21,6 +21,9 @@ from django.contrib.auth.models import User
# wger
from wger.core.tests.base_testcase import WgerTestCase
+from wger.exercises.models.base import Exercise
+from wger.exercises.models.category import ExerciseCategory
+from wger.manager.models.log import WorkoutLog
from wger.trophies.checkers.count_based import CountBasedChecker
from wger.trophies.checkers.date_based import DateBasedChecker
from wger.trophies.checkers.inactivity_return import InactivityReturnChecker
@@ -485,3 +488,118 @@ class InactivityReturnCheckerTestCase(WgerTestCase):
checker = InactivityReturnChecker(self.user, self.trophy, {'inactive_days': 30})
self.assertEqual(checker.get_progress(), 100.0)
+
+class PersonalRecordCheckerTestCase(WgerTestCase):
+ def setUp(self):
+ super().setUp()
+
+ self.user = User.objects.get(username='admin')
+ self.exercise = Exercise.objects.create(category=ExerciseCategory.objects.create(name='c3'))
+
+ self.trophy, _ = Trophy.objects.get_or_create(
+ name='Personal Record',
+ defaults={
+ 'trophy_type': Trophy.TYPE_OTHER,
+ 'checker_class': 'personal_record',
+ 'checker_params': {},
+ 'is_active': True,
+ 'is_repeatable': True,
+ }
+ )
+
+ def test_check_returns_false_with_no_logs(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ checker = PersonalRecordChecker(self.user, self.trophy, {})
+ self.assertFalse(checker.check())
+
+ def test_first_log_counts_as_pr(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ log = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)
+
+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})
+
+ self.assertTrue(checker.check())
+ context = checker.get_context_data()
+ self.assertIsNotNone(context)
+
+ def test_improvement_detected_and_context_values(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ log1 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)
+ checker1 = PersonalRecordChecker(self.user, self.trophy, {'log': log1})
+ self.assertTrue(checker1.check())
+
+ log2 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=110)
+ checker2 = PersonalRecordChecker(self.user, self.trophy, {'log': log2})
+ self.assertTrue(checker2.check())
+
+ context = checker2.get_context_data()
+ self.assertIsNotNone(context)
+
+ def no_award_if_not_an_improvement(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ log1 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)
+ checker1 = PersonalRecordChecker(self.user, self.trophy, {'log': log1})
+ self.assertTrue(checker1.check())
+
+ # lower weight
+ log2 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=90)
+ checker2 = PersonalRecordChecker(self.user, self.trophy, {'log': log2})
+ self.assertFalse(checker2.check())
+
+ # same weight
+ log3 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)
+ checker3 = PersonalRecordChecker(self.user, self.trophy, {'log': log3})
+ self.assertFalse(checker3.check())
+
+ # better weight but lower repetitions
+ log4 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=3, weight=110)
+ checker4 = PersonalRecordChecker(self.user, self.trophy, {'log': log4})
+ self.assertFalse(checker4.check())
+
+ def test_estimate_1rm(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ log = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)
+ one_rm = round(100 * (36.0 / (37 - 10)), 2)
+
+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})
+ estimate = checker._estimate_one_rep_max()
+ self.assertEquals(estimate, one_rm)
+ self.assertEquals(checker.get_context_data().get("one_rep_max_estimate"), one_rm)
+
+ def test_estimate_1rm_raises_on_missing_values(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ # No log
+ checker = PersonalRecordChecker(self.user, self.trophy, {})
+ with self.assertRaises(ValueError):
+ checker._estimate_one_rep_max()
+
+ # Missing weight
+ log = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10)
+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})
+ with self.assertRaises(ValueError):
+ checker._estimate_one_rep_max()
+
+ # Missing repetitions
+ log = WorkoutLog(user=self.user, exercise=self.exercise, weight=100)
+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})
+ with self.assertRaises(ValueError):
+ checker._estimate_one_rep_max()
+
+ context = checker.get_context_data()
+ self.assertIsNone(context.get("one_rep_max_estimate"))
+
+ def test_estimate_1rm_raises_on_repetitions_37(self):
+ from wger.trophies.checkers.personal_record import PersonalRecordChecker
+
+ log = WorkoutLog(user=self.user, exercise=self.exercise, weight=100, repetitions=37)
+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})
+ with self.assertRaises(ValueError):
+ checker._estimate_one_rep_max()
+
+
\ No newline at end of file
diff --git a/wger/trophies/tests/test_integration.py b/wger/trophies/tests/test_integration.py
index 40ba8ebc6..c5a3833c4 100644
--- a/wger/trophies/tests/test_integration.py
+++ b/wger/trophies/tests/test_integration.py
@@ -21,6 +21,8 @@ from django.contrib.auth.models import User
# wger
from wger.core.tests.base_testcase import WgerTestCase
+from wger.exercises.models.base import Exercise
+from wger.exercises.models.category import ExerciseCategory
from wger.manager.models import (
WorkoutLog,
WorkoutSession,
@@ -84,6 +86,15 @@ class TrophyIntegrationTestCase(WgerTestCase):
is_progressive=True,
)
+ self.personal_record_trophy = Trophy.objects.create(
+ name='Personal Record',
+ trophy_type=Trophy.TYPE_OTHER,
+ checker_class='personal_record',
+ checker_params={},
+ is_active=True,
+ is_repeatable=True,
+ )
+
def test_first_workout_earns_beginner_trophy(self):
"""Test that completing first workout earns Beginner trophy"""
# Create user statistics
@@ -105,6 +116,49 @@ class TrophyIntegrationTestCase(WgerTestCase):
self.assertEqual(len(awarded), 1)
self.assertEqual(awarded[0].trophy, self.beginner_trophy)
+ def test_personal_record_not_awarded_if_no_pr(self):
+ """Only awards the Personal Record trophy if the log is a PR"""
+ UserTrophy.objects.filter(user=self.user).delete()
+ exercise = Exercise.objects.create(category=ExerciseCategory.objects.create(name='pr_cat'))
+
+ # first log = PR
+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=100)
+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)
+ self.assertEqual(pr_trophies.count(), 1)
+
+ # not a PR
+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=100)
+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)
+ self.assertEqual(pr_trophies.count(), 1)
+
+ # not a PR
+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=90)
+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)
+ self.assertEqual(pr_trophies.count(), 1)
+
+ # not a PR
+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=5, weight=101)
+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)
+ self.assertEqual(pr_trophies.count(), 1)
+
+ # PR
+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=11, weight=100)
+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)
+ self.assertEqual(pr_trophies.count(), 2)
+
+ def test_personal_record_awarded_on_log_creation(self):
+ """Creating a new WorkoutLog which is a PR awards the Personal Record trophy"""
+ UserTrophy.objects.filter(user=self.user).delete()
+
+ exercise = Exercise.objects.create(category=ExerciseCategory.objects.create(name='pr_cat'))
+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=100)
+
+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)
+ self.assertEqual(pr_trophies.count(), 1)
+
+ context = pr_trophies.first().context_data
+ self.assertIsNotNone(context)
+
def test_lifting_5000kg_earns_lifter_trophy(self):
"""Test that lifting 5000kg total earns Lifter trophy"""
# Create user statistics
diff --git a/wger/trophies/tests/test_models.py b/wger/trophies/tests/test_models.py
index d62a7d69e..5a99aa845 100644
--- a/wger/trophies/tests/test_models.py
+++ b/wger/trophies/tests/test_models.py
@@ -172,6 +172,9 @@ class UserTrophyModelTestCase(WgerTestCase):
def setUp(self):
super().setUp()
self.user = User.objects.get(username='admin')
+
+ UserTrophy.objects.filter(user=self.user).delete()
+
self.trophy = Trophy.objects.create(
name='Test Trophy',
trophy_type=Trophy.TYPE_COUNT,
@@ -293,11 +296,11 @@ class UserTrophyModelTestCase(WgerTestCase):
checker_class='volume',
)
- user_trophy1 = UserTrophy.objects.create(
+ UserTrophy.objects.create(
user=self.user,
trophy=self.trophy,
)
- user_trophy2 = UserTrophy.objects.create(
+ UserTrophy.objects.create(
user=self.user,
trophy=trophy2,
)
diff --git a/wger/trophies/tests/test_services.py b/wger/trophies/tests/test_services.py
index 5f3e3b2e3..b8b87007d 100644
--- a/wger/trophies/tests/test_services.py
+++ b/wger/trophies/tests/test_services.py
@@ -302,6 +302,19 @@ class TrophyServiceTestCase(WgerTestCase):
hidden_in_list = any(p['trophy'].id == hidden_trophy.id for p in progress_list)
self.assertTrue(hidden_in_list)
+ def test_award_pr_trophy_multiple_times(self):
+ """PR trophies can be awarded multiple times via TrophyService"""
+ pr_trophy, _ = Trophy.objects.get_or_create(
+ name="Personal Record",
+ defaults={'is_repeatable': True, 'is_active': True},
+ )
+
+ ut1 = TrophyService.award_trophy(self.user, pr_trophy, progress=100.0, context_data={'log_id': 1})
+ ut2 = TrophyService.award_trophy(self.user, pr_trophy, progress=100.0, context_data={'log_id': 2})
+
+ self.assertEqual(UserTrophy.objects.filter(user=self.user, trophy=pr_trophy).count(), 2)
+ self.assertNotEquals(ut1, ut2)
+
def test_should_skip_user_inactive(self):
"""Test skipping inactive users"""
# Set user's last login to over 30 days ago