aircox-radiocampus/aircox/tests/models/test_diffusion.py

import pytest
import random
import datetime
from model_bakery import baker
from django.utils import timezone as tz
from datetime import timedelta
from aircox.models import Diffusion


class TestDiffusionQuerySet:
    @pytest.mark.django_db
    def test_episode_by_obj(self, 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
        )
        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, 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
        )
        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

    @pytest.mark.django_db
    def test_now(self, episodes):
        now = tz.now()
        random_episode = random.choice([episodes[1], episodes[0], episodes[2]])
        now_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=now - timedelta(minutes=30),
            end=now + timedelta(minutes=30),
        )
        after_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=now + timedelta(minutes=30),
            end=now + timedelta(minutes=60),
        )
        before_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=now - timedelta(minutes=60),
            end=now - timedelta(minutes=30),
        )
        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

    @pytest.mark.django_db
    def test_date_without_date_arg(self, episodes):
        today = datetime.date.today()
        tomorrow = today + timedelta(days=1)
        random_episode = random.choice([episodes[1], episodes[0], episodes[2]])
        second_today_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=tz.datetime.combine(today, datetime.time.min)
            + timedelta(minutes=30),
            end=tz.datetime.combine(today, datetime.time.max)
            + timedelta(minutes=60),
        )
        first_today_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=tz.datetime.combine(today, datetime.time.min),
            end=tz.datetime.combine(today, datetime.time.max)
            + timedelta(minutes=30),
        )
        another_day_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=tz.datetime.combine(tomorrow, datetime.time.min),
            end=tz.datetime.combine(tomorrow, datetime.time.max),
        )

        result = Diffusion.objects.date()

        assert len(result) == 2
        assert result[0] == first_today_diffusion
        assert result[1] == second_today_diffusion

    @pytest.mark.django_db
    def test_date_with_date_arg(self, episodes):
        today = datetime.date.today()
        tomorrow = today + timedelta(days=1)
        random_episode = random.choice([episodes[1], episodes[0], episodes[2]])
        first_today_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=tz.datetime.combine(today, datetime.time.min)
            - timedelta(minutes=30),
            end=tz.datetime.combine(today, datetime.time.min)
            + timedelta(minutes=30),
        )
        second_tomorrow_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=tz.datetime.combine(tomorrow, datetime.time.min)
            + timedelta(minutes=30),
            end=tz.datetime.combine(tomorrow, datetime.time.min)
            + timedelta(minutes=60),
        )
        first_tomorrow_diffusion = baker.make(
            Diffusion,
            episode=random_episode,
            start=tz.datetime.combine(tomorrow, datetime.time.min),
            end=tz.datetime.combine(tomorrow, datetime.time.min)
            + timedelta(minutes=60),
        )

        result = Diffusion.objects.date(date=tomorrow)

        assert len(result) == 2
        assert result[0] == first_tomorrow_diffusion
        assert result[1] == second_tomorrow_diffusion

    # @pytest.mark.django_db
    # def test_at(self, episodes):
    #    date = datetime.date.today()