#103 test model diffusion

aircox/models/diffusion.py

@@ -76,7 +76,10 @@ class DiffusionQuerySet(RerunQuerySet):
 
     def range(self, start, end):
         # FIXME can return dates that are out of range...
-        return self.after(start).before(end)
+        qs = self.filter(start__gte=start)
+        qs = qs.filter(end__lte=end)
+        return qs.order_by("start")
+        # return self.after(start).before(end)
 
 
 class Diffusion(Rerun):

aircox/tests/models/test_diffusion.py

@@ -5,29 +5,27 @@ from model_bakery import baker
 from django.utils import timezone as tz
 from datetime import timedelta
 import pytz
-from aircox.models import Diffusion
+from aircox.models import Diffusion, Episode
 
-
+#TODO fixture for rerun diffusion
-# TODO déplacer fixutre dans conftest.py / rechercher si il y a une méthode plus lisible que celle utilisée dans ce test pour utiliser ces deux fixtures.
 @pytest.fixture
 def diffusions_time_variation(episodes):
     random_episode = random.choice([episodes[1], episodes[0], episodes[2]])
-    now = tz.now()
     now_date = datetime.date.today()
     now_datetime = tz.now()
-    tomorrow_datetime = now + timedelta(hours=25)
+    tomorrow_datetime = now_datetime + timedelta(hours=25)
-    yesterday_datetime = now - timedelta(hours=25)
+    yesterday_datetime = now_datetime - timedelta(hours=25)
     now_diffusion = baker.make(
         Diffusion,
         episode=random_episode,
-        start=now - timedelta(minutes=30),
+        start=now_datetime - timedelta(minutes=30),
-        end=now + timedelta(minutes=30),
+        end=now_datetime + timedelta(minutes=30),
     )
     after_diffusion = baker.make(
         Diffusion,
         episode=random_episode,
-        start=now + timedelta(minutes=30),
+        start=now_datetime + timedelta(minutes=30),
-        end=now + timedelta(minutes=60),
+        end=now_datetime + timedelta(minutes=60),
     )
     tomorrow_diffusion = baker.make(
         Diffusion,
@@ -38,8 +36,8 @@ def diffusions_time_variation(episodes):
     before_diffusion = baker.make(
         Diffusion,
         episode=random_episode,
-        start=now - timedelta(minutes=60),
+        start=now_datetime - timedelta(minutes=60),
-        end=now - timedelta(minutes=30),
+        end=now_datetime - timedelta(minutes=30),
     )
     yesterday_diffusion = baker.make(
         Diffusion,
@@ -222,20 +220,22 @@ class TestDiffusionQuerySet:
         assert result[2] == after_diffusion
 
     @pytest.mark.django_db
-    def test_after_without_date_arg(self, diffusions_time_variation):
+    def test_after_without_arg(self, diffusions_time_variation):
         (
             _,
             _,
             yesterday_diffusion,
-            _,
+            before_diffusion,
             now_diffusion,
-            _,
+            after_diffusion,
             tomorrow_diffusion,
         ) = diffusions_time_variation
         from_now_diffusions = Diffusion.objects.after()
 
         assert tomorrow_diffusion in from_now_diffusions
+        assert after_diffusion in from_now_diffusions
         assert now_diffusion in from_now_diffusions
+        assert before_diffusion not in from_now_diffusions
         assert yesterday_diffusion not in from_now_diffusions
 
     @pytest.mark.django_db
@@ -270,10 +270,158 @@ class TestDiffusionQuerySet:
         ) = diffusions_time_variation
         from_today_diffusions = Diffusion.objects.after(date=now_date)
 
-        #assert now_date == 'today'
         assert tomorrow_diffusion in from_today_diffusions
         assert after_diffusion in from_today_diffusions
         assert now_diffusion in from_today_diffusions
         assert before_diffusion in from_today_diffusions
         assert yesterday_diffusion not in from_today_diffusions
 
+    @pytest.mark.django_db
+    def test_before_without_arg(self, diffusions_time_variation):
+        (
+            _,
+            _,
+            yesterday_diffusion,
+            before_diffusion,
+            now_diffusion,
+            after_diffusion,
+            tomorrow_diffusion,
+        ) = diffusions_time_variation
+        before_now_diffusions = Diffusion.objects.before()
+
+        assert tomorrow_diffusion not in before_now_diffusions
+        assert after_diffusion not in before_now_diffusions
+        assert now_diffusion in before_now_diffusions
+        assert before_diffusion in before_now_diffusions
+        assert yesterday_diffusion in before_now_diffusions
+
+    @pytest.mark.django_db
+    def test_before_with_datetime_arg(self, diffusions_time_variation):
+        (
+            _,
+            now_datetime,
+            yesterday_diffusion,
+            before_diffusion,
+            now_diffusion,
+            after_diffusion,
+            tomorrow_diffusion,
+        ) = diffusions_time_variation
+        before_now_diffusions = Diffusion.objects.before(date=now_datetime)
+
+        assert tomorrow_diffusion not in before_now_diffusions
+        assert after_diffusion not in before_now_diffusions
+        assert now_diffusion in before_now_diffusions
+        assert before_diffusion in before_now_diffusions
+        assert yesterday_diffusion in before_now_diffusions
+
+    @pytest.mark.django_db
+    def test_before_with_date_arg(self, diffusions_time_variation):
+        (
+            now_date,
+            _,
+            yesterday_diffusion,
+            before_diffusion,
+            now_diffusion,
+            after_diffusion,
+            tomorrow_diffusion,
+        ) = diffusions_time_variation
+        before_today_diffusions = Diffusion.objects.before(date=now_date)
+
+        assert tomorrow_diffusion not in before_today_diffusions
+        assert after_diffusion not in before_today_diffusions
+        assert now_diffusion not in before_today_diffusions
+        assert before_diffusion not in before_today_diffusions
+        assert yesterday_diffusion in before_today_diffusions
+
+    @pytest.mark.django_db
+    def test_range(self, episodes, diffusions_time_variation):
+        (
+            _,
+            _,
+            yesterday_diffusion,
+            before_diffusion,
+            now_diffusion,
+            after_diffusion,
+            tomorrow_diffusion,
+        ) = diffusions_time_variation
+        start = before_diffusion.start
+        end = after_diffusion.end
+        overlaping_start_diffusion = baker.make(
+            Diffusion,
+            episode=episodes[0],
+            start=start - timedelta(minutes=30),
+            end=end,
+        )
+        overlaping_end_diffusion = baker.make(
+            Diffusion,
+            episode=episodes[0],
+            start=start,
+            end=end + timedelta(minutes=30),
+        )
+
+        range_diffusion = Diffusion.objects.range(start=start, end=end)
+
+        assert before_diffusion in range_diffusion
+        assert after_diffusion in range_diffusion
+        assert now_diffusion in range_diffusion
+        assert overlaping_start_diffusion not in range_diffusion
+        assert overlaping_end_diffusion not in range_diffusion
+        assert tomorrow_diffusion not in range_diffusion
+        assert yesterday_diffusion not in range_diffusion
+
+
+class TestDiffusion:
+    @pytest.mark.django_db
+    def test__str__initial_diffusion(self, programs):
+        episode = baker.make(
+            Episode, program=programs[0], title="Episode title"
+        )
+        diffusion = baker.make(
+            Diffusion,
+            episode=episode,
+            start=datetime.datetime(2023, 5, 12, 13, 0, tzinfo=pytz.UTC),
+        )
+        expected_str = "Episode title - 2023/05/12 13:00+0000"
+        returned_str = diffusion.__str__()
+
+        assert expected_str == returned_str
+
+    @pytest.mark.django_db
+    def test__str__rerun_diffusion(self, programs):
+        episode = baker.make(
+            Episode, program=programs[0], title="Episode title"
+        )
+        initial_diffusion = baker.make(Diffusion, episode=episode)
+        rerun_diffusion = baker.make(
+            Diffusion,
+            episode=episode,
+            start=datetime.datetime(2023, 5, 12, 13, 0, tzinfo=pytz.UTC),
+            initial=initial_diffusion,
+        )
+        expected_str = "Episode title - 2023/05/12 13:00+0000 (rerun)"
+        returned_str = rerun_diffusion.__str__()
+
+        assert expected_str == returned_str
+
+    # dans la méthode self._initial[valeur] est un dictionnaire qui stocke les valeurs initiales des champs de l'objet au moment de sa création
+    # save
+    # si diffusion est initial et si son épisode a été modifié depuis la création initiale
+    # la méthode save update l'épisode et le programme sur paramètre initial (rerun_set) de la rediffusion (qui représente l'objet diffusion initial).
+    """ je ne comprends pas rerun_set.update, que la méthode l'update ou pas, on accède quand même à l'épisode mis à jour sur la diffusion initiale"""
+    @pytest.mark.django_db
+    def test_save_rerun_diffusion(self, episodes, programs):
+        initial_diffusion = baker.make(
+            Diffusion, program=programs[0], episode=episodes[0]
+        )
+        rerun_diffusion = baker.make(
+            Diffusion,
+            program=programs[0],
+            episode=episodes[0],
+            initial=initial_diffusion,
+        )
+        initial_diffusion.episode = episodes[1]
+        initial_diffusion.program = programs[1]
+        initial_diffusion.save()
+
+        assert rerun_diffusion.initial.episode == episodes[1]
+        assert rerun_diffusion.initial.program == programs[1]