From 2a034fc46778830f78a41db795dee2845e0cf521 Mon Sep 17 00:00:00 2001 From: lauvwbk Date: Thu, 11 May 2023 19:44:14 +0200 Subject: [PATCH] #103 test model diffusion --- aircox/models/diffusion.py | 5 +- aircox/tests/models/test_diffusion.py | 180 +++++++++++++++++++++++--- 2 files changed, 168 insertions(+), 17 deletions(-) diff --git a/aircox/models/diffusion.py b/aircox/models/diffusion.py index 2949885..1587112 100644 --- a/aircox/models/diffusion.py +++ b/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): diff --git a/aircox/tests/models/test_diffusion.py b/aircox/tests/models/test_diffusion.py index b537607..5af19a1 100644 --- a/aircox/tests/models/test_diffusion.py +++ b/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 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. +#TODO fixture for rerun diffusion @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) - yesterday_datetime = now - timedelta(hours=25) + tomorrow_datetime = now_datetime + timedelta(hours=25) + yesterday_datetime = now_datetime - timedelta(hours=25) now_diffusion = baker.make( Diffusion, episode=random_episode, - start=now - timedelta(minutes=30), - end=now + timedelta(minutes=30), + start=now_datetime - timedelta(minutes=30), + end=now_datetime + timedelta(minutes=30), ) after_diffusion = baker.make( Diffusion, episode=random_episode, - start=now + timedelta(minutes=30), - end=now + timedelta(minutes=60), + start=now_datetime + timedelta(minutes=30), + 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), - end=now - timedelta(minutes=30), + start=now_datetime - timedelta(minutes=60), + 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]