forked from rc/aircox
428 lines
15 KiB
Python
428 lines
15 KiB
Python
import pytest
|
|
import random
|
|
import datetime
|
|
from model_bakery import baker
|
|
from django.utils import timezone as tz
|
|
from datetime import timedelta
|
|
import pytz
|
|
from aircox.models import Diffusion, Episode
|
|
|
|
#TODO fixture for rerun diffusion
|
|
@pytest.fixture
|
|
def diffusions_time_variation(episodes):
|
|
random_episode = random.choice([episodes[1], episodes[0], episodes[2]])
|
|
now_date = datetime.date.today()
|
|
now_datetime = tz.now()
|
|
tomorrow_datetime = now_datetime + timedelta(hours=25)
|
|
yesterday_datetime = now_datetime - timedelta(hours=25)
|
|
now_diffusion = baker.make(
|
|
Diffusion,
|
|
episode=random_episode,
|
|
start=now_datetime - timedelta(minutes=30),
|
|
end=now_datetime + timedelta(minutes=30),
|
|
)
|
|
after_diffusion = baker.make(
|
|
Diffusion,
|
|
episode=random_episode,
|
|
start=now_datetime + timedelta(minutes=30),
|
|
end=now_datetime + timedelta(minutes=60),
|
|
)
|
|
tomorrow_diffusion = baker.make(
|
|
Diffusion,
|
|
episode=random_episode,
|
|
start=tomorrow_datetime,
|
|
end=tomorrow_datetime + timedelta(minutes=30),
|
|
)
|
|
before_diffusion = baker.make(
|
|
Diffusion,
|
|
episode=random_episode,
|
|
start=now_datetime - timedelta(minutes=60),
|
|
end=now_datetime - timedelta(minutes=30),
|
|
)
|
|
yesterday_diffusion = baker.make(
|
|
Diffusion,
|
|
episode=random_episode,
|
|
start=yesterday_datetime,
|
|
end=yesterday_datetime + timedelta(minutes=30),
|
|
)
|
|
return (
|
|
now_date,
|
|
now_datetime,
|
|
yesterday_diffusion,
|
|
before_diffusion,
|
|
now_diffusion,
|
|
after_diffusion,
|
|
tomorrow_diffusion,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def diffusions_episode_variation(episodes):
|
|
key_episode = episodes[1]
|
|
another_episode = episodes[2]
|
|
diffusions_with_the_key_episode = baker.make(
|
|
Diffusion, _quantity=3, episode=key_episode
|
|
)
|
|
diffusions_without_the_key_episode = baker.make(
|
|
Diffusion, _quantity=3, episode=another_episode
|
|
)
|
|
return (
|
|
key_episode,
|
|
another_episode,
|
|
diffusions_with_the_key_episode,
|
|
diffusions_without_the_key_episode,
|
|
)
|
|
|
|
|
|
class TestDiffusionQuerySet:
|
|
@pytest.mark.django_db
|
|
def test_episode_by_obj(self, diffusions_episode_variation):
|
|
(
|
|
key_episode,
|
|
_,
|
|
diffusions_with_the_key_episode,
|
|
diffusions_without_the_key_episode,
|
|
) = diffusions_episode_variation
|
|
result = Diffusion.objects.episode(episode=key_episode)
|
|
|
|
for diffusion in diffusions_with_the_key_episode:
|
|
assert diffusion in result
|
|
for diffusion in diffusions_without_the_key_episode:
|
|
assert diffusion not in result
|
|
|
|
@pytest.mark.django_db
|
|
def test_episode_by_id(self, diffusions_episode_variation):
|
|
(
|
|
key_episode,
|
|
_,
|
|
diffusions_with_the_key_episode,
|
|
diffusions_without_the_key_episode,
|
|
) = diffusions_episode_variation
|
|
result = Diffusion.objects.episode(id=key_episode.id)
|
|
|
|
for diffusion in diffusions_with_the_key_episode:
|
|
assert diffusion in result
|
|
for diffusion in diffusions_without_the_key_episode:
|
|
assert diffusion not in result
|
|
|
|
@pytest.mark.django_db
|
|
def test_on_air(self, episodes):
|
|
for episode in episodes:
|
|
random_type = random.choice(
|
|
[Diffusion.TYPE_ON_AIR, Diffusion.TYPE_UNCONFIRMED]
|
|
)
|
|
baker.make(Diffusion, episode=episode, type=random_type)
|
|
result = Diffusion.objects.on_air()
|
|
|
|
for diffusion in result:
|
|
assert diffusion.type == Diffusion.TYPE_ON_AIR
|
|
assert diffusion.type != Diffusion.TYPE_UNCONFIRMED
|
|
|
|
# la méthode "now" filtre les diffusions en cours d'un moment précis.
|
|
# elle prend en compte un objet datetime (date + heure)
|
|
# les diffusions en cours sont définie en fonction de l'argument "now" ou de l'heure actuelle si now=None.
|
|
# la méthode distinct élimine les doublons de diffusions (si ils ont des valeurs identiques pour tous les champs de la db)
|
|
# TODO test si il y a doublon qu'un seul objet soit récupéré.
|
|
@pytest.mark.django_db
|
|
def test_now_test(self, diffusions_time_variation):
|
|
now = tz.now()
|
|
(
|
|
_,
|
|
_,
|
|
_,
|
|
_,
|
|
now_diffusion,
|
|
_,
|
|
_,
|
|
) = diffusions_time_variation
|
|
result = Diffusion.objects.now(now=now, order=True)
|
|
|
|
assert len(result) == 1
|
|
assert result[0] == now_diffusion
|
|
assert result[0].start <= now <= result[0].end
|
|
|
|
# méthode date filtre les diffusions en cours d'une date précise.
|
|
# elle ne prend pas en compte un objet datetime mais un "objet date" uniquement
|
|
# elle crée deux objets datetime (start and end) à partir de l'argument "date" (if none = today)
|
|
# elle utilise la méthode "combine" de la classe "datetime" pour créer ces deux objets à partir de la date
|
|
# elle filtre ensuite les diffusions qui ont lieu entre "start" et "end".
|
|
@pytest.mark.django_db
|
|
def test_date_without_date_arg(self, diffusions_time_variation):
|
|
(
|
|
_,
|
|
_,
|
|
_,
|
|
before_diffusion,
|
|
now_diffusion,
|
|
after_diffusion,
|
|
_,
|
|
) = diffusions_time_variation
|
|
result = Diffusion.objects.date()
|
|
|
|
assert len(result) == 3
|
|
assert result[0] == before_diffusion
|
|
assert result[1] == now_diffusion
|
|
assert result[2] == after_diffusion
|
|
|
|
@pytest.mark.django_db
|
|
def test_date_with_date_arg(self, diffusions_time_variation):
|
|
today_date = datetime.date.today()
|
|
tomorrow_date = today_date + timedelta(days=1)
|
|
(
|
|
_,
|
|
_,
|
|
_,
|
|
_,
|
|
_,
|
|
_,
|
|
tomorrow_diffusion,
|
|
) = diffusions_time_variation
|
|
result = Diffusion.objects.date(date=tomorrow_date)
|
|
|
|
assert len(result) == 1
|
|
assert result[0] == tomorrow_diffusion
|
|
|
|
# la méthode at récupère les diffusions à une date donnée.
|
|
# elle utilise la méthode now si la date est un objet datetime
|
|
# elle utilise la méthode date si la date est un objet date
|
|
@pytest.mark.django_db
|
|
def test_at_datetimeobj(self, diffusions_time_variation):
|
|
(
|
|
_,
|
|
now_datetime,
|
|
_,
|
|
_,
|
|
now_diffusion,
|
|
_,
|
|
_,
|
|
) = diffusions_time_variation
|
|
result = Diffusion.objects.at(date=now_datetime)
|
|
|
|
assert len(result) == 1
|
|
assert now_diffusion in result
|
|
|
|
@pytest.mark.django_db
|
|
def test_at_dateobj(self, diffusions_time_variation):
|
|
(
|
|
now_date,
|
|
_,
|
|
_,
|
|
before_diffusion,
|
|
now_diffusion,
|
|
after_diffusion,
|
|
_,
|
|
) = diffusions_time_variation
|
|
result = Diffusion.objects.at(date=now_date)
|
|
|
|
assert len(result) == 3
|
|
assert result[0] == before_diffusion
|
|
assert result[1] == now_diffusion
|
|
assert result[2] == after_diffusion
|
|
|
|
@pytest.mark.django_db
|
|
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
|
|
def test_after_with_datetime_arg(self, diffusions_time_variation):
|
|
(
|
|
_,
|
|
now_datetime,
|
|
yesterday_diffusion,
|
|
before_diffusion,
|
|
now_diffusion,
|
|
after_diffusion,
|
|
tomorrow_diffusion,
|
|
) = diffusions_time_variation
|
|
from_now_diffusions = Diffusion.objects.after(date=now_datetime)
|
|
|
|
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
|
|
def test_after_with_date_arg(self, diffusions_time_variation):
|
|
(
|
|
now_date,
|
|
_,
|
|
yesterday_diffusion,
|
|
before_diffusion,
|
|
now_diffusion,
|
|
after_diffusion,
|
|
tomorrow_diffusion,
|
|
) = diffusions_time_variation
|
|
from_today_diffusions = Diffusion.objects.after(date=now_date)
|
|
|
|
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]
|