Update tests

lego/apps/users/managers.py

@@ -50,5 +50,9 @@ class UserPenaltyManager(PersistentModelManager):
     def valid(self):
         from lego.apps.users.models import Penalty
 
-        offset = Penalty.penalty_offset(timezone.now(), False)
-        return super().filter(created_at__gt=timezone.now() - offset)
+        valid_penalties = [
+            penalty.pk
+            for penalty in Penalty.objects.all()
+            if penalty.exact_expiration > timezone.now()
+        ]
+        return super().filter(pk__in=valid_penalties)

lego/apps/users/tests/test_models.py

@@ -241,71 +241,96 @@ class PenaltyTestCase(BaseTestCase):
 
     def setUp(self):
         self.test_user = User.objects.get(pk=1)
-        self.source = Event.objects.all().first()
 
     def test_create_penalty(self):
+        source = Event.objects.all().first()
         penalty = Penalty.objects.create(
-            user=self.test_user, reason="test", weight=1, source_event=self.source
+            user=self.test_user, reason="test", weight=1, source_event=source
         )
 
         self.assertEqual(self.test_user.number_of_penalties(), 1)
         self.assertEqual(self.test_user, penalty.user)
         self.assertEqual("test", penalty.reason)
         self.assertEqual(1, penalty.weight)
-        self.assertEqual(self.source, penalty.source_event)
-        self.assertEqual(self.source.id, penalty.source_event.id)
+        self.assertEqual(source, penalty.source_event)
+        self.assertEqual(source.id, penalty.source_event.id)
 
     def test_count_weights(self):
+        source = Event.objects.all().first()
         weights = [1, 2]
         for weight in weights:
             Penalty.objects.create(
                 user=self.test_user,
                 reason="test",
                 weight=weight,
-                source_event=self.source,
+                source_event=source,
             )
 
         self.assertEqual(self.test_user.number_of_penalties(), sum(weights))
 
     @mock.patch("django.utils.timezone.now", return_value=fake_time(2016, 10, 1))
     def test_only_count_active_penalties(self, mock_now):
+        event1 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now() - timedelta(days=20),
+            end_time=mock_now() - timedelta(days=20),
+        )
+
+        event2 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now() - timedelta(days=19, hours=23, minutes=59),
+            end_time=mock_now() - timedelta(days=19, hours=23, minutes=59),
+        )
+
         Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=20),
             user=self.test_user,
             reason="test",
             weight=1,
-            source_event=self.source,
+            source_event=event1,
         )
         Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=19, hours=23, minutes=59),
             user=self.test_user,
             reason="test",
             weight=1,
-            source_event=self.source,
+            source_event=event2,
         )
         self.assertEqual(self.test_user.number_of_penalties(), 1)
 
     @override_settings(PENALTY_IGNORE_WINTER=((12, 10), (1, 10)))
     @mock.patch("django.utils.timezone.now", return_value=fake_time(2016, 12, 10))
     def test_frozen_penalties_count_as_active_winter(self, mock_now):
-        # This penalty is created slightly less than 20 days from the freeze-point.
-        # It should be counted as active.
+        # This event is created slightly less than 20 days from the freeze-point.
+        # The penalty should be counted as active.
+        event1 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now().replace(day=1),
+            end_time=mock_now().replace(day=1),
+        )
+
         Penalty.objects.create(
             created_at=mock_now() - timedelta(days=20, hours=23, minutes=59),
             user=self.test_user,
             reason="active",
             weight=1,
-            source_event=self.source,
+            source_event=event1,
         )
 
-        # This penalty is created exactly 20 days from the freeze-point.
-        # It should be counted as inactive.
+        # This event is created exactly 20 days from the freeze-point.
+        # The penalty should be counted as inactive.
+        event2 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now() - timedelta(days=21),
+            end_time=mock_now() - timedelta(days=21),
+        )
         Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=21),
             user=self.test_user,
             reason="inactive",
             weight=1,
-            source_event=self.source,
+            source_event=event2,
         )
 
         self.assertEqual(self.test_user.number_of_penalties(), 1)
@@ -314,24 +339,35 @@ def test_frozen_penalties_count_as_active_winter(self, mock_now):
     @override_settings(PENALTY_IGNORE_SUMMER=((6, 12), (8, 15)))
     @mock.patch("django.utils.timezone.now", return_value=fake_time(2016, 6, 12))
     def test_frozen_penalties_count_as_active_summer(self, mock_now):
-        # This penalty is created slightly less than 20 days from the freeze-point.
-        # It should be counted as active.
+        # This event is created slightly less than 20 days from the freeze-point.
+        # The penalty should be counted as active.
+        event1 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now() - timedelta(days=19, hours=23, minutes=59),
+            end_time=mock_now() - timedelta(days=19, hours=23, minutes=59),
+        )
+
         Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=20, hours=23, minutes=59),
             user=self.test_user,
             reason="active",
             weight=1,
-            source_event=self.source,
+            source_event=event1,
         )
 
-        # This penalty is created exactly 20 days from the freeze-point.
-        # It should be counted as inactive.
+        # This event is created exactly 20 days from the freeze-point.
+        # The penalty should be counted as inactive.
+        event2 = Event.objects.create(
+            title="Another simple event",
+            event_type=0,
+            start_time=mock_now() - timedelta(days=21),
+            end_time=mock_now() - timedelta(days=21),
+        )
         Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=21),
             user=self.test_user,
             reason="inactive",
             weight=1,
-            source_event=self.source,
+            source_event=event2,
         )
 
         self.assertEqual(self.test_user.number_of_penalties(), 1)
@@ -342,25 +378,36 @@ def test_frozen_penalties_count_as_active_summer(self, mock_now):
     def test_penalty_offset_is_calculated_correctly(self, mock_now):
         # This penalty is set to expire the day before the penalty freeze
         # It should not be active
+        event1 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now().replace(day=1),
+            end_time=mock_now().replace(day=1),
+        )
+
         inactive = Penalty.objects.create(
-            created_at=mock_now().replace(day=1),
             user=self.test_user,
             reason="inactive",
             weight=1,
-            source_event=self.source,
+            source_event=event1,
         )
         self.assertEqual(self.test_user.number_of_penalties(), 0)
         self.assertEqual(
             (inactive.exact_expiration.month, inactive.exact_expiration.day), (12, 21)
         )
 
         # This penalty is set to expire the same day as the freeze
+        event2 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now().replace(day=2),
+            end_time=mock_now().replace(day=2),
+        )
         active = Penalty.objects.create(
-            created_at=mock_now().replace(day=2),
             user=self.test_user,
             reason="active",
             weight=1,
-            source_event=self.source,
+            source_event=event2,
         )
         self.assertEqual(self.test_user.number_of_penalties(), 1)
         self.assertEqual(

lego/apps/users/tests/test_users_api.py

@@ -1,4 +1,4 @@
-from datetime import date, timedelta
+from datetime import date
 from unittest import mock
 
 from django.contrib.auth import authenticate
@@ -453,21 +453,20 @@ def test_self_unauthed(self):
 
     @mock.patch("django.utils.timezone.now", return_value=fake_time(2016, 10, 1))
     def test_own_penalties_serializer(self, mock_now):
-        source = Event.objects.all().first()
-        Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=20),
-            user=self.user,
-            reason="test",
-            weight=1,
-            source_event=source,
+        event1 = Event.objects.create(
+            title="A simple event",
+            event_type=0,
+            start_time=mock_now(),
+            end_time=mock_now(),
         )
+
         Penalty.objects.create(
-            created_at=mock_now() - timedelta(days=19, hours=23, minutes=59),
             user=self.user,
             reason="test",
             weight=1,
-            source_event=source,
+            source_event=event1,
         )
+
         self.client.force_authenticate(user=self.user)
         response = self.client.get(reverse("api:v1:user-me"))